SPI_AFE031

/*main.c

 Created on: Jun 9, 2013
     Author: Dany

Description: Generating a sine output from the DAC and PA of the AFE031
Pinout:
    ADCINA0---RxPGA2_Out
    SPICLK----SCLK
    GPIO6-----SD (Shutdown)
    GPIO12----INT (Interrupt flag)
    GPIO4-----Tx_Flag
    GPIO5-----Rx_Flag
    SPISIMOA--DIN
    SPIDOMIA--DOUT
    SPISTEA---CS (active low)
    GPIO7-----DAC (active high)
*/

#include <stdio.h>
#include <file.h>

#include "DSP28x_Project.h"     // DSP28x Headerfile

#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/wdog.h"

#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/sci_io.h"
#include "f2802x_common/include/spi.h"

extern void DSP28x_usDelay(Uint32 Count);

CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;
CLK_Handle myClk;

ADC_Handle myAdc;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;
SPI_Handle mySpi;

void setup_handles(void) {
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
    mySpi = SPI_init((void *)SPIA_BASE_ADDR, sizeof(SPI_Obj));
    myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
}

void init_system(void) {
    WDOG_disable(myWDog);
    (*Device_cal)();
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
    PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif
}

void init_scia(void) {
    volatile int status = 0;
    volatile FILE *fid;
    CLK_enableSciaClock(myClk);

    // 1 stop bit,  No loopback
    // No parity,8 char bits,
    // async mode, idle-line protocol
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits);

    SCI_enableTx(mySci);
    SCI_enableRx(mySci);
    SCI_enableTxInt(mySci);
    SCI_enableRxInt(mySci);

    // SCI BRR = LSPCLK/(SCI BAUDx8) - 1
    // Configured for 115.2kbps
#if (CPU_FRQ_60MHZ)
    SCI_setBaudRate(mySci, SCI_BaudRate_115_2_kBaud);
#elif (CPU_FRQ_50MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)13);
#elif (CPU_FRQ_40MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)10);
#endif

    SCI_enableFifoEnh(mySci);
    SCI_resetTxFifo(mySci);
    SCI_clearTxFifoInt(mySci);
    SCI_resetChannels(mySci);
    SCI_setTxFifoIntLevel(mySci, SCI_FifoLevel_Empty);

    SCI_resetRxFifo(mySci);
    SCI_clearRxFifoInt(mySci);
    SCI_setRxFifoIntLevel(mySci, SCI_FifoLevel_4_Words);

    SCI_setPriority(mySci, SCI_Priority_FreeRun);

    SCI_enable(mySci);

   // Initalize GPIO for USB Communication via Serial
    GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
    GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
    GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
    GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);

    //Redirect STDOUT to SCI
    status = add_device("scia", _SSA, SCI_open, SCI_close, SCI_read, SCI_write, SCI_lseek, SCI_unlink, SCI_rename);
    fid = fopen("scia","w");
    freopen("scia:", "w", stdout);
    setvbuf(stdout, NULL, _IONBF, 0);
}

void spi_init(void) {
    CLK_enableSpiaClock(myClk);

    // Reset on, rising edge, 16-bit char bits
    SPI_setCharLength(mySpi, SPI_CharLength_16_Bits);

    // Enable master mode, delayed phase,
    // enable talk, and SPI int disabled.
    //SPI_setClkPhase(mySpi, SPI_ClkPhase_Delayed);
    //SPI_setClkPolarity(mySpi, SPI_ClkPolarity_OutputFallingEdge_InputRisingEdge);
    SPI_setMode(mySpi, SPI_Mode_Master);
    SPI_enableTx(mySpi);

    SPI_setBaudRate(mySpi, SPI_BaudRate_1_MBaud);

    // Relinquish SPI from Reset
    SPI_enable(mySpi);

    // Set so breakpoints don't disturb xmission
    SPI_setPriority(mySpi, SPI_Priority_FreeRun);
}

void spi_fifo_init(void) {
    // Initialize SPI FIFO registers
    SPI_enableChannels(mySpi);
    SPI_enableFifoEnh(mySpi);
    SPI_resetTxFifo(mySpi);
    SPI_clearTxFifoInt(mySpi);
    SPI_resetRxFifo(mySpi);
    SPI_clearRxFifoInt(mySpi);
    SPI_setRxFifoIntLevel(mySpi, SPI_FifoLevel_4_Words);
}

void main(void) {
  uint16_t txdata = 0x0040;
  uint16_t rxdata;

  setup_handles();
  init_system();
  init_scia();

  //Turnoff LEDs
  GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
  GPIO_setMode(myGpio, GPIO_Number_1, GPIO_0_Mode_GeneralPurpose);
  GPIO_setMode(myGpio, GPIO_Number_2, GPIO_0_Mode_GeneralPurpose);
  GPIO_setMode(myGpio, GPIO_Number_3, GPIO_0_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
  GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
  GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
  GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);
  GPIO_setHigh(myGpio, GPIO_Number_0);
  GPIO_setHigh(myGpio, GPIO_Number_1);
  GPIO_setHigh(myGpio, GPIO_Number_2);
  GPIO_setHigh(myGpio, GPIO_Number_3);

  //Disable SD
  /*
  GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_6, GPIO_Direction_Output);
  GPIO_setLow(myGpio, GPIO_Number_6);
  */

  //DAC pin
  GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_7, GPIO_Direction_Output);
  GPIO_setLow(myGpio, GPIO_Number_7);

  //Configure SPI
  GPIO_setPullUp(myGpio, GPIO_Number_16, GPIO_PullUp_Enable);
  GPIO_setPullUp(myGpio, GPIO_Number_17, GPIO_PullUp_Enable);
  GPIO_setPullUp(myGpio, GPIO_Number_18, GPIO_PullUp_Enable);
  GPIO_setPullUp(myGpio, GPIO_Number_19, GPIO_PullUp_Enable);
  GPIO_setQualification(myGpio, GPIO_Number_16, GPIO_Qual_ASync);
  GPIO_setQualification(myGpio, GPIO_Number_17, GPIO_Qual_ASync);
  GPIO_setQualification(myGpio, GPIO_Number_18, GPIO_Qual_ASync);
  GPIO_setQualification(myGpio, GPIO_Number_19, GPIO_Qual_ASync);
  GPIO_setMode(myGpio, GPIO_Number_16, GPIO_16_Mode_SPISIMOA);
  GPIO_setMode(myGpio, GPIO_Number_17, GPIO_17_Mode_SPISOMIA);
  GPIO_setMode(myGpio, GPIO_Number_18, GPIO_18_Mode_SPICLKA);
  GPIO_setMode(myGpio, GPIO_Number_19, GPIO_19_Mode_SPISTEA_NOT);

  spi_init();
  spi_fifo_init();

  /*DEBUG
  for(;;){
  SPI_write(mySpi, 0x8B00);
  while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  }
  */

  SPI_write(mySpi, 0x8A00);
  //SPI_write(mySpi, 0x8A00);
  while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  rxdata = SPI_read(mySpi);
  printf("DieID: %X\n", rxdata);

  //enable PA
  //SPI_write(mySpi, 0x0308);

  SPI_write(mySpi, 0x8B00);
  //SPI_write(mySpi, 0x8B00);
  while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  rxdata = SPI_read(mySpi);
  printf("DieRev: %X\n", rxdata);

  //set gains
  //SPI_write(mySpi, 0x0200);

  //Enable DAC
  SPI_write(mySpi, 0x0127);
  SPI_write(mySpi, 0x0304);

  //read enables
  SPI_write(mySpi, 0x8100);
  //SPI_write(mySpi, 0x8100);
  while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  rxdata = SPI_read(mySpi);
  printf("Enables: %X\n", rxdata);

  while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  GPIO_setHigh(myGpio, GPIO_Number_7);
  SPI_write(mySpi, txdata);
  //SPI_write(mySpi, 832);

  for(;;) {
      long int i;
  }
}