spi.c

Go to the documentation of this file.

 
#include "user_config.h"
#include <stdlib.h>
#include "spi.h"
 
static uint32_t SPI0_Speed_value = 0;
 
void SPI0_Speed(uint32_t speed)
{
    uint32_t rate;
 
// Computer Prescale rate - truncate.
 
#if 1
// We only make changes if the speed actually changes
    if(speed == SPI0_Speed_value)
        return;
#endif
 
    // rate = ((uint32_t) F_CPU) / speed;
    // Round
    rate = ((uint32_t) F_CPU + (speed/2)) / speed;
    printf("spi rate: %ld\n", (unsigned long) rate);
 
 
    if(rate >= 128)
    {
// 128
        BIT_CLR(SPSR, SPI2X);
        BIT_SET(SPCR, SPR1);
        BIT_SET(SPCR, SPR0);
    }
    else if(rate >= 64)
    {
// 64
        BIT_CLR(SPSR, SPI2X);
        BIT_SET(SPCR, SPR1);
        BIT_SET(SPCR, SPR0);
    }
    else if(rate >= 32)
    {
// 32
        BIT_SET(SPSR, SPI2X);
        BIT_SET(SPCR, SPR1);
        BIT_CLR(SPCR, SPR0);
    }
    else if(rate >= 16)
    {
// 16
        BIT_CLR(SPSR, SPI2X);
        BIT_CLR(SPCR, SPR1);
        BIT_SET(SPCR, SPR0);
    }
    else if(rate >= 8)
    {
// 8;
        BIT_SET(SPSR, SPI2X);
        BIT_CLR(SPCR, SPR1);
        BIT_SET(SPCR, SPR0);
    }
    else if(rate >= 4)
    {
// 4;
        BIT_CLR(SPSR, SPI2X);
        BIT_CLR(SPCR, SPR1);
        BIT_CLR(SPCR, SPR0);
    }
    else if(rate >= 2)
    {
// 2;
        BIT_SET(SPSR, SPI2X);
        BIT_CLR(SPCR, SPR1);
        BIT_CLR(SPCR, SPR0);
    }
    else
    {
// 2 fastest rate;
        BIT_SET(SPSR, SPI2X);
        BIT_CLR(SPCR, SPR1);
        BIT_CLR(SPCR, SPR0);
    }
    SPI0_Speed_value = speed;
}
 
 
uint32_t SPI0_Get_Speed( void )
{
    return(SPI0_Speed_value);
}
 
 
static int SPI0_Mode_value = 0;
 
void SPI0_Mode(int mode)
{
    switch(mode)
    {
        case 0:
            BIT_CLR(SPCR,CPOL);
            BIT_CLR(SPCR,CPHA);
            break;
        case 1:
            BIT_CLR(SPCR,CPOL);
            BIT_SET(SPCR,CPHA);
            break;
        case 2:
            BIT_SET(SPCR,CPOL);
            BIT_CLR(SPCR,CPHA);
            break;
        case 3:
            BIT_SET(SPCR,CPOL);
            BIT_SET(SPCR,CPHA);
            break;
        default:
            printf("SPI0_Mode: Invalid mode(%d)\n",mode);
            break;
    }
    SPI0_Mode_value = mode;
}
 
 
int SPI0_Get_Mode( void )
{
    return(SPI0_Mode_value);
}
 
 
static int SPI0_Init_state = 0;
 
void SPI0_Init(uint32_t speed)
{
 
    volatile uint8_t D  __attribute__((unused));
 
#ifdef SPI_DEBUG
    printf("SPI0_Init speed:%ld\n",speed);
#endif
 
#ifdef SPI_DEBUG
    printf("SS HI\n");
    printf("Port B DDR:   0x%02x\n", (int) GPIO_PORT_DDR_RD(GPIO_B));
    printf("Port B LATCH: 0x%02x\n", (int) GPIO_PORT_LATCH_RD(GPIO_B));
    printf("Port B PINS:  0x%02x\n", (int) GPIO_PORT_LATCH_RD(GPIO_B));
#endif
 
    SPCR = 0;                                     // Clear SPCR in case we are not called after RESET
 
    GPIO_PIN_HI(SCK);                             // SCK Output
    GPIO_PIN_HI(MOSI);                            // MOSI Output
    GPIO_PIN_FLOAT(MISO);                         // MISO Input, no pull-up
 
// Warning *** MSTR MUST be set BEFORE SPE!!!! *** otherwise SS will NOT behave as an output
    GPIO_PIN_LOW(SS);                             // SS Output must be HI prevent slave mode from getting set while initializing
    BIT_SET(SPCR, MSTR);                          // Master Mode
    BIT_SET(SPCR, SPE);                           // Enable SPI
 
// SPI Clear any pending interrupt flags
    D = SPSR;
    D = SPDR;
 
    SPI0_Mode(0);
 
// Set SPI clock speed
    SPI0_Speed(speed);
 
    SPI0_TXRX_Byte(0xff);                         // Send dummy 0xFF
    SPI0_Init_state = 1;
 
}
 
 
uint8_t SPI0_TXRX_Byte(uint8_t Data)
{
    SPDR = Data;                                  // Transmit
 
    while( !BIT_TST(SPSR,SPIF) )                  // Wait for send
        ;
 
    return (SPDR);                                // Received Data
}
 
 
// =============================================
 
void SPI0_TX(uint8_t *data, int count)
{
 
    while(count > 0)
    {
        SPI0_TXRX_Byte(*data);
        ++data;
        --count;
    }
}
 
 
 
void SPI0_TXRX(uint8_t *data, int count)
{
 
    while(count > 0)
    {
        *data = SPI0_TXRX_Byte(*data);
        ++data;
        --count;
    }
}
 
 
void SPI0_RX(uint8_t *data, int count)
{
 
    while(count > 0)
    {
        *data = SPI0_TXRX_Byte(0xff);
        ++data;
        --count;
    }
}