21ic电子技术开发论坛 › 单片机与嵌入式系统 › 德州仪器MCU › 【MSP432评测】迟来的开箱测试
返回列表 发新帖我要提问

[MCU] 【MSP432评测】迟来的开箱测试

[复制链接]
1903|14
 楼主| yinwuqing110 发表于 2020-4-18 16:44 | 显示全部楼层 |阅读模式
MSP432, TI, IO, timer, TE
本帖最后由 yinwuqing110 于 2020-4-18 16:47 编辑

       昨晚发帖没有保存到草稿箱，过了晚上十一点，平台不接受任何的发帖存储，哎，悲哀，我服了这个规定了！今天周六来补补昨晚的帖子吧。其实收到MSP‑EXP432P401R LaunchPad开发套件是在周一晚上，至于有关MSP432P401R的开发资料，早已经准备好了，由于公司正在进行新项目的开发，所以最近没来得及发帖评测MSP432P401R。其实TI的在各大网站论坛举办的活动层出不穷，收到的礼品都是有TI的**。但TI举办的开发板试用评测的活动还是比较少的，所以能够通过此次MSP432P401R开发板试用的申请，也属幸运了。
      收到快递包裹后，拆开包装袋，有一个标识好MSP‑EXP432P401R LaunchPad开发套件的盒子，盒子底部一如既往地采用TI的**。

         然后拆开盒子，里面有此次评测的开发核心板，使用防静电袋封装着。还有Micro USB数据线，用来连接PC端，可当串口下载线，提供了快速操作手册，小喇叭的发帖提醒语，来一张全家福如下：

      阅读快速操作手册，可以得知关于此开发板的大概资源，下载资源及软件开发包的链接网址。这里着重介绍如何去使用官方提供的“outofbox_msp432p401r”工程。

       接下来打开防静电袋，取出MSP432P401R核心板，来一张正面特写

        MSP432P401R是MSP432系列器件中首款具有ARM Cortex-M4F内核的低功耗高性能产品。板卡上面集成了按键、LED等外设。开发板是黑色的，官方提供的资料都是针对红色的，那么它们到底存在哪些差异呢？其实两者区别不大，只是存在几处不同，开发起来两者并无其他区别。

     MSP-EXP432P401R的模块框图如下：

     核心MCU采用100PIN的QFP封装，MSP432P401RIPZ的pin脚定义如下：

     然后来看看板卡的底面，底面没有采用一个电子元器件，有的只是两个双排10pin的2.54mm母座插针孔，图案很有个性。

      了解了板卡上的硬件资源，接下来搭建软件开发平台。MSP432P401R支持GCC、CCS、Keil以及IAR集成开发工具，由于本人使用的Keil比较多，习惯先搭建一下基于Keil的开发环境。首先根据快速操作手册指引，进入SDK下载网址，如下图所示：

       下载SDK后，双击安装即可。然后下载使用Keil的支持pack包，地址在pack包下载网址中查找，然后下载

      下载完“TexasInstruments.MSP432P4xx_DFP.3.2.6.zip”的pack包后，然后解压，进入到“TexasInstruments.MSP432P4xx_DFP.3.2.6\Examples\BlinkLED\ARM”目录下，双击打开“BlinkLED”工程，Keil会自动获取拷贝，完成pack包的安装，如下图所示：

     完成了pack包的安装，然后进入“D:\ti\simplelink_msp432p4_sdk_3_40_01_02\examples\nortos\MSP_EXP432P401R\demos\outofbox_msp432p401r\keil”（当然我的SDK是安装在D盘根目录下）目录下，打开快速操作手册所推荐的工程“outOfBox_msp432p401r”，然后进行全编译，没有错误，没有警告，说明工程已经导入成功。main.c的程序如下：
复制
  1. #include <ti/devices/msp432p4xx/driverlib/driverlib.h>
    

  2. #include <time.h>
    

  3. #include <stdlib.h>
    


  4. 

  5. #define MCLK_FREQUENCY 3000000
    

  6. #define PWM_PERIOD (MCLK_FREQUENCY/5000)
    


  7. 

  8. unsigned int S1buttonDebounce = 0; // Deboounce state for button S1
    

  9. unsigned int S2buttonDebounce = 0; // Deboounce state for button S1
    


  10. 

  11. int32_t interval = 0;       // Elapsed interval between taps
    

  12. int32_t periods[4];         // LED blink periods for each color state
    

  13. int oldTick = 0;            // SysTick value of previous tap
    

  14. int newTick = 0;            // SysTick value of current tap
    


  15. 

  16. int counting = 0;           // Whether currently counting taps and interval between taps
    

  17. int count = 0;              // Counts # of seconds elapsed since last tap
    

  18. int sysTickCount = 0;       // Counts # of SysTick interrupts since last tap
    

  19. int taps = 0;               // Counts # of taps from last reset
    


  20. 

  21. /* Current color of the blinking RGB LED
    

  22.  * 4 possible states: R, G, B, random color */
    

  23. unsigned int currentColor = 0;
    


  24. 

  25. #define RED     255
    

  26. #define GREEN   255
    

  27. #define BLUE    255
    


  28. 

  29. int bytesReceived = 7;      // Keeps track of # UART bytes received
    

  30. int32_t receiveFreq = 0;    // Receives LED blink frequency from GUI
    

  31. char start[5];              // Receives 'START' keyword
    

  32. int ack = 0;                // Track acknowledgement sent to GUI
    


  33. 

  34. /* TimerA UpMode Configuration Parameter */
    

  35. const Timer_A_UpModeConfig upConfig =
    

  36. {
    

  37.         TIMER_A_CLOCKSOURCE_SMCLK,              // SMCLK Clock Source
    

  38.         TIMER_A_CLOCKSOURCE_DIVIDER_1,          // SMCLK/1 = 3MHz
    

  39.         45000,                                  // 15ms debounce period
    

  40.         TIMER_A_TAIE_INTERRUPT_DISABLE,         // Disable Timer interrupt
    

  41.         TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE ,    // Enable CCR0 interrupt
    

  42.         TIMER_A_DO_CLEAR                        // Clear value
    

  43. };
    


  44. 

  45. const Timer_A_UpModeConfig TA2upConfig =
    

  46. {
    

  47.         TIMER_A_CLOCKSOURCE_SMCLK,              // SMCLK Clock Source
    

  48.         TIMER_A_CLOCKSOURCE_DIVIDER_64,         // SMCLK/64 ~ 46.9 kMHz
    

  49.         46875,                                  // 1s timer period
    

  50.         TIMER_A_TAIE_INTERRUPT_DISABLE,         // Disable Timer interrupt
    

  51.         TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE ,    // Enable CCR0 interrupt
    

  52.         TIMER_A_DO_CLEAR                        // Clear value
    

  53. };
    


  54. 

  55. /* Port mapper configuration register */
    

  56. const uint8_t port_mapping[] =
    

  57. {
    

  58.     //Port P2:
    

  59.     PM_TA0CCR1A, PM_TA0CCR2A, PM_TA0CCR3A, PM_NONE, PM_TA1CCR1A, PM_NONE, PM_NONE, PM_NONE
    

  60. };
    


  61. 

  62. /* UART Configuration Parameter. These are the configuration parameters to
    

  63.  * make the eUSCI A UART module to operate with a 115200 baud rate. These
    

  64.  * values were calculated using the online calculator that TI provides
    

  65.  * at:
    

  66.  *http://processors.wiki.ti.com/index.php/USCI_UART_Baud_Rate_Gen_Mode_Selection
    

  67.  */
    

  68. const eUSCI_UART_ConfigV1 uartConfig =
    

  69. {
    

  70.         EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
    

  71.         26,                                      // BRDIV = 26
    

  72.         0,                                       // UCxBRF = 0
    

  73.         0,                                       // UCxBRS = 0
    

  74.         EUSCI_A_UART_NO_PARITY,                  // No Parity
    

  75.         EUSCI_A_UART_LSB_FIRST,                  // MSB First
    

  76.         EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
    

  77.         EUSCI_A_UART_MODE,                       // UART mode
    

  78.         EUSCI_A_UART_LOW_FREQUENCY_BAUDRATE_GENERATION,  // Low Frequency Mode
    

  79.         EUSCI_A_UART_8_BIT_LEN                  // 8 bit data length
    

  80. };
    


  81. 

  82. /*
    

  83.  * Main function
    

  84.  */
    

  85. int main(void)
    

  86. {
    

  87.     /* Halting WDT and disabling master interrupts */
    

  88.     MAP_WDT_A_holdTimer();
    

  89.     MAP_Interrupt_disableMaster();
    


  90. 

  91.     /* Seed the pseudo random num generator */
    

  92.     srand(TLV->RANDOM_NUM_1);
    


  93. 

  94.     /* Set the core voltage level to VCORE1 */
    

  95.     MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
    


  96. 

  97.     /* Set 2 flash wait states for Flash bank 0 and 1*/
    

  98.     MAP_FlashCtl_setWaitState(FLASH_BANK0, 2);
    

  99.     MAP_FlashCtl_setWaitState(FLASH_BANK1, 2);
    


  100. 

  101.     /* Default SysTick period for all 4 color states = 0.5s */
    

  102.     periods[0] = 1500000;
    

  103.     periods[1] = 1500000;
    

  104.     periods[2] = 1500000;
    

  105.     periods[3] = 1500000;
    


  106. 

  107.     /* Initialize main clock to 3MHz */
    

  108.     MAP_CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_3);
    

  109.     MAP_CS_initClockSignal(CS_MCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1 );
    

  110.     MAP_CS_initClockSignal(CS_HSMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1 );
    

  111.     MAP_CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1 );
    


  112. 

  113.     /* Selecting P1.2 and P1.3 in UART mode and P1.0 as output (LED) */
    

  114.     MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
    

  115.         GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
    


  116. 

  117.     /* GPIO Setup for Pins 2.0-2.2 */
    

  118.     MAP_PMAP_configurePorts((const uint8_t *) port_mapping, PMAP_P2MAP, 1,
    

  119.         PMAP_DISABLE_RECONFIGURATION);
    


  120. 

  121.     MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P2,
    

  122.         GPIO_PIN0 | GPIO_PIN1 | GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);
    


  123. 

  124.     /* Confinguring P1.1 & P1.4 as an input and enabling interrupts */
    

  125.     MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1 | GPIO_PIN4);
    

  126.     MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1 | GPIO_PIN4);
    

  127.     MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1 | GPIO_PIN4);
    

  128.     MAP_GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN1 | GPIO_PIN4, GPIO_HIGH_TO_LOW_TRANSITION);
    


  129. 

  130.     /* Configuring UART Module */
    

  131.     MAP_UART_initModule(EUSCI_A0_BASE, &uartConfig);
    


  132. 

  133.     /* Enable UART module */
    

  134.     MAP_UART_enableModule(EUSCI_A0_BASE);
    


  135. 

  136.     /* Configure TimerA0 without Driverlib (CMSIS style register access) */
    

  137.     TIMER_A0->CCR[0] = PWM_PERIOD;
    

  138.     TIMER_A0->CCTL[1] = TIMER_A_CCTLN_OUTMOD_7;                      // CCR1 reset/set
    

  139.     TIMER_A0->CCR[1] = PWM_PERIOD * (RED/255);         // CCR1 PWM duty cycle
    

  140.     TIMER_A0->CCTL[2] = TIMER_A_CCTLN_OUTMOD_7;                      // CCR2 reset/set
    

  141.     TIMER_A0->CCR[2] = PWM_PERIOD * (0/255);           // CCR2 PWM duty cycle
    

  142.     TIMER_A0->CCTL[3] = TIMER_A_CCTLN_OUTMOD_7;                      // CCR3 reset/set
    

  143.     TIMER_A0->CCR[3] = PWM_PERIOD * (0/255);           // CCR3 PWM duty cycle
    

  144.     TIMER_A0->CTL = TIMER_A_CTL_SSEL__SMCLK | TIMER_A_CTL_MC__UP | TIMER_A_CTL_CLR;  // SMCLK, up mode, clear TAR
    


  145. 

  146.     /* Configuring TimerA1 and TimerA2 for Up Mode  using Driverlib*/
    

  147.     MAP_Timer_A_configureUpMode(TIMER_A1_BASE, &upConfig);
    

  148.     MAP_Timer_A_configureUpMode(TIMER_A2_BASE, &TA2upConfig);
    


  149. 

  150.     MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    

  151.     MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    


  152. 

  153.     /* Configure and enable SysTick */
    

  154.     MAP_SysTick_setPeriod(1500000);
    

  155.     MAP_SysTick_enableModule();
    

  156.     MAP_SysTick_enableInterrupt();
    


  157. 

  158.     /* Main while loop */
    

  159.     while(1)
    

  160.     {
    

  161.         MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1 | GPIO_PIN4);
    

  162.         MAP_UART_enableInterrupt(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    

  163.         MAP_Interrupt_enableInterrupt(INT_EUSCIA0);
    

  164.         MAP_Interrupt_enableInterrupt(INT_PORT1);
    

  165.         MAP_Interrupt_enableInterrupt(INT_TA1_0);
    

  166.         MAP_Interrupt_enableInterrupt(INT_TA2_0);
    

  167.         MAP_Interrupt_enableMaster();
    

  168.         MAP_PCM_gotoLPM0();
    

  169.     }
    

  170. }
    


  171. 

  172. /*
    

  173.  * Port 1 interrupt handler. This handler is called whenever switches attached
    

  174.  * to P1.1 (S1) and P1.4 (S2) are pressed.
    

  175.  */
    

  176. void PORT1_IRQHandler(void)
    

  177. {
    

  178.     newTick = MAP_SysTick_getValue();
    

  179.     uint32_t status = MAP_GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);
    

  180.     MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, status);
    


  181. 

  182.     /* Handles S1 button press */
    

  183.     if (status & GPIO_PIN1)
    

  184.     {
    

  185.         if (S1buttonDebounce == 0)
    

  186.         {
    

  187.             S1buttonDebounce = 1;
    


  188. 

  189.             MAP_Interrupt_disableInterrupt(INT_PORT1);
    


  190. 

  191.             MAP_GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0);
    


  192. 

  193.             MAP_Timer_A_stopTimer(TIMER_A2_BASE);
    

  194.             MAP_Timer_A_configureUpMode(TIMER_A2_BASE, &TA2upConfig);
    

  195.             MAP_Timer_A_startCounter(TIMER_A2_BASE, TIMER_A_UP_MODE);
    


  196. 

  197.             count = 0;
    

  198.             taps++;
    


  199. 

  200.             if (counting == 0)
    

  201.             {
    

  202.                 oldTick = newTick;
    

  203.                 counting = 1;
    

  204.             }
    

  205.             else
    

  206.             {
    

  207.                 if (sysTickCount == 0)
    

  208.                 {
    

  209.                     interval = oldTick - newTick;
    

  210.                     periods[currentColor] = interval/2;
    

  211.                     oldTick = newTick;
    

  212.                 }
    

  213.                 else
    

  214.                 {
    

  215.                     interval = (MAP_SysTick_getPeriod() - newTick) + ((sysTickCount-1) * MAP_SysTick_getPeriod()) + oldTick;
    

  216.                     oldTick = newTick;
    

  217.                     sysTickCount = 0;
    

  218.                 }
    

  219.                 periods[currentColor] = ((periods[currentColor] * (taps-2)) + interval/2) / (taps-1);
    

  220.                 MAP_SysTick_setPeriod(periods[currentColor]);
    

  221.             }
    


  222. 

  223.             /* Start button debounce timer */
    

  224.             MAP_Timer_A_startCounter(TIMER_A1_BASE, TIMER_A_UP_MODE);
    

  225.         }
    

  226.     }
    

  227.     /* Handles S2 button press */
    

  228.     if (status & GPIO_PIN4)
    

  229.     {
    

  230.         if (S2buttonDebounce == 0)
    

  231.         {
    

  232.             S2buttonDebounce = 1;
    


  233. 

  234.             MAP_Interrupt_disableInterrupt(INT_PORT1);
    


  235. 

  236.             /* Cycle through R, G, B, random color */
    

  237.             if (currentColor < 3)
    

  238.                 currentColor++;
    

  239.             else
    

  240.                 currentColor = 0;
    


  241. 

  242.             switch(currentColor)
    

  243.             {
    

  244.                 case 0:  // Red
    

  245.                     TIMER_A0->CCR[1] = PWM_PERIOD * (RED/255);              // CCR1 PWM duty cycle
    

  246.                     TIMER_A0->CCR[2] = PWM_PERIOD * (0/255);                // CCR2 PWM duty cycle
    

  247.                     TIMER_A0->CCR[3] = PWM_PERIOD * (0/255);                // CCR3 PWM duty cycle
    

  248.                     break;
    

  249.                 case 1:  // Green
    

  250.                     TIMER_A0->CCR[1] = PWM_PERIOD * (0/255);                // CCR1 PWM duty cycle
    

  251.                     TIMER_A0->CCR[2] = PWM_PERIOD * (GREEN/255);            // CCR2 PWM duty cycle
    

  252.                     TIMER_A0->CCR[3] = PWM_PERIOD * (0/255);                // CCR3 PWM duty cycle
    

  253.                     break;
    

  254.                 case 2:  // Blue
    

  255.                     TIMER_A0->CCR[1] = PWM_PERIOD * (0/255);                // CCR1 PWM duty cycle
    

  256.                     TIMER_A0->CCR[2] = PWM_PERIOD * (0/255);                // CCR2 PWM duty cycle
    

  257.                     TIMER_A0->CCR[3] = PWM_PERIOD * (BLUE/255);             // CCR3 PWM duty cycle
    

  258.                     break;
    

  259.                 case 3:  // Random Color
    

  260.                     TIMER_A0->CCR[1] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);      // CCR1 PWM duty cycle
    

  261.                     TIMER_A0->CCR[2] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);      // CCR2 PWM duty cycle
    

  262.                     TIMER_A0->CCR[3] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);      // CCR3 PWM duty cycle
    

  263.                     break;
    

  264.                 default:
    

  265.                     break;
    

  266.             }
    


  267. 

  268.             /* Set current color's LED blink period */
    

  269.             MAP_SysTick_setPeriod(periods[currentColor]);
    


  270. 

  271.             /* Start button debounce timer */
    

  272.             MAP_Timer_A_startCounter(TIMER_A1_BASE, TIMER_A_UP_MODE);
    

  273.         }
    

  274.     }
    

  275. }
    


  276. 

  277. /*
    

  278.  * Timer A1 interrupt handler. This handler determines whether to reset button
    

  279.  * debounce after debounce timer expires.
    

  280.  */
    

  281. void TA1_0_IRQHandler(void)
    

  282. {
    

  283.     MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    

  284.     if (P1IN & GPIO_PIN1)
    

  285.     {
    

  286.         S1buttonDebounce = 0;
    

  287.     }
    

  288.     if (P1IN & GPIO_PIN4)
    

  289.     {
    

  290.         S2buttonDebounce = 0;
    

  291.     }
    


  292. 

  293.     if ((P1IN & GPIO_PIN1) && (P1IN & GPIO_PIN4))
    

  294.     {
    

  295.         MAP_Timer_A_stopTimer(TIMER_A1_BASE);
    

  296.     }
    

  297.     MAP_Timer_A_clearCaptureCompareInterrupt(TIMER_A1_BASE,
    

  298.                 TIMER_A_CAPTURECOMPARE_REGISTER_0);
    

  299. }
    


  300. 

  301. /*
    

  302.  * Timer A2 interrupt handler. This handler resets tapping state variables if button S1 is
    

  303.  * not pressed for more than 4 seconds.
    

  304.  */
    

  305. void TA2_0_IRQHandler(void)
    

  306. {
    

  307.     if (counting == 1)
    

  308.     {
    

  309.         if (count < 4)
    

  310.             count++;
    

  311.         else
    

  312.         {
    

  313.             counting = 0;
    

  314.             count = 0;
    

  315.             sysTickCount = 0;
    

  316.             taps = 0;
    

  317.             MAP_Timer_A_stopTimer(TIMER_A2_BASE);
    

  318.         }
    

  319.     }
    

  320.     MAP_Timer_A_clearCaptureCompareInterrupt(TIMER_A2_BASE,
    

  321.                 TIMER_A_CAPTURECOMPARE_REGISTER_0);
    

  322. }
    


  323. 

  324. /*
    

  325.  * SysTick interrupt handler. This handler toggles RGB LED on/off.
    

  326.  */
    

  327. void SysTick_Handler(void)
    

  328. {
    

  329.     if (counting == 1)
    

  330.         sysTickCount++;
    


  331. 

  332.     /* Toggle RGB LED OFF */
    

  333.     if (TIMER_A0->CCTL[1] & TIMER_A_CCTLN_OUTMOD_7){
    

  334.         TIMER_A0->CCTL[1] = TIMER_A_CCTLN_OUTMOD_0;
    

  335.         TIMER_A0->CCTL[2] = TIMER_A_CCTLN_OUTMOD_0;
    

  336.         TIMER_A0->CCTL[3] = TIMER_A_CCTLN_OUTMOD_0;
    

  337.     }
    

  338.     /* Toggle RGB LED ON */
    

  339.     else if (!(TIMER_A0->CCTL[1] & TIMER_A_CCTLN_OUTMOD_0)){
    

  340.         if (currentColor == 3)
    

  341.         {
    

  342.             TIMER_A0->CCR[1] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);                 // CCR1 PWM duty cycle
    

  343.             TIMER_A0->CCR[2] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);                // CCR2 PWM duty cycle
    

  344.             TIMER_A0->CCR[3] = (int)((rand() % 255) / 255.0f * PWM_PERIOD);                  // CCR3 PWM duty cycle
    

  345.         }
    

  346.         TIMER_A0->CCTL[1] = TIMER_A_CCTLN_OUTMOD_7;
    

  347.         TIMER_A0->CCTL[2] = TIMER_A_CCTLN_OUTMOD_7;
    

  348.         TIMER_A0->CCTL[3] = TIMER_A_CCTLN_OUTMOD_7;
    

  349.     }
    

  350. }
    


  351. 

  352. /*
    

  353.  * EUSCI A0 UART interrupt handler. Receives data from GUI and sets LED color/blink frequency
    

  354.  */
    

  355. void EUSCIA0_IRQHandler(void)
    

  356. {
    

  357.     int receiveByte = UCA0RXBUF;
    


  358. 

  359.     /* Send acknowledgement to the GUI */
    

  360.     if (ack == 0) {
    

  361.         MAP_UART_transmitData(EUSCI_A0_BASE, 'A');
    

  362.         ack = 1;
    

  363.     }
    


  364. 

  365.     /* Wait for 'START' keyword to be received before changing color */
    

  366.     if (bytesReceived > 6) {
    

  367.         start[0] = start[1];
    

  368.         start[1] = start[2];
    

  369.         start[2] = start[3];
    

  370.         start[3] = start[4];
    

  371.         start[4] = receiveByte;
    


  372. 

  373.         if (start[0] == 'S' && start[1] == 'T' && start[2] == 'A' && start[3] == 'R' && start[4] == 'T')
    

  374.             bytesReceived = -1;
    

  375.     }
    


  376. 

  377.     /* Receive/Set color and frequency of LED */
    

  378.     else {
    

  379.         if (bytesReceived == 0)
    

  380.             TIMER_A0->CCR[1] = (int)(PWM_PERIOD * (receiveByte/255.0f));                  // CCR3 PWM duty cycle
    

  381.         else if (bytesReceived == 1)
    

  382.             TIMER_A0->CCR[2] = (int)(PWM_PERIOD * (receiveByte/255.0f));                  // CCR3 PWM duty cycle
    

  383.         else if (bytesReceived == 2)
    

  384.             TIMER_A0->CCR[3] = (int)(PWM_PERIOD * (receiveByte/255.0f));                  // CCR3 PWM duty cycle
    

  385.         else if (bytesReceived == 3)
    

  386.         {
    

  387.             receiveFreq = 0;
    

  388.             receiveFreq |= receiveByte;
    

  389.         }
    

  390.         else if (bytesReceived == 4)
    

  391.             receiveFreq |= (receiveByte << 8);
    

  392.         else if (bytesReceived == 5)
    

  393.             receiveFreq |= (receiveByte << 16);
    

  394.         else if (bytesReceived == 6)
    

  395.         {
    

  396.             receiveFreq |= (receiveByte << 24);
    

  397.             MAP_SysTick_setPeriod(receiveFreq);
    

  398.             ack = 0;
    

  399.         }
    

  400.     }
    


  401. 

  402.     if (bytesReceived < 7)
    

  403.         bytesReceived++;
    

  404. }


     由此可见，基本上都是采用按键中断的形式来触发改变LED点亮的状态。接下来需要将编译好的二进制文件烧写到开发板中，我这里采用的是JLink调试下载器，使用DAP方式也是可以下载，但速度有点慢，因此不推荐。将JLink调试下载器与开发板的下载接口相连接，打开Keil中的魔法棒，在Debug选项中勾选JLink方式，能够识别到JLink设备说明安装的JLink驱动也没问题了。

     然后在Keil的菜单栏中直接点击load图标，即可完成程序的烧写。

     然后将板卡重新上电，与原来出厂的程序一样，也是通过按键S1来切换灯光变化的频率，通过按键S2来切换灯光的颜色变化。具体的操作演示视频如下：
     https://v.youku.com/v_show/id_XNDYzNjg3NDg5Mg==.html

    https://v.youku.com/v_show/id_XNDYzNTQxNDEyOA==.html


    接下来体验一下使用TI主推的CCS集成开发工具，通过TI的官网很容易获得CCS的下载地址，工具完全免费，选择最新版的下载安装。下载的网址如下截图：

     解压“CCS10.0.0.00010_win64.zip”文件，双击“ccs_setup_10.0.0.00010.exe”，然后进入安装界面：

    一路默认，今日选择组件界面，我们使用的是MSP-EXP432P401R 版本1.0（黑色）LaunchPad 开发套件，因此勾选如下图所示即可

     根据需求，勾选是否需要安装调试JLink驱动，安装过程中建议将杀毒软件关闭，此次将CCS安装在C盘，安装进度信息如下：


      安装完成后重启计算机，打开安装好的CCS软件，初次使用建议先更新Code Composer Studio IDE，然后创建基本的SimpleLink MSP432项目，与其它的软件设置一样，选择器件型号，设置项目名称，获取模板工程示例选择从“TI资源浏览器导入SimpleLink”示例，然后进行调试器的设置，调试应用程序。具体操作可参照《zhcu166f.pdf》文档，附件奉上：
      以上就是基于MSP-EXP432P401R开发板的开发demo体验，总体感觉TI的资源整理的很规范，文档资料相当齐全。TI的SimpleLink MCU SDK兼容性比较好，SimpleLink MCU SDK包括支持CC13xx/CC26xx、CC32xx 和MSP432器件的整体框架，此三个MCU系列均可使用相同的顶层API。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
 楼主| yinwuqing110 发表于 2020-4-18 22:34 | 显示全部楼层

【MSP432评测】迟来的开箱体验

       说也奇怪，今天下班回来发帖，昨晚的发帖文本又可以恢复了，由于白天在公司已经重新提交了帖子，附件没有提示恢复了。今天发帖忘记将接线示意图附上了，今晚补上，如下照片所示：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

full_stack 发表于 2020-4-19 20:21 | 显示全部楼层
yinwuqing110 发表于 2020-4-18 22:34
说也奇怪，今天下班回来发帖，昨晚的发帖文本又可以恢复了，由于白天在公司已经重新提交了帖子，附 ...

你下面这个板子叫什么
回复

收藏 举报

zhangmangui 发表于 2020-4-19 21:27 | 显示全部楼层
full_stack 发表于 2020-4-19 20:21
你下面这个板子叫什么

是不是FT232啥的做的仿真器
回复

收藏 举报

zhangmangui 发表于 2020-4-19 21:37 | 显示全部楼层
建议下载MSP432WARE
回复

收藏 举报

full_stack 发表于 2020-4-19 22:39 | 显示全部楼层
zhangmangui 发表于 2020-4-19 21:27
是不是FT232啥的做的仿真器

一转多 调试下载器
回复

收藏 举报

 楼主| yinwuqing110 发表于 2020-4-20 09:14 | 显示全部楼层
full_stack 发表于 2020-4-19 20:21
你下面这个板子叫什么

这个就是传说中的JLink烧录器呀，兄弟。
回复

收藏 举报

full_stack 发表于 2020-4-20 09:33 | 显示全部楼层
yinwuqing110 发表于 2020-4-20 09:14
这个就是传说中的JLink烧录器呀，兄弟。

自制的吗
回复

收藏 举报

 楼主| yinwuqing110 发表于 2020-4-20 09:58 | 显示全部楼层
full_stack 发表于 2020-4-20 09:33
自制的吗

淘宝上淘的呀
回复

收藏 举报

gaoyang9992006 发表于 2020-4-20 20:16 | 显示全部楼层
MSP432WARE里面例子多
回复

收藏 举报

zhangmangui 发表于 2020-4-21 21:38 | 显示全部楼层
gaoyang9992006 发表于 2020-4-20 20:16
MSP432WARE里面例子多

羔羊没申请一块吗
回复

收藏 举报

gaoyang9992006 发表于 2020-4-21 22:54 | 显示全部楼层
zhangmangui 发表于 2020-4-21 21:38
羔羊没申请一块吗

几年前我就用过这个版本的了，TI库存卖不掉的，总是拿出来搞活动。
回复

收藏 举报

zhangmangui 发表于 2020-4-23 22:14 | 显示全部楼层
gaoyang9992006 发表于 2020-4-21 22:54
几年前我就用过这个版本的了，TI库存卖不掉的，总是拿出来搞活动。

好吧   这处理器主要突出射频是吧
回复

收藏 举报

gaoyang9992006 发表于 2020-4-24 09:01 | 显示全部楼层
zhangmangui 发表于 2020-4-23 22:14
好吧   这处理器主要突出射频是吧

432跟射频没有一毛钱关系啊
回复

收藏 举报

zhangmangui 发表于 2020-4-25 19:20 | 显示全部楼层
gaoyang9992006 发表于 2020-4-24 09:01
432跟射频没有一毛钱关系啊

被误导了

SimpleLink MSP432P401x 微控制器 (MCU) 是具有集成 16 位精密 ADC 的优化型无线主机 MCU，可借助 FPU 和 DSP 扩展提供超低功耗性能，其中包括 80µA/MHz 的工作功率和 660nA 的待机功耗。作为优化的无线主机 MCU，MSP432P401x 可让开发人员向 基于 SimpleLink 无线连接解决方案的应用中添加高精度模拟和存储器扩展。

MSP432P401x 器件是 SimpleLink 微控制器 (MCU) 平台的一部分，其中包括 Wi-Fi®、低功耗 低功耗 Bluetooth®、低于 1GHz 器件和主机 MCU。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

yinwuqing110

107

主题

1102

帖子

7

粉丝
快速回复 在线客服 返回列表 返回顶部