I2C ISR Verständnisfrage

Gast #2218304
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
6
#define TWCR_ACK   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);  
7

8
//NACK nach empfangenen Daten senden/ NACK nach gesendeten Daten erwarten     
9
#define TWCR_NACK   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);
10

11
//switched to the non adressed slave mode...
12
#define TWCR_RESET   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);  
13

14

15
ISR (TWI_vect)  
16
{
17
  uint8_t data=0;
18
  switch (TW_STATUS)                 // TWI-Statusregister prüfen und nötige Aktion bestimmen 
19
    {
20
    case TW_SR_SLA_ACK:             // 0x60 Slave Receiver, wurde adressiert  
21
      TWCR_ACK;                 // nächstes Datenbyte empfangen, ACK danach
22
      buffer_adr=0xFF;             // Bufferposition ist undefiniert
23

24
      break;
25

26
    case TW_SR_DATA_ACK:             // 0x80 Slave Receiver,Daten empfangen
27
      data=TWDR;                 // Empfangene Daten auslesen
28

29
      
30
      if (buffer_adr == 0xFF)         // erster Zugriff, Bufferposition setzen
31
        {
32
          if(data<=buffer_size)      // Kontrolle ob gewünschte Adresse im erlaubten bereich
33
            {
34
              buffer_adr= data;     // Bufferposition wie adressiert setzen
35
            }
36
          else
37
            {
38
            buffer_adr=0;         // Adresse auf Null setzen. Ist das sinnvoll?
39
            }        
40
          TWCR_ACK;            // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
41
        }
42
      else                   // weiterer Zugriff, Daten empfangen
43
        {
44
          rxbuffer[buffer_adr]=data;     // Daten in Buffer schreiben
45

46
          buffer_adr++;           // Buffer-Adresse weiterzählen für nächsten Schreibzugriff
47
          if(buffer_adr<(buffer_size-1)) // im Buffer ist noch Platz für mehr als ein Byte
48
            {
49
              TWCR_ACK;        // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
50
            }
51
          else                 // es kann nur noch ein Byte kommen, dann ist der Buffer voll
52
            {
53
              TWCR_NACK;        // letztes Byte lesen, dann NACK, um vollen Buffer zu signaliseren
54
            }
55
        }
56
        
57

58
      
59
      break;
60

61
    case TW_ST_SLA_ACK:             //
62
    case TW_ST_DATA_ACK:             // 0xB8 Slave Transmitter, weitere Daten wurden angefordert
63
    
64
      
65
      if (buffer_adr == 0xFF)         // zuvor keine Leseadresse angegeben! 
66
        {
67
          buffer_adr=0;
68
        }  
69

70
      
71
      TWDR = txbuffer[buffer_adr];       // Datenbyte senden 
72

73
      
74
      buffer_adr++;               // bufferadresse für nächstes Byte weiterzählen
75
      if(buffer_adr<(buffer_size-1))     // im Buffer ist mehr als ein Byte, das gesendet werden kann
76
        {
77
          TWCR_ACK;             // nächstes Byte senden, danach ACK erwarten
78
        }
79
      else
80
        {
81
          TWCR_NACK;             // letztes Byte senden, danach NACK erwarten
82
        }
83
        
84

85
      //TWCR_ACK; 
86
      break;
87

88
          
89
    case TW_ST_DATA_NACK:             // 0xC0 Keine Daten mehr gefordert 
90
    case TW_SR_DATA_NACK:             // 0x88 
91
    case TW_ST_LAST_DATA:             // 0xC8  Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received
92
      TWCR_RESET;
93
    case TW_SR_STOP:               // 0xA0 STOP empfangen  
94
      TWCR_RESET; 
95
      break;
96
    default:
97
    //befehl=rxbuffer[0];
98
    //PORTD = rxbuffer[0];
99
    //select_case(befehl);
100
      TWCR_RESET;               // Übertragung beenden, warten bis zur nächsten Adressierung
101
      break;  
102
    } //end.switch (TW_STATUS)
103
    
104
    
105
    
106
} //end.ISR(TWI_vect)
Moderator Persönliche Seite #2218827
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.
#2220182
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)

Antwort schreiben

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.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.