Hi Leute
ich hab angefangen mich mit dem I2C Bus zu beschäftigen. Mein
ATmega644p, I2C-Slave wird erkannt und lässt sich auf von dem Master
adressieren. Das Auslesen der Daten klappt auch, wenn ich ihm genau
sage, was in dem TWDR Register drinne stehen soll. Ich versteh
allerdings nicht ganz, wie das mit den buffer_adr funktioniert,
beziehungsweiße, wie ich ihm beibringen soll, welche buffer_adr die
richtige ist. Ich möchte gerne 8 Byte speichern. Ich hab schon testweiße
versucht den rxbuffer[0] und rxbuffer[0xff]auf den PORTD auszugeben, es
funktioniert aber nur, wenn ich direkt das TWDR Register auf den PORTD
ausgebe. Daher nehme ich an, dass das irgendwo gespeichert wird, warum
wird eigentlich die buffer_adr zuerst auf 0xFF gestellt?
Meine Interruptroutine sieht folgendermaßen aus.
Wäre echt super, wenn ihr mir sagen könntet, welchen rxbuffer ich
auslesen muss
lg Thomas
1
#define SLAVE_ADRESSE 0x70 // Slave-Adresse
2
3
4
//#################################### Macros
5
//ACK nach empfangenen Daten senden/ ACK nach gesendeten Daten erwarten
I2C_anfänger schrieb:> Ich versteh> allerdings nicht ganz, wie das mit den buffer_adr funktioniert
Wir auch nicht, du solltest also denjenigen fragen, der den Code
geschrieben hat. ;-)
Naja. Ein I²C-Slave arbeitet als zustandsgesteuerter Automat
(state machine). Abhängig vom aktuellen Zustand und dem empfangenen
Ereignis führt er eine Aktion aus, und danach wechselt er in einen
Zustand (der der gleiche sein kann wie der gegenwärtige). Da der
Slave sich nicht aussuchen kann, was ihm der Master schickt, muss
er in jedem Zustand in der Lage sein, auf die Anforderung des Masters
eine korrekte (möglicherweise unsinnige *) Antwort zu liefern.
Das Zustandsdiagramm, das deinem Protokoll entspricht, musst du dir
einfach mal aufmalen. Jedes I²C-Gerät verhält sich hier ja anders,
da es eine Vereinbarungssache zwischen Master und Slave ist, welches
Kommando wie zu behandeln ist usw.
(*) Eine unsinnige Antwort entsteht beispielsweise dann, wenn du keine
Daten mehr hast. Der Slave hat das zwar durch ein NACK in der
vorherigen Busphase bereits signalisiert, aber wenn der Master der
Meinung ist, dieses NACK zu ignorieren (was letztlich einen
Programmierfehler im Master darstellt), dann muss der Slave trotzdem
eine Antwort geben (wenn auch unsinnig, kann also bspw. 42 ausgeben ;),
er darf sich nicht "aufhängen", und wenn der Master im nächsten
Buszyklus ordentlich reagiert (bspw. dann die komplette Aktion
beendet), dann sollte er sich auch passend wieder zum Ausgangszustand
bewegen.
Einen Master (zumindest einen single master, d. h. es kann kein
Arbitrierungsverlust am Bus auftreten) kann man noch so "gerade
heraus" programmieren, da dieser die Zustandsübergänge am Bus ja
immer selbst festlegt. Bei einem Slave muss man sich immer um
das Zustandsdiagramm des Automaten im Klaren sein, bevor man ihn
zu programmieren beginnt.
I2C_anfänger schrieb:> in welche buffer_adr werden denn die Daten hineingeschrieben?>> das muss doch mit der 0 losgehen oder?
Da die Variblendefinition fehlen, wirst du das wohl selbst herausbkommen
müssen...
I2C_anfänger schrieb:> sage, was in dem TWDR Register drinne stehen soll. Ich versteh> allerdings nicht ganz, wie das mit den buffer_adr funktioniert,> beziehungsweiße, wie ich ihm beibringen soll, welche buffer_adr die> richtige ist.
Das muss der Sender mitteilen.
Diese Routinen implementieren einen I2C Speicher Baustein.
D.h. der Sender sendet, welche Adresse er gelesen/geschrieben haben
möchte. Und diese 'Adresse' landet dann in buffer_adr
> ausgebe. Daher nehme ich an, dass das irgendwo gespeichert wird, warum> wird eigentlich die buffer_adr zuerst auf 0xFF gestellt?
Um anzuzeigen, dass der Sender eben bisher noch keine Adresse geschickt
hat.
Analysieren musst du den Code schon erst mal alleine. Die Kommentare
sind zwar nicht unbedingt die besten, aber so schlimm ist das auch
wieder nicht.
Und so schwer ist der Code dann auch wieder nicht zu verstehen.
Interesant ist, dass der Autor eigentlich einen ungewöhnlichen
Speicherbaustein implementiert: Was der Sender an Daten sendet, landet
in einem Speicher, was der Slave auf Anforderung zurückschickt kommt aus
einem anderen Speicher. Im eigentlichen Sinne ist das daher kein
Speicherbaustein, wie es ein SRAM oder ein EEPROM wäre, sondern mehr die
Basisfunktionalität, in der der Slave 2 Speicherbänke bereitstellt und
das Hauptprogramm ist dann dafür zuständig, wie sich die
Ausgangsspeicherbank bei einer Veränderung der Eingangsspeicherbank
verändert. Aber auf seiner Web-Site beschreibt er dieses Verhalten dann
auch unter "Anwendung"
(Ich würde mir den Code erst mal vernünftig formatieren. Das ist ja
grauenhaft, was der Autor da als Einrückungsschema benutzt. Als
Nebeneffekt dieser umformatierung ergibt sich nämlich oft: Man versteht
plötzlich, wie das alles funktioniert, weil man sich mit dem Code
beschäftigen muss, wenn man das alles erst mal zurecht rückt)
Eine eigene Frage?
Dieser Thread ist über 15 Jahre alt.
Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.