ATTiny2313 I2C - Master (Peter Fleury) / Slave (jtronics)

[Anthony S. (anthony_02)]

Hallo,

hab Versuch mit dem Tutorial von jtronics.de eine Verbundung zwischen 
Zwei ATTiny2313 (Master und Slave) zum laufen zu bekommen.

http://www.jtronics.de/avr-projekte/library-i2c-twi-slave-usi.html

Wollte nun mit dem Programm Ein Zeichen welches ich dem Master via UART 
mitteile an den Slave senden und dann wieder auslesen und wieder via 
UART ausgeben.
Das funktioniert leider nicht. Wenn ich ein Zeichen übermittel, kommt 
nichts zurück, und ein zweites Zeichen kann er garnicht mehr einlesen, 
weil er davor scheinbar irgendwo hängen bleibt.

Im folgenden sind meine beiden Main.c Programm vom Master und Slave. Hat 
vieleicht jemand eine Idee was ich da falsch gemacht habe?

Gruß
Philipp

Master Module: (Verwendung der Peter Fleury Libary)
-Main.c Sieht Wiefolgt aus:

#include <avr/io.h>
#include "i2cmaster.h"
#include <util/delay.h>

//############# I2C/TWI Adressen
#define Adr_AttinyI 0b00110100 


//############# Macro 2x 8Bit --> 16Bit
#define uniq(LOW,HEIGHT)   ((HEIGHT << 8)|LOW)
//############# Macro 16Bit --> 2x 8Bit
#define LOW_BYTE(LONG)     (LONG & 0xff)
#define HIGH_BYTE(LONG)    ((LONG >> 8) & 0xff)

//############# Functions
uint8_t read_Attiny0(void);
void read_Attiny1(void);
void write_slave(uint8_t);
uint8_t Byte0, Byte1, Byte2, Byte3 = 0;  // Bytes
uint8_t hig,low = 0; // hight und Low Variable
uint16_t word1,word2 =0;

//############# Variabels
void InitUART (uint8_t baudrate);
void TransmitByte (uint8_t data);
uint8_t ReceiveByte (void);


//############# Main
int main(void)
{
  InitUART (12);
  while (1)
  {
    write_slave(ReceiveByte());
    _delay_ms(1000);
    TransmitByte (read_Attiny0());
    _delay_ms(1000);
    read_Attiny1();
    _delay_ms(1000);
  }
  
}

//############# Abfrage einzelner Bytes.
uint8_t read_Attiny0(void)
{
  i2c_start_wait(Adr_AttinyI + I2C_WRITE); // Adr_AttinyI ansprechen
  i2c_write(0); // startadresse zum lesen

  i2c_rep_start (Adr_AttinyI + I2C_READ ); // Lesen beginnen 
  Byte0 = i2c_readAck(); // Byte empfangen 
  Byte1 = i2c_readAck(); // Byte empfangen 
  Byte2 = i2c_readAck(); // Byte empfangen 
  Byte3 = i2c_readNak(); // letes Byte empfangen 

  i2c_stop(); // stopt I2C Verbindung
  return Byte0;
}


//############# Abfrage einzelner Bytes (8 Bits) und anschließend zusammenfügen zu einem Word (16 Bit)
void read_Attiny1(void)
{
  i2c_start_wait(Adr_AttinyI + I2C_WRITE); // Adr_AttinyI ansprechen
  i2c_write(0); // startadresse zum lesen

  i2c_rep_start (Adr_AttinyI + I2C_READ ); // Lesen beginnen 

  low = i2c_readAck(); // Byte0 lesen
  hig = i2c_readAck(); // Byte1 lesen
  word1 = uniq(low,hig); // 2x 8Bit --> 16Bit

  low = i2c_readAck(); // Byte2 lesen
  hig = i2c_readAck(); // Byte3 lesen
  word2 = uniq(low,hig); // 2x 8Bit --> 16Bit

  i2c_stop(); // stopt I2C Verbindung
}  


//############# Senden einzelner Bytes (8 Bits) und anschließend senden von einem Word (16 Bit), durch zerlegen in 2 Bytes
void write_slave(uint8_t Data)
{
  i2c_start_wait(Adr_AttinyI + I2C_WRITE);
  i2c_write(0); // Startadresse / Register

  i2c_write(Data); // 8bit Information - adresse 0 
  i2c_write(0x42); // 8bit Information - adresse 1 

  i2c_write(0x43); // 8bit Information - adresse 2 
  i2c_write(0x44); // 8bit Information - adresse 3 

  //i2c_write(LOW_BYTE(5678)); // 16bit --> 8bit - adresse 2 
  //i2c_write(HIGH_BYTE(5678)); // 16bit --> 8bit - adresse 3 

  i2c_stop();                          // stopt I2C Verbindung
}



//############# Initialize UART
void InitUART (uint8_t baudrate)
{
  //Eigene Initialisierung WatchDog
  MCUSR =0;

  MCUCR = 0x80;    //JTAG abschalten
  MCUCR = 0x80;

  //Eigene Initialisierung (Outputs)
  DDRD |= (1<<PD5);

  //Set the baud rate
  UBRRL = baudrate;

  // Enable UART receiver and transmitter
  UCSRB = (1 << RXEN) | (1 << TXEN);

  // 8 data bits, 1 stop bit
  UCSRC = (1 << UCSZ1) | (1 << UCSZ0);

   
}

//############# Read and write functions
uint8_t ReceiveByte (void)
{
  // Wait for incomming data
  while (!(UCSRA & (1 << RXC)));


  if(UDR == 0x41)
  {
    PORTD |= (1<<PD5); // Led on
    _delay_ms(1000);
    PORTD &= !(1<<PD5); // Led off
    _delay_ms(1000);
  }
  //Return the data
  return UDR;
}
void TransmitByte (uint8_t data)
{
  // Wait for empty transmit buffer
  while (!(UCSRA & (1 << UDRE)));

  //Start transmittion
  UDR = data;

    PORTD |= (1<<PD5); // Led on
    _delay_ms(1000);
    PORTD &= !(1<<PD5); // Led off
    _delay_ms(1000);
}

Slave Module: (Verwendung der usiTwiSlave.h von jtronics)
-Main.c Sieht Wiefolgt aus:

#include   <stdlib.h>
#include   <avr/io.h>
#include   <avr/interrupt.h>
#include   <avr/pgmspace.h>

//################################################################## USI-TWI-I2C

#include   "usiTwiSlave.h"         

// Note: The LSB is the I2C r/w flag and must not be used for addressing!
#define   SLAVE_ADDR_ATTINY       0b00110100

#ifndef   F_CPU
#define   F_CPU 8000000UL
#endif

//####################################################################### Macros

#define uniq(LOW,HEIGHT)  ((HEIGHT << 8)|LOW)        // Create 16 bit number from two bytes
#define LOW_BYTE(x)          (x & 0xff)              // Get low byte from 16 bit number  
#define HIGH_BYTE(x)         ((x >> 8) & 0xff)        // Get high byte from 16 bit number

#define sbi(ADDRESS,BIT)   ((ADDRESS) |= (1<<(BIT)))  // Set bit
#define cbi(ADDRESS,BIT)   ((ADDRESS) &= ~(1<<(BIT)))// Clear bit
#define  toggle(ADDRESS,BIT)  ((ADDRESS) ^= (1<<BIT))  // Toggle bit

#define  bis(ADDRESS,BIT)  (ADDRESS & (1<<BIT))      // Is bit set?
#define  bic(ADDRESS,BIT)  (!(ADDRESS & (1<<BIT)))    // Is bit clear?

//#################################################################### Variables

  uint16_t   word=0;        // Counter
  uint8_t    byte1, byte2;
  uint16_t  buffer;
  uint8_t    high,low = 0;  // Variables used with uniq (high and low byte)


//################################################################# Main routine
int main(void)
{   
  
  cli();  // Disable interrupts
  
  usiTwiSlaveInit(SLAVE_ADDR_ATTINY);  // TWI slave init
  
  sei();  // Re-enable interrupts
  
  for (int i = 0; i < 10; i++)  // Fill buffers with arbitrary data
    txbuffer[i] = i + 10;
    
  for (int i = 0; i < 4; i++)
    rxbuffer[i] = i + 20;


while(1)
    {
  //############################################ Read data from reception buffer

  // 8 bit variables
  byte1  = rxbuffer[0];
  byte2  = rxbuffer[1];

  // 2 8 bit variables converted into a 16 bit number
  low    = rxbuffer[2];
  high    = rxbuffer[3];
  word  = uniq(low,high);

  //########################################## Write data to transmission buffer
  
  // 8 bit variables
  txbuffer[0]= byte1;
  txbuffer[1]= byte2;
  
  // 16 bit variable broken up into its high and low byte
  buffer    = word;
  txbuffer[2]  = LOW_BYTE(buffer);
  txbuffer[3]  = HIGH_BYTE(buffer);
  
  //############################################################################
  
  } //end.while
} //end.main

[Daniel K. (epyx)]

Würde als Erstes davon ausgehen, dass der TWIMaster von Fleury Hardware 
TWI macht und den gibt es nicht auf dem 2313.

Der Code für den Slave funktioniert bei mir eigentlich recht gut. 
Benutze den für die Ansteuerung zweier Motoren bei meinem 
RP5/RP6-Chassis.

[Anthony S. (anthony_02)]

Ist I2C und TWI nicht eigendlich das gleiche?

Bei dem Tutorial auf jtronics.de ist das Beispiel für einen ATTiny2313. 
Allerdings steht da jetzt nicht expliziet, das auch das Mastermodul (Wo 
man die Fleury Libary verwenden soll) auch ein ATTiny2313 sein kann.

Gibt es denn kein Beispiel, oder Libary, mit dem man bei einem ATTiny 
ein Master über USI einrichten kann?

[Daniel K. (epyx)]

Man kann den Attiny als Master betreiben, wenn man den ASM-Code der Lib 
nutzt. Der C-Code ist jedoch nur für Devices mit Hardware-TWI.

TWI und I2C ist das Gleiche. I2C ist nur von Phillips/NXP namens 
rechtlich geschützt.

Kannst gucken, ob Atmel für die AppNote [1] Beispielcode hat.

[1] AVR310: Using the USI module as a I2C master

[Anthony S. (anthony_02)]

Hab mir jetzt die PDF zu "AVR310: Using the USI module as a I2C master" 
angeschaut.
Da steht dann ja weiter unten, (Seite 4) dass man den Treiber einfach 
einbinden kann und das man den code dann als beispiel verwenden kann 
oder ändern.

Wo bekomme ich diesen Treiber denn her???

Gruß
Philipp

[Martin J. (bluematrix)]

Im anhang findest du ein beispiel für einen twi master.
die Fleury Lib ist eine Master Lib für ein normales TWI interface.
die jtronics Lib ist, wie es auch da steht eine Lib für ein USI 
Interface und implementiert damit einen I2C Slave.

Um Mit USI einen I2C master zu erzeugen benötigst du also anderen code 
oder schreibst diesen um.

im anhang findest du dazu ein Bsp von atmel.

grüße martin

[Martin J. (bluematrix)]

oder diese Hilfe

[Anthony S. (anthony_02)]

Hab jetzt versucht AVR310 meinem ATTiny anzupassen.

Aber gleich am Anfang habe ich schon das Problem, das er die includes 
ioavr.h and inavr.h nicht finden kann.

Habe die dann durch avr/io.h erstetzt.
Dann habe ich aber folgende Fehler meldung zur folgenden Zeile Bekommen:

__x unsigned char USI_TWI_Start_Transceiver_With_Data( unsigned char * , unsigned char );

../USI_TWI_Master.h:116:5: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'unsigned'

Hat da Jemand eine Idee wie ich die weg bekomme?

Gruß
Philipp

[holger (Gast)]

__x unsigned char USI_TWI_Start_Transceiver_With_Data(

>Hat da Jemand eine Idee wie ich die weg bekomme?

Das __x wegmachen.

[Anthony S. (anthony_02)]

Hat ich auch schon versucht. Leider bleibt die fehler meldung bestehen.

Weitere Ideen?

[Anthony S. (anthony_02)]

Hab den Fehler jetzt weg bekommen, indem ich die .c und .h Datei neu 
erstellt habe und den Code dann reinkopiert.

Hatten dann noch paar andere Fehlermeldungen die ich wiefolgt 
ausgebessert habe:
Das linke habe ich durch die Ausdrücke rechts ausgetaut:

__no_operation(); /*-->>*/ _delay_ms(1);

__enable_interrupt(); /*-->>*/ sei();

 ausgetauscht.

__delay_cycles( T4_TWI ); /*-->>*/ if (T4_TWI%2){ _delay_loop_1(T4_TWI/3);}
                                   else {_delay_loop_2(T4_TWI/4);}

Hab jetzt keine Fehlermeldung mehr aber die Kommunikation funktioniert 
immer noch nicht.

Ich habe die vermutung das das Programm beim Warten auf den ACK-Bit 
hängen bleibt.

In dem Slave Programm musste ich die CPU_Frequenz meinem µC anpassen, 
muss ich das bei dem Master auch irgendwo angeben?

Muss ich da eventuell in der Zeile:

#define SYS_CLK   4000.0  // [kHz]

die 4000.0 durch 20000000 austauschen?

Würde mich über jegliche Lösungsvorschläge freuen.

Gruß
Philipp