Colony » Colony Scout

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#define RECV_BUF_SIZE 2

uint8_t address;

enum {

  IDLE,

  ADDRESS,

  SEND_READ_ACK,

  SEND_WRITE_ACK,

  SEND_DATA,

  RECV_DATA,

  RECV_ACK

} state;

uint8_t recv_idx;

uint8_t recv_data[RECV_BUF_SIZE];

slave_rx_t onDataRecieved;

static void twi_set_ctr(char n) {

  USISR &= ~0x0F;

  USISR |= n;

}

static void twi_release_scl() {

  DDRB &= ~_BV(DDB2);

}

static void twi_sink_sda() {

  DDRB |= _BV(DDB0);

}

static void twi_release_sda() {

  DDRB &= ~_BV(DDB0);

}

static void twi_ready() {

  // enable start condition interrupt

  USICR |= _BV(USISIE);

  // disable counter overflow interrupt

  USICR &= ~_BV(USIOIE);

  state = IDLE;

}

static void twi_start() {

  // zero counter

  twi_set_ctr(0);

  // enable counter overflow interrupt (fires after 8 bits)

  USICR |= _BV(USIOIE);

  state = ADDRESS;

  recv_idx = 0;

}

static void twi_send_ack(char is_read) {

  // set counter to 14

  twi_set_ctr(14);

  // set SDA low

  USIDR = 0;

  twi_sink_sda();

  // set state

  state = is_read? SEND_READ_ACK : SEND_WRITE_ACK;

}

ISR(USI_START_vect) {

  twi_start();

}

ISR(USI_OVF_vect) {

  uint8_t input = USIBR;

  switch (state) {

    case IDLE:

      // shouldn't reach here

      twi_ready();

      break;

    case ADDRESS:

      if (input >> 1 == address) {

        // send ack

        twi_send_ack(input & 1);

      } else {

        // go back to listening for start condition

        twi_ready();

      }

      break;

    case SEND_WRITE_ACK:

      twi_release_sda();

      state = RECV_DATA;

      break;

    case RECV_DATA:

      twi_send_ack(0);

      recv_data[recv_idx] = USIBR;

      recv_idx++;

      if (recv_idx == RECV_BUF_SIZE) {

        twi_ready();

        onDataRecieved(recv_data, RECV_BUF_SIZE);

      }

      break;

    case SEND_READ_ACK:

      twi_release_sda();

      // TODO write to USIDR

      state = SEND_DATA;

      break;

    case SEND_DATA:

      break;

    case RECV_ACK:

      break;

  }

  twi_release_scl();

}

<<<<<<< HEAD

void smb_init(slave_rx_t callback) {

  state = START;

=======

void smb_init() {

>>>>>>> Added sink/release sda/scl

  // TODO do we want USICS0 (3)?

  USICR = _BV(USIWM1) | _BV(USIWM0) | _BV(USICS1);

  twi_ready();

  onDataRecieved = callback;

}

void smb_set_address(uint8_t addr) {

  address = addr;

}

void testCB(uint8_t* data, int length) {

  PORTB |= _BV(PB4);

  if (data[0])

    _delay_ms(1000);

  else

    _delay_ms(500);

  PORTB &= ~_BV(PB4);

}

int main() {

  smb_set_address(5);

  DDRB |= _BV(DDB4);

  smb_init(testCB);

}