Colony

/* @file spi.c

 * @brief

 * SPI module

 * @bug broken

 */

#include <avr/interrupt.h>

#include "ring_buffer.h"

#include "spi.h"

#include <dragonfly_lib.h>

/*

SS = PB0

SCK = PB1

MOSI = PB2

MISO = PB3

*/

/* Controls clock freq. see Table 72 of specs*/

#define DOUBLE_SCK 1

#define SPR0_BIT 1

#define SPR1_BIT 0

#define LSB 1

#define MSB 0

RING_BUFFER_NEW(spi_buffer, 16, char, spi_send_buff, spi_rec_buff);

volatile char spi_status;

char spi_mode;

static spi_fun_recv_t  spi_recv_function;

//static spi_fun_send_t  spi_send_function;

void spi_init(char mode, spi_fun_recv_t recv_func) {

    usb_puts("spi_init: start\n");

        spi_mode = mode;

        RING_BUFFER_CLEAR(spi_send_buff);

        RING_BUFFER_CLEAR(spi_rec_buff);

        spi_recv_function = recv_func;

        //spi_send_function = send_func;

    /* Enables the SPI module

     * Enable Interrupt, Enable SPI Module, LSB First, Master Mode, Clock div = 64

     */

    SPCR = 0x00;

        SPCR = _BV(SPIE) | _BV(SPE) | _BV(DORD) | _BV(MSTR)| _BV(SPR1) | _BV(SPR0);

    SPSR = 0x00;

        SPSR = _BV(SPI2X); 

        spi_status = SPI_IDLE;

    /* Set SCLK, SS, MOSI as outputs. MISO as input */

        if(mode == MASTER) {

            DDRB |= MOSI | SCLK | SS;

            DDRB &= ~MISO;

                PORTB |= SS;        //Keep SS High until transmit

        /* Set SCLK, SS, MOSI as inputs. MISO as output */

        } else {

            DDRB &= ~MOSI & ~SCLK & ~SS;

            DDRB |= MISO;

    }

        //sei();

        usb_puts("spi_init: end\n");

}

int spi_send(char *data, int bytes) {

        int i;

    if(bytes == 0) 

        return -1; /* ...needed?*/

    //Prevent race condition on the buffer

    cli();

    for(i = 1; i < bytes; i++) {

        // Fail if the buffer is full

            if(RING_BUFFER_FULL(spi_send_buff)) {

                sei();

                return -1;

            }

            RING_BUFFER_ADD(spi_send_buff, data[i]);

    }

    sei();

    spi_status |= SPI_SEND;

        if (spi_mode == MASTER ){

                PORTB &= ~SS;        //Select slave

        }

    SPDR = *data;

        if(spi_mode)

                usb_puts("MASTER");

        else

                usb_puts("SLAVE");

        usb_puts(": sending [");usb_putc(*data);usb_puts("]\n\r");

        //sei();

        return 1;

}

void spi_read(int bytes) {

    cli();

    for(int i = 1; i < bytes; i++) {

        // Fail if the buffer is full

            if(RING_BUFFER_FULL(spi_send_buff)) {

                sei();

                return;

            }

            RING_BUFFER_ADD(spi_send_buff, '\n');

    }

    sei();

    spi_status |= SPI_RECV;

        if (spi_mode == MASTER ){

                PORTB &= ~SS;        //Select slave

        }

    SPDR = '\n';

}

void spi_read_one(void)

{

        PORTB &= ~SS;

        SPDR = 'x';

}

ISR(SIG_SPI) {

        char c;

    //The clock is running so dequeue another byte to send        

        if(!RING_BUFFER_EMPTY(spi_send_buff)) {//cheap way to test if SPI_SEND

                RING_BUFFER_REMOVE(spi_send_buff, c);

                SPDR = c;

        //If we're the master and we're done sending, end the transmission

        } else if (spi_mode == MASTER) {

            PORTB |= SS;

        }

        //You always receive something. You need to handle it.

    spi_recv_function(SPDR);        

        /*

        if(spi_status & SPI_SEND) {

                spi_status ^= SPI_SEND;

        if (spi_mode == MASTER) {

                    PORTB |= SS;

        }

    } else if (spi_status & SPI_RECV) {

    }

    */

    //End the transmission if we are not sending or recieving anymore

        //} else if(spi_mode == MASTER) {

        //   PORTB |= SS;

        //}

        //Call the recv function whenver we recieve a byte

        //if(spi_status == SPI_RECV){

                //spi_recv_function(SPDR);

                //if(spi_mode == MASTER)

                        //PORTB |= SS;

        //}

}