API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 17th, 2013
152
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.21 KB | None | 0 0
raw download clone embed print report
  1. /*main.c
  2.  
  3.  Created on: Jun 9, 2013
  4.      Author: Dany
  5.  
  6. Description: Generating a sine output from the DAC and PA of the AFE031
  7. Pinout:
  8.     ADCINA0---RxPGA2_Out
  9.     SPICLK----SCLK
  10.     GPIO6-----SD (Shutdown)
  11.     GPIO12----INT (Interrupt flag)
  12.     GPIO4-----Tx_Flag
  13.     GPIO5-----Rx_Flag
  14.     SPISIMOA--DIN
  15.     SPIDOMIA--DOUT
  16.     SPISTEA---CS (active low)
  17.     GPIO7-----DAC (active high)
  18. */
  19.  
  20. #include <stdio.h>
  21. #include <file.h>
  22.  
  23. #include "DSP28x_Project.h"     // DSP28x Headerfile
  24.  
  25. #include "f2802x_common/include/pll.h"
  26. #include "f2802x_common/include/clk.h"
  27. #include "f2802x_common/include/wdog.h"
  28.  
  29. #include "f2802x_common/include/flash.h"
  30. #include "f2802x_common/include/gpio.h"
  31. #include "f2802x_common/include/pie.h"
  32. #include "f2802x_common/include/adc.h"
  33. #include "f2802x_common/include/sci.h"
  34. #include "f2802x_common/include/sci_io.h"
  35. #include "f2802x_common/include/spi.h"
  36.  
  37. extern void DSP28x_usDelay(Uint32 Count);
  38.  
  39. CPU_Handle myCpu;
  40. PLL_Handle myPll;
  41. WDOG_Handle myWDog;
  42. CLK_Handle myClk;
  43.  
  44. ADC_Handle myAdc;
  45. FLASH_Handle myFlash;
  46. GPIO_Handle myGpio;
  47. PIE_Handle myPie;
  48. SCI_Handle mySci;
  49. SPI_Handle mySpi;
  50.  
  51. const unsigned char sine[32]= {
  52.   8,9,11,12,13,14,14,15,15,15,
  53.   14,14,13,12,11,9,8,7,5,4,3,
  54.   2,2,1,1,1,2,2,3,4,5,7
  55.  };
  56. unsigned int i=0;
  57.  
  58. void setup_handles(void) {
  59.     myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
  60.     myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
  61.     myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
  62.     myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
  63.     myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
  64.     myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
  65.     myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
  66.     mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
  67.     mySpi = SPI_init((void *)SPIA_BASE_ADDR, sizeof(SPI_Obj));
  68.     myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
  69. }
  70.  
  71. void init_system(void) {
  72.     WDOG_disable(myWDog);
  73.     (*Device_cal)();
  74.     CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
  75.     PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);
  76.  
  77.     PIE_disable(myPie);
  78.     PIE_disableAllInts(myPie);
  79.     CPU_disableGlobalInts(myCpu);
  80.     CPU_clearIntFlags(myCpu);
  81. #ifdef _FLASH
  82.     memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
  83. #endif
  84. }
  85.  
  86. void init_scia(void) {
  87.     volatile int status = 0;
  88.     volatile FILE *fid;
  89.     CLK_enableSciaClock(myClk);
  90.  
  91.     // 1 stop bit,  No loopback
  92.     // No parity,8 char bits,
  93.     // async mode, idle-line protocol
  94.     SCI_disableParity(mySci);
  95.     SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
  96.     SCI_setCharLength(mySci, SCI_CharLength_8_Bits);
  97.    
  98.     SCI_enableTx(mySci);
  99.     SCI_enableRx(mySci);
  100.     SCI_enableTxInt(mySci);
  101.     SCI_enableRxInt(mySci);
  102.  
  103.     // SCI BRR = LSPCLK/(SCI BAUDx8) - 1
  104.     // Configured for 115.2kbps
  105. #if (CPU_FRQ_60MHZ)
  106.     SCI_setBaudRate(mySci, SCI_BaudRate_115_2_kBaud);    
  107. #elif (CPU_FRQ_50MHZ)
  108.     SCI_setBaudRate(mySci, (SCI_BaudRate_e)13);
  109. #elif (CPU_FRQ_40MHZ)
  110.     SCI_setBaudRate(mySci, (SCI_BaudRate_e)10);
  111. #endif
  112.  
  113.     SCI_enableFifoEnh(mySci);
  114.     SCI_resetTxFifo(mySci);
  115.     SCI_clearTxFifoInt(mySci);
  116.     SCI_resetChannels(mySci);
  117.     SCI_setTxFifoIntLevel(mySci, SCI_FifoLevel_Empty);
  118.  
  119.     SCI_resetRxFifo(mySci);
  120.     SCI_clearRxFifoInt(mySci);
  121.     SCI_setRxFifoIntLevel(mySci, SCI_FifoLevel_4_Words);
  122.  
  123.     SCI_setPriority(mySci, SCI_Priority_FreeRun);
  124.    
  125.     SCI_enable(mySci);
  126.  
  127.    // Initalize GPIO for USB Communication via Serial
  128.     GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
  129.     GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
  130.     GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
  131.     GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
  132.     GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);
  133.    
  134.     //Redirect STDOUT to SCI
  135.     status = add_device("scia", _SSA, SCI_open, SCI_close, SCI_read, SCI_write, SCI_lseek, SCI_unlink, SCI_rename);
  136.     fid = fopen("scia","w");
  137.     freopen("scia:", "w", stdout);
  138.     setvbuf(stdout, NULL, _IONBF, 0);
  139. }
  140.  
  141. void spi_init(void) {
  142.     CLK_enableSpiaClock(myClk);
  143.  
  144.     // Reset on, rising edge, 16-bit char bits
  145.     SPI_setCharLength(mySpi, SPI_CharLength_16_Bits);
  146.  
  147.     // Enable master mode, delayed phase,
  148.     // enable talk, and SPI int disabled.
  149.     //SPI_setClkPhase(mySpi, SPI_ClkPhase_Delayed);
  150.     //SPI_setClkPolarity(mySpi, SPI_ClkPolarity_OutputFallingEdge_InputRisingEdge);
  151.     SPI_setMode(mySpi, SPI_Mode_Master);
  152.     SPI_enableTx(mySpi);
  153.  
  154.     SPI_setBaudRate(mySpi, SPI_BaudRate_1_MBaud);
  155.  
  156.     // Relinquish SPI from Reset
  157.     SPI_enable(mySpi);
  158.  
  159.     // Set so breakpoints don't disturb xmission
  160.     SPI_setPriority(mySpi, SPI_Priority_FreeRun);
  161. }
  162.  
  163. void spi_fifo_init(void) {
  164.     // Initialize SPI FIFO registers
  165.     SPI_enableChannels(mySpi);
  166.     SPI_enableFifoEnh(mySpi);
  167.     SPI_resetTxFifo(mySpi);
  168.     SPI_clearTxFifoInt(mySpi);
  169.     SPI_resetRxFifo(mySpi);
  170.     SPI_clearRxFifoInt(mySpi);
  171.     SPI_setRxFifoIntLevel(mySpi, SPI_FifoLevel_4_Words);
  172. }
  173.  
  174. void delay(long int i) {
  175.     long int ctr;
  176.     for(ctr = i; ctr > 0; ctr--);
  177. }
  178.  
  179. void main(void) {
  180.   uint16_t txdata = 0x0000;
  181.   uint16_t rxdata;
  182.  
  183.   setup_handles();
  184.   init_system();
  185.   init_scia();
  186.  
  187.   //Turnoff LEDs
  188.   GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
  189.   GPIO_setMode(myGpio, GPIO_Number_1, GPIO_0_Mode_GeneralPurpose);
  190.   GPIO_setMode(myGpio, GPIO_Number_2, GPIO_0_Mode_GeneralPurpose);
  191.   GPIO_setMode(myGpio, GPIO_Number_3, GPIO_0_Mode_GeneralPurpose);
  192.   GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
  193.   GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
  194.   GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
  195.   GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);
  196.   GPIO_setHigh(myGpio, GPIO_Number_0);
  197.   GPIO_setHigh(myGpio, GPIO_Number_1);
  198.   GPIO_setHigh(myGpio, GPIO_Number_2);
  199.   GPIO_setHigh(myGpio, GPIO_Number_3);
  200.  
  201.   //Disable SD
  202.   /*
  203.   GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_GeneralPurpose);
  204.   GPIO_setDirection(myGpio, GPIO_Number_6, GPIO_Direction_Output);
  205.   GPIO_setLow(myGpio, GPIO_Number_6);
  206.   */
  207.  
  208.   //DAC pin
  209.   GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_GeneralPurpose);
  210.   GPIO_setDirection(myGpio, GPIO_Number_7, GPIO_Direction_Output);
  211.   GPIO_setLow(myGpio, GPIO_Number_7);
  212.  
  213.   //Rx_FLAG
  214.   GPIO_setMode(myGpio, GPIO_Number_5, GPIO_5_Mode_GeneralPurpose);
  215.   GPIO_setDirection(myGpio, GPIO_Number_5, GPIO_Direction_Input);
  216.   GPIO_setPullUp(myGpio, GPIO_Number_5, GPIO_PullUp_Disable);
  217.  
  218.   //Configure SPI
  219.   GPIO_setPullUp(myGpio, GPIO_Number_16, GPIO_PullUp_Enable);
  220.   GPIO_setPullUp(myGpio, GPIO_Number_17, GPIO_PullUp_Enable);
  221.   GPIO_setPullUp(myGpio, GPIO_Number_18, GPIO_PullUp_Enable);
  222.   GPIO_setPullUp(myGpio, GPIO_Number_19, GPIO_PullUp_Enable);
  223.   GPIO_setQualification(myGpio, GPIO_Number_16, GPIO_Qual_ASync);
  224.   GPIO_setQualification(myGpio, GPIO_Number_17, GPIO_Qual_ASync);
  225.   GPIO_setQualification(myGpio, GPIO_Number_18, GPIO_Qual_ASync);
  226.   GPIO_setQualification(myGpio, GPIO_Number_19, GPIO_Qual_ASync);
  227.   GPIO_setMode(myGpio, GPIO_Number_16, GPIO_16_Mode_SPISIMOA);
  228.   GPIO_setMode(myGpio, GPIO_Number_17, GPIO_17_Mode_SPISOMIA);
  229.   GPIO_setMode(myGpio, GPIO_Number_18, GPIO_18_Mode_SPICLKA);
  230.   GPIO_setMode(myGpio, GPIO_Number_19, GPIO_19_Mode_SPISTEA_NOT);
  231.  
  232.   spi_init();
  233.   spi_fifo_init();
  234.   delay(1000);
  235.  
  236.   SPI_write(mySpi, 0x8B00);
  237.   delay(100);
  238.   SPI_write(mySpi, 0x8B00);
  239.   while(SPI_getRxFifoStatus(mySpi) == SPI_FifoStatus_Empty);
  240.   rxdata = SPI_read(mySpi);
  241.   printf("DieRev: %X\n", rxdata);
  242.  
  243.   //set gains
  244.   SPI_write(mySpi, 0x0332);
  245.   delay(100);
  246.  
  247.   //Enable DAC, Rx, Tx, PA
  248.   SPI_write(mySpi, 0x0127);
  249.   delay(100);
  250.   SPI_write(mySpi, 0x030E);
  251.  
  252.   while(GPIO_getData(myGpio, GPIO_Number_5) == 1);
  253.   GPIO_setHigh(myGpio, GPIO_Number_7);
  254.  
  255.   for(;;) {
  256.       /*
  257.       SPI_write(mySpi, (sine[i]<<6)*64);
  258.       i = (i+1)%(sizeof(sine)/sizeof(unsigned char));
  259.       while(GPIO_getData(myGpio, GPIO_Number_5) == 1);
  260.       delay(10);
  261.       */
  262.  
  263.       /*
  264.       SPI_write(mySpi, 0);
  265.       delay(1000);
  266.       SPI_write(mySpi, 1<<6);
  267.       delay(1000);
  268.       SPI_write(mySpi, 512<<6);
  269.       delay(1000);
  270.       SPI_write(mySpi, 0xFFFF);
  271.       delay(1000);
  272.       */
  273.  
  274.       SPI_write(mySpi, txdata++);
  275.       delay(1000);
  276.   }
  277. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!