I2C Problem, ATMEGA64 zieht SDA dauerhaft auf Masse

[gr33n (Gast)]

Hallo Zusammen,

Bin gerade dabei eine Kommunikation zwischen einem AT89C51CC03 und einem 
ATMEGA64 über I2C zu realisieren.
Der 8051 arbeitet als Master und die Steuerung ist über Software gelöst.
Im ATMEGA verwende die interne TWI-Hardware und eine Interruptsteuerung.

Wenn ich jetzt einen write-befehl an den Slave schicke, erkennt dieser 
seine eigene Adresse und schickt auch Daten zurück. Das sind wie im Bild 
zu erkennen zwei Byte (1.Byte: 19; 2.Byte: 27).
Dann sollte eigentlich die Stop-Condition kommen. Tut sie aber nicht. 
Soweit ich erkenne zieht der Slave die Datenleitung auf Masse und 
unterbricht so eine weitere Kommunikation.

Ein anderer Baustein (MAX520) kann problemlos angesteuert werden. Bei 
dem treten dann auch keine zeitlichen Abstände zwischen den einzelnen 
Bytes auf.

Hoffe mir kann jemand weiter helfen

[Sascha W. (sascha-w)]

gr33n schrieb:
> Hoffe mir kann jemand weiter helfen

ohne deinen Code im M64?? - NEIN!

Sascha

[gr33n (Gast)]

Guten Morgen,

habe hier das Programm vom ATMEGA64:

 
#include "defines.h"
#include "TWI2/TWI_Slave.h"
#include "lcd/lcd.h"

//---------------

volatile uint16_t SWSI[6];  //!< Register fuer AD-Werte (soll alle 100ms neu beschrieben werden)

uint16_t Zaehler=0;

char ausgabe[16];

volatile uint8_t akt=0;  //!< Aktiviert Schreibvorgang des Spannungswerts ins Menue

uint8_t jj=0, SWSIAuswahl=0;

//----------------

void init_io(void);      //!< Initialisierung Allgemein
void I2Cfkt(uint8_t TWIS_ResonseType);


int main(void)
{
  uint8_t uebergabe,jj=0,kk=0;
  uint8_t  TWIS_ResonseType;

  init_io();
  lcd_init();
  
  cli();
  _delay_ms(500);  // wait 500ms
  uebergabe = ATMEGA;
  
  if(!(TWIS_Init(uebergabe, 20000))) // IC Slave Einstellungen
  {
    lcd_string("i2c falsche bitrate");
    _delay_ms(1000);
  }
  sei();

//---------------- P R O G R A M M ------------------

  lcd_string(">>>");
  while (1)
  {
  }      
}

void I2Cfkt(uint8_t TWIS_ResonseType)
{
  uint8_t eingang, uebergabe;
  
  jj++;
  itoa(TWIS_ResonseType,ausgabe,16);
  lcd_string(ausgabe);
  lcd_string(",");
  switch (TWIS_ResonseType)
  {
    case TWIS_ReadBytes:
      uebergabe=TWIS_ReadAck();
      itoa(uebergabe,ausgabe,10);
      lcd_string(ausgabe);
      uebergabe=TWIS_ReadAck();
      itoa(uebergabe,ausgabe,10);
      lcd_string(ausgabe);
        
      TWIS_Stop();
      break;

    case TWIS_WriteBytes:
      TWIS_Write(19);
      TWIS_Write(27);

      TWIS_Stop();
      break;
          
    default:
      break;
  }
}/*I2Cfkt*/


/**
* Initialisierung Datenrichtung, Timer0, Timer1, Interruptenable
*/
void init_io()
{  
  DDRA = 0b00000100;  //HW Addresses and LDAC
  DDRB = 0b11110000;  //PORT B Outputs
  DDRC = 0x0FF;
  DDRD = 0b01100000;  //Enable signals
  DDRE = 0b00000011;
  DDRF = 0b10111111;
    PORTF = 0b01000000;
}

ISR (TWI_vect)
{
  uint8_t  TWIS_ResonseType;
  
  TWIS_ResonseType = TWSR;
  I2Cfkt(TWIS_ResonseType);
}

Die Funktion TWI_Slave.c ist übernommen von Manfred Langemann und 
abgeändert, damit sie auch mit der ISR läuft.

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

#include "TWI_Slave.h"

/**
* @brief Initialise the TWI Slave Interface
* @param[in] Address  Slave address
* @param[in] Bitrate  TWI_Bitrate (Hz)
*
* @return FALSE  Bitrate too high
* @return TRUE  Bitrate OK
*/
uint8_t TWIS_Init (uint8_t Address, uint32_t Bitrate)
  {
/*
** Set the TWI bitrate
** If TWBR is less 11, then error
*/
  TWBR = ((F_CPU/Bitrate)-16)/2;
  if (TWBR < 11) return FALSE;
/*
** Set the TWI slave address
*/
  TWAR = (Address << 1);
/*
** Activate TWI interface
*/
  TWCR = (1<<TWEN)|(1<<TWEA)|(1<<TWIE);

  return TRUE;
  }
/**
* @brief Stop the TWI Slave Interface
*/
void TWIS_Stop (void)
  {
  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)|(1<<TWEA)|(0<<TWSTA)|(1<<TWSTO)|(0<<TWWC)|(1<<TWIE);
  }
  
/**
* @brief Write a byte to the master
*
* @param[in] byte to be sent
*
* @return TRUE OK, Byte sent
* @return FALSE Error in byte transmission
*/
void TWIS_Write (uint8_t byte)
  { 
  TWDR = byte;
  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
  while (!(TWCR & (1<<TWINT)));
  }
  
/**
* @brief Read a byte from the master and request next byte
* @return Read byte
*/
uint8_t  TWIS_ReadAck (void)
  {
  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
  while (!(TWCR & (1<<TWINT)));
  return TWDR;
  }
  
/**
* @brief Read the last byte from the master
* @return Read byte
*/
uint8_t  TWIS_ReadNack (void)
  {
  TWCR = (1<<TWINT)|(1<<TWEN);
  while (!(TWCR & (1<<TWINT)));
  return TWDR;
  }
  
/**
* @brief Get the response type to be performed by slave
* @param[in] *TWI_ResonseType Pointer to response type
* - TWIS_ReadBytes  --> Read byte(s) from master
* - TWIS_WriteBytes  --> Write byte(s) to master
*
* @return Response required
* - TRUE: Yes, response required
* - FALSE: No response required
*/
uint8_t  TWIS_ResonseRequired (uint8_t *TWI_ResonseType)
  {
  *TWI_ResonseType = TWSR;
  return TWCR & (1<<TWINT);
  }

[gr33n (Gast)]

So hab mein Problem gelöst. War ein typisches 30cm Problem...

Damit andere nicht vlt in die selbe Falle tappen, schreibe ich hier kurz 
worauf man auf jeden Fall achten sollte:

Möchte man mehrere Bytes übertragen sollte man darauf achten, dass nach 
dem letzten Byte ein NotAck zurück gegeben wird. Tut man das nicht 
passieren unerwartete Effekte...

Dachte man braucht das nur wenn man variable Byte-längen hat.

[Sascha W. (sascha-w)]

Hallo,

schön das es jetzt geht.
Was soll eigentlich das TWIS_Stop() wenn du der Slave bist? - das Stop 
kommt vom Master! Dieses Stop brauchst du eigentlich nur wenn der Bus 
einen ungültigen Zustand hat (TWSR=0x00).
Und noch was - die Displayausgabe hat in der ISR nichts zu suchen, kein 
Wunder wenn du in der Übertragung laaaange Pausen hast.

Sascha

[gr33n (Gast)]

Hi Sascha,

> Was soll eigentlich das TWIS_Stop() wenn du der Slave bist? - das Stop
> kommt vom Master! Dieses Stop brauchst du eigentlich nur wenn der Bus
> einen ungültigen Zustand hat (TWSR=0x00).

Wenn ichs nicht mit rein nehme hängt sich der Bus auf -> nach dem 
letzten Byte bleiben beide Signale (scl und sda) auf Masse.
Die Funktionen habe ich von hier 
Beitrag "AVR TWI Master und Slave Funtionen in C".

Manfred Langemann macht es in dem Beispielcode TWI_Slave_main.c genauso:

main(){
//...
while(1){

//Check wether something is to do for the TWI slave interface

    if (TWIS_ResonseRequired (&TWIS_ResonseType))
      {
      switch (TWIS_ResonseType)
        {
/*
** Slave is requests to read bytes from the master.
** It is expliciltely assumed, that the master sends 8 bytes
*/
        case TWIS_ReadBytes:
          for (i=0;i<7;i++)
            {
            byte[i] = TWIS_ReadAck ();
            printf ("Byte read: %d\n",byte[i]);
            }
          byte[7] = TWIS_ReadNack ();
          printf ("Byte read: %d\n",byte[7]);
          TWIS_Stop ();
          break;
/*
** Slave is requested to send bytes to the master.
** It is expliciltely assumed, that the master expects 8 bytes
*/
        case TWIS_WriteBytes:
          for (i=0;i<8;i++)
            {                   
            TWIS_Write (j++);
            printf ("Byte sent:  %d\n", j-1);
            }
            TWIS_Stop ();
          break;
        }
      } 
    }
}

Was die Displayausgabe angeht: Da hast du recht! Hatte sie nur zu 
Testzwecken drinnen um mir das Statusbyte anzeigen zu lassen. Ohne gehts 
natürlich deutlich schneller :)
wobei 15kHz nicht wirklich schnell ist...