Nunchuk + Bascom + Atmega8 . Brauche hilfe :-)

[MrTaco]

Hallo ich würde gerne ein Atmega8 mit einen Nunchuk verbinden und ihn dann mit Bascom Programmieren. Doch leider finde ich nur Beispiel die in C geschrieben wurden.
Kann mir da einer Helfen?


Hier die Beispiele in C
http://www.michael.lesauvage.name/cod4-nunchuk-leaner/

http://todbot.com/blog/2007/10/25/boarduino-wii-nunchuck-servo/

http://www.windmeadow.com/node/42

[Furtion]

Hi,

das Ding bringt mich auf eine tolle Idee. Also das Teil verwendet I²C
also sollte man das entweder mit der Bascom Funktionen arbeiten oder
das selber über die Register machen. Beim Letzten Link sind die
Datenabläufe doch relativ gut erklärt.

[radbruch]

Hallo

Ein spannendes Thema. Der Nunchuk für 20€ scheint echt ein Schnäppchen zu sein. Er hat zwei Knöpfe, zwei analoge Sticks und drei Beschleunigungssensoren, kommuniziert mit I2C und kann mit 5V betrieben werden. Genial geeignet zum Anschluss an einen Microkontroller :)

Eine gute Basis für eigene Entwicklungen (neben den oben genannten netten Links) ist wohl diese Seite:
http://www.wiili.org/index.php/Wiimote/Extension_Controllers/Nunchuk

Obwohl ich mit Bascom noch nicht viel gemacht habe, versuche ich mal den Nunchuk mit meinem RP6 in Bascom auszuwerten. Bin mal gespannt ob ich das hinbekomme, danke für die Anregung :)

Gruß

mic

[MrTaco]

Alles erklärt :-)
Habe aber leider nicht so viel wissen um das umzuformen
aber für ein paar Hilfen wäre ich super dankbar

[linux_80]

Hallo,

Das Ding geht per I2C,
dazu könnte man von hier die Init-Routine verwenden:
https://www.roboternetz.de/wissen/index.php/Bascom_I2C_Master#Hardware_TWI


So, schnell zusammengetippt wie ich das verstanden hätte (nur mit Debugausgaben der Werte), deshalb ungetestet, auch weil ich keine Wii-Teile habe:

$regfile = "M8def.dat" ' the used chip
$crystal = 16000000 ' frequency used
$baud = 9600

$lib "i2c_twi.lbx" ' Für Hardware TWI

Config Scl = Portc.5 ' Ports fuer IIC-Bus
Config Sda = Portc.4

Config Twi = 400000 ' Init TWBR und TWSR

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Dim Buffer(6) As Byte
Dim B As Byte
Dim Tmp As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print

Do

Gosub Nunchuck_init

Buffer(1) = 0

I2creceive Nunchuck_read , Buffer(1) , 0 , 6

For B = 1 To 6

' Hier soll noch etwas rumcodiert werden:
Tmp = Buffer(b) Xor &H17
Tmp = Tmp + &H17

Print B ; ": " ; Hex(Tmp )

Buffer(b) = 0 ' löschen

Next B

Gosub Send_zero

Print "------"

Waitms 1000
Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Send_zero:

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Return


schaut aber interessant aus das Teil :-k

Edit:
EOR/XOR Bug entfernt !
I2C-Adresse richtig

[BlackDevil]

Diesen Kopfsensor gibts übrigens auch fertig - weis den Namen nur gerade nicht :(

Aber mit dem Wii Kram kann man sehr viel machen - wie den Wiibrator aus der Bauhaus Hochschule/Universität für Sie und Ihn (kein Witz) oder die 3D Virtuellen Räume (auch hier im FOrum irgendwo)

[zerush]

Hi,

das hört sich sehr interessant an!
Damit könnte man schön eine simple aber effektive Fernsteuerung zum Testen von Robotern basteln!

Wenn jemand das erfolgreich zusammen gebastelt hat, wäre es toll, wenn es dazu einen Eintrag im Wiki gäbe...
Mit allen wichtigen Kommandos zusammengefasst, und ggf. ein paar Code-Schnippsel!

Praktisch wäre noch, wenn es eine passende Anschlussbuchse bei reichelt oder so gäbe.. (weiß das jemand?)

P.S.: @BlackDevil: Du meinst die Seite hier oder: Johnny Chung Lee - Projects - Wii (http://www.cs.cmu.edu/~johnny/projects/wii/)

[BlackDevil]

Unter anderem den ja und den: http://www.shortnews.de/start.cfm?id=717965

[radbruch]

Hallo

Nur um es gleich klarzumachen: Ich habe keine Ahnung von I2C/TWI, dies sind meine ersten Versuche.

Ich habe mir einen kleinen Adapter gebastelt:
http://radbruch.roboterbastler.de/rp6/nunchuk/nunchuk-adapter_klein.jpg (http://radbruch.roboterbastler.de/rp6/nunchuk/nunchuk-adapter.jpg)
Und das Programm von linux_80 (danke) an den RP6 angepasst:

'$regfile = "M8def.dat" ' the used chip
'$crystal = 16000000 ' frequency used
'$baud = 9600

$regfile = "M32def.dat" ' RP6 mit Mega32
$crystal = 8000000 ' taktet mit 8MHz
$baud = 38400 ' Loader-Baud

$lib "i2c_twi.lbx" ' Für Hardware TWI

'Config Scl = Portc.5 ' Ports fuer IIC-Bus
'Config Sda = Portc.4

Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1

Config Twi = 400000 ' Init TWBR und TWSR

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

Const Nunchuck_write = &H52 ' Slaveadresse
Const Nunchuck_read = &H53

Dim Buffer(6) As Byte
Dim B As Byte
Dim Tmp As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print

Do

Gosub Nunchuck_init

Buffer(1) = 0

I2creceive Nunchuck_read , Buffer(1) , 0 , 6

For B = 1 To 6

' Hier soll noch etwas rumcodiert werden:
Tmp = Buffer(b) Eor &H17
Tmp = Tmp + &H17

Print B ; ": " ; Hex(tmp )

Buffer(b) = 0 ' löschen

Next B

Gosub Send_zero

Print "------"

Waitms 1000
Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Send_zero:

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Return
Die Ausgabe dazu in meinem Terminal:

I2C-TWI Demo mit Wii Nunchuck

1: 6A
2: 6A
3: 6A
4: 6A
5: 6A
6: 6A
------
1: 6A
2: 6A
3: 6A
4: 6A
5: 6A
6: 6A
------
1: 6A
2: 6A
3: 6A
4: 6A
5: 6A
6: 6A
------

[RP6BOOT]

[READY]
Egal ob der Nunchuk eingesteckt ist oder nicht, die Werte sind immer gleich:(
Vielleicht könnten die TWI-Profis mal drüberschaun. Ich versuche es nun erstmal in C mit der TWI-Libray des RP6...

Gruß

mic

[zerush]

Also mit Bascom kenne ich mich leider nicht aus, aber gibts da nicht auch sowas wie I2CInit ?

[radbruch]

Juhu!

Ich habe eine Ausgabe! Der "Fehler" war die Slave-Adresse:

The device address is "0x52" ("0xA4" in 8-bit addressing).(aus dem oben erwähnten wiili-wiki)

'Const Nunchuck_write = &H52 ' Slaveadresse
'Const Nunchuck_read = &H53
Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Nachdem ich nun die 8bit-Adresse eingetragen habe (k.A. was das bedeutet) erhalte ich Werte.

Das Nunchuck_init habe ich aus der Schleife genommen, denn sonst würde doch send_zero am Schleifenende überschrieben werden:

'$regfile = "M8def.dat" ' the used chip
'$crystal = 16000000 ' frequency used
'$baud = 9600

$regfile = "M32def.dat" ' RP6 mit Mega32
$crystal = 8000000 ' taktet mit 8MHz
$baud = 38400 ' Loader-Baud

$lib "i2c_twi.lbx" ' Für Hardware TWI

'Config Scl = Portc.5 ' Ports fuer IIC-Bus
'Config Sda = Portc.4

Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1

Config Twi = 400000 ' Init TWBR und TWSR

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

'Const Nunchuck_write = &H52 ' Slaveadresse
'Const Nunchuck_read = &H53
Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Dim Buffer(6) As Byte
Dim B As Byte
Dim Tmp As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print

Gosub Nunchuck_init
Gosub Send_zero

Do
Buffer(1) = 0

I2creceive Nunchuck_read , Buffer(1) , 0 , 6
'Print Err

For B = 1 To 6

' Hier soll noch etwas rumcodiert werden:
Tmp = Buffer(b) Eor &H17
Tmp = Tmp + &H17

Print B ; ": " ; Hex(tmp ) ; " ";

Buffer(b) = 0 ' löschen

Next B

Gosub Send_zero

'Print "------"
Print

Waitms 500
Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
'Print "Fehler beim Init: " ; Err
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Send_zero:

I2cstart
I2cwbyte Nunchuck_write
'Print "Fehler beim null senden: " ; Err
I2cwbyte &H00 ' sends one byte
I2cstop

Return

Hier die Ausgabe:

I2C-TWI Demo mit Wii Nunchuck

1: BC 2: BC 3: BC 4: BC 5: BC 6: BC
1: 88 2: 95 3: 91 4: 94 5: E8 6: 0A
1: 8A 2: 95 3: 87 4: 90 5: EA 6: F6
1: 8A 2: 95 3: 96 4: 91 5: E7 6: C2
1: 8A 2: 95 3: 87 4: 91 5: E7 6: BA
1: 6F 2: 94 3: 87 4: 92 5: F6 6: CE
1: 2A 2: 96 3: 87 4: 92 5: F6 6: 02
1: 2A 2: 96 3: 88 4: 93 5: E7 6: 6E
1: 2A 2: 96 3: 88 4: 93 5: F6 6: 2E
1: 31 2: 96 3: 88 4: 93 5: F6 6: 32
1: 4F 2: 93 3: 88 4: 93 5: E7 6: BA
1: 8B 2: 94 3: 87 4: 94 5: E7 6: 42
1: 96 2: 95 3: 88 4: 94 5: E7 6: E2
1: B1 2: 88 3: 87 4: 94 5: E7 6: AA
1: BD 2: 87 3: 87 4: 94 5: E7 6: 46
1: F6 2: 88 3: 87 4: 94 5: F6 6: 46
1: F6 2: 88 3: 96 4: 95 5: E7 6: F2
1: B3 2: 8A 3: 96 4: 95 5: E7 6: E2
1: 89 2: 95 3: 88 4: 94 5: F6 6: 6A
1: 8B 2: 94 3: 87 4: 95 5: F6 6: 6E
1: 94 2: 6E 3: 87 4: 95 5: E7 6: F2
1: 94 2: 53 3: 88 4: 95 5: F6 6: 9A
1: 95 2: 30 3: 88 4: 96 5: E7 6: CE
1: 95 2: 36 3: 88 4: 96 5: F6 6: 1A
1: 95 2: 36 3: 88 4: 96 5: E7 6: 6A
1: 93 2: 54 3: 88 4: 96 5: E7 6: F6
1: 92 2: 6C 3: 87 4: 87 5: E7 6: EE
1: 90 2: 95 3: 88 4: 87 5: E7 6: 16
1: A9 2: 97 3: 87 4: 88 5: E7 6: 32
1: B3 2: C4 3: 87 4: 88 5: E7 6: 6A
1: A9 2: EE 3: 87 4: 88 5: E7 6: 8A
1: 86 2: E9 3: 87 4: 88 5: E7 6: 5E
1: 86 2: E9 3: 87 4: 89 5: E7 6: 56
1: 79 2: C9 3: 87 4: 89 5: E7 6: 4E
1: 7A 2: A9 3: 87 4: 88 5: E7 6: 3A
1: 89 2: 94 3: 87 4: 88 5: E8 6: 8A
1: 89 2: 94 3: 87 4: 96 5: F6 6: 14
1: 89 2: 94 3: 87 4: 87 5: E7 6: C0
1: 8A 2: 94 3: 87 4: 88 5: E8 6: F0
1: 8A 2: 94 3: 87 4: 88 5: E8 6: AE
1: 8A 2: 94 3: 87 4: 87 5: E7 6: 42
1: 8A 2: 94 3: 87 4: 88 5: E7 6: 62
1: 8A 2: 94 3: 88 4: 88 5: E7 6: 47
1: 8A 2: 94 3: 87 4: 89 5: E7 6: 63
1: 8A 2: 94 3: 88 4: 89 5: E7 6: 07
1: 8B 2: 94 3: 88 4: 89 5: E7 6: A6
1: 8B 2: 94 3: 87 4: 88 5: E7 6: D2
1: 8B 2: 94 3: 96 4: 88 5: E8 6: 7E
1: 8B 2: 94 3: 89 4: 88 5: E8 6: BA
1: 8B 2: 94 3: 87 4: 87 5: E8 6: BE
1: 8B 2: 94 3: 96 4: 94 5: E7 6: 12

[RP6BOOT]

[READY]

Das erste Byte links/rechts Analogstick, Byte 2 ist Vor und Zurück. Am Ende werden noch die Tasten gedrückt. Das sieht doch vielversprechend aus. Ich denke, ich kann mich ans dekodieren ranmachen :)

Gruß

mic

[linux_80]

Hi,

ja schaut doch gut aus, ich hab mir auch mal so ein Ding bestellt :-)

Die Beschleunigungswerte sind 10-bittig, also etwas Bitgeschiebe usw. notwendig um auf den offiziellen Wert zu kommen.
Ausser man nimmts nicht so genau, dann reichen auch die 8 Bit aus dem Entsprechendem Byte.
Zu Testzwecken, kann man das 6. Byte evtl. in binärer Weise ausgeben, damit Taster besser abtechen.

Zu I2C, die Adressen sind immer 7 Bit, das übrige Bit wird als kennzeichen, ob gelesen oder geschrieben werden soll, verwendet, und ist das Bit0.
Wenn man die $52 um eins nach links verschiebt, kommt $A4 raus.

[radbruch]

Hallo

Seit ein paar Minuten kann ich keine Werte mehr einlesen, möglicherweise habe ich den RP6 abgeschossen. Nunchuk an WII funktioniert.

Vorsicht beim Nachbau, eigene Gewähr!

Gruß

mic

[zerush]

Kannst du keine Werte mehr einlesen oder wird nichts mehr ausgegeben?

[radbruch]

Es wird immer der selbe Wert ausgegeben(&H16). Da die Ausgabefunktion unverändert ist, vermute ich, dass das Einlesen nicht klappt. Möglicherweise sind auch nur die Akkus leer, der RP6 hängt grad an der Steckdose...

[MrTaco]

Ich würde gerne den Nunchuk mit den USB mit Strom versorgen.
Musste doch gehen mit nen Vorwiderstand ?

USB , 5 Volt , max 500mA glaub ich
Nunchuck 3.3 Volt , ???mA
Was bräuchte ich da für nen Widerstand?

[radbruch]

Hallo

Basierend auf den Eingangs genannten Links:
http://www.michael.lesauvage.name/wp-content/uploads/2008/03/my_arduino.jpg
Hier ist der Nunchuk an 5V angeschlossen, aber dazu steht noch die Warnung:

The nunchuck is only supposed to get 3.3+ volts. So far it has worked fine at 5 volts, but be warned. I am guessing that using the higher voltage will shorten the nunchucks lifespan.
"Höhere Spannung könnte die Lebensdauer des Nunchuks verkürzen". Dazu kann ich keine Aussagen machen ;)

Gruß

mic

[MrTaco]

hier hab ich ein Netzteil für den Nunchuk

http://cgi.ebay.de/LED-Netzteil-3-3-Volt-4550-mA-keine-Vorwiderstaende-LEDs_W0QQitemZ110274855339QQihZ001QQcategoryZ31334 QQssPageNameZWDVWQQrdZ1QQcmdZViewItem

Kann ich damit auch 2 nunchucks anschließen (parallel).
Das Netzteil ist schon etwas teuer kennt einer von euch ne biligere lösung.

[linux_80]

@MrTaco
ganz soviel wird der Nunchuk auch nicht brauchen ;-)
Aber was willst Du damit machen, wenn der mit 3,3V läuft, sollte dann auch der AVR mit dieser Spannung betrieben werden, sonst bekommt man evtl. ein Problem bei I2C und den unterschiedlichen Pegeln.

[Furtion]

Hi,

es gibt auch so tolle Spannungswandler Low Drop 3V3. Die machen aus
5V ---> 3,3Volt.

[radbruch]

Hallo

Das war wohl ein Fehlalarm, es funktioniert wieder. Der Fehler wird irgendwie durch das LCD verursacht. Damit wird TWI scheinbar nicht richtig initialisiert. Blöderweise bleibt die alte Initialisierung aber bis zum Ausschalten erhalten, deshalb habe ich den Zusammenhang nicht gleich erkannt.

Hier nun das erste Video. Das Display ist aber schwer zu filmen, man sieht leider kaum etwas. Die Sternchen sind die analogen x/y-Positionen, unten links sind kippen seitlich/vor-zurück, ganz rechts die zwei Bits für C und Z-Taste:
http://i.ytimg.com/vi/ubiJGgd02DU/default.jpg (http://www.youtube.com/watch?v=ubiJGgd02DU)
http://www.youtube.com/watch?v=ubiJGgd02DU

Das klappt überraschend gut. Allerdings bezweifle ich etwas den Sinn der "+&h17"-Operation beim Decodieren der Daten.

Gruß

mic

[m.a.r.v.i.n]

Hallo,

im CC2-Forum (http://www.cczwei-forum.de) gibt es auch ein Projekt mit dem Wii-Nunchuk für das ATM18 Modul (mega88). Dort gibt es auch Schaltpläne für einen 3,3V Spannungsregler und die I2C Pegelanpassung.
http://www.cczwei-forum.de/cc2/thread.php?threadid=1785

Gruß Peter

[radbruch]

Hallo

Spannender als die Knöpfe und der analoge Stick sind wohl die Beschleunigungssensoren. Um es Vorweg zu nehmen, die funktionieren prima. Was man vom Abfilmen des LC-Displays nicht sagen kann:
http://i.ytimg.com/vi/nzs39xchhN4/1.jpg (http://www.youtube.com/watch?v=nzs39xchhN4)
http://www.youtube.com/watch?v=nzs39xchhN4

Die zweiseitige Platine für den Adapter habe ich übrigens aus einer alten ISA-Karte (Paradise Accelerator24 mit EEprom von 1994...)rausgebissen.

Der obere Balken ist Neigen links/rechts, der untere Balken Kippen vor/zurück. Es werden nur 8-Bit ausgewertet, aber mit 20 Zeichen/Zeile kann man das nicht vernünftig auflösen. Die LSB im 6ten Datenbyte sind extrem empfindlich. Ich werde mal eine kleine Anwendung mit Servos dazu basteln. Fahren wäre schwieriger weil ich erst die Bascom-Motorroutinen für den RP6 schreiben müßte.

Das Initialisieren funktioniert jetzt, wichtig scheint zudem eine kurze Pause zwischen dem Senden der "0" und der Abfrage der Bytes zu sein. Der Code sieht nun so aus:

'WII-Nunchuk mit Bascom auslesen. Grundgerüst des Codes von Linux_80 4.8.08 mic

'https://www.roboternetz.de/phpBB2/viewtopic.php?p=389309

'$regfile = "M8def.dat" ' the used chip
'$crystal = 16000000 ' frequency used
'$baud = 9600

$regfile = "M32def.dat" ' RP6 mit Mega32
$crystal = 8000000 ' taktet mit 8MHz
$baud = 38400 ' Loader-Baud

$lib "i2c_twi.lbx" ' Für Hardware TWI

'Config Scl = Portc.5 ' Ports fuer IIC-Bus
'Config Sda = Portc.4

Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1

Config Twi = 400000 ' Init TWBR und TWSR
I2cinit

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

'Const Nunchuck_write = &H52 ' Slaveadresse
'Const Nunchuck_read = &H53
Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Config Lcdpin = Pin , Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portb.7 , Db7 = Portb.1 , E = Portb.0 , Rs = Portc.6
Config Lcd = 20 * 4
Deflcdchar 0 , 63 , 63 , 63 , 63 , 63 , 63 , 63 , 63
Cls 'clear the LCD display
Cursor Off Noblink
Lcd " RP6 ROBOT SYSTEM" 'display this at the top line



Dim Buffer(6) As Byte
Dim B As Byte
Dim Tmp As Byte
Dim Pos_x As Byte
Dim Pos_y As Byte
Dim Acc_x As Byte
Dim Acc_y As Byte
Dim Acc_z As Byte
Dim Buttons As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print "Ausgabe auf dem LCD beachten"

Waitms 1000
Gosub Nunchuck_init

Cls
Lcd " WII-Nunchuk am RP6"

Do
Gosub Nunchuk_read

'Print Hex(pos_x) ; " " ; Hex(pos_y)

Locate 2 , 1
Lcd Hex(pos_x)
Lcd " "
Lcd Hex(pos_y)
Locate 2 , 19
If Buttons.0 = 1 Then
Lcd "Z"
Else
Lcd "z"
End If

If Buttons.1 = 1 Then
Lcd "c"
Else
Lcd "C"
End If

Locate 3 , 1
Tmp = Acc_x / 10
For B = 1 To Tmp
Lcd Chr(0)
Next
For B = Tmp To 19
Lcd " "
Next

Locate 4 , 1
Tmp = Acc_y / 10
For B = 1 To Tmp
Lcd Chr(0)
Next
For B = Tmp To 19
Lcd " "
Next

Waitms 100
Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Nunchuk_read:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Waitms 1
Buffer(1) = 0
I2creceive Nunchuck_read , Buffer(1) , 0 , 6

Tmp = Buffer(1) Eor &H17
'Tmp = Tmp + &H17
Pos_x = Tmp

Tmp = Buffer(2) Eor &H17
'Tmp = Tmp + &H17
Pos_y = Tmp

Tmp = Buffer(3) Eor &H17
'Tmp = Tmp + &H17
Acc_x = Tmp

Tmp = Buffer(4) Eor &H17
'Tmp = Tmp + &H17
Acc_y = Tmp

Tmp = Buffer(5) Eor &H17
'Tmp = Tmp + &H17
Acc_z = Tmp

Tmp = Buffer(6) Eor &H17
Tmp = Tmp + &H17
Buttons = Tmp

Return
Die &H17-Addition braucht man zwingend beim 6tem Byte und wenn man mehr als die hochwertigen 8 Bit der Beschleunigungsmesser auswerten möchte ;) Die blockierenden Funktionen gefallen mir noch nicht besonders, soweit ich weiß, kann TWI auch einen Interrupt auslösen. Muss ich mich aber erst etwas einlesen...

Gruß

mic

[linux_80]

Hallo,

dann scheint die Lösung ja schon brauchbar zu sein,
jetzt brauchts nur noch ein gescheites Problem dazu :mrgreen:

[radbruch]

Hallo

Nun sind die Servos angeschlossen und werden wahlweise (Umschaltung mit Z/C) mit dem analogen Stick oder den Beschleunigungssensoren gesteuert:
http://i.ytimg.com/vi/gIlwGfXJxvM/2.jpg (http://www.youtube.com/watch?v=gIlwGfXJxvM)
http://www.youtube.com/watch?v=gIlwGfXJxvM

Trotz minimalem Rechenaufwand kann man schon erkennen, das hier etwas funktioniert :) Allerdings noch sehr "zappelig" und ungenau. Ich vermute auch, dass mit den eingelesenen Werten etwas nicht ganz stimmt.

Das inzwischen gewachsene Programm kann nun den Nunchuk abfragen, Servos steuern, auf dem LCD ausgeben und die Tasten meines LCDs einlesen. Erstaunlich wie einfach das alles mit Bascom funktioniert:

'WII-Nunchuk mit Bascom auslesen. Grundgerüst des Codes von Linux_80 5.8.08 mic

'https://www.roboternetz.de/phpBB2/viewtopic.php?p=389309

'$regfile = "M8def.dat" ' the used chip
'$crystal = 16000000 ' frequency used
'$baud = 9600

$regfile = "M32def.dat" ' RP6 mit Mega32
$crystal = 8000000 ' taktet mit 8MHz
$baud = 38400 ' Loader-Baud

$lib "i2c_twi.lbx" ' Für Hardware TWI

'Config Scl = Portc.5 ' Ports fuer IIC-Bus
'Config Sda = Portc.4

Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1

Config Twi = 400000 ' Init TWBR und TWSR
I2cinit

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

'Const Nunchuck_write = &H52 ' Slaveadresse
'Const Nunchuck_read = &H53
Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Config Lcdpin = Pin , Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portb.7 , Db7 = Portb.1 , E = Portb.0 , Rs = Portc.6
Config Lcd = 20 * 4
Deflcdchar 0 , 63 , 63 , 63 , 63 , 63 , 63 , 63 , 63
Cls 'clear the LCD display
Cursor Off Noblink
Lcd " RP6 ROBOT SYSTEM" 'display this at the top line

Config Servos = 2 , Servo1 = Porta.0 , Servo2 = Porta.1 , Reload = 10
Servo(1) = 90
Servo(2) = 85
Config Porta.0 = Output
Config Porta.1 = Output
Enable Interrupts

Dim A As Byte
Dim Tmp As Byte
Dim Pos_x As Byte
Dim Pos_y As Byte
Dim Acc_x As Word
Dim Acc_y As Word
Dim Acc_z As Word
Dim Buttons As Byte
Dim Tasten As Byte
Dim Stick As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print "Ausgabe auf dem LCD beachten"

Waitms 1000
Gosub Nunchuck_init

Cls
'Lcd " WII-Nunchuk am RP6"
Lcd "acceleration values: "
Stick = 1

Do
'(
Gosub Getkeys
Locate 1 , 1
Lcd Bin(tasten)
')
Gosub Nunchuk_read

'Print Hex(pos_x) ; " " ; Hex(pos_y)

'(
Locate 2 , 1
Lcd Hex(pos_x)
Lcd " "
Lcd Hex(pos_y)
Locate 2 , 19
If Buttons.0 = 1 Then
Lcd "Z"
Else
Lcd "z"
End If

If Buttons.1 = 0 Then
Lcd "C"
Else
Lcd "c"
End If

Locate 3 , 1
Lcd "Accs X: " ; Hex(acc_x) ; " y: " ; Acc_y;
Locate 4 , 6
Lcd "Z: " ; Acc_z
')
Locate 2 , 1
Lcd "X: " ; Bin(acc_x)
Locate 3 , 1
Lcd "Y: " ; Bin(acc_y)
Locate 4 , 1
Lcd "Z: " ; Bin(acc_z)

If Buttons.0 = 1 Then Stick = 0
If Buttons.1 = 0 Then Stick = 1

If Stick = 0 Then
Servo(1) = Acc_y
Servo(2) = Acc_x
Else
Servo(1) = Pos_y - 30
Servo(2) = Pos_x - 30
End If

Waitms 100

Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Nunchuk_read:
Dim Buffer(6) As Byte

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Waitms 1
Buffer(1) = 0
I2creceive Nunchuck_read , Buffer(1) , 0 , 6

Tmp = Buffer(1) Eor &H17
'Tmp = Tmp + &H17
Pos_x = Tmp

Tmp = Buffer(2) Eor &H17
'Tmp = Tmp + &H17
Pos_y = Tmp

Tmp = Buffer(3) Eor &H17
Tmp = Tmp + &H17
Acc_x = Tmp * 4
Acc_x = Acc_x And &HFFC


Tmp = Buffer(4) Eor &H17
Tmp = Tmp + &H17
Acc_y = Tmp * 4
Acc_y = Acc_y And &HFFC

Tmp = Buffer(5) Eor &H17
Tmp = Tmp + &H17
Acc_z = Tmp * 4
Acc_z = Acc_z And &HFFC

Tmp = Buffer(6) Eor &H17
Tmp = Tmp + &H17
Buttons = Tmp

If Buttons.2 = 1 Then Set Acc_x.0 ' Die acc-LSB einlesen
If Buttons.3 = 1 Then Set Acc_x.1
If Buttons.4 = 1 Then Set Acc_y.0
If Buttons.5 = 1 Then Set Acc_y.1
If Buttons.6 = 1 Then Set Acc_z.0
If Buttons.7 = 1 Then Set Acc_z.1

Return

Getkeys:
' Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portb.7 , Db7 = Portb.1 , E = Portb.0 , Rs = Portc.6

Tasten = 0

'Disable Interrupts

Config Pinc.4 = Input
Config Pinc.5 = Input
Config Pinb.7 = Input
Config Pinb.1 = Input
Config Pinc.6 = Input

Set Portc.4
Set Portc.5
Set Portb.7
Set Portb.1
Set Portc.6

If Pinc.4 = 0 Then Set Tasten.3
If Pinc.5 = 0 Then Set Tasten.2
If Pinb.7 = 0 Then Set Tasten.1
If Pinb.1 = 0 Then Set Tasten.0
If Pinc.6 = 0 Then Set Tasten.4

Reset Portc.4
Reset Portc.5
Reset Portb.7
Reset Portb.1
Reset Portc.6

Config Pinc.4 = Output
Config Pinc.5 = Output
Config Pinb.7 = Output
Config Pinb.1 = Output
Config Pinc.6 = Output

'Enable Interrupts

Return
Beim Durchlesen ist mir aufgefallen, dass ich dem servo()-Array die 10-bit Werte der Beschleunigungssensoren zuweise. Leider finde ich in der Bascom-Hilfe keinen Hinweis wieviele Bits servo() speichert. Es gibt noch viel zu erforschen...

Gruß

mic

[linux_80]

Hallo,

Servos ist ein Byte-Array, also theoretisch 0-255. Es hängt aber vom Timing, der Anzahl Servos, vom Reload-Wert, und vom Servo selbst ab, in welchem Bereich man sich bewegen kann. Muss man ausprobieren, damit die Zahnräder am Servo ganz bleiben.

[radbruch]

Hallo

Mein Verdacht scheint sich zu bestätigen. Ich habe nun die Daten des ersten Accelerometer untersucht. Das niederwertige Nipple (bit0 bis 3) funktioniert tadellos, zusammen mit den zwei LSB aus dem 6ten TWI-Datenbyte erhalte ich beim Schwenken je nach Richtung aufsteigende oder abfallende Werte von 0 bis 63.

Leider funktioniert es aber mit dem hochwertigen Nipple (bit4-7) überhaupt nicht. Die Werte sind in einer für mich nicht erkennbaren Reihenfolge. Hier ein Beispiel:

Highnipple (links) und Lownipple jeweils binär und dezimal

Schwenken von links nach rechts:
(Werte low Nipple aufsteigend)

00001010 10 00010100 20
00001010 10 00000000 0
00001010 10 00010101 21
00001001 9 00011110 30
00001001 9 00100001 33
00001001 9 00011110 30
00001010 10 00010010 18
00001001 9 00100101 37
00001001 9 00101111 47
00001011 11 00010101 21
00001011 11 00001111 15
00001010 10 00100101 37
00001010 10 00011101 29
00001000 8 00000010 2
00001000 8 00001101 13
00000111 7 00101001 41
00001001 9 00001011 11
00001001 9 00001111 15
00001000 8 00101010 42
00001000 8 00111011 59
00000101 5 00111101 61
00000110 6 00001101 13
00000101 5 00100001 33
00000101 5 00110000 48
00000110 6 00111101 61
00000111 7 00001100 12
00000110 6 00011110 30
00000110 6 00110010 50
00000011 3 00111100 60
00000100 4 00000101 5
00000100 4 00011011 27
00000011 3 00100011 35
00000011 3 00111001 57
00000011 3 00101110 46
00000011 3 00111001 57
00000100 4 00111110 62
00000101 5 00000101 5
00000101 5 00000100 4
00000101 5 00001011 11
00000101 5 00001000 8
00000101 5 00001011 11
00000100 4 00111111 63
00000101 5 00000010 2
00000011 3 00110101 53

Und ca. ab hier zurück von rechts nach links:
(Werte low Nipple abfallend)

00000100 4 00111100 60
00000011 3 00110100 52
00000011 3 00110100 52
00000101 5 00001011 11
00000101 5 00000111 7
00000101 5 00010000 16
00000101 5 00000111 7
00000101 5 00000000 0
00000101 5 00001010 10
00000101 5 00011010 26
00000101 5 00000101 5
00000101 5 00000000 0
00000101 5 00001101 13
00000101 5 00000011 3
00000100 4 00011001 25
00000110 6 00100001 33
00000101 5 00100100 36
00000110 6 00000001 1
00001000 8 00011111 31
00000111 7 00111001 57
00001000 8 00011001 25
00001000 8 00000110 6
00001010 10 00101101 45
00001010 10 00011111 31
00001011 11 00010011 19
00001011 11 00000110 6
00001001 9 00110101 53
00001001 9 00100101 37
00001001 9 00101011 43
00001001 9 00100001 33
00001001 9 00011100 28
00001010 10 00011001 25
00001001 9 00011100 28
00001010 10 00010100 20
00001010 10 00010101 21
00001010 10 00010101 21
00001010 10 00001110 14
00001010 10 00001010 10
00001010 10 00010010 18
00001001 9 00011111 31
00001001 9 00101000 40
00001010 10 00011000 24

Der Wert des Highnipples schwankt zwischen 10 (max links) und 3 (max rechts). Aber die Werte ändern sich nicht linear. Die Zuordnung der Werte zu den Winkeln ist immer gleich, aber eben nicht folgerichtig. Was nun? Kann das jemand in eine Formel fassen oder muss ich mit einer Umrechnungstabelle arbeiten?

Hier noch der Testcode:

Do
While Buttons.1 = 1 ' solange z-Knopf nicht gedrückt
Gosub Nunchuk_read
Waitms 100
Wend

While Buttons.1 = 0 ' solange z-Knopf gedrückt
Gosub Nunchuk_read ' Werte einlesen
Tmp = Acc_x / 16 ' linkes Nipple nach rechts schieben
Print Bin(tmp) ; " " ; Tmp ; " "; ' und binär und dezimal ausgeben
Tmp = Acc_x And 15 ' nur das rechte nipple
Tmp = Tmp * 4 ' um zwei Bits nach Links Schieben
If Buttons.2 = 1 Then Set Tmp.0 ' und die acc-LSB einlesen
If Buttons.3 = 1 Then Set Tmp.1
' binär und dezimal ausgeben
Print Bin(tmp) ; " " ; Tmp
Waitms 10
Wend
Loop

Gruß

mic

[radbruch]

Es geht Schlag auf Schlag :)

Der Fehler steckt hier:

Tmp = Buffer(1) EOR &H17

Besser ist:

Tmp = Buffer(1) Xor &H17

Dann sieht der Schwenk von links nach rechts so aus:

00000100 4 00001011 11
00000100 4 00001101 13
00000100 4 00001110 14
00000100 4 00010001 17
00000100 4 00010000 16
00000100 4 00001100 12
00000100 4 00001110 14
00000100 4 00010001 17
00000100 4 00010101 21
00000100 4 00010100 20
00000100 4 00011001 25
00000100 4 00011111 31
00000100 4 00100110 38
00000100 4 00100111 39
00000100 4 00101010 42
00000100 4 00110001 49
00000100 4 00110111 55
00000101 5 00000001 1
00000101 5 00001110 14
00000101 5 00011110 30
00000101 5 00101000 40
00000101 5 00110000 48
00000101 5 00111111 63
00000110 6 00001001 9
00000110 6 00010001 17
00000110 6 00011110 30
00000110 6 00100000 32
00000110 6 00101011 43
00000110 6 00111001 57
00000111 7 00000101 5
00000111 7 00001011 11
00000111 7 00011001 25
00000111 7 00011011 27
00000111 7 00100001 33
00000111 7 00101001 41
00000111 7 00110110 54
00001000 8 00000011 3
00001000 8 00000100 4
00001000 8 00001001 9
00001000 8 00010101 21
00001000 8 00011111 31
00001000 8 00101011 43
00001000 8 00111000 56
00001000 8 00110111 55
00001000 8 00111100 60
00001001 9 00000011 3
00001001 9 00001000 8
00001001 9 00001110 14
00001001 9 00010100 20
00001001 9 00011100 28
00001001 9 00100010 34
00001001 9 00101011 43
00001001 9 00101011 43
00001001 9 00110010 50
00001001 9 00111100 60
00001010 10 00000001 1
00001010 10 00000100 4
00001010 10 00001011 11
00001010 10 00001110 14
00001010 10 00010100 20
00001010 10 00011111 31
00001010 10 00100011 35
00001010 10 00100101 37
00001010 10 00100101 37
00001010 10 00101000 40
00001010 10 00101110 46
00001010 10 00110101 53
00001010 10 00110010 50
00001010 10 00111010 58
00001010 10 00110110 54
00001010 10 00110111 55
00001010 10 00111010 58
00001010 10 00111001 57
00001010 10 00111111 63
00001011 11 00000011 3
00001011 11 00000001 1
00001010 10 00111110 62
00001010 10 00111100 60
00001010 10 00111111 63
00001011 11 00000001 1
00001011 11 00000010 2
00001010 10 00111101 61
00001010 10 00111000 56
00001011 11 00000001 1
00001010 10 00111101 61
00001010 10 00111100 60
00001010 10 00111110 62
00001010 10 00111010 58
00001010 10 00110101 53
00001010 10 00111100 60
00001010 10 00110011 51
00001010 10 00110001 49
00001010 10 00101101 45
00001010 10 00110010 50
00001010 10 00110010 50
00001011 11 00000010 2
00001010 10 00100011 35


Sehr hübsch. Von waagrecht links=4 bis waagrecht rechts=10 sind 7 Schritte im Highnipple mal 64 Lownipple+LSBs ergibt über 400 Schritte für 180 Grad. (Auf dem Kopf zählt er rückwärts ;)

Gruß

mic

[linux_80]

Hi radbruch,

mir gings heute auch so, auch wegen dem Xor, Eor heissts in ASM #-o
dachte mir auch schon ich werd deppert :-)

Ich hab seit gestern auch so ein Teil, das ging mit 5V nicht so gut, bzw. nach ca. 20 abfragen war Sense.
Hab heute Nachmittag dann diesen FET-Level-shifter zusammengebruzelt, und schon funzte das Teil. Noch besser seit das exclusiv oder auch das macht was es soll !

Hast Du auch schon mal versucht mehr als die 6 Bytes zu lesen ? Bis 63 kommen noch welche, so wie in dem einen Wiki beschrieben. Da soll ja dann stehen wie weit die Werte vom Joystick usw. gehen. Würde auch in etwa passen.

Mit dem Classic-Controller soll das genauso gehen, I2C-Adresse ist dieselbe nur die Werte müssen anders ausgewertet werden.

PS:
Ich hab mir so einen Nachbau geholt:
http://cgi.ebay.de/ws/eBayISAPI.dll?ViewItem&item=300244769330
Dieser soll auch den Classic-mode können, zumindest soweit es die Tasten erlauben. Hab ich aber noch ned hingebacht, nach dem Umschalten sind alle Werte gleich die zurück kommen :-)
Aja, und Pin 2 ist bei dem auch belegt, mal sehen was man mit dem anstellt.

[radbruch]

Hallo

Nachdem der "Bug" entfernt ist sieht es nun richtig klasse aus:

http://i4.ytimg.com/vi/KKtTXcCFqGo/3.jpg (http://www.youtube.com/watch?v=KKtTXcCFqGo)
http://www.youtube.com/watch?v=KKtTXcCFqGo

Somit würde ich sagen: Ziel erreicht. Das sollte auch mit einem Mega8 funktionieren :)

Hier noch der finale Code:

'WII-Nunchuk mit Bascom auslesen. Grundgerüst des Codes von Linux_80 7.8.08 mic

'https://www.roboternetz.de/phpBB2/viewtopic.php?p=389309

$regfile = "M32def.dat" ' RP6 mit Mega32
$crystal = 8000000 ' taktet mit 8MHz
$baud = 38400 ' Loader-Baud

$lib "i2c_twi.lbx" ' Für Hardware TWI
Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1
Config Twi = 400000 ' Init TWBR und TWSR
I2cinit
' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Config Lcdpin = Pin , Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portb.7 , Db7 = Portb.1 , E = Portb.0 , Rs = Portc.6
Config Lcd = 20 * 4
Deflcdchar 0 , 63 , 63 , 63 , 63 , 63 , 63 , 63 , 63
Cls 'clear the LCD display
Cursor Off Noblink
Lcd " RP6 ROBOT SYSTEM" 'display this at the top line

Config Servos = 2 , Servo1 = Porta.0 , Servo2 = Porta.1 , Reload = 10
Servo(1) = 90
Servo(2) = 85
Config Porta.0 = Output
Config Porta.1 = Output
Enable Interrupts

Dim A As Byte
Dim Tmp As Byte
Dim Pos_x As Byte
Dim Pos_y As Byte
Dim Acc_x As Byte
Dim Acc_y As Byte
Dim Acc_z As Byte
Dim Buttons As Byte
Dim Tasten As Byte
Dim Stick As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print "Ausgabe auf dem LCD beachten"

Gosub Nunchuck_init
Waitms 1000
Gosub Nunchuk_read

Cls
'Lcd " WII-Nunchuk am RP6"
Stick = 1

Do
'(
Gosub Getkeys
Locate 1 , 1
Lcd Bin(tasten)
')
Gosub Nunchuk_read

'Print Hex(pos_x) ; " " ; Hex(pos_y)


Locate 2 , 1
Lcd Hex(pos_x)
Lcd " "
Lcd Hex(pos_y)
Locate 2 , 19

If Buttons.1 = 0 Then
Lcd "C"
Else
Lcd "c"
End If

If Buttons.0 = 0 Then
Lcd "Z"
Else
Lcd "z"
End If

Locate 3 , 1
Lcd "Accs X: " ; Hex(acc_x) ; " y: " ; Acc_y;
Locate 4 , 6
Lcd "Z: " ; Acc_z
'(
Locate 2 , 1
Lcd "X: " ; Bin(acc_x) ; " " ; Acc_x ; " "
Locate 3 , 1
Lcd "Y: " ; Bin(acc_y) ; " " ; Acc_y ; " "
Locate 4 , 1
Lcd "Z: " ; Bin(acc_z) ; " " ; Acc_z ; " "
')

If Buttons.0 = 0 Then Stick = 0
If Buttons.1 = 0 Then Stick = 1
If Stick = 0 Then
Servo(1) = Acc_y - 40
Servo(2) = Acc_x - 40
Else
Servo(1) = Pos_y - 40
Servo(2) = Pos_x - 40
End If

'Waitms 10

Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Nunchuk_read:
Dim Buffer(6) As Byte

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Waitms 1
Buffer(1) = 0
I2creceive Nunchuck_read , Buffer(1) , 0 , 6

Tmp = Buffer(1) Xor &H17
Tmp = Tmp + &H17
Pos_x = Tmp

Tmp = Buffer(2) Xor &H17
Tmp = Tmp + &H17
Pos_y = Tmp

Tmp = Buffer(3) Xor &H17
Tmp = Tmp + &H17
Acc_x = Tmp

Tmp = Buffer(4) Xor &H17
Tmp = Tmp + &H17
Acc_y = Tmp

Tmp = Buffer(5) Xor &H17
Tmp = Tmp + &H17
Acc_z = Tmp

Tmp = Buffer(6) Xor &H17
Tmp = Tmp + &H17
Buttons = Tmp
'(
If Buttons.2 = 1 Then Set Acc_x.0 ' Die acc-LSB einlesen
If Buttons.3 = 1 Then Set Acc_x.1
If Buttons.4 = 1 Then Set Acc_y.0
If Buttons.5 = 1 Then Set Acc_y.1
If Buttons.6 = 1 Then Set Acc_z.0
If Buttons.7 = 1 Then Set Acc_z.1
')
Return

Getkeys:
' Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portb.7 , Db7 = Portb.1 , E = Portb.0 , Rs = Portc.6

Tasten = 0

Config Pinc.4 = Input
Config Pinc.5 = Input
Config Pinb.7 = Input
Config Pinb.1 = Input
Config Pinc.6 = Input

Set Portc.4
Set Portc.5
Set Portb.7
Set Portb.1
Set Portc.6

If Pinc.4 = 0 Then Set Tasten.3
If Pinc.5 = 0 Then Set Tasten.2
If Pinb.7 = 0 Then Set Tasten.1
If Pinb.1 = 0 Then Set Tasten.0
If Pinc.6 = 0 Then Set Tasten.4

Reset Portc.4
Reset Portc.5
Reset Portb.7
Reset Portb.1
Reset Portc.6

Config Pinc.4 = Output
Config Pinc.5 = Output
Config Pinb.7 = Output
Config Pinb.1 = Output
Config Pinc.6 = Output

Return
Damit beende ich mein kleines Bascom-Gastspiel und verkrümmel mich wieder in meine C-Ecke. Viel Spass und Erfolg beim Nachbau.

Gruß

mic

[MrTaco]

Wenn ich den Atmega8 (5 Volt) mit den Nunchuck (3.3 Volt ) verbinden will könnte ich das doch wie hier im Bild. An den Wiederständen steht 3k3 oder 1k8 .
Also 3k und 1k ist klar doch was ist diese 3 und 8 ???

[BlaueLed]

Hi,

3k3 bedeutet 3,3k und 1k8 bedeutet 1,8k.

mfg Kay

[radbruch]

Hallo

Wenn man weiß wie es funktioniert klappt das auch mit der orginalen RP6-TWI-Library in C:

// WII-Nunchuk am RP6 erste Versuche mit TWI in C 8.8.2008 mic

#include "rblib.h"
#include "rblib.c"
#include "rblcdlib.c"
#include "RP6I2CmasterTWI.h"
#include "RP6I2CmasterTWI.c"

uint8_t i=0; // Hilfsvariable
uint8_t nunchuk_data[6]; // Nunchuk-Daten

void lcd_start(void)
{
lcd_init(); // lcd initialisieren
lcd_cls(); // lcd Inhalt löschen
lcd_locate(2,0);
lcd_writeString("RP6 ROBOT SYSTEM");
lcd_locate(1,1);
lcd_writeString("WII-Nunchuk am RP6");
}
void lcd_ausgabe(void)
{
lcd_locate(2,2);
for(i=0; i<5; i++)
{
lcd_writeInteger((nunchuk_data[i] ^ 0x17) + 0x17, 16);
lcd_writeString(" ");
}
lcd_writeInteger(((nunchuk_data[i] ^ 0x17) + 0x17) & 3, 16);

lcd_locate(2,3);
lcd_writeString("Tasten: ");
lcd_writeInteger(128+lcd_getkeys(), 2);
}

int main(void)
{
rblib_init(); // rblib initialisieren

I2CTWI_initMaster(400); // TWI mit 400kHz initialisieren
I2CTWI_transmit2Bytes(0xa4, 0x40, 0); // Nunchuk Speicheradresse setzen

lcd_start(); // LCD-Startbildschirm darstellen
while(1)
{
I2CTWI_transmitByte(0xa4, 0); // Datenlesemodus starten
I2CTWI_readBytes(0xa5, &nunchuk_data[0], 6); // sechs Bytes lesen

for(i=0; i<5; i++)
{
writeInteger((nunchuk_data[i] ^ 0x17) + 0x17, 16);
writeString(" ");
}
writeInteger(((nunchuk_data[i] ^ 0x17) + 0x17) & 3, 16);
writeString("\n");

lcd_ausgabe();
delay_ms(50);
}
return(0);
}

Die Ausgabe dazu sind die sechs Daten-Bytes des Nunchuk:

Terminal cleared!

7c 81 76 84 dc 3
7c 81 7a 8c df 3
7c 81 82 8e dc 3
7c 81 83 8a dc 3
7c 81 7d 8c df 3
7c 81 6f 8c dd 3
7b 81 4b 7f c2 3
7b 81 42 79 a7 3
7b 81 3f 79 ab 3
7b 81 4b 82 d3 3
7b 81 88 8d db 3
7c 81 af 7d b1 3
7c 81 ab 6e 91 3
7c 80 a0 7b b5 3
7b 80 8b a7 c0 3
7b 80 91 bc a8 3
7b 80 85 c1 a8 3
7b 80 86 b2 cb 3
7b 80 81 7e de 3
7b 80 7b 58 aa 3
7b 80 76 57 bf 3
7b 80 8e 88 dc 3
7b 81 93 8f d9 3
78 81 89 8f d6 3
4f 7f 87 91 db 3
1b 7d 85 90 dd 3
1b 7e 86 90 dd 3
1b 7e 82 90 dc 3
1b 7e 82 90 dc 3
7a 81 83 91 dd 3
7b 81 84 8f dc 3
80 80 85 8f db 3
a5 7d 86 8f db 3
df 80 86 8f dc 3
df 7f 85 8f dc 3
df 7f 88 8f db 3
df 7f 88 90 db 3
79 81 87 8e db 3
7a 80 86 8e db 3
78 a0 86 8f dc 3
71 d5 84 8e db 3
71 df 87 8d dc 3
71 df 85 8d dd 3
71 df 86 8e dd 3
7a 81 85 8d dd 3
7a 81 85 8c dd 3
80 79 85 8c db 3
82 3d 84 8c dc 3
83 22 85 8c dc 3
82 21 85 8c dc 3
81 20 84 8c dc 3
80 1f 86 8c dc 3
7a 81 84 8c dc 3
7a 81 86 8d dd 3
7a 81 81 8b db 3
7a 81 7e 8b db 3
7a 81 7d 87 db 3
7a 81 7e 8a df 3
7a 81 81 8a dc 3

[RP6BOOT]

[READY]

Echt einfach.

Gruß

mic

[Bluesmash]

Hallo zusammen

Anstatt einen neuen Tread anzufangen schreibe ich hier weiter.

Erstmal ein grosses dankeschön an Radbruch. Dank deiner Entwicklungsarbeit funktioniert das auslesen des Nunchuk einwandfrei!

Nun zu meinem Problem:
Ich habe das Nunchuk an den I2C Bus meines Hexas gehängt. Wenn ich ein kleines Programm schreibe welches nur das Nunchuk ausliest funktioniert es einwandfrei (5 weitere I2C Teilnehmer hängen auch am Bus werden aber nicht angesprochen).
Wenn ich jetzt aber das Nunchuk Programm in meinen kompletten Hexacode einbaue stürzt der Bus ab und mein Mastercontroller bleibt einfach stehen und macht nix mehr.
Hat jemand das Nunchuk schon einmal zusammen mit anderen Busteilnehmern getestet? Das Nunchuk hat eigene 1k8 Pullup Widerstände für den I2C Bus eingebaut, ich habe diese mal ausgelötet da ich am Master ja schon Widerstände habe, dies hat aber nichts gebracht.

Hat jemand eine Idee warum der Bus abstürzt? hat schonmal jemand das Nunchuk zusammen mit anderen I2C Teilnehmern verwendet?

gruss Bluesmash

[m.a.r.v.i.n]

Hallo Bluesmash,

direkt probiert hatte ich das zwar noch nicht, hatte das aber bei meiner Anpass-Schaltung berücksichtigt. Das sollte aber funktionieren, die Schaltung stammt aus einer Philips Application note (http://www.nxp.com/acrobat_download/applicationnotes/AN10441_1.pdf).

http://farm4.static.flickr.com/3110/2660878560_928cfecd7b_o.jpg

Es müssen nur alle 5V I2C Bus Teilnehmer auf der rechten Seite angeschlossen werden, und alle 3V I2C Teilnehmer, wie der Nunchuk, auf der linken Seite. Wenn bei dir schon I2C Bus Pullup Widerstände am Controller bzw. am Nunchuk vorhanden sind, kannst du die Widerstände aus der Schaltung natürlich weglassen, dann brauchst du nur die beiden FETs. Den BSN10A gibt es z.B bei Conrad (http://www.conrad.de/goto.php?artikel=159204). Du brauchst aber auf jeden Fall I2C Pullups auf beiden Seiten (5V u. 3V) sonst funktioniert die Schaltung nicht.

Hier nochmal der Link zum cc2 Thread (http://www.cczwei-forum.de/cc2/thread.php?threadid=1785)

[Bluesmash]

Danke für den Schaltplan.
Ich habe zum testen das Nunchuk einfach an 5V gehängt, funktioniert ja auch aber wenn zusätzlich die anderen I2C Teilnehmer abgefragt werden bleibt der Mastercontroller einfach stehen und macht nix mehr....
Ich habe das Gefühl dass, das nunchuk bei der kommunikation mit anderen I2C Teilnehmern "durcheinander" kommt und den Bus blockiert und der Master bleibt dann auch stehen da die Kommunikation nicht weitergeht....

gruss Bluesmash

[m.a.r.v.i.n]

Hallo Bluesmash,

liegt vielleicht ein I2C Adressen Konflikt vor?

Ich probier das heute Abend mal aus. Den Aufbau habe ich hier noch rumliegen, zudem noch jede Menge I2C Peripherie, die ich zusätzlich dranhängen kann.

[Bluesmash]

nö das kann nicht sein, das nunchuk hat ja etwas mit 160 und meine Module haben die Adressen 2,4,6,10 und 12 (sind alles eigene Module mit M8/M168/M32)

Das währe Super wenn du dies mal testen könntest.

gruss Bluesmash

[m.a.r.v.i.n]

Hallo Bluesmash,

hier kann ich keinen Fehler feststellen. Ich kann einen PCF8574, einen DS1307 und ein 24C256 EEPROM zusammen mit dem Wii Nunchuk an einem I2C Bus ohne Fehler betreiben. Egal ob der Nunchuk mit 5V betrieben wird oder mit 3,3V.

[Bluesmash]

vielen dank für deine mühe! ich bin jetzt auch wieder seit 2h am testen. momentan sieht es so aus dass,das nunchuk nur eingesteckt sein muss damit der bus abstürzt... es muss nicht einmal abgefragt werden... ich vermute jetzt langsam die 5V stromversorgung... werde mal meinen oskar rufen...

gruss Buesmash

[Bluesmash]

Hilft alles nix.. :( hab jetzt extra noch nen 100nF Kerko und 220uF Elko an die Spannungsversorgung des Nunchuk gehängt, hat aber nichts gebracht...
wenn ich es so nicht hinbringe, muss ich halt nen "i2C to I2C" Adapter basteln ;)

gruss Bluesmash

[m.a.r.v.i.n]

Hallo,

hast du mal versucht zusätzliche delays zwischen die i2c Übertragungen einzubauen? Vielleichts hilft das ja.

[Bluesmash]

Habe ich leider auch schon versucht... leider ohne Erfolg... :(

gruss Bluesmash

[m.a.r.v.i.n]

Hallo,

mir ist noch etwas eingefallen. Du verwendest als I2C Adressen 2,4,6,8. Diese Adressen sind laut Wiki reserviert. Gültige I2C Adressen müssen zwischen 0x10 und 0xEF liegen.

[Bluesmash]

Danke für den Tipp! werde es heute Abend mal ausprobieren, und die Adressen in den gültigen Bereich verschieben. Gestern war ich soweit dass der Betrieb immer so ca. 2-8sec funktionierte, danach hat sich irgendwie der Bus und der Master aufgehängt und machte nix mehr...

gruss Bluesmash

[Bluesmash]

So jetzt läuft es (fast) einwandfrei :)
Ich habe die Adressen auf 100-112 verschoben, dies brachte aber keine Verbesserung. Aber dank deinem Versuch (nochmals ein herzliches dankeschön!) wusste ich dass irgendwas an meine Programm nicht ganz sauber ist. Ich habe es jetzt mal ein bisschen umgestrikt und noch vor jeder I2C übertragung ein delay von 200us gemacht und jetzt läuft es recht gut. der Bus hängt sich nur noch sehr selten auf...
Es macht riesigen Spass den Hexa mit dem Nunchuk zu steuern :)

Ich habe jetzt aber noch ein anderes Problem... ich habe mir noch ein Wireless Nunchuk von nyko gekauft, in der Annahme dass dieses ja eigentlich genau gleich angesteuert werden muss. Das Auslesen der Daten funktionert grundsätzlich, der Wireless Adapter antwortet auch. Aber leider erhalte ich für alle Werte 0. Da der Wireless Adapter den Funkteil für die Übertragung zum Nunchuk nicht einschaltet....
Wenn ich den Adapter an die Wiimote anstöpsle fängt eine Blaue Led am Nunchuk empfänger an zu blinken und sobald das nunchuk erkannt wurde Leuchtet sie konstant blau. Doch wenn ich den Adapter an meinen M32 anschliesse kann ich die Daten auslesen (alle Daten immer 0) aber die Led fängt nicht an zu blinken :( da muss es wohl noch irgend ein Kommando geben welches den Funkteil des Adapaters einschaltet, nur wie finde ich dieses Kommando heraus? Oder kennt Jemand dieses Kommando?

gruss Bluesmash

[-tomas-]

Hallo,

ich habe mir eine (Original) Nunchuk gekauft und bekomme Sie partout nicht zum laufen.

Zwischenstand:
Spannung: 3,3V
Stromverbrauch (Ruhe): 1,7mA
I2C Pullup: 10kohm (ist egal - siehe unten)

Messungen haben ergeben, dass der CLK-Eingang(!!) der Nunchuk derart niederohmig ist und auf High liegt, dass mein Master-µC (anderes Design als bei Euch) den Pegel nicht runtergezogen bekommt. Um den CLK-Pegel auf LOW zu ziehen müsste ich den Bus mit >1 mA treiben. Mein LOW-Pegel liegt bei 2,5V. Ihr verwendet einen Atmega. Der zieht den Pegel auf LOW problemlos bis 20mA.

An den externen Pullups liegt das nicht. Ich kann sie auch entfernen, da die Nunchuk auf High zieht.

Die Pin-Belegung ist klar. Ich habe auch mal das Board durchgemessen. Der ST Microelectronics LIS3L02AL Beschleunigungssensor hat Spannung und liefert auch Analogwerte. Am TQFP48-µC habe ich kein PIN gefunden, an dem irgendein Clock-Signal messbar war - das hat aber nichts zu sagen, da das Board nur Analog-Sensoren besitzt.

Bevor ich jetzt weiter herumfummel und einen I2C-Treiberstufe für meinen µC bastel, um den Bus mit 8mA zu treiben oder ein Atmega-Board zusammenstecke:

Kann mir jemand dieses ungewöhnliche I2C-Verhalten bestätigen? Ich habe noch nie erlebt, dass ein so kurzer I2C-Bus so niederohmig ausgelegt wurde.
EDIT: siehe unten, das Problem sind die Eingangsschutzwiderstände des µC

Muss man erst die Nunchuk aufwecken (schütteln, Taste etc)?

Wie hoch ist Euer Ruhestrom?

Ich habe keine Wii, so dass ich keinen Funktionstest der Nunchuk machen kann.

[Bluesmash]

Hallo!

Also das Nunchuk hat nach meinen Messungen Pullup-Widerstände im Bereich von ca. 1,8kOhm ich habe sie auch ausgelötet und an meinem Master 10kOhm Pullups verwendet...
Die Pullups sind beim Nunchuk in der Nähe wo die Anschlusskabel angelötet sind.
vielleicht hilft dir das weiter...

gruss Bluesmash

--Edit--
Das Nunchuk muss nicht aufgeweckt werden. einfach Spannung dran und auslesen...

[-tomas-]

Danke für den Tip.

Ich habe mir mal das Board-Layout angesehen, vor dem ich sitze:
Lego hat bei dem NXT die Eingänge des Atmega48 mit 4,7k geschützt und gibt eine Pullup-Empfehlung von 82k heraus.
Lego NXT Hardware Developer Kit (HDK) (http://cache.lego.com/upload/contentTemplating/MindstormsOverview/otherfiles/2057/LEGO%20MINDSTORMS%20NXT%20Hardware%20Developer%20K it(3)_7A0CF630-CCE5-4AAF-91FA-D1E7C911817C.zip)

Wenn der Nunchuk Pullups von 1,8k verwendet, kann der NXT den 3,3V-Bus nur noch auf 3,3*4,7/6,5=2,4V herunterziehen. Das entspricht meiner Messung.
Dann passt alles zusammen.
Ich fummel weiter...

[silas]

Ist zwar schon älter der Thread, aber ich wollte keinen neuen aufmachen.

Ich bin grade beim Bau eines Rasenmäh Roboters, und suche noch nach einer Handsteuerung. Da bin ich auf diesen Thread hier gestoßen.
Der Nunchuck ist echt spitze (spiele ab und zu Wii). Ich würde ihn gern auf meinem Bot einrasten und als Neigungssensor verwenden, aber auch rausnehmem können, zum Steuern im Handbetrieb.
Bei Handbetrieb wäre ja ein wireless Nunchuck nicht schlecht. Hat den schon jemand am laufen. Ich will mir so ein Ding bald bestellen, damit ich meinen Mähbot mal fahren lassen kann.
Bitte schnelle Antwort!

Silas

[radbruch]

Bitte schnelle Antwort! Ja klar, sende mir bitte einen wireless Nunchuk zur Ansicht.

Ich vermute, der wireless Nunchuk funktioniert mit Bluetooth (http://lmgtfy.com/?q=nunchuk+avr+bluetooth+)

[justin]

Hallo

Ich seh den Thread auch gerade erst. Das scheint ja wirklich praktisch zu sein. Könnt mir irgendjemand mal sagen, wie groß die Platine von Nunchuck ist?(am besten mit Foto) Ich würd das nämlich gerne anstatt nem ADXL330 - der ja mit Versand und Adapterplatine(smd auf Lochrster löten kann ich nicht :wink: ) bald das selbe kostet - verwenden. Nur zu groß dürfts halt nicht sein. Wär sehr nett, wenn mir da jemand weiterhelfen könnte.

Gruß Justin

[silas]

Ich hab halt noch keinen, da ich nicht weis, ob der kabellose nun zu betreiben geht. Bluesmash hats ja schon versucht, ohne Erfolg (also fals doch, noch nicht Berichtet).
Kabelgebunden würde ich dann mit einer Ringel-Telefonleitung machen.
Wenn ich von der Außengröße von meinem Schwiegervater seiner Wii ausgehe, müßte die Platine nicht größer als 3x6cm sein.

[Bluesmash]

hallo zusammen

nach den fehlversuchen mit dem kabellosen nunchuck habe ich es nicht mehr weiter verfolgt... und ich habe es auch nicht zum laufen gebracht...

gruss bluesmash

[silas]

schade.

Ich habe noch was schönes gefunden
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1215475673
So kann man auch einen Wireless draus machen. Da sieht man auch die Platine im Inneren.
Also wirds bei mir auch nur einer mit Kabel (mit Umbauoption)

[stefan_Z]

Der Wireless Nunchuck hat doch auch nur einen Stecker, der in die WiiMote kommt.
Die Funkstrecke interessiert daher nicht, ist garantiert wieder I2C am Stecker... Ggfs. musst du die I2C Adresse anpassen.
Den normalen Nunchuck habe ich ohne Probleme angesteuert:
http://www.ledstyles.de/fpost131515.html
Vorlage war hier aus dem Forum: https://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=42153&start=22

[justin]

@silas: Danke

Ich denke, das wird von der größe her gerade gehen

[nospam2000]

Hallo Bluesmash,



nach den fehlversuchen mit dem kabellosen nunchuck habe ich es nicht mehr weiter verfolgt... und ich habe es auch nicht zum laufen gebracht...
gruss bluesmash

Ich habe vor zwei Wochen mal hier beschrieben, wie man das mit dem Wireless Nunchuck (und anderen Wii Controllern) zum laufen bekommt:
http://www.windmeadow.com/node/42#comment-3130

Der Code ist für die Arduino Umgebung geschrieben, lässt sich aber sehr leicht anpassen.

nospam2000

[Richard]

Hallo Bluesmash,



nach den fehlversuchen mit dem kabellosen nunchuck habe ich es nicht mehr weiter verfolgt... und ich habe es auch nicht zum laufen gebracht...
gruss bluesmash

Ich habe vor zwei Wochen mal hier beschrieben, wie man das mit dem Wireless Nunchuck (und anderen Wii Controllern) zum laufen bekommt:
http://www.windmeadow.com/node/42#comment-3130

Der Code ist für die Arduino Umgebung geschrieben, lässt sich aber sehr leicht anpassen.

nospam2000

Kennt jemand zufällig eine ähnlich gute beschreibung in Deutsch?
ich besitze eine WII und würde diese gerne mit nen AVR auswerten.
Wenn möglich ohne die WII zu "schlachten".

Gruß Richard

[nospam2000]

Hallo Richard,


Kennt jemand zufällig eine ähnlich gute beschreibung in Deutsch?
ich besitze eine WII und würde diese gerne mit nen AVR auswerten.
Wenn möglich ohne die WII zu "schlachten".


Die Wii Fernbedienung selbst arbeitet mit Bluetooth und dem HID Profile. Um das mit einem AVR auszuwerten musst du schon einiges für die Bluetooth Hardware und Programmierung des HID Profils (Server Seite) investieren. Mit dem PC ist das kein Problem, da gibt es spezielle Treiber.

Die Controller, welche an die Wii Fernbedienung angeschlossen werden (z.B. Nunchuck), arbeiten mit I2C und sind daher einfacher in der Verwendung mit dem AVR.

95% zu dem Thema werden in entweder in englisch oder in C/C++ sein. Wenn Du dir den Sourcecode unter http://www.windmeadow.com/node/42#comment-3130 ab "The whole code put together:" anschaust, sollte schon einiges klar werden.

Hier die Beschreibung für den Nunchuck:
1. Kommunikation über I2C (TWI) mit 400 kHz

2. Initialisierung und Ausschalten der Verschlüsselung (in Funktion nunchuck_init()):
Teil 1:
I2C Adresse: 0x52
Register Adresse: 0xF0
Daten: 0x55
Teil 2:
I2C Adresse: 0x52
Register Adresse: 0xFB
Daten: 0x00

3. zyklisch 6 Bytes über I2C lesen
I2C Adresse: 0x52
Register Adresse: 0x00

4. Die 6 Bytes auswerten
a) Rohdaten extrahieren (siehe Tabelle unter http://wiibrew.org/wiki/Wiimote/Extension_Controllers#Nunchuk):
Buttons
Joystick
Beschleunigungs-Sensoren
b) Werte der Beschleunigungswerte umrechnen
Erdbeschleunigung für Orientierung (Ruhelage)
Beschleunigungsrichtung- und Betrag der Bewegung

Kalibrierungswerte (Nullpunkte) für Joystick und Beschleunigung müssen ermittelt und verwendet werden.

Michael

[holzi]

Guten Morgen Richard,
schau mal hier, wie ich das gemacht habe:
https://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=49390&highlight=
Ich benutze mit Absicht die serielle Schnittstelle, damit die Wii bzw. der Nunchuk nicht fest mit dem Controller verbunden ist und somit eine gewisse Freiheit gegeben ist. Mittlerweile fliege ich mein Modell mit Nunchuk.

Gruß Peter

[dirtyklaus]

Frage zum Nunchup I2C Interface:

Habe einen RN-Mini (mega168) und den Nunchuk zusammengeschaltet. Der Nunchuk bekommt genau 3,66 V (2 Dioden in Plus geschaltet - zur Spannungsabsenkung + Elko).
Als Konverter der I2C Spannungen habe ich obigen Schaltplan (mit den 2 FETs BSN10A nachgebaut). Die Software ist der letzte Stand aus diesem Thread.

Auf der RN-Mini Seite sind ja schon 2x10K Pullups vorhanden. Auf der Nunchuck seite sind wahrscheinlich im Nunchuk auch schon Pullups.

D.h. Die Philips schaltung besteht nur aus den beiden FETs.

Alles läuft wunderbar, aber nach einiger Zeit (1-3 minuten) läuft gar nichts mehr - keine Auslesung der Werte mehr.

Hatte vorher schon mal die Pullups auf den Nunchuk Seite eingelötet (2x 4,7k) aber damit lief nichts - alle Werte nur konstant 255.

Nebenbei ist sonst nichts am I2C Bus. Das kommt später noch...

Jetzt weiß ich auch nicht mehr weiter - löte ich die Nunchuck Pullups ein, dann geht nichts. lasse ich sie weg, dann geht nach einiger Zeit nichts.

Woran kann das liegen?

Anm: habe schon mal einen 4700müF an die 3,66 V gehängt - war auch nicht besser.
habe verschiedene Delay eingebaut - auch nicht besser.

[justin]

Was ich noch fragen(/sagen) wollte:
Kann man nicht einfach die Pullups vom Nunchuk auslöten, den Nunchuck mit 3,3V versorgen und als Pegel für Clk und DAT auf 5V lassen? Es ist doch alles Opendrain und müsste deswegen etwas mehr Spannung vertragen.

[dirtyklaus]

Ich verstehe es auch nicht ganz. Eigendlich ist alles opencollector und sollte nur auf 0 gezogen werden um keine 1 zu sein. das sollte auch bei den unterschiedlichen Spannungen funktionieren.

Mittlerweile habe ich noch die Spannung auf 3,4 Volt stabilisiert - also nicht einfach 2 Dioden - sondern geregelt. Klappt aber auch nicht.

Komischerweise habe ich die gleiche Schaltung ein zweites mal (mit den FETs und den stabilen 3,4V) auch an meinem RN-control MEGA32 gebaut - und dort laufen die Daten vom Nunchuk ohne Ende.
Den Unterschied verstehe ich nicht. Scheint Hardware zu sein. Beim Mega168 ist nach spätestens 1 min Schluss mit den Daten vom Nunchuk und alles steht still bis RESET.

Cooler wäre aber der Mega168 - ist halt kleiner als der 32.

[Thomas$]

@radbruch das weiße kabel ist an analog pin 5 oder? und das grüne an 4

[radbruch]

Hallo

Ähm, da muss ich jetzt echt passen. Das war vor über einem Jahr und ich hatte den Nunchuk ungeöffnet mit Stecker verwendet:
http://radbruch.roboterbastler.de/rp6/nunchuk/nunchuk-adapter_klein.jpg (http://radbruch.roboterbastler.de/rp6/nunchuk/nunchuk-adapter.jpg)
(Bild aus: https://www.roboternetz.de/phpBB2/viewtopic.php?p=389157#389157)

Ich vermute, du meinst die TWI/I2C-Pins auf dem RP6-Board. Dort ist Pin 5 der Interrupteingang der beim Nunchuk-Anschluss nicht verwendet wird. Benötigt werden, neben VDD und GND, noch SDA (Pin3) und SCL(Pin4). Die Belegung des Nunchukkabels findet man z.B. hier:
http://todbot.com/blog/2007/10/25/boarduino-wii-nunchuck-servo

Allerdings muss man hier etwas um die Ecke denken:
Das Arduino-Board läuft mit einem Mega8 (glaube ich) und bei diesem sind die SDA/SCL-Pins die Eingänge PC4/5 oder eben ADC4 und 5. Es würde sich dann diese Anschlussbelegung ergeben:

rot - VDD (RP6 Pin1, XBUS 3/5)
weis - GND (RP6 Pin2, XBUS 1/2/14)
grün - SDA (RP6 Pin3, XBUS 12)
gelb - SCL (RP6 Pin4, XBUS 10)
(Angaben natürlich ohne Gewähr)

Viel Erfolg

mic

[Thomas$]

deine angaben stimmen ich hatte mich irgendwie verguckt und weiß und gelb verwechselt da ging natürlich nichts und zum glück auch nichts kaput es geht jetzt jedenfals auch bei mir. ich hab den arduino mit nem atmega 328 und usb

[Bammel]

Hallo,

ich habe mir gerade einen nunchuk demontiert und an meinem bot angeschlossen. ich möchte den joystick und die buttons für die spätere menüführung nutzen und den beschleunigungssensor um die lage bestimmen zu können. das ganze erstmal alles experimentel habe noch nie mit beschleunigungssensoren gearbeitet.

nun habe ich das program ein wenig meinen bedürfnissen angepasst (lcd anzeige) der kern ist der selbe. die werte vom nunchuk lasse ich mir dezimal anzeigen.

beim joystick passt alle von einem anschlag zum anderen reichen die werte von 5 - 255 - alles okay

bei den beschleunigungssensor allerdingt bekomme ich schon bei einem winkel von 45° den vollausschlag - wert: 255 - und das in alle drei achsen. wird da evtl ein word oder 10bit ausgegeben?

zudem wenn ich C und Z gleichzeitig drücke stürzt der bus ab.

habe den nunchuck über 5volt mit spannungsteile an 3,4volt angeschlossen und an den I2C leitungen habe ich nicht gemacht. muss ich umbedingt so ein levelshifter einbauen?

über den spannungteiler habe ich es auch nur gemacht da ich keinen festspannungsregler für 3,3volt da habe das soll aber sowieso noch auf meinen bot mit rauf.

freundlicher gruß, Bammel

[Coleone]

Ich versuche jetzt schon seit gestern Mittag das Nunchuck auszulesen, aber ich bekomme immer nur die 255 ausgegeben. Habe jetzt schon viel ausprobiert, aber immer das gleiche ergebnis. Was ich halt nicht verstehe, ist das es bei anderen mit diesem beispielscode ja zu funktionieren scheint.

Hoffe mir kann hier jemand weiter helfen


$regfile = "m168def.dat"
$crystal = 20000000
$baud = 9600

$lib "i2c_twi.lbx" ' Für Hardware TWI

Config Scl = Portc.5 ' Ports fuer IIC-Bus
Config Sda = Portc.4


Config Twi = 400000 ' Init TWBR und TWSR

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen

Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5

Dim Buffer(6) As Byte
Dim B As Byte
Dim Tmp As Byte

' Startausgabe
Print
Print "I2C-TWI Demo mit Wii Nunchuck"
Print

Gosub Nunchuck_init
Gosub Send_zero

Do
Buffer(1) = 0

I2creceive Nunchuck_read , Buffer(1) , 0 , 6
'Print Err

For B = 1 To 6


Tmp = Buffer(b) Xor &H17
Tmp = Tmp + &H17

Print B ; ": " ; Tmp ; " ";

Buffer(b) = 0 ' löschen

Next B

Gosub Send_zero

Print

Waitms 500
Loop

End

Nunchuck_init:
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40 ' sends memory address
I2cwbyte &H00 ' sends sent a zero.
I2cstop

Return

Send_zero:

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00 ' sends one byte
I2cstop

Return

[radbruch]

Hallo

Deins:

$lib "i2c_twi.lbx" ' Für Hardware TWI

Config Scl = Portc.5 ' Ports fuer IIC-Bus
Config Sda = Portc.4


Config Twi = 400000 ' Init TWBR und TWSR

' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen


Meins:

$lib "i2c_twi.lbx" ' Für Hardware TWI
Config Scl = Portc.0 ' Ports fuer IIC-Bus
Config Sda = Portc.1
Config Twi = 400000 ' Init TWBR und TWSR
I2cinit
' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100 ' nur TWEN setzen


Wo ist dein I2cinit?

Die Pause zwischen dem Initialisieren und dem Auslesen der I2C-Daten ist wichtig:

Gosub Nunchuck_init
Waitms 1000
Gosub Nunchuk_read

Das war die letzte und funktionierende Version:
https://www.roboternetz.de/phpBB2/viewtopic.php?p=389966#389966

Gruß

mic

[Coleone]

Danke schonmal für die schnelle Antwort!

Hmm, ja das I2Cinit ist mir wohl unter den Tisch gefallen, aber wenn mich jetzt nicht alles Täuscht (was durchaus sein kann, ich hab heut nacht nur noch bascom code vor augen gehabt), dann fehlt das in deinem Code den du damals gepostet hast, aber auch.

Ich habe jetzt aber wo anders einen funktionierenden Code gefunden, der bei mir auf Anhieb funktionierte. Ich hab das I2cinit in deinem mal schnell eingefügt, aber da hats auch nicht funktioniert, ich versteh das grad einfach nicht.

Aber hier mal der Code der funktioniert, ich werde jetzt nur die auswertung ändern, da ich eigentlich einen Classic Controller verwenden möchte


$regfile = "m168def.dat"
$crystal = 20000000
$baud = 9600
$hwstack = 64
$swstack = 64
$framesize = 64

$lib "i2c_twi.lbx"


Config Scl = Portc.5
Config Sda = Portc.4
Config Twi = 100000
I2cinit

Const Nunchuck_write = &HA4
Const Nunchuck_read = &HA5

Dim Buffer(16) As Byte
Dim Joy_x As Byte
Dim Joy_y As Byte
Dim Accel_x As Integer
Dim Accel_y As Integer
Dim Accel_z As Integer
Dim Buttons As Byte
Dim But_c As Byte
Dim But_z As Byte


Waitms 250
Print "Nunchack Init"
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40
If Err <> 0 Then
Print "Error data sending"
End If
I2cwbyte &H00
If Err <> 0 Then
Print "Error data sending"
End If
I2cstop
If Err <> 0 Then
Print "Error IC2 Stop"
End If
Waitms 250

Print "Nunchack Init finished"
Waitms 250
Print "Nunchuck active"

Do
Gosub Nunchuk_read
Print Accel_x ; "," ; Accel_y , ; "," ; Accel_z ; "," ; Joy_x ; "," ; Joy_y ; "," ; Buttons.0 ; "," ; Buttons.1

Waitms 500
Loop

End

Nunchuk_read:
Dim I As Byte
Dim Tmp As Byte

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00
If Err <> 0 Then
Print "Error data sending"
End If
I2cstop

Waitms 5
Buffer(1) = 0
I2creceive Nunchuck_read , Buffer(1) , 0 , 6
If Err <> 0 Then
Print "Error data receving"
End If

For I = 1 To 6
Tmp = Buffer(i) Xor &H17
Tmp = Tmp + &H17
Buffer(i) = Tmp
Next I

Joy_x = Buffer(1)
Joy_y = Buffer(2)
Accel_x = Buffer(3) * 4
Accel_y = Buffer(4) * 4
Accel_z = Buffer(5) * 4

Buttons = Buffer(6)

If Buttons.2 = 1 Then Accel_x = Accel_x + 1
If Buttons.3 = 1 Then Accel_x = Accel_x + 2
If Buttons.4 = 1 Then Accel_y = Accel_y + 1
If Buttons.5 = 1 Then Accel_y = Accel_y + 2
If Buttons.6 = 1 Then Accel_z = Accel_z + 1
If Buttons.7 = 1 Then Accel_z = Accel_z + 2

Return

[Matahalii]

Hallo Leute!
Ich bin neu hier und hab mir so einiges angelesen, programmiert und so...
Klasse Sache so ein Atmel!
Bisher haben meine Programme alle funktioniert. nun hab ich mir mal den Nunchuk vorgenommen. Ich hab vor, ihn als Steuerung für Roboter etc zu verwenden.So weit bin ich noch lange nicht, erstmal muss das Ding Werte liefern, mit denen man arbeiten kann.
Irgendwas mach ich falsch. Sämtliche versionen des Programms aus dem Thread hab ich durch. Es kommen keine Werte an!

Hier der letztgenannte Code, ein wenig abgeändert.
An Port D hingen eh einige LEDs rum. Die CLK und DAT hab ich an Port D 4/5 Wahlweise wird mit Levelshifter und 3,3V oder ohne Levelshifter und mit 5,0V getestet. Ergebnis immer gleich.



$regfile = "m32def.dat"
$crystal = 16000000
$baud = 9600
$hwstack = 32
$swstack = 32
$framesize = 32

$lib "i2c_twi.lbx"

Config Portd.4 = Output ' Port d.4/5/6 LEDs - für Startsequenz / Statusanzeige
Config Portd.5 = Output '
Config Portd.6 = Output


Config Scl = Portc.5
Config Sda = Portc.4
Config Twi = 100000
I2cinit

Const Nunchuck_write = &HA4
Const Nunchuck_read = &HA5

Dim Buffer(16) As Byte
Dim Joy_x As Byte
Dim Joy_y As Byte
Dim Accel_x As Integer
Dim Accel_y As Integer
Dim Accel_z As Integer
Dim Buttons As Byte
Dim But_c As Byte
Dim But_z As Byte


Waitms 250

' Startausgabe
Portd.4 = 1 'alle LED aus
Portd.5 = 1
Portd.6 = 1
Waitms 5000 'led nacheinander einschalten
Portd.4 = 0
Waitms 500
Portd.5 = 0
Waitms 500
Portd.6 = 0

Print "--- nunchuk ---"
Print " "
Print "Nunchuk Init"
I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H40
If Err <> 0 Then
Print "Error data sending"
End If
I2cwbyte &H00
If Err <> 0 Then
Print "Error data sending"
End If
I2cstop
If Err <> 0 Then
Print "Error IC2 Stop"
End If
Waitms 250

Print "Nunchack Init finished"
Waitms 250
Print "Nunchuck active"

Do
Gosub Nunchuk_read
Print Accel_x ; "," ; Accel_y , ; "," ; Accel_z ; "," ; Joy_x ; "," ; Joy_y ; "," ; Buttons.0 ; "," ; Buttons.1

Waitms 500
Loop

End

Nunchuk_read:
Dim I As Byte
Dim Tmp As Byte

I2cstart
I2cwbyte Nunchuck_write
I2cwbyte &H00
If Err <> 0 Then
Print "Error data sending"
End If
I2cstop

Waitms 5
Buffer(1) = 0
I2creceive Nunchuck_read , Buffer(1) , 0 , 6
If Err <> 0 Then
Print "Error data receving"
End If

For I = 1 To 6
Tmp = Buffer(i) Xor &H17
Tmp = Tmp + &H17
Buffer(i) = Tmp
Next I

Joy_x = Buffer(1)
Joy_y = Buffer(2)
Accel_x = Buffer(3) * 4
Accel_y = Buffer(4) * 4
Accel_z = Buffer(5) * 4

Buttons = Buffer(6)

If Buttons.2 = 1 Then Accel_x = Accel_x + 1
If Buttons.3 = 1 Then Accel_x = Accel_x + 2
If Buttons.4 = 1 Then Accel_y = Accel_y + 1
If Buttons.5 = 1 Then Accel_y = Accel_y + 2
If Buttons.6 = 1 Then Accel_z = Accel_z + 1
If Buttons.7 = 1 Then Accel_z = Accel_z + 2

Return

und DAS kommt im Terminal an:



Nunchuk Init
Error data sending
Error data sending
Error IC2 Stop
Nunchack Init finished
Nunchuck active
Error data sending


Es scheint NICHTS zu funktionieren. Warum?
JTAG ist ausgefust, sonst gingen die i2C-Ports nicht.
Der Nunchuk ist per Isakartenadapter angeschlossen. Sowohl mit Levelshifter als auch ohne ist das Ergebnis gleich.

[Matahalii]

Au Weia!
Jetzt gehts. Ich hab mal die Datenblätter der Chips verglichen. Beim Atmega32 liegen die L2C / TWI Pins auf C0 und C1
und ich wundere mich warum in vielen Codes das schon auskommentiert drin steht----- AUA!
nun fliessen die Daten und alles ist plüschi!

Matahalii

[High Light]

Hallo zusammen,

wenn ich einen Wii Nunchuk Wireless verwenden möchte,
kann ich dann den BASCOM - Code genau so verwenden,
oder muss ich Änderungen durchführen?

Grüße High Light

[High Light]

1 Jahr ist es zwar schon her, aber weiß es denn keiner???

Grüße High Light

[tbasnoopy]

Hast dus in dem Jahr mal ausprobiert?

[High Light]

Nein, habe ich noch nicht, sonst müsste ich nicht fragen...
Es wäre halt interesant zu wissen, denn es wäre nicht so toll, wenn ich mir einen mit Wireless kaufe und es dann nicht funktioniert!

[RAM]

Hallo Leute,

ich weiß, der Thread hier ist schon ewig alt, aber ich hol ihn doch nochmal raus aus der Versenkung :)
Ich habe das ganze vor kurzem nachgebaut und mit dem finalen Code auf Seite 3 getestet, alles funktioniert. Allerdings habe ich ein Verständnisproblem bei dem Code. Und zwar kann mir vielleicht jemand erklären was es damit auf sich hat:



Tmp = Buffer(1) Xor &H17
Tmp = Tmp + &H17
Pos_x = Tmp
Ich hatte bisher noch nichts mit dem I2C-Bus zu tun, würde aber gerne verstehen, was es mit dem Xor &H17 und der Addition auf sich hat.

[Klebwax]

Tmp = Buffer(1) Xor &H17
Tmp = Tmp + &H17
Pos_x = Tmp[/CODE]
Ich hatte bisher noch nichts mit dem I2C-Bus zu tun, würde aber gerne verstehen, was es mit dem Xor &H17 und der Addition auf sich hat.

Was bringt dich zu der Annahme, daß dieser Code etwas mit I2C zu tun hat?

MfG Klebwax

[RAM]

Hallo klebwax,

dass es nicht direkt etwas mit i2c zu tun hat sondern mit der Umwandlung der empfangenen Bytes ist mir klar, allerdings nicht, warum das ganze gemacht bzw. gebraucht wird.

[Klebwax]

Wenn man die richtigen Fragen stellt, wird die Antwort einfach. Google liefert bei "nunchuk 0x17" (die C-Notation für hex ist gängiger als Basic) Antworten, bei "i2c 0x17" nicht so wirklich was.

MfG Klebwax

[radbruch]

Warum man die Daten des Nunchuk mit 0x17 verknüpfen muss kann dir wohl nur Nintendo beantworten.

[RAM]

Ok, also ist das nur eine Eigenheit vom Nunchuk. Alles klar, danke für die Infos!