USI.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include <ioavr.h>
#include <inavr.h>

#include "enums.h"
#include "structs.h"

#include "main.h"
#include "ADC.h"
#include "battery.h"
#include "time.h"
#include "USI.h"


//******************************************************************************
// Variables
//******************************************************************************
SPI_Status_t SPI;


//******************************************************************************
//Functions
//*****************************************************************************
#pragma vector=USI_OVF_vect
__interrupt void USI_OVF_ISR(void)
{
        // If the communication timed out, set ST_CMD as current state.
        if (!Time_Left(TIMER_USI)) {
                SPI.State = ST_CMD;
        }

        // Start communication timer. If further communication doesn't happen
        // within 1 second, the SPI communication state is reset to CMD.
        Time_Set(TIMER_USI, 0, 1, 0);
        
        // Clear USI counter and flag completed transfer.
        USISR = (1<<USIOIF);
        SPI.XferComplete = TRUE;
        
        // Process incoming data.
        switch(SPI.State)       {
        // A valid SPI transfer starts with a Command Byte sent by the Master.
        case ST_CMD:   
                SPI.Data = USIDR;  // Store the transferred byte.
                
                // If the master sent 0, it is trying to get data. Ignore in this state.
                if (SPI.Data != 0) {
                        // Does the master want to read or write?
                        if (SPI.Data & 0x40) {
                                SPI.Read = FALSE;
                        } else {
                                SPI.Read = TRUE;
                        }

                                // From/to EEPROM or SRAM?
                        if (SPI.Data &0x80) {
                                SPI.EEPROM = TRUE;
                        } else {
                                SPI.EEPROM = FALSE;
                        }

                        SPI.Count = (SPI.Data & 0x3F);  // Get number of bytes to receive/send.
                        SPI.State = ST_ADDR;  // The Master will send the address byte next.

                        SPI_Put(0xCC);  // Signal that command was received.
                }
        break;

                        
        case ST_ADDR:  
                SPI.Data = USIDR;  // Store the address.
                SPI.Address = SPI.Data;
                SPI.State = ST_DATA;  // The master will send/wait for data next.

                SPI_Put(0xBB);  // Signal that address was received.
        break;


        // Note well: this will process at least one byte, regardless of Count.
        case ST_DATA:
                if (SPI.Count-- > 0) {
                        // Write specified variable to SPI, "back to front".
                        if (SPI.Read) {
                                switch (SPI.Address) {
                                case ADR_ADCS:
                                        SPI_Put(*(((unsigned char*)&ADCS) + (SPI.Count)));
                                break;
                                
                                
                                case ADR_BATTACTIVE:
                                        SPI_Put(*((unsigned char*)&BattActive + (SPI.Count)));
                                break;
                                
                                
                                case ADR_BATTDATA:
                                        SPI_Put(*((unsigned char*)&BattData + (SPI.Count)));
                                break;
                                
                                
                                case ADR_BATTCTRL:
                                        SPI_Put(*((__eeprom unsigned char*)&BattControl + (SPI.Count)));
                                break;
                                
                                case ADR_TIMERS:
                                        SPI_Put(*((unsigned char*)&timeval + (SPI.Count)));
                                break;

                                
                                default:
                                        SPI_Put(0);
                                break;
                                }
                        } else {
                                // Read byte from SPI
                                SPI.Data = USIDR;

                                // ********************************************
                                // THIS FUNCTION HAS NOT BEEN FULLY IMPLEMENTED
                                // ********************************************
                                                                
                                // Save byte to specified variable.
                                switch (SPI.Address) {
                                case ADR_BATTCTRL:
                                        *((__eeprom unsigned char*)&BattControl + SPI.Count) = SPI.Data;
                                break;

                                
                                default:
                                break;
                                }
                        }
                        

                } else {
                        SPI.State = ST_CMD;
                }
        break;

        default:  // Shouldn't end up here. (Unknown SPI-state)
        break;
        }
}


void SPI_Init(unsigned char spi_mode)
{
        __disable_interrupt();
        
        // Configure outputs and inputs, enable pull-ups for DATAIN and CLOCK pins.
        USI_DIR_REG |= (1<<USI_DATAOUT_PIN);
        USI_DIR_REG &= ~((1<<USI_DATAIN_PIN) | (1<<USI_CLOCK_PIN));
        USI_OUT_REG |= (1<<USI_DATAIN_PIN) | (1<<USI_CLOCK_PIN);
        
        // Configure USI to 3-wire slave mode with overflow interrupt
        USICR = ( (1<<USIOIE) | (1<<USIWM0) | (1<<USICS1) | (spi_mode<<USICS0) );

        // Initialize the SPI struct
        SPI.Data = 0;                 // Clear data.
        SPI.State = ST_CMD;           // Initial SPI state: wait for command.
        SPI.Read = FALSE;             // Doesn't matter right now.
        SPI.EEPROM = FALSE;           // Doesn't matter right now.
        SPI.Count = 0;                // Doesn't matter right now.
        SPI.Address = 0;              // Doesn't matter right now.
        SPI.XferComplete = FALSE;     // We haven't even started a transfer yet.
        SPI.WriteCollision = FALSE;   // ..And therefore a collision hasn't happened.

        __enable_interrupt();
}


// Put one byte on bus. Use this function like you would write to the SPDR
// register in the native SPI module. Calling this function will prepare a
// byte for the next transfer initiated by the master device. If a transfer
// is in progress, this function will set the write collision flag and return
// without altering the data registers.
//
// Returns 0 if a write collision occurred, 1 otherwise.
unsigned char SPI_Put(unsigned char val)
{
        // Check if transmission in progress, i.e. if USI counter doesn't equal zero.
        // If this fails, flag a write collision and return.
        if((USISR & 0x0F) != 0) {
                SPI.WriteCollision = TRUE;
                return(FALSE);
        }

        // Reinitialize flags.
        SPI.XferComplete = FALSE;
        SPI.WriteCollision = FALSE;

        USIDR = val;  // Put data in USI data register.

        return (TRUE);
}


// Get one byte from bus. This function only returns the previous stored
// USIDR value. The transfer complete flag is not checked. Use this function
// like you would read from the SPDR register in the native SPI module.
unsigned char SPI_Get(void)
{
        return SPI.Data;
}


void SPI_Wait(void)
{
        do {  // Wait for transfer complete.
        } while (SPI.XferComplete == FALSE);
}

---