Erneute Frage zu TWI (Code)

[Martin K. (thereallife)]

Moin moin alle zusammen,
erstmal nochmal ein Danke an alle die mir gestern geholfen haben die 
Thematik zu verstehen, ich habs jetzt glaube ich endlich geblickt.

Ich hab jetzt nen Code für den Master und für den Slave geschrieben, 
scheinbar hängt es aber an einer stelle,

Ok So ist mein Aufbau:
2 Atmega ein Master ein Slave.
SDA und SCL sind miteinander verbunden, die Leitungen gehen über jeweils 
einen Widerstand an VCC

Was passiert:
Die Verbindung scheint zu "abzubrechen" scheinbar hab ich irgendeinen 
Fehler im Code so das Master und Slave auseinanderlaufen?! bzw sich 
einfach unterbrechen...

den Master hab ich mit TX und RX an den Arduino, somit kann ich mir ne 
monitor ausgabe geben.

Wenn ich den Slave neu programmiere, kommt dort die ganze Zeit
Kann nix vom Bus lesen
Kann auf den Bus nicht schreiben
Was ja auch klar ist wenn der Slave nicht da ist.
Wenn der Slave wieder da ist, gibt es eine aktion,
Entweder
gelesenes Byte : 30,
oder
20 wurde gesendet

beide richtig, mit dem Slave sende ich testeshalber ne 30 rüber und der 
master sendet eine 20.

Hier mal der Code, eventuell habt ihr ja auch tipps wie ich das ganze 
debuggen kann um den Fehler zu finden.
Meine Kommentare könnt ihr Ignorieren, Sie waren nur für mich da um mir 
das ganze mehr einzuprägen.
Außer in der TWIMaster_Stop funktion da wäre es interessant ob das so 
richtig ist, oder so wie im Kommentar steht ;)

while (TWCR & (1<<TWINT)); // müsste das nicht while(!(TWCR & (1<<TWINT) sein?

Master Main

#include <avr/io.h>
#include <avr/interrupt.h>
#ifndef F_CPU
#define F_CPU 8000000L
#endif
#include <stdio.h>
#include <util/delay.h>
#include <string.h>
//#include "ShiftOut.h"
//#include "ShiftIn.h"
#include "UART.h"
#include "TWIInclude.h"
// #include "Encoder.h"
#define LED1    PD2
#define LED2    PD3
#define LED3    PD4
#define LED4    PD5
#define LED5    PD6
#define LED6    PD7
#define LED_DDR    DDRD
#define LED_PORT  PORTD

static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

int main (void)
{
  uint8_t    i;
  uint8_t    j=0;
  uint8_t    Data[8];
  uint8_t    SlaveAddresse = 50;
  cli ();
  stdout = &mystdout;
  long baud = 9600UL;
  UART_Init(baud);
  LED_DDR = (_BV(LED1)) | (_BV(LED2)) | (_BV(LED3)) | (_BV(LED4)) | (_BV(LED5)) | (_BV(LED6));
  if (!TWIMaster_Init (100000))
  {
    printf ("Fehler beim Initialisieren des TWI Interfaces");
    while(1);
    {
      //
    }
  }
  LED_PORT ^= ( 1 << LED1 ); // LEd 1 An wenn bis hier alles funzt
  while(1)
  {
      if (!TWIMaster_Start (SlaveAddresse, TWIM_READ))
      {
        TWIMaster_Stop();
        printf("Kann nix vom Bus lesen\n");
        LED_PORT ^= ( 1 << LED2 );  
      }
      else
      {
        Data[1] = TWIMaster_ReadNack ();
        printf ("gelesenes Byte : %d, \n", Data[1]);
        LED_PORT ^= (1<<LED3);
      }
      if (!TWIMaster_Start (SlaveAddresse, TWIM_WRITE))
      {
        TWIMaster_Stop();
        printf ("Kann auf den Bus nicht schreiben\n");
        LED_PORT ^= ( 1 << LED4 ); 
      }
      else
      {
        TWIMaster_Write(20);
        printf("20 wurde gesendet\n");
        TWIMaster_Stop();
        LED_PORT ^= ( 1 << LED5); 
      }
  }
  return 0;
}

Master Funktionen C-Datei

#include <avr/io.h>
#include <avr/interrupt.h>
#ifndef F_CPU
#define F_CPU 8000000L
#endif
#include <stdio.h>
#include <util/delay.h>
#include <string.h>

#define FALSE            0
#define TRUE            1
#define TWI_START          0x08  // 00001000 // START has been transmitted
#define TWI_REP_START        0x10  // 00010000 // Repeated START has been transmitted
#define TWI_MTX_ADR_ACK        0x18  // 00011000 // SLA+W has been tramsmitted and ACK received
#define TWI_MRX_ADR_ACK        0x40  // 01000000 // SLA+R has been tramsmitted and ACK received
#define TWI_MTX_DATA_ACK      0x28  // 00101000 // Data byte has been tramsmitted and ACK received

uint8_t TWIMaster_Init (uint32_t TWI_Bitrate)
{
  TWBR = ((F_CPU/TWI_Bitrate)-16)/2;
  if (TWBR < 11) 
  {
    return FALSE;
  }
}

uint8_t TWIMaster_Start (uint8_t Adresse, uint8_t TWIMaster_Typ)
{
  uint8_t twst;
  TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); // TWI Interrupt // TWI Start Condition Bit // TWI Enable Blit 
  //TWint löscht den Flag, TWSTA sagt master möchte auf den Bus zugreifen // TWEN = schaltet TWI an
  while(!(TWCR & (1<<TWINT))); // Es wird darauf gewartet das TWI die änderung übernommen hat
  twst = TWSR & 0xF8; // 11111000 in twst steht nun die ersten 5 Bits
  if ((twst != TWI_START) && ( twst != TWI_REP_START))
  {
    return FALSE;
  }
  TWDR = (Adresse<<1) + TWIMaster_Typ; // beschreibt das TWDR Register
  TWCR = (1<<TWINT) | (1<<TWEN); // schreibt Daten raus
  while (!(TWCR & (1<<TWINT))); // Wartet darauf das die übertragung abgeschlossen ist
  twst = TWSR & 0xF8;
  if ((twst != TWI_MTX_ADR_ACK) && (twst != TWI_MRX_ADR_ACK))
  {
    return FALSE;
  }
  return TRUE;
}

uint8_t TWIMaster_Stop (void)
{
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
  // TWINT flag gelöscht // TWEN Enable TWI // TWSTO - TWI Stop Condition 
  while (TWCR & (1<<TWINT)); // müsste das nicht while(!(TWCR & (1<<TWINT) sein?
}

uint8_t TWIMaster_Write(uint8_t byte)
{
  uint8_t twst;
  TWDR = byte;
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));
  twst = TWSR & 0xF8;
  if (twst != TWI_MTX_DATA_ACK)
  {
    return 1;
  }
  return 0;
}

uint8_t TWIMaster_ReadNack (void)
{
  TWCR = (1<<TWINT) | (1<<TWEN);
  while(!(TWCR & (1<<TWINT)));
  return TWDR;
}

Master Include.h

#define TWIM_READ    1
#define TWIM_WRITE   0

uint8_t TWIMaster_Init (uint32_t);
uint8_t TWIMaster_Start (uint8_t , uint8_t);
uint8_t TWIMaster_Stop (void);
uint8_t TWIMaster_Write(uint8_t);

Slave Main Datei

#define LED1    PD2
#define LED2    PD3
#define LED3    PD4
#define LED4    PD5
#define LED5    PD6
#define LED6    PD7
#define LED_DDR    DDRD
#define LED_PORT  PORTD

#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 8000000L
#endif

#include <stdio.h>
#include <util/delay.h>
#include <string.h>
#include "TWISlave.h"
#include "UART.h"

static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

int main (void)
{
  uint8_t i=0;
  uint8_t j=0;
  uint8_t byte[8];
  uint8_t TWIS_ResonseType;
  cli();
  stdout = &mystdout;
  long baud = 9600L;
  UART_Init(baud);
  TWISlave_Init(50, 100000);
  printf("Hallo\n");
  LED_DDR = (_BV(LED1)) | (_BV(LED2)) |(_BV(LED3)) | (_BV(LED4));
  LED_PORT = _BV(LED1);
  while (1)
  {
    if (TWISlave_ResonseRequired(&TWIS_ResonseType))
    {
      switch (TWIS_ResonseType)
      {
        case TWISlave_ReadBytes:
            LED_PORT ^= _BV(LED2);
            byte[7] = TWISlave_ReadNack();
            printf ("Byte gelesen: %d\n", byte[7]);
            TWISlave_Stop();
          break;
        case TWISlave_RESTART:
            LED_PORT = _BV(LED4);
            TWISlave_Write(50);
            printf("Repeat Start wurde ausgeführt\n");
            TWISlave_Stop();
          break;  
        case TWISlave_WriteBytes:
            LED_PORT ^= _BV(LED3);
            TWISlave_Write(30);
            TWISlave_Stop();
          break;
      }
    }
    i++;// wozu hier das i++?
  }
  return 0;
}

Slave Funktion C-Datei

#include <stdio.h>
#include <avr/interrupt.h>
#ifndef F_CPU
#define F_CPU 8000000L
#endif

uint8_t TWISlave_Init(uint8_t Adresse, uint32_t Bitrate)
{
  TWBR = ((F_CPU/Bitrate)-16)/2;
  if (TWBR < 11) 
  {
    return 0;
  }
  TWAR = (Adresse << 1);
  TWCR = (1<<TWEN) | (1<<TWEA); 
  return 1;
}

uint8_t TWISlave_ResonseRequired(uint8_t * TWI_ResonseType)
{
  *TWI_ResonseType = TWSR; 
  return TWCR & (1<<TWINT); 
}

uint8_t TWISlave_ReadAck(void)
{
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
  while (!(TWCR & (1<<TWINT)));
  return TWDR;  
}

uint8_t TWISlave_ReadNack (void)
{
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));
  return TWDR;
}

uint8_t TWISlave_Stop()
{
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO) | (1<<TWEA);
}

TWISlave_Write(uint8_t byte)
{
  TWDR = byte; 
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
  while (!(TWCR & (1<<TWINT)));
}

Slave Include:

#ifndef _TWISlave
#define _TWISlave

#define TWISlave_RESTART       0xA0
#define  TWISlave_ReadBytes    0x60
#define  TWISlave_WriteBytes    0xA8

uint8_t TWISlave_Init(uint8_t, uint32_t);
uint8_t TWISlave_ResonseRequired(uint8_t *);
uint8_t TWISlave_ReadAck(void);
uint8_t TWISlave_ReadNack(void);
void TWISlave_Stop(void);
void TWISlave_Write(uint8_t);

#endif

Danke!

[Martin K. (thereallife)]

ok, das eine TWIMaster_Stop() was ihm Read aufruf gefehlt hab, hab ich 
hinzugefügt.

Ich hab auch schon bereits ausprobiert ob eins von den beiden für sich 
funktioniert,
Weder der Write noch der Read aufruf stoppen noch einer übertragung.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Du solltest das etwas strukturierter angehen. Als I²C-Neuling 
gleichzeitig Master und Slave programmieren zu wollen, funktioniert nur 
mit sehr sehr viel Glück :-)

a) besorg dir einen "Hardware-Slave", also irgendeinen Sensor oder was 
immer, welches per I2C angesprochen wird, und wo du dich einigermaßen 
drauf verlassen kannst dass er funktioniert.

b) besorg dir einen I2C-Master für den PC (ich nutze hierfür das geniale 
Teil vom Till Harbaum: 
http://www.harbaum.org/till/i2c_tiny_usb/index.shtml) um a) wirklich 
ganz ganz fest abzusichern (es gibt nix frustrierenderes als 
stundenlanges Fehler suchen im eigenen I2C-Master Code, um dran 
draufzukommen dass der Slave kaputt ist... been there, seen it :-(


dann machst du dich erstmal an den Master. Aber auch hier strukturiert.

1. erzeuge ein Start-Condition, und prüfen den Status. Dieser sollte 
0x08 "A START condition has been transmitted" sein (für Details bitte 
Datenblatt fragen, ich rede hier immer vom ATmega328P). Wenn nicht, ist 
schon was faul, und du brauchst nicht weiterzumachen.

2. sende ein SLA+R an eine nicht existente Adresse, und prüfe den 
Status. Dieser sollte 0x48 "SLA+R has been transmitted; NOT ACK has been 
received" sein. Wenn nicht, ist was faul, und du brauchst nicht 
weiterzumachen.

3. sende ein SLA+R an eine sehr wohl existente Adresse (Sensor aus Punkt 
a von oben), und prüfe den Status. Dieser sollte 0x40 "SLA+R has been 
transmitted; ACK has been received" sein. Wenn nicht, ist was faul, und 
du brauchst nicht weiterzumachen.

Wenn du mal soweit gekommen bist, hast du schon den größten Schritt 
erfolgreich erledigt: Du hast beim Slave "angerufen" und der hat den 
Hörer abgenommen und "ja bitte?" geantwortet. Dann meld dich nochmal, 
dann sehen wir weiter (ich hab jetzt keine zeit den ganzen Rest 
aufzuschreiben)

[Michael R. (Firma: Brainit GmbH) (fisa)]

Im Übrigen ist Schritt 2 und 3 von oben der Schlüssel zum Verständnis 
von I2C (zumindest wars bei mir so): Ein Paket besteht immer aus 9 Bits: 
8 Datenbits, und das ACK/NAK. Der Trick ist nun: Die Datenbits werden 
immer vom Transmitter erzeugt (das muss nicht der Master sein!), das 
ACK/NACK aber vom Receiver. Der Receiver empfängt die 8 Bits, und 
erzeugt er im selben Paket noch schnell das 9te Bit. Am Transmitter 
umgekehrt: Er sendet 8 bits, und lauscht noch kurz auf der 9te bit. Das 
heisst aber auch für die Software: Zwischen Empfang eines Pakets und 
Senden des ACK oder NAK hast du keine Möglichkeit zu reagieren, oder 
anders gesagt: schon bevor du das Paket empfängst, musst du der 
TWI-Hardware sagen, ob sie den nächsten Empfang mit ACK oder NAK 
quittieren soll!

Ein Spezialfall ist noch die Reaktion auf ein SLA+RW: Streng genommen 
"empfängt" der master kein NAK wenn keiner antwortet, die 
Statusbeschreibung "SLA+R has been transmitted; NOT ACK has been 
received" ist insofern irreführend, als das nciht wirklich ein NAK 
empfangen wird, weil auch niemand ein NAK sendet. NAK bedeutet in diesem 
Fall einfach ein Ausbleiben das ACK, elektrisch gesehen bleibt die 
SDA-Leitung auf high, weil sie keiner auf Low zieht.

[Martin K. (thereallife)]

Ich habe ein funktionierendes gegenstück,
ich hab zwar ein paar Schritte übersprungen, allerdings funktioniert der 
Master am Arduino ohne Probleme,

Verbinde ich Master mit Arduino und packe auf den Arduino folgende 
Software:

// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>

// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this

// Created 29 March 2006

// This example code is in the public domain.


#include <Wire.h>

void setup()
{
  Wire.begin(50);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent); // register event
  Serial.begin(9600);           // start serial for output
}

void loop()
{
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  while(1 < Wire.available()) // loop through all but the last
  {
    char c = Wire.read(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  int x = Wire.read();    // receive byte as an integer
  Serial.println(x);         // print the integer
}

void requestEvent()
{
  Wire.write(50); // respond with message of 6 bytes
                       // as expected by master
}

In meinem Atmega Log steht fröhlich
gelesenes Byte : 50,
20 wurde gesendet
(in endlos ausführung) ;)
und in meinem Arduino werden die Daten auch ausgegeben

(ich sollte vill erwähnen, ich hab hier 2 arduinos,
einmal den mega2560 der master bzw slave spielt. und ein Arduino Uno in 
dil variante, wo der prozessor abgezogen ist und nur tx,rx und masse 
verbunden sind. Der 2te arduino dient mir als monitor ausgabe für den 
Atmega

wenn ich den Arduino mit dem Slave verbinde und dem Arduino folgenden 
Code gebe:

#include <Wire.h>

void setup()
{
  Wire.begin();        // join i2c bus (address optional for master)
  Serial.begin(9600);  // start serial for output
}
int x = 40;
void loop()
{
  Wire.requestFrom(50, 1);    // request 6 bytes from slave device #2

  while(Wire.available())    // slave may send less than requested
  { 
    char c = Wire.read(); // receive a byte as character
    Serial.print(c);         // print the character
  }
    int y = Wire.read(); // receive a byte as character
    Serial.print(y);
      Wire.beginTransmission(50); // transmit to device #4
    Wire.write(x);              // sends one byte  
    Wire.endTransmission();    // stop transmitting
}

läuft laut meines Atmega Monitors alles super:

byte geschrieben
Byte gelesen: 40

40 ist richtig,

was mir dabei aber grade aufgefallen ist (und das auch nur durch zufall 
weil der Arduino Monitor noch offen war)
ist der Arduino Master und ließt werte ein, kommt da nur -1 an ?! das 
ist mir vorher noch nicht aufgefallen weil ich dummerweise nur auf das 
TX lämpchen geschaut habe und gesehn hab ok er schickt was raus.

Denn fehler im Code vom Slave beim schreiben konnte ich allerdings nicht 
ausfindig machen...

[Michael R. (Firma: Brainit GmbH) (fisa)]

Nachdem du meinen rat, das ganze strukturiert anzugehen, ignorierst 
(oder erst gar nicht gelesen) hast, und stattdessen weiter einfach 
wahllos Code aus dem Internet per Copy&Paste zusammenwürfelst, dabei 
auch noch munter nativen AVR und Arduiono-Code mischst, bin ich raus. 
ich wünsch dir noch viel Erfolg.

[Martin K. (thereallife)]

Michael Reinelt schrieb:
> 1. erzeuge ein Start-Condition, und prüfen den Status. Dieser sollte
> 0x08 "A START condition has been transmitted" sein (für Details bitte
> Datenblatt fragen, ich rede hier immer vom ATmega328P). Wenn nicht, ist
> schon was faul, und du brauchst nicht weiterzumachen.
>
> 2. sende ein SLA+R an eine nicht existente Adresse, und prüfe den
> Status. Dieser sollte 0x48 "SLA+R has been transmitted; NOT ACK has been
> received" sein. Wenn nicht, ist was faul, und du brauchst nicht
> weiterzumachen.

Vielleicht hätte ich erwähnen sollen, das ich
  if (TWSR == 0x48)
  {
    LED_PORT = _BV(LED5);
    while(1)
    {
      _delay_ms(200);
      LED_PORT ^= ( 1 << LED4 );
    }
in meine TWIMaster_Start Routine reingepackt habe...
natürlich habe ich auch das ganze mal mit einer falschen adresse 
ausprobiert. Dann springt er auch in diese schleife.

Michael Reinelt schrieb:
> 3. sende ein SLA+R an eine sehr wohl existente Adresse (Sensor aus Punkt
> a von oben), und prüfe den Status. Dieser sollte 0x40 "SLA+R has been
> transmitted; ACK has been received" sein. Wenn nicht, ist was faul, und
> du brauchst nicht weiterzumachen.

gut das habe ich übersprungen.

I²C funktioniert meines wissens überall gleich, warum also keinen 
Arduino nehmen? Ich möchte halt weiterkommen und nicht 2 tage warten bis 
die entsprechende Hardware da ist.


mag auch gut sein das ich von einer Libary abgeschrieben habe. 
Allerdings nur von einer und diesen Code habe ich 3 mal abgeschrieben 
und mir kommentare & gedanken dazu gemacht. Anfangs und das hast du 
gestern gesehen, habe ich mir fragen aufgeschrieben weil ich nicht 
wusste was die einzelnen Register bedeuten. Als ich die Register 
beschreibung im Datenblatt gefunden habe. hab ich mir alles auf DINA4 
blätter geschrieben und hier im Zimmer aufgeghangen damit ich 
nachschauen kann. Anschließend bin ich nochmal durch den gesamten code 
gegangen und hab alles verstanden und mir nur als komentar 
hingeschrieben was genau passiert und bis auf die eine Zeile die ich 
oben hingeschrieben habe. Habe ich alles verstanden. Ich mag noch ein 
Noob sein was die ganze mpu geschichte angeht, aber ich mach hier 
bestimmt kein copy und paste.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Martin Kathke schrieb:
> Vielleicht hätte ich erwähnen sollen, das ich [das] in meine TWIMaster_Start 
Routine reingepackt habe...
Ja hättest du :-)

Martin Kathke schrieb:
> natürlich habe ich auch das ganze mal mit einer falschen adresse
> ausprobiert. Dann springt er auch in diese schleife.

Gut.

Martin Kathke schrieb:
> gut das habe ich übersprungen.

schlecht. Dann hol das bitte nach.

Martin Kathke schrieb:
> I²C funktioniert meines wissens überall gleich, warum also keinen
> Arduino nehmen? Ich möchte halt weiterkommen und nicht 2 tage warten bis
> die entsprechende Hardware da ist.

Aber du kannst nicht sicher sein dass der Arduino-Slave funktioniert. 
Solange ist das Glaskugel-Lesen, auf das hier keiner Lust hat. Aber 
versuch trotzdem mal, ob du wenigstens ein ACK kriegst.

[Martin K. (thereallife)]

if (TWSR == 0x40)
  {
    LED_PORT = _BV(LED6);
  }

hatte ich erst drin,
da ging die led nicht an,
dann ist mir aufgefallen das er wenn ich starte meistens nur einmal 
schreibt und dann stopt
also hab ich
  if (TWSR == 0x18)
  {
    LED_PORT = _BV(LED6);
  }

draus gemacht und die LED6 geht an ;)

[Michael R. (Firma: Brainit GmbH) (fisa)]

Martin Kathke schrieb:
> if (TWSR == 0x18)

und was heisst 0x18? (bin grad etwas offline)

[Martin K. (thereallife)]

0x18 SLA+W has been tramsmitted and ACK received