Suche Soft-I2C-Slave Lib

#ifndef TWISLAVE_H_

#define TWISLAVE_H_

#include <avr/io.h>

#include <avr/interrupt.h>

#define SDA PD2        // Definition of pin used as SDA

#define SCL PD7        // Definition of pin used as SCL

#define SLAVE_ADDRESS 0x5D  // Definition of 7 bit slave address

#define INITIALIZE_SDA()        ( PORTD &= ~ (1 << SDA) )    // Clear port

#define READ_SDA()              ( PIND & (1 << SDA) )      // Read SDA pin value

#define READ_SCL()              ( PIND & (1 << SCL) )      // Read SCL pin value

#define SETSDA()  ( PORTD &= ~(1 << SDA) )            // Set SDA pin Tristate

#define CLRSDA()  ( PORTD |= (1 << SDA) )            // Set SDA pin pull it low

#define INITIALIZE_TWI_INTERRUPT()    (EICRA |= (1<<ISC01))    // Sets falling edge of SDA generates interrupt

#define ENABLE_TWI_INTERRUPT()        (EIMSK |= (1<<INT0))    // Enables SDA interrupt

#define DISABLE_TWI_INTERRUPT()       (EIMSK &= ~(1<<INT0))    // Disables SDA interrupt

#define CLEAR_TWI_INTERRUPT_FLAG()    (EIFR = (1<<INTF0))    // Clears interrupt flag

#define TWI_SLA_REQ_W_ACK_RTD              0x60

#define TWI_SLA_DATA_RCV_ACK_RTD           0x80

#define TWI_SLA_DATA_RCV_NACK_RTD          0x88

#define TWI_SLA_REQ_R_ACK_RTD              0xA8

#define TWI_SLA_DATA_SND_ACK_RCV           0xB8

#define TWI_SLA_DATA_SND_NACK_RCV          0xC0

#define TWI_SLA_LAST_DATA_SND_ACK_RCV      0xC8

#define TWI_SLA_REPEAT_START               0xA0

#define TWI_SLA_STOP                       0x68

#define I2C_IDLE                           0x00

unsigned char readI2Cslavebyte(void);

void twi_slave_init(void);

void twi_slave_enable(void);

void twi_slave_disable(void);

void receivedata(void);

void senddata(void);

void TWI_state_machine(void);

void GetStartCondition(void);

#include "twislave.h"

unsigned char incomingBuffer[8];                  // Incoming buffer

unsigned char outgoingBuffer[6] = {0xAA,0xAB,0xAC,0xAD,0xAE,0xAF};  // Preloaded outgoing buffer for testing

unsigned char walker = 0;                      // Walks through the buffer array.

static char TWI_SLA_TWSR = 0;                    // Emulates TWI module TWSR

static char TWI_SLA_TWDR = 0;                    // Emulates TWI module TWDR

static char TWI_SLA_TWEA = 0;                    // If set, ACK is sent otherwise not. Similar to TWEA bit of TWI module.

void twi_slave_init(void)

{

  INITIALIZE_SDA();

  INITIALIZE_TWI_INTERRUPT();

  TWI_SLA_TWEA = 1;  

  TWI_SLA_TWSR = I2C_IDLE;

}

void twi_slave_enable(void)

{

  CLEAR_TWI_INTERRUPT_FLAG();

  ENABLE_TWI_INTERRUPT();

}

void twi_slave_disable(void)

{

  DISABLE_TWI_INTERRUPT();

  CLEAR_TWI_INTERRUPT_FLAG();

}

ISR (INT0_vect)

{

  volatile char retval;

  if(TWI_SLA_TWSR == I2C_IDLE)

  {

    GetStartCondition();

  }

  //!Call the TWi state machine

  TWI_state_machine();

  CLEAR_TWI_INTERRUPT_FLAG();

  ENABLE_TWI_INTERRUPT();

}

inline unsigned char readI2Cslavebyte(void)

{

  char index = 0;

  unsigned char val = 0;

  char cPin = 0;

  //Let SCL go low first. MCU comes here while SCL is still high

  while(READ_SCL());

  //!read 8 bits from master, respond with ACK.

  //!SCL could be high or low depending on CPU speed

  for(index = 0;index < 8; index++)

  {

    while(!READ_SCL());

    cPin = READ_SDA();

    val = (val<<1) | cPin;

    while(READ_SCL())

    {

      //if SDA changes while SCL is high, it indicates STOP or START

      if((val & 1)!= cPin)

      {

        if(READ_SDA())

        TWI_SLA_TWSR = TWI_SLA_STOP;

        else

        TWI_SLA_TWSR = TWI_SLA_REPEAT_START;

        return 0;

        //!return READ_SDA()?I2C_STOP_DETECTED:I2C_START_DETECTED;

      }

      else

      cPin = READ_SDA();

    }

  }

  //!Send ACK, SCL is low now

  if((val & 0xFE) == (SLAVE_ADDRESS << 1))

  {

    CLRSDA();

    while(!READ_SCL());

    while(READ_SCL());

    SETSDA();

  }

  else

  {

    TWI_SLA_TWSR = I2C_IDLE;

    return 0;

  }

  return val;

}

inline void senddata(void)

{

  char index;

  for(index = 0;index < 8; index++)

  {

    while(READ_SCL());

    if((TWI_SLA_TWDR >> (7 - index))&1)

    SETSDA();

    else

    CLRSDA();

    while(!READ_SCL());

  }

  //!See if we get ACK or NACk

  while(READ_SCL());

  //!tristate the pin to see if ack comes or not

  SETSDA();

  while(!READ_SCL());

  if(!READ_SDA())

  TWI_SLA_TWSR = TWI_SLA_DATA_SND_ACK_RCV;

  else

  TWI_SLA_TWSR = TWI_SLA_DATA_SND_NACK_RCV;

}

inline void receivedata(void)

{

  char index;

  TWI_SLA_TWDR = 0;

  //!read 8 bits from master, respond with ACK.

  //!SCL could be high or low depending on CPU speed

  for(index = 0;index < 8; index++)

  {

    while(!READ_SCL());

    TWI_SLA_TWDR = (TWI_SLA_TWDR<<1) | READ_SDA();

    while(READ_SCL())

    {

      //!if SDA changes while SCL is high, it indicates STOP or START

      if((TWI_SLA_TWDR & 1)!= READ_SDA())

      {

        if(READ_SDA())

        TWI_SLA_TWSR = TWI_SLA_STOP;

        else

        TWI_SLA_TWSR = TWI_SLA_REPEAT_START;

        return;

      }

    }

  }

  if(TWI_SLA_TWEA)

  {

    //!Send ACK, SCL is low now

    CLRSDA();

    while(!READ_SCL());

    while(READ_SCL());

    SETSDA();

    TWI_SLA_TWSR = TWI_SLA_DATA_RCV_ACK_RTD;

    TWI_SLA_TWEA = 0;

  }

  else

  {

    TWI_SLA_TWSR = TWI_SLA_DATA_RCV_NACK_RTD;

  }

}

void TWI_state_machine(void)

{

    //! get current state

START: 

    //! \brief lock twi task              

    switch (TWI_SLA_TWSR) 

    {    

        /*! Own SLA_W has been received; 

         *! ACK has been returned

         */

        case TWI_SLA_REQ_W_ACK_RTD: 

            walker = 0;

            incomingBuffer[walker++] = TWI_SLA_TWDR; 

            TWI_SLA_TWEA = 1;

            receivedata();

            goto START;

            break;

        //! data recieved, NACK has been returned

        case TWI_SLA_DATA_RCV_NACK_RTD:

            TWI_SLA_TWSR = I2C_IDLE;

            TWI_SLA_TWEA = 1;

            break;

        //! data recieved, ack has been returned

        case TWI_SLA_DATA_RCV_ACK_RTD:

            incomingBuffer[walker++] = TWI_SLA_TWDR;

            TWI_SLA_TWEA = 1;

            receivedata();

            goto START;

            break;

        /*! Own SLA_R has been received; 

         *! ACK has been returned

         */

        case TWI_SLA_REQ_R_ACK_RTD:

            walker = 0;  

            TWI_SLA_TWDR = outgoingBuffer[walker++];

            TWI_SLA_TWEA = 1;

            senddata();

            goto START;

            break;

        //! data has been transmitted, ACK has been received.

        case TWI_SLA_DATA_SND_ACK_RCV:

            TWI_SLA_TWDR = outgoingBuffer[walker++];

            TWI_SLA_TWEA = 1;

            senddata();

            goto START;

            break;

        //! last data has been transmitted, ACK has been received.

        case TWI_SLA_LAST_DATA_SND_ACK_RCV:

        //! data has been transmitted, NACK has been received.

        case TWI_SLA_DATA_SND_NACK_RCV:

            TWI_SLA_TWEA = 1;

            TWI_SLA_TWSR = I2C_IDLE;

            break;

        //! met stop or repeat start

        case TWI_SLA_STOP:

            //! return to idle state

            TWI_SLA_TWEA = 1;

            TWI_SLA_TWSR = I2C_IDLE;

            break;

        case TWI_SLA_REPEAT_START:  

      GetStartCondition();

      goto START;

        //! Idle or bus error

        case I2C_IDLE:

        default:

            TWI_SLA_TWEA = 1;

            break;        

    }

}

inline void GetStartCondition(void)

{

  char retval = 0;

  // Make sure it is the start by checking SCL high when SDA goes low

  if(READ_SCL())

  {

    DISABLE_TWI_INTERRUPT();

  }

  else // false trigger; exit the ISR

  {

    CLEAR_TWI_INTERRUPT_FLAG();

    ENABLE_TWI_INTERRUPT();

    return;

  }

  // lop for one or several start conditions before a STOP

  if(TWI_SLA_TWSR == I2C_IDLE || TWI_SLA_TWSR == TWI_SLA_REPEAT_START)

  {

    retval = readI2Cslavebyte(); // read address

    if(retval == 0) // STOP or other address received

    {

      TWI_SLA_TWSR = I2C_IDLE;

      CLEAR_TWI_INTERRUPT_FLAG();

      ENABLE_TWI_INTERRUPT();

      return;

    }

    else

    {

      if(retval & 1)

      TWI_SLA_TWSR = TWI_SLA_REQ_R_ACK_RTD;

      else

      TWI_SLA_TWSR = TWI_SLA_REQ_W_ACK_RTD;

    }

  }

  TWI_SLA_TWDR = retval;

}