开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
experiment_m_9.c
资源名称：TMS320F2812-EVM.rar　[点击查看]
上传用户：qingfan3
上传日期：2014-10-27
资源大小：31439k
文件大小：13k
源码类别：

DSP编程

开发平台：

C/C++

experiment_m_9.c：源码内容
  1. //###########################################################################
  2. //
  3. // FILE:    experiment_m_9.c
  4. //
  5. // TITLE:   DSP281x eCAN Back-to-back transmission and reception in
  6. //          SELF-TEST mode
  7. //
  8. //###########################################################################
  11. #include "DSP281x_Device.h"       // DSP281x Headerfile Include File
  12. #include "DSP281x_Examples.h"     // DSP281x Examples Include File
  14. // Prototype statements for functions found within this file.
  15. void mailbox_check(int32 T1, int32 T2, int32 T3);
  16. void mailbox_read(int16 i);
  17. void Gpio_select(void);
  18. void InitSystem(void);
  19. void InitCan(void);
  21. // Global variable for this example
  22. Uint32  ErrorCount;
  23. Uint32  MessageReceivedCount;
  25. Uint32  TestMbox1 = 0;
  26. Uint32  TestMbox2 = 0;
  27. Uint32  TestMbox3 = 0;
  29. void main(void)
  30. {
  32.   Uint16  j;
  34. // eCAN control registers require read/write access using 32-bits.  Thus we
  35. // will create a set of shadow registers for this example.  These shadow
  36. // registers will be used to make sure the access is 32-bits and not 16.
  37.   struct ECAN_REGS ECanaShadow;
  39. // Step 1. Initialize System Control:
  40. // PLL, WatchDog, enable Peripheral Clocks
  41.   InitSystem();
  43. // Step 2. Initalize GPIO:
  44. // This example function is found in the DSP281x_Gpio.c file and
  45. // illustrates how to set the GPIO to it's default state.
  46.   Gpio_select();
  47.   GpioDataRegs.GPBDAT.all = 0xFFFF;    // Switch LED's off
  49. // Step 3. Clear all interrupts and initialize PIE vector table:
  50. // Disable CPU interrupts
  51.   DINT;
  53. // Initialize PIE control registers to their default state.
  54. // The default state is all PIE interrupts disabled and flags
  55. // are cleared.
  56. // This function is found in the DSP281x_PieCtrl.c file.
  57.   InitPieCtrl();
  59. // Disable CPU interrupts and clear all CPU interrupt flags:
  60.   IER = 0x0000;
  61.   IFR = 0x0000;
  63. // Initialize the PIE vector table with pointers to the shell Interrupt
  64. // Service Routines (ISR).
  65. // This will populate the entire table, even if the interrupt
  66. // is not used in this example.  This is useful for debug purposes.
  67. // The shell ISR routines are found in DSP281x_DefaultIsr.c.
  68. // This function is found in DSP281x_PieVect.c.
  69.   InitPieVectTable();
  71. // Step 4. Initialize all the Device Peripherals:
  72. // This function is found in DSP281x_InitPeripherals.c
  73. // InitPeripherals(); // Not required for this example
  75. // Step 5. User specific code, enable interrupts:
  77.   MessageReceivedCount = 0;
  78.   ErrorCount = 0;
  80. // eCAN control registers require 32-bit access.
  81. // If you want to write to a single bit, the compiler may break this
  82. // access into a 16-bit access.  One solution, that is presented here,
  83. // is to use a shadow register to force the 32-bit access.
  85. // Read the entire register into a shadow register.  This access
  86. // will be 32-bits.  Change the desired bit and copy the value back
  87. // to the eCAN register with a 32-bit write.
  89. // Configure the eCAN RX and TX pins for eCAN transmissions
  90.   EALLOW;
  91.   ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
  92.   ECanaShadow.CANTIOC.bit.TXFUNC = 1;
  93.   ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;
  95.   ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
  96.   ECanaShadow.CANRIOC.bit.RXFUNC = 1;
  97.   ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;
  98.   EDIS;
  100. // Disable all Mailboxes
  101. // Since this write is to the entire register (instead of a bit
  102. // field) a shadow register is not required.
  103.   ECanaRegs.CANME.all = 0;
  105. // Mailboxs can be written to 16-bits or 32-bits at a time
  106. // Write to the MSGID field of TRANSMIT mailboxes MBOX0 - 15
  107.   ECanaMboxes.MBOX0.MSGID.all = 0x9555AAA0;
  108.   ECanaMboxes.MBOX1.MSGID.all = 0x9555AAA1;
  109.   ECanaMboxes.MBOX2.MSGID.all = 0x9555AAA2;
  110.   ECanaMboxes.MBOX3.MSGID.all = 0x9555AAA3;
  111.   ECanaMboxes.MBOX4.MSGID.all = 0x9555AAA4;
  112.   ECanaMboxes.MBOX5.MSGID.all = 0x9555AAA5;
  113.   ECanaMboxes.MBOX6.MSGID.all = 0x9555AAA6;
  114.   ECanaMboxes.MBOX7.MSGID.all = 0x9555AAA7;
  115.   ECanaMboxes.MBOX8.MSGID.all = 0x9555AAA8;
  116.   ECanaMboxes.MBOX9.MSGID.all = 0x9555AAA9;
  117.   ECanaMboxes.MBOX10.MSGID.all = 0x9555AAAA;
  118.   ECanaMboxes.MBOX11.MSGID.all = 0x9555AAAB;
  119.   ECanaMboxes.MBOX12.MSGID.all = 0x9555AAAC;
  120.   ECanaMboxes.MBOX13.MSGID.all = 0x9555AAAD;
  121.   ECanaMboxes.MBOX14.MSGID.all = 0x9555AAAE;
  122.   ECanaMboxes.MBOX15.MSGID.all = 0x9555AAAF;
  124. // Write to the MSGID field of RECEIVE mailboxes MBOX16 - 31
  125.   ECanaMboxes.MBOX16.MSGID.all = 0x9555AAA0;
  126.   ECanaMboxes.MBOX17.MSGID.all = 0x9555AAA1;
  127.   ECanaMboxes.MBOX18.MSGID.all = 0x9555AAA2;
  128.   ECanaMboxes.MBOX19.MSGID.all = 0x9555AAA3;
  129.   ECanaMboxes.MBOX20.MSGID.all = 0x9555AAA4;
  130.   ECanaMboxes.MBOX21.MSGID.all = 0x9555AAA5;
  131.   ECanaMboxes.MBOX22.MSGID.all = 0x9555AAA6;
  132.   ECanaMboxes.MBOX23.MSGID.all = 0x9555AAA7;
  133.   ECanaMboxes.MBOX24.MSGID.all = 0x9555AAA8;
  134.   ECanaMboxes.MBOX25.MSGID.all = 0x9555AAA9;
  135.   ECanaMboxes.MBOX26.MSGID.all = 0x9555AAAA;
  136.   ECanaMboxes.MBOX27.MSGID.all = 0x9555AAAB;
  137.   ECanaMboxes.MBOX28.MSGID.all = 0x9555AAAC;
  138.   ECanaMboxes.MBOX29.MSGID.all = 0x9555AAAD;
  139.   ECanaMboxes.MBOX30.MSGID.all = 0x9555AAAE;
  140.   ECanaMboxes.MBOX31.MSGID.all = 0x9555AAAF;
  142. // Configure Mailboxes 0-15 as Tx, 16-31 as Rx
  143. // Since this write is to the entire register (instead of a bit
  144. // field) a shadow register is not required.
  145.   ECanaRegs.CANMD.all = 0xFFFF0000;
  147. // Enable all Mailboxes */
  148. // Since this write is to the entire register (instead of a bit
  149. // field) a shadow register is not required.
  150.   ECanaRegs.CANME.all = 0xFFFFFFFF;
  152. // Specify that 8 bits will be sent/received
  153.   ECanaMboxes.MBOX0.MSGCTRL.bit.DLC = 8;
  154.   ECanaMboxes.MBOX1.MSGCTRL.bit.DLC = 8;
  155.   ECanaMboxes.MBOX2.MSGCTRL.bit.DLC = 8;
  156.   ECanaMboxes.MBOX3.MSGCTRL.bit.DLC = 8;
  157.   ECanaMboxes.MBOX4.MSGCTRL.bit.DLC = 8;
  158.   ECanaMboxes.MBOX5.MSGCTRL.bit.DLC = 8;
  159.   ECanaMboxes.MBOX6.MSGCTRL.bit.DLC = 8;
  160.   ECanaMboxes.MBOX7.MSGCTRL.bit.DLC = 8;
  161.   ECanaMboxes.MBOX8.MSGCTRL.bit.DLC = 8;
  162.   ECanaMboxes.MBOX9.MSGCTRL.bit.DLC = 8;
  163.   ECanaMboxes.MBOX10.MSGCTRL.bit.DLC = 8;
  164.   ECanaMboxes.MBOX11.MSGCTRL.bit.DLC = 8;
  165.   ECanaMboxes.MBOX12.MSGCTRL.bit.DLC = 8;
  166.   ECanaMboxes.MBOX13.MSGCTRL.bit.DLC = 8;
  167.   ECanaMboxes.MBOX14.MSGCTRL.bit.DLC = 8;
  168.   ECanaMboxes.MBOX15.MSGCTRL.bit.DLC = 8;
  170. // No remote frame is requested
  171. // Since RTR bit is undefined upon reset,
  172. // it must be initialized to the proper value
  173.   ECanaMboxes.MBOX0.MSGCTRL.bit.RTR = 0;
  174.   ECanaMboxes.MBOX1.MSGCTRL.bit.RTR = 0;
  175.   ECanaMboxes.MBOX2.MSGCTRL.bit.RTR = 0;
  176.   ECanaMboxes.MBOX3.MSGCTRL.bit.RTR = 0;
  177.   ECanaMboxes.MBOX4.MSGCTRL.bit.RTR = 0;
  178.   ECanaMboxes.MBOX5.MSGCTRL.bit.RTR = 0;
  179.   ECanaMboxes.MBOX6.MSGCTRL.bit.RTR = 0;
  180.   ECanaMboxes.MBOX7.MSGCTRL.bit.RTR = 0;
  181.   ECanaMboxes.MBOX8.MSGCTRL.bit.RTR = 0;
  182.   ECanaMboxes.MBOX9.MSGCTRL.bit.RTR = 0;
  183.   ECanaMboxes.MBOX10.MSGCTRL.bit.RTR = 0;
  184.   ECanaMboxes.MBOX11.MSGCTRL.bit.RTR = 0;
  185.   ECanaMboxes.MBOX12.MSGCTRL.bit.RTR = 0;
  186.   ECanaMboxes.MBOX13.MSGCTRL.bit.RTR = 0;
  187.   ECanaMboxes.MBOX14.MSGCTRL.bit.RTR = 0;
  188.   ECanaMboxes.MBOX15.MSGCTRL.bit.RTR = 0;
  190. // Write to the mailbox RAM field of MBOX0 - 15
  191.   ECanaMboxes.MBOX0.MDL.all = 0x9555AAA0;
  192.   ECanaMboxes.MBOX0.MDH.all = 0x89ABCDEF;
  194.   ECanaMboxes.MBOX1.MDL.all = 0x9555AAA1;
  195.   ECanaMboxes.MBOX1.MDH.all = 0x89ABCDEF;
  197.   ECanaMboxes.MBOX2.MDL.all = 0x9555AAA2;
  198.   ECanaMboxes.MBOX2.MDH.all = 0x89ABCDEF;
  200.   ECanaMboxes.MBOX3.MDL.all = 0x9555AAA3;
  201.   ECanaMboxes.MBOX3.MDH.all = 0x89ABCDEF;
  203.   ECanaMboxes.MBOX4.MDL.all = 0x9555AAA4;
  204.   ECanaMboxes.MBOX4.MDH.all = 0x89ABCDEF;
  206.   ECanaMboxes.MBOX5.MDL.all = 0x9555AAA5;
  207.   ECanaMboxes.MBOX5.MDH.all = 0x89ABCDEF;
  209.   ECanaMboxes.MBOX6.MDL.all = 0x9555AAA6;
  210.   ECanaMboxes.MBOX6.MDH.all = 0x89ABCDEF;
  212.   ECanaMboxes.MBOX7.MDL.all = 0x9555AAA7;
  213.   ECanaMboxes.MBOX7.MDH.all = 0x89ABCDEF;
  215.   ECanaMboxes.MBOX8.MDL.all = 0x9555AAA8;
  216.   ECanaMboxes.MBOX8.MDH.all = 0x89ABCDEF;
  218.   ECanaMboxes.MBOX9.MDL.all = 0x9555AAA9;
  219.   ECanaMboxes.MBOX9.MDH.all = 0x89ABCDEF;
  221.   ECanaMboxes.MBOX10.MDL.all = 0x9555AAAA;
  222.   ECanaMboxes.MBOX10.MDH.all = 0x89ABCDEF;
  224.   ECanaMboxes.MBOX11.MDL.all = 0x9555AAAB;
  225.   ECanaMboxes.MBOX11.MDH.all = 0x89ABCDEF;
  227.   ECanaMboxes.MBOX12.MDL.all = 0x9555AAAC;
  228.   ECanaMboxes.MBOX12.MDH.all = 0x89ABCDEF;
  230.   ECanaMboxes.MBOX13.MDL.all = 0x9555AAAD;
  231.   ECanaMboxes.MBOX13.MDH.all = 0x89ABCDEF;
  233.   ECanaMboxes.MBOX14.MDL.all = 0x9555AAAE;
  234.   ECanaMboxes.MBOX14.MDH.all = 0x89ABCDEF;
  236.   ECanaMboxes.MBOX15.MDL.all = 0x9555AAAF;
  237.   ECanaMboxes.MBOX15.MDH.all = 0x89ABCDEF;
  239. // Since this write is to the entire register (instead of a bit
  240. // field) a shadow register is not required.
  241.   EALLOW;
  242.   ECanaRegs.CANMIM.all = 0xFFFFFFFF;
  244. // Request permission to change the configuration registers
  245.   ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  246.   ECanaShadow.CANMC.bit.CCR = 1;
  247.   ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  248.   EDIS;
  250. // Wait until the CPU has been granted permission to change the
  251. // configuration registers
  252. // Wait for CCE bit to be set..
  253.   do
  254.   {
  255.     ECanaShadow.CANES.all = ECanaRegs.CANES.all;
  256.   } while(ECanaShadow.CANES.bit.CCE != 1 );
  258. // Configure the eCAN timing
  259.   EALLOW;
  260.   ECanaShadow.CANBTC.all = ECanaRegs.CANBTC.all;
  262.   ECanaShadow.CANBTC.bit.BRPREG = 9;   // (BRPREG + 1) = 10 feeds a 15 MHz CAN clock
  263.   ECanaShadow.CANBTC.bit.TSEG2REG = 5 ;// to the CAN module. (150 / 10 = 15)
  264.   ECanaShadow.CANBTC.bit.TSEG1REG = 7; // Bit time = 15
  265.   ECanaRegs.CANBTC.all = ECanaShadow.CANBTC.all;
  267.   ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  268.   ECanaShadow.CANMC.bit.CCR = 0;
  269.   ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  270.   EDIS;
  272. // Wait until the CPU no longer has permission to change the
  273. // configuration registers
  274.   do
  275.   {
  276.     ECanaShadow.CANES.all = ECanaRegs.CANES.all;
  277.   } while(ECanaShadow.CANES.bit.CCE != 0 );
  279. // Configure the eCAN for self test mode
  280. // Enable the enhanced features of the eCAN.
  281.   EALLOW;
  282.   ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  283.   ECanaShadow.CANMC.bit.STM = 1;  // Configure CAN for self-test mode
  284.   ECanaShadow.CANMC.bit.SCB = 1;  // eCAN mode (reqd to access 32 mailboxes)
  285.   ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  286.   EDIS;
  288. // Begin transmitting
  289.   while(1)
  290.   {
  291.     ECanaRegs.CANTRS.all = 0x0000FFFF;      // Set TRS for all transmit mailboxes
  292.     while(ECanaRegs.CANTA.all != 0x0000FFFF ) {} // Wait for all TAn bits to be set..
  293.     ECanaRegs.CANTA.all = 0x0000FFFF;       // Clear all TAn
  294.     MessageReceivedCount++;
  296. //Read from Receive mailboxes and begin checking for data */
  297.     for(j=0; j<16; j++)      // Read & check 16 mailboxes
  298.     {
  299.       mailbox_read(j);       // This func reads the indicated mailbox data
  300.       mailbox_check(TestMbox1,TestMbox2,TestMbox3); // Checks the received data
  301.     }
  302.   }
  303. }
  305. void Gpio_select(void)
  306. {
  307.   EALLOW;
  308.   GpioMuxRegs.GPAMUX.all = 0x0;   // all GPIO port Pin's to I/O
  309.   GpioMuxRegs.GPBMUX.all = 0x0;
  310.   GpioMuxRegs.GPDMUX.all = 0x0;
  311.   GpioMuxRegs.GPFMUX.all = 0x0;
  312.   GpioMuxRegs.GPEMUX.all = 0x0;
  313.   GpioMuxRegs.GPGMUX.all = 0x0;
  314.   GpioMuxRegs.GPFMUX.bit.CANTXA_GPIOF6 = 1; // Enable CAN - lines
  315.   GpioMuxRegs.GPFMUX.bit.CANRXA_GPIOF7 = 1;
  317.   GpioMuxRegs.GPADIR.all = 0x0;   // GPIO PORT  as input
  318.   GpioMuxRegs.GPBDIR.all = 0x00FF;// GPIO Port B15-B8 input , B7-B0 output
  319.   GpioMuxRegs.GPDDIR.all = 0x0;   // GPIO PORT  as input
  320.   GpioMuxRegs.GPEDIR.all = 0x0;   // GPIO PORT  as input
  321.   GpioMuxRegs.GPFDIR.all = 0x0;   // GPIO PORT  as input
  322.   GpioMuxRegs.GPGDIR.all = 0x0;   // GPIO PORT  as input
  324.   GpioMuxRegs.GPAQUAL.all = 0x0;  // Set GPIO input qualifier values to zero
  325.   GpioMuxRegs.GPBQUAL.all = 0x0;
  326.   GpioMuxRegs.GPDQUAL.all = 0x0;
  327.   GpioMuxRegs.GPEQUAL.all = 0x0;
  328.   EDIS;
  329. }
  332. void InitSystem(void)
  333. {
  334.   EALLOW;                         // Enable EALLOW protected register access
  336.   SysCtrlRegs.WDCR= 0x00E8;  // Setup the watchdog
  337.                    // 0x00E8  to disable the Watchdog , Prescaler = 1
  338.                    // 0x00AF  to NOT disable the Watchdog, Prescaler = 64
  339.   SysCtrlRegs.SCSR = 0;      // Watchdog generates a RESET
  340.   SysCtrlRegs.PLLCR.bit.DIV = 10; // Setup the Clock PLL to multiply by 5
  342.   SysCtrlRegs.HISPCP.all = 0x1;   // Setup Highspeed Clock Prescaler to divide by 2
  343.   SysCtrlRegs.LOSPCP.all = 0x2;   // Setup Lowspeed CLock Prescaler to divide by 4
  345. // Peripheral clock enables set for the selected peripherals.
  346.   SysCtrlRegs.PCLKCR.bit.EVAENCLK=0;
  347.   SysCtrlRegs.PCLKCR.bit.EVBENCLK=0;
  348.   SysCtrlRegs.PCLKCR.bit.SCIAENCLK=0;
  349.   SysCtrlRegs.PCLKCR.bit.SCIBENCLK=0;
  350.   SysCtrlRegs.PCLKCR.bit.MCBSPENCLK=0;
  351.   SysCtrlRegs.PCLKCR.bit.SPIENCLK=0;
  352.   SysCtrlRegs.PCLKCR.bit.ECANENCLK=1;
  353.   SysCtrlRegs.PCLKCR.bit.ADCENCLK=0;
  354.   EDIS;
  355. }
  358. // This function reads out the contents of the indicated
  359. // by the Mailbox number (MBXnbr).
  360. void mailbox_read(int16 MBXnbr)
  361. {
  362.   volatile struct MBOX *Mailbox;
  363.   Mailbox = &ECanaMboxes.MBOX0 + MBXnbr;
  364.   TestMbox1 = Mailbox->MDL.all;   // = 0x9555AAAn (n is the MBX number)
  365.   TestMbox2 = Mailbox->MDH.all;   // = 0x89ABCDEF (a constant)
  366.   TestMbox3 = Mailbox->MSGID.all; // = 0x9555AAAn (n is the MBX number)
  368. } // MSGID of a rcv MBX is transmitted as the MDL data.
  371. void mailbox_check(int32 T1, int32 T2, int32 T3)
  372. {
  373.   if((T1 != T3) || ( T2 != 0x89ABCDEF))
  374.   {
  375.     ErrorCount++;
  376.   }
  377. }
  380. //===========================================================================
  381. // End
  382. //===========================================================================