AtTiny2313 <-> FoxBoard G20 mit I2C

[Alex B. (alde_oma)]

Hallo,

ich bin gerade am Aufbau einer I2C-Verbindung zwischen einem AtTiny2313 
und dem FoxBoard G20. Ich habe nun das Problem, dass ich den AtTiny 
nicht "finden" kann.

Mit dem Befehl "i2cdetect -y 0" werden die I2C-Adressen von 00h bis 77h 
durchsucht, ob sich Geräte melden. Beim AtTiny wird aber nichts erkannt. 
Andere Bausteine funktionieren.

Muss man beim AtTiny zuvor noch irgendwelche Register setzen 
(Umschaltung SPI/I2C) oder ähnliches?

Die Pinbelgung:

AtTiny - FoxBoard

10 GND - J6.40 GND
17 SDA - J6.32 SDA
19 SCL - J6.31 SCL
20 VCC - +5V

Der Bus hat 2 Pullup-R mit 4,7kOhm auf 5V.

Um Hilfe wäre ich sehr Dankbar.

[Sven K. (Gast)]

Ähm,

Im tiny muss ein I2C Slave Programm laufen?

Gruß Sven

[c-hater (Gast)]

Alex B. schrieb:

> Muss man beim AtTiny zuvor noch irgendwelche Register setzen
> (Umschaltung SPI/I2C) oder ähnliches?

Du mußt vor allem erstmal ein Programm drauf flashen, was den Tiny zum 
I2C-Slave macht. Das Ding ist ein µC und wie jeder µC macht der ohne ein 
Programm erstmal garnix (jedenfalls nix sinnvolles).

[katastrophenheinz (Gast)]

Und außerdem: Bist du sicher, daß die I2C-Leitungen vom FoxBoard 
TTL-Level haben? Meistens hat dieser ARM-basierende Kram nur noch 3.3 V

Gruss, Heinz

[Alex B. (alde_oma)]

Danke.
Ich dachte die Adresse sei von Anfang an ansprechbar.
Die 5V Busspannung sind ein Fehler von mir. Müssen natürlich 3,3V sein.

[spess53 (Gast)]

Hi

>Ich dachte die Adresse sei von Anfang an ansprechbar.

Nö. Aber es gibt eine AppNote bei ATMEL:

http://www.atmel.com/Images/doc2560.pdf

Software: http://www.atmel.com/Images/AVR312.zip

MfG Spess

[Alex B. (alde_oma)]

Danke.
Ich habs mittlerweile hinbekommen. Jedoch hab ich grad Verständnis 
Probleme.

Ich schreibe vom FoxBoard zum Tiny mit dem Befehl:

I2C_WriteToDevice(i2c_fd, 0x02, 0x00);

wobei die Routine so aussieht:

void I2C_WriteToDevice(int fd, int reg, int val) {

    char buf[2];
    buf[0] = reg; //Register
    buf[1] = val; //Wert
    if (write(fd, buf, 2) != 2) {
        printf("Schreiben fehlgeschlagen...\n");
        return(0);
    }
}

Ich schreibe also den Wert 0x00 an das Register 0x02.

Die Auswertung auf dem Tiny hat ergeben, dass wenn ich an Register 2 
schreibe, ich auf "Wert == 2" abfragen muss, bei Register 1 auf "Wert == 
1" usw., damit ich ein True erhalte.

Ich kann jetzt aber nicht einfach auf irgendwelche Register schreiben. 
Daher die Frage auf welche kann ich? Die freien, auf dem Datenblatt mit 
Reserved gekenzeichneten? Passt das ganze so überhaupt wie ich das hier 
erkläre??? Kommt mir etwas komisch vor.

Mfg
Alex

[Alex B. (alde_oma)]

Hallo,

das Thema oben hat sich mittlerweile erledigt. Nun habe ich aber ein 
weiteres "Problem" bzw ein Verhalten, dass ich nicht verstehe.

Zunächst mal der Code vom Master:

i2c_buffer[0] = 3;
i2c_buffer[1] = 6;
i2c_buffer[2] = 40;
i2c_buffer[3] = 50;
i2c_buffer[4] = 152;
I2C_WriteToDevice();

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

void I2C_WriteToDevice(void) {

    if (write(i2c_fd, i2c_buffer, sizeof(i2c_buffer)) != sizeof(i2c_buffer)) {
        printf("Schreiben fehlgeschlagen...\n");
        return(0);
    }
}

ich möchte also die oben geschriebenen Werte dem Slave übergeben 
(ATTiny2313).

Der hat folgenden Code:

/****************************************************/
/* The USI as Slave                                 */
/* Author: Axel Gartner                             */
/****************************************************/
#define  F_CPU 1000000UL

#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define USI_DATA         USIDR
#define USI_STATUS      USISR
#define USI_CONTROL     USICR
#define USI_ADDRESS      0x20

#define NONE        0
#define ACK_PR_RX      1
#define BYTE_RX        2
#define ACK_PR_TX      3
#define PR_ACK_TX      4
#define BYTE_TX        5

// Device dependant defines
/*#if defined(__at90tiny26__) | defined(__attiny26__)
#define DDR_USI             DDRB
#define PORT_USI            PORTB
#define PIN_USI             PINB
#define PORT_USI_SDA        PORTB0
#define PORT_USI_SCL        PORTB2
#endif*/

#if defined(__AVR_ATtiny2313A__)
#define DDR_USI             DDRB
#define PORT_USI            PORTB
#define PIN_USI             PINB
#define PORT_USI_SDA        PORTB5
#define PORT_USI_SCL        PORTB7
#endif

volatile uint8_t COMM_STATUS = NONE;


//uint8_t tmp1[2];


void USI_init(void) {
  // 2-wire mode; Hold SCL on start and overflow; ext. clock
  USI_CONTROL |= (1<<USIWM1) | (1<<USICS1);
  USI_STATUS = 0xf0;  // write 1 to clear flags, clear counter
  DDR_USI  &= ~(1<<PORT_USI_SDA);
  PORT_USI &= ~(1<<PORT_USI_SDA);
  DDR_USI  |=  (1<<PORT_USI_SCL);
  PORT_USI |=  (1<<PORT_USI_SCL);
  // startcondition interrupt enable
  USI_CONTROL |= (1<<USISIE);
}

int main(void) {

  USI_init();
  sei();

  for(;;)  {
  }

}

SIGNAL(USI_START_vect ) {
  uint8_t tmpUSI_STATUS;
  tmpUSI_STATUS = USI_STATUS;
  COMM_STATUS = NONE;
  // Wait for SCL to go low to ensure the "Start Condition" has completed.
  // otherwise the counter will count the transition
  while ( (PIN_USI & (1<<PORT_USI_SCL)) );
  USI_STATUS = 0xf0; // write 1 to clear flags; clear counter
  // enable USI interrupt on overflow; SCL goes low on overflow
  USI_CONTROL |= (1<<USIOIE) | (1<<USIWM0);
}

SIGNAL(USI_OVERFLOW_vect ) {
  uint8_t BUF_USI_DATA = USI_DATA;
  
  switch(COMM_STATUS) {
    case NONE:
      if (((BUF_USI_DATA & 0xfe) >> 1) != USI_ADDRESS) {  // if not receiving my address
        // disable USI interrupt on overflow; disable SCL low on overflow
        USI_CONTROL &= ~((1<<USIOIE) | (1<<USIWM0));
      }
      else { // else address is mine
        DDR_USI  |=  (1<<PORT_USI_SDA);
        USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
        if (BUF_USI_DATA & 0x01) COMM_STATUS = ACK_PR_TX; else COMM_STATUS = ACK_PR_RX;
      }
    break;
    
    case ACK_PR_RX:
      DDR_USI  &= ~(1<<PORT_USI_SDA);
      COMM_STATUS = BYTE_RX;
    break;
    
    case BYTE_RX:
      /* Save received byte here! ... = USI_DATA */
          
      if (USI_DATA == 6) {
        PORTD |= (1<<PD3);
        _delay_ms(1000);
        PORTD &= ~(1<<PD3);
      }
          
      DDR_USI  |=  (1<<PORT_USI_SDA);
      USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
      COMM_STATUS = ACK_PR_RX;
    break;
    
    case ACK_PR_TX:
      /* Put first byte to transmit in buffer here! USI_DATA = ... */
          
      PORT_USI |=  (1<<PORT_USI_SDA); // transparent for shifting data out
      COMM_STATUS = BYTE_TX;
    break;
    
    case PR_ACK_TX:
    if(BUF_USI_DATA & 0x01) {
      COMM_STATUS = NONE; // no ACK from master --> no more bytes to send
    }
    else {
      /* Put next byte to transmit in buffer here! USI_DATA = ... */
      PORT_USI |=  (1<<PORT_USI_SDA); // transparent for shifting data out
      DDR_USI  |=  (1<<PORT_USI_SDA);
      COMM_STATUS = BYTE_TX;
    }
    break;
    
    case BYTE_TX:
      DDR_USI  &= ~(1<<PORT_USI_SDA);
      PORT_USI &= ~(1<<PORT_USI_SDA);
      USI_STATUS = 0x0e;  // reload counter for ACK, (SCL) high and back low
      COMM_STATUS = PR_ACK_TX;
    break;
  }
  USI_STATUS |= (1<<USIOIF); // clear overflowinterruptflag, this also releases SCL
}

Wenn ich nun das Register "USI_DATA" abfrage, sind darin alle gesendeten 
Werte vom Master enthalten. Die If-Abfrage trifft also bei 3, 6 ... zu. 
USI_DATA ist ja aber nur ein 1 Byte Register. Wie können darin dann 5 
Bytes enthalten sein? Und wie bekomme ich es hin, die Bytes einzel 
auszulesen?

[Marcel (Gast)]

Alex B. schrieb:
> /* Save received byte here! ... = USI_DATA */

Indem du an der Stelle, genau wie es im Kommentar steht, die empfangenen 
Bytes speicherst. Dazu machst du dir ein Array und merkst dir die 
aktuelle Schreibeposition. Dahin kommt dann dein Byte.

[c]
empfangsbuffer[akutelle_position] = USI_DATA;
[c]

Noch ein bisschen Verwaltungskram drumrum und eine Erkennung dafür, wann 
ein Datenpaket komplett ist, und du bist fertig.

[Alex B. (alde_oma)]

Hi,

das ist klar.

      for (uint8_t i=0; i<5; i++) {
        tmp1[i] = USI_DATA;
      }

Aber so wird in jedes tmp1-Byte der gesamt Inhalt geschrieben.
Wie es dann aber weiter geht, kapier ich nicht. Hab mir das DB auch 
schon durchgelesen, blicks aber nicht. Wird nach jedem Byte ein 
Interrupt ausgelöst, oder wenn alle Bytes angekommen sind?
Wann muss ich in tmp das nächste Byte angeben?

[Marcel (Gast)]

Ich habe mit dem I²C des ATTiny2313 noch nicht gearbeitet, aber 
normalerweise wird für jedes Byte ein Interrupt erzeugt. Daher ist eine 
Schleife an der Stelle vollkommen ungeeignet.
Du schreibst jeden Interrupt-Aufruf ein Byte in dein Array und wertest 
es aus, wenn du deine 5 Bytes hast.