Druckbare Version
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/bo...unchuck-servo/
http://www.windmeadow.com/node/42
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.
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/Wiimo...ollers/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
Alles erklärt :-)
Habe aber leider nicht so viel wissen um das umzuformen
aber für ein paar Hilfen wäre ich super dankbar
Hallo,
Das Ding geht per I2C,
dazu könnte man von hier die Init-Routine verwenden:
https://www.roboternetz.de/wissen/in...r#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:
schaut aber interessant aus das Teil :-kCode:$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 "I2C-TWI Demo mit Wii Nunchuck"
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
Edit:
EOR/XOR Bug entfernt !
I2C-Adresse richtig
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)
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
Unter anderem den ja und den: http://www.shortnews.de/start.cfm?id=717965
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:
Bild hier
Und das Programm von linux_80 (danke) an den RP6 angepasst:
Die Ausgabe dazu in meinem Terminal:Code:'$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 "I2C-TWI Demo mit Wii Nunchuck"
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
Egal ob der Nunchuk eingesteckt ist oder nicht, die Werte sind immer gleich:(Zitat:
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]
Vielleicht könnten die TWI-Profis mal drüberschaun. Ich versuche es nun erstmal in C mit der TWI-Libray des RP6...
Gruß
mic
Also mit Bascom kenne ich mich leider nicht aus, aber gibts da nicht auch sowas wie I2CInit ?
Juhu!
Ich habe eine Ausgabe! Der "Fehler" war die Slave-Adresse:
(aus dem oben erwähnten wiili-wiki)Zitat:
The device address is "0x52" ("0xA4" in 8-bit addressing).
Nachdem ich nun die 8bit-Adresse eingetragen habe (k.A. was das bedeutet) erhalte ich Werte.Code:'Const Nunchuck_write = &H52 ' Slaveadresse
'Const Nunchuck_read = &H53
Const Nunchuck_write = &HA4 ' Slaveadresse
Const Nunchuck_read = &HA5
Das Nunchuck_init habe ich aus der Schleife genommen, denn sonst würde doch send_zero am Schleifenende überschrieben werden:
Hier die Ausgabe:Code:'$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 "I2C-TWI Demo mit Wii Nunchuck"
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 "------"
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
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 :)Zitat:
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]
Gruß
mic
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.
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
Kannst du keine Werte mehr einlesen oder wird nichts mehr ausgegeben?
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...
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?
Hallo
Basierend auf den Eingangs genannten Links:
Bild hier
Hier ist der Nunchuk an 5V angeschlossen, aber dazu steht noch die Warnung:
"Höhere Spannung könnte die Lebensdauer des Nunchuks verkürzen". Dazu kann ich keine Aussagen machen ;)Zitat:
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.
Gruß
mic
hier hab ich ein Netzteil für den Nunchuk
http://cgi.ebay.de/LED-Netzteil-3-3-...QQcmdZViewItem
Kann ich damit auch 2 nunchucks anschließen (parallel).
Das Netzteil ist schon etwas teuer kennt einer von euch ne biligere lösung.
@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.
Hi,
es gibt auch so tolle Spannungswandler Low Drop 3V3. Die machen aus
5V ---> 3,3Volt.
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:
Bild hier
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
Hallo,
im CC2-Forum 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
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:
Bild hier
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:
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...Code:'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 "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
Gruß
mic
Hallo,
dann scheint die Lösung ja schon brauchbar zu sein,
jetzt brauchts nur noch ein gescheites Problem dazu :mrgreen:
Hallo
Nun sind die Servos angeschlossen und werden wahlweise (Umschaltung mit Z/C) mit dem analogen Stick oder den Beschleunigungssensoren gesteuert:
Bild hier
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:
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...Code:'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 "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
Gruß
mic
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.
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:
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?Code: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
Hier noch der Testcode:
GrußCode: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
mic
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:
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 ;)Code: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
Gruß
mic
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?...m=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.
Hallo
Nachdem der "Bug" entfernt ist sieht es nun richtig klasse aus:
Bild hier
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:
Damit beende ich mein kleines Bascom-Gastspiel und verkrümmel mich wieder in meine C-Ecke. Viel Spass und Erfolg beim Nachbau.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 "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
Gruß
mic
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 ???
Hi,
3k3 bedeutet 3,3k und 1k8 bedeutet 1,8k.
mfg Kay
Hallo
Wenn man weiß wie es funktioniert klappt das auch mit der orginalen RP6-TWI-Library in C:
Die Ausgabe dazu sind die sechs Daten-Bytes des Nunchuk:Code:// 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);
}
Echt einfach.Code: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]
Gruß
mic
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
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.
Bild hier
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. 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
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
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.
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
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.
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