ATMega I2C Slave - 16-Bit antwort?

[Johannes M. (Gast)]

Hallo,

Ich habe mit 5x 74HC4051 und 5 x ADC Eingängen des ATMega328P einen 
Analogmultiplexer für ein 40-Potentiometer-Array gebaut.

Nun möchte ich, dass der ATMega als I2C-Slave läuft. Die 40 Werte für 
die 40 Potis werden in einem uint16_t array mit 40 Elementen 
gespeichert. Ich habe nun zwei befehle: OP_RESET, zum resetten des array 
counters (von vorn beginnen) und OP_PROBE zum auslesen eines Potis, 
welcher nun 40 mal aufgerufen wird um 40 Potis auszulesen. Das TWDR 
(Two-Wire/I2C Data register ist aber 8-Bit weit).. Was ist die gängige 
Praxis um 2 x 8-Bit als Antwort auf einen Request über I2C zu schicken?

Hier der Code:

#include <avr/io.h>
#include <util/delay.h>
#include <compat/twi.h>
#include <avr/interrupt.h>
#include "l74hc4051.h"
#include "adc.h"

#define I2C_ADDR 0x4E

#deinfe OP_RESET 0x00
#define OP_PROBE 0x01
#define OP_SINGLE 0x02

#define IODIR 0x00
#define GPIO 0x09
#define OLAT 0x0A
unsigned char regaddr;    // Store the MCP23008 Requested Register Address
unsigned char regdata;    // Store the MCP23008 Register Address Data
unsigned char index;

uint16_t current_values[40] = {0};
uint16_t old_values[40] = {0};

void i2c_slave_action(unsigned char rw_status)
{
   // rw_status: 0-Read, 1-Write
   switch(regaddr) {

     case OP_RESET:
  if(rw_status)++
  {
    index = 0;
  }
  else
  {
    index = 0;
    regdata = 0xFF;
  }
  break;


     case OP_PROBE:
       if (rw_status) {
       } else {
  if(index < 80)
  {
     regdata=current_values[index++];
  }
   else
  {
    index = 0;
    regdata=0x00;
  }
       }    
       break;
   }
}
ISR(TWI_vect)
{
   static unsigned char i2c_state;
   unsigned char twi_status;
   // Disable Global Interrupt
   cli();
   // Get TWI Status Register, mask the prescaler bits (TWPS1,TWPS0)
   twi_status=TWSR & 0xF8;     

   switch(twi_status) {
     case TW_SR_SLA_ACK:      // 0x60: SLA+W received, ACK returned
       i2c_state=0;           // Start I2C State for Register Address required   

       TWCR |= (1<<TWINT);    // Clear TWINT Flag
       break;
     case TW_SR_DATA_ACK:     // 0x80: data received, ACK returned
       if (i2c_state == 0) {
         regaddr = TWDR;      // Save data to the register address
   i2c_state = 1;
       } else {
   regdata = TWDR;      // Save to the register data
   i2c_state = 2;
       }

       TWCR |= (1<<TWINT);    // Clear TWINT Flag
       break;
     case TW_SR_STOP:         // 0xA0: stop or repeated start condition received while selected
       if (i2c_state == 2) {
   i2c_slave_action(1); // Call Write I2C Action (rw_status = 1)
   i2c_state = 0;        // Reset I2C State
       }     

       TWCR |= (1<<TWINT);    // Clear TWINT Flag
       break;

     case TW_ST_SLA_ACK:      // 0xA8: SLA+R received, ACK returned
     case TW_ST_DATA_ACK:     // 0xB8: data transmitted, ACK received
       if (i2c_state == 1) {
   i2c_slave_action(0); // Call Read I2C Action (rw_status = 0)
   TWDR = regdata;      // Store data in TWDR register
   i2c_state = 0;        // Reset I2C State
       }         

       TWCR |= (1<<TWINT);    // Clear TWINT Flag
       break;
     case TW_ST_DATA_NACK:    // 0xC0: data transmitted, NACK received
     case TW_ST_LAST_DATA:    // 0xC8: last data byte transmitted, ACK received
     case TW_BUS_ERROR:       // 0x00: illegal start or stop condition
     default:
       TWCR |= (1<<TWINT);    // Clear TWINT Flag
       i2c_state = 0;         // Back to the Begining State
   }
   // Enable Global Interrupt
   sei();
}
int main(void)
{
  DDRB = 0xFE;      // Set PORTB: PB0=Input, Others as Output
  PORTB = 0x00;
  DDRD = 0xFF;      // Set PORTD to Output
  PORTD = 0x00;     // Set All PORTD to Low


  // XXX 
  l74hc4051_init();
  adc_setchannel(1);
  adc_init();

  // Initial I2C Slave
  TWAR = I2C_ADDR & 0xFE; // Set I2C Address, Ignore I2C General Address 0x00
  TWDR = 0x00;                 // Default Initial Value
  // Start Slave Listening: Clear TWINT Flag, Enable ACK, Enable TWI, TWI Interrupt Enable
  TWCR = (1<<TWINT) | (1<<TWEA) | (1<<TWEN) | (1<<TWIE);
  // Enable Global Interrupt
  sei();

  // Initial Variable Used
  regaddr=0;
  regdata=0;

  for(;;) {
  uint8_t i,j = 0;
        for(j=0; j < 5; j++)
  {
    for(i=0; i<L74HC4051_MAXCH; i++) {
      l74hc4051_setchannel(i);
      current_values[i*j] = adc_read(j);
    }
    _delay_us(100);
  }

  }
  return 0;
}

[Johannes M. (Gast)]

PS: Dieser Code beinhaltet noch einige "tote" Elemente aus einem anderen 
code aus dem AVR-Forum. Daher bitte den Rest ignorieren.

[Peter D. (peda)]

Johannes M. schrieb:
> Was ist die gängige
> Praxis um 2 x 8-Bit als Antwort auf einen Request über I2C zu schicken?

Einfach soviele Bytes senden, wie Du lustig bist.
Du kannst auch alle 80 Bytes übertragen.
Der Master sendet die Nummer des zu lesenden Potis und liest dann die 2 
Bytes aus. Liest er mehr Bytes aus, wird einfach das nächste Poti 
übertragen usw. Hat er keine Lust mehr, zu lesen, setzt er vor dem 
letzten Byte einfach das NACK.

[Johannes M. (Gast)]

Das heißt in der Praxis?
Kann TWDR mehrere male hintereinander gesetzt werden?
Oder muss ein bestimmtes register dazwischen gesetzt werden?

[Peter D. (peda)]

Steht alles im Datenblatt:

21.7.4 Slave Transmitter Mode

Table 21-5. Status Codes for Slave Transmitter Mode

Figure 21-18. Formats and States in the Slave Transmitter Mode

[jonas biensack (Gast)]

>Oder muss ein bestimmtes register dazwischen gesetzt werden?

Meistens muss man ein Register auslesen, welches einen Status über das 
Versenden beinhaltet (noch im Puffer, schon gesendet...).

Gruß Jonas

[Johannes M. (Gast)]

Hmm, anders als 2 Kommandos für MSB-Übertragen und LSB-Übertragen zu 
haben kriege ich es aktuell nicht ohne Probleme hin.

[Peter D. (peda)]

Woran hapert es denn?
Du mußt bei jedem Daten-Interrupt (0xA8, 0xB8) einfach das nächste Byte 
senden.

Funktioniert denn der Master überhaupt?
Nimm doch erstmal einen EEPROM (z.B. 24C02) und schreibe / lese den im 
Page-Mode (z.B. 8 Byte).
Ehe das nicht geht, brauchst Du mit dem Slave garnicht erst anfangen.

[Johannes M. (Gast)]

Nene, das funktioniert schon alles.
Nur bisher habe ich Byte-Weise ausgelesen und hatte ein Kommando
für LSB lesen und eins für MSB lesen.

[Peter D. (peda)]

Johannes M. schrieb:
> Nene, das funktioniert schon alles.

D.h. bei einem standard Slave kann dein Master erfolgreich mehrere Bytes 
am Stück lesen/schreiben?

Johannes M. schrieb:
> Nur bisher habe ich Byte-Weise ausgelesen

Wenn der Master nur ein Byte liest, kann doch der Slave nichts für.

[Johannes M. (Gast)]

Der Slave ist ein bare-bones ATMega328P.
Der Master ist ein mega328p mit Arduino-Firmare und macht folgendes:

Wire.beginTransmission(I2C_deviceAddress);
Wire.send(registerLocation);
Wire.endTransmission();
Wire.requestFrom(I2C_deviceAddress, howManyBytes);
... Wire.read() (howManyBites mal)

Ich würde jetzt erwarten, dass ich 20 x uint8_t ankommen,
wenn ich 20 Bytes anfrage.