21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 使用 PSIO 实现 ARGB2 LED 灯效
返回列表 发新帖我要提问

[DemoCode下载] 使用 PSIO 实现 ARGB2 LED 灯效

[复制链接]
1713|4
 楼主| 小灵通2018 发表于 2024-5-20 21:34 | 显示全部楼层 |阅读模式
ps, RGB, LED, IO, GB
en-us--EC_M252_PSIO_ARGB2_LED_Control_V1.00.zip (2.52 MB, 下载次数: 2)
使用M252 PSIO实现ARGB2 LED时序并实现彩虹灯、跑马灯等灯效
PSIO (Programmable Serial I/O) 提供简易的方法达到各种串行传输的接收与传送，例如: HDQ、DMX512、1-wire、IR、PS/2、Microwire、Wiegand、LED等。本文描述如何使用PSIO实现ARGB2 LED灯效，并演示ARGB2 LED彩虹灯、跑马灯效果，此范例代码使用一组Timer来定时更新ARGB2 LED彩虹灯、跑马灯的颜色，一组UART来选择执行模式；其内容包含PSIO与ARGB2 LED的基本介绍、范例程序的说明以及运行结果。
44038664b515614f05.png
丰富的操作技术下载附件观看吧。
回复

收藏 举报

相关帖子
 楼主| 小灵通2018 发表于 2024-5-20 21:35 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     PSIO_ARGB2_Driver.h
    

  3.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Nuvoton ARGB2 strip basic setting header file
    

  4.  *
    

  5.  * @note
    

  6.  * Copyright (C) 2022 Nuvoton Technology Corp. All rights reserved.
    

  7.  ******************************************************************************/
    

  8. #ifndef _PSIO_ARGB2_STRIP_H_
    

  9. #define _PSIO_ARGB2_STRIP_H_
    


  10. 

  11. //------------------------------------------------------------------------------
    

  12. #include <stdint.h>
    


  13. 

  14. //------------------------------------------------------------------------------
    

  15. #define PIXEL_NUM                       30         //LED's number in ARGB2 strip
    

  16. #define GRB                             24         //Total bits of RGB
    


  17. 


  18. 

  19. //Th20 SET Mode Setting
    

  20. #define TH20_24bits                     0xDF1F1F
    


  21. 

  22. //------------------------------------------------------------------------------
    

  23. // Don't remove
    

  24. //------------------------------------------------------------------------------
    

  25. #define BIT1_HIGH                       1        //Denote BIT1
    

  26. #define BIT0_LOW                        0        //Denote BIT0
    


  27. 

  28. //------------------------------------------------------------------------------
    

  29. typedef struct
    

  30. {
    

  31.     uint8_t u8SlotCtrl;
    

  32.     uint8_t u8DataPin;
    

  33.     uint8_t u8Brightness;
    

  34.     uint8_t u8Reserved;
    

  35.     uint16_t u16PulseCnt;
    

  36.     uint8_t au8PixelBuffer[PIXEL_NUM][GRB];
    

  37. } S_PSIO_ARGB2_STRIP_CFG_T;
    


  38. 

  39. //------------------------------------------------------------------------------
    

  40. void Delay_Init(void);
    


  41. 

  42. void PSIO_StripInit(uint8_t u8Slot, uint8_t u8DataPin);
    

  43. void PSIO_StripClear(void);
    

  44. void PSIO_StripReset(void);
    

  45. void PSIO_StripShow(void);
    


  46. 

  47. void PSIO_StripSetRGBColor(uint8_t u8Red, uint8_t u8Green, uint8_t u8Blue);
    

  48. void PSIO_StripSetBrightness(uint8_t u8Brightness);
    

  49. uint32_t PSIO_StripWheel(uint8_t u8WheelPos);
    

  50. void PSIO_StripSetPixelColor(uint16_t u16Num, uint32_t u32RGBColor);
    

  51. uint16_t PSIO_StripFeedBackMode(void);
    

  52. void PSIO_StripHighLevelSetup(void);
    


  53. 

  54. void PSIO_StripWakeupMode(void);
    

  55. void PSIO_StripSleepMode(void);
    


  56. 

  57. void PSIO_SetStripID(uint8_t u8ID);
    

  58. void PSIO_ClearStripID(uint8_t u8ID);
    

  59. void PSIO_CheckStripkID(uint8_t u8ID);
    

  60. void PSIO_SpecifyStripID(uint8_t u8ID);
    


  61. 

  62. #endif /* _PSIO_ARGB2_STRIP_H_ */
    


  63. 

  64. /*** (C) COPYRIGHT 2022 Nuvoton Technology Corp. ***/
回复

收藏 举报

 楼主| 小灵通2018 发表于 2024-5-20 21:35 | 显示全部楼层
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <stdint.h>
    

  4. #include <string.h>
    


  5. 

  6. #include "NuMicro.h"
    

  7. #include "PSIO_ARGB2_Driver.h"
    


  8. 

  9. //------------------------------------------------------------------------------
    

  10. // Global variable
    

  11. //------------------------------------------------------------------------------
    

  12. static S_PSIO_ARGB2_STRIP_CFG_T gsPSIO_ARGB2_Cfg = {0};
    

  13. static uint32_t u32TimeoutUs = 0;
    

  14. static uint32_t multipliter = 0;
    


  15. 

  16. //------------------------------------------------------------------------------
    

  17. // Define functions prototype
    

  18. //------------------------------------------------------------------------------
    

  19. static void PSIO_Strip_OpenInput(uint32_t u32Switch);
    

  20. static void PSIO_Strip_OpenOutput(uint32_t u32Switch);
    


  21. 

  22. //------------------------------------------------------------------------------
    

  23. void Delay_Init(void)
    

  24. {
    

  25.     /* while loop takes 3 ~ 4 cycles */
    

  26.     /* for 1 us delay, we need to divide with 3M */
    

  27.     multipliter = (CLK_GetCPUFreq() / 12000000);
    

  28. }
    


  29. 

  30. uint32_t TimeoutUsInit(uint32_t micros)
    

  31. {
    

  32.     return (u32TimeoutUs = ((multipliter * (micros + 16)) - 10));
    

  33. }
    


  34. 

  35. void DelayUs(uint32_t micros)
    

  36. {
    

  37.     /* multiply micro with multipliter */
    

  38.     micros = ((multipliter * (micros + 16)) - 10);
    


  39. 

  40.     /* 4 cycles for one loop */
    

  41.     while (micros--);
    

  42. }
    


  43. 

  44. void DelayMs(uint32_t mills)
    

  45. {
    

  46.     /* multiply mills with multipliter */
    

  47.     mills = multipliter * mills * 1100 - 10;
    


  48. 

  49.     /* 4 cycles for one loop */
    

  50.     while (mills--);
    

  51. }
    


  52. 

  53. void DelayS(uint32_t mills)
    

  54. {
    

  55.     /* multiply mills with multipliter */
    

  56.     mills = multipliter * mills * 1100000 - 10;
    


  57. 

  58.     /* 4 cycles for one loop */
    

  59.     while (mills--);
    

  60. }
    


  61. 

  62. /**
    

  63.   * @brief  Clear PSIO SLOT setting.
    

  64.   * @param  None
    

  65.   * @retval None
    

  66.   */
    

  67. void PSIO_ResetAllSlotSetting(void)
    

  68. {
    

  69.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  70. 

  71.     /* Slot 0 ~ 7 */
    

  72.     sDataConfig.CKPT0SLT = PSIO_SLOT_DISABLE;
    

  73.     sDataConfig.CKPT1SLT = PSIO_SLOT_DISABLE;
    

  74.     sDataConfig.CKPT2SLT = PSIO_SLOT_DISABLE;
    

  75.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  76.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  77.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  78.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  79.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  80. 

  81.     /* Actions 0 ~ 7 */
    

  82.     sDataConfig.CKPT0ACT = PSIO_NO_ACTION;
    

  83.     sDataConfig.CKPT1ACT = PSIO_NO_ACTION;
    

  84.     sDataConfig.CKPT2ACT = PSIO_NO_ACTION;
    

  85.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  86.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  87.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  88.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  89.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  90. 

  91.     /* Set check point configuration */
    

  92.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  93. 

  94.     /* Set slot tick count */
    

  95.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 0);
    

  96.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 0);
    

  97.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 0);
    

  98.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT3, 0);
    

  99.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT4, 0);
    

  100.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT5, 0);
    

  101.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT6, 0);
    

  102.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT7, 0);
    


  103. 

  104.     /* Trigger slot controller */
    

  105.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  106. 

  107.     /* Wait for slot controller is not busy */
    

  108.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  109. 

  110.     /* Stop slot controller */
    

  111.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    

  112. }
    


  113. 

  114. /**
    

  115.   * @brief  Send BIT0 and BIT1 to complete burst data transfer
    

  116.   * @param  None
    

  117.   * @retval None
    

  118.   */
    

  119. void PSIO_StripSendBurstData(uint32_t u32DataSize,
    

  120.                              uint32_t *u32Data,
    

  121.                              uint32_t u32DataCount)
    

  122. {
    

  123.     uint32_t u32i = 0;
    

  124.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  125. 

  126.     /* Slot 0 ~ 7 */
    

  127.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  128.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  129.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  130.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  131.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  132.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  133.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  134.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  135. 

  136.     /* Actions 0 ~ 7 */
    

  137.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  138.     sDataConfig.CKPT1ACT = PSIO_OUT_BUFFER;
    

  139.     sDataConfig.CKPT2ACT = PSIO_OUT_LOW;
    

  140.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  141.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  142.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  143.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  144.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  145. 

  146.     /* Set check point configuration */
    

  147.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  148. 

  149.     /* Set slot count */
    

  150.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 1);
    

  151.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 2);
    

  152.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 1);
    


  153. 

  154.     /* Enable repeat slot0 ~ slot2 u32DataSize - 1 times */
    

  155.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT2, u32DataSize - 1, PSIO_REPEAT_DISABLE);
    


  156. 

  157.     /* Set out data width as u32DataSize bit */
    

  158.     PSIO_SET_WIDTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, 0, u32DataSize);
    


  159. 

  160.     /* Set out data depth as 1 */
    

  161.     PSIO_SET_OUTPUT_DEPTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, PSIO_DEPTH1);
    


  162. 

  163.     for (u32i = 0; u32i < u32DataCount; u32i++)
    

  164.     {
    

  165.         /* Set output data to buffer */
    

  166.         PSIO_SET_OUTPUT_DATA(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, u32Data[u32i]);
    


  167. 

  168.         /* Trigger slot controller */
    

  169.         PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  170. 

  171.         /* Wait for slot controller is not busy */
    

  172.         while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    

  173.     }
    


  174. 

  175.     /* Wait for slot controller is not busy */
    

  176.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  177. 

  178.     /* Stop slot controller */
    

  179.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  180. 

  181.     /* Disable repeat slot0 ~ slot2 */
    

  182.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  183. }
    


  184. 

  185. /**
    

  186.   * @brief  Send BIT0 and BIT1 to complete the data transfer
    

  187.   * @param  None
    

  188.   * @retval None
    

  189.   */
    

  190. void PSIO_SendDataWithSize(uint32_t u32DataSize, uint32_t u32Data)
    

  191. {
    

  192.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  193. 

  194.     /* Slot 0 ~ 7 */
    

  195.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  196.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  197.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  198.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  199.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  200.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  201.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  202.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  203. 

  204.     /* Actions 0 ~ 7 */
    

  205.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  206.     sDataConfig.CKPT1ACT = PSIO_OUT_BUFFER;
    

  207.     sDataConfig.CKPT2ACT = PSIO_OUT_LOW;
    

  208.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  209.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  210.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  211.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  212.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  213. 

  214.     /* Set check point configuration */
    

  215.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  216. 

  217.     /* Set slot count */
    

  218.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 1);
    

  219.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 2);
    

  220.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 1);
    


  221. 

  222.     /* Enable repeat slot0 ~ slot2 u32DataSize - 1 times */
    

  223.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT2, u32DataSize - 1, PSIO_REPEAT_DISABLE);
    


  224. 

  225.     /* Set out data width as u32DataSize bit */
    

  226.     PSIO_SET_WIDTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, 0, u32DataSize);
    


  227. 

  228.     /* Set out data depth as 1 */
    

  229.     PSIO_SET_OUTPUT_DEPTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, PSIO_DEPTH1);
    


  230. 

  231.     /* Set output data to buffer */
    

  232.     PSIO_SET_OUTPUT_DATA(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, u32Data);
    


  233. 

  234.     /* Trigger slot controller */
    

  235.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  236. 

  237.     /* Wait for slot controller is not busy */
    

  238.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  239. 

  240.     /* Stop slot controller */
    

  241.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  242. 

  243.     /* Disable repeat slot0 ~ slot2 */
    

  244.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  245. }
    


  246. 

  247. void PSIO_StripSetupID(uint32_t u32DataSize, uint32_t u32Data)
    

  248. {
    

  249.     S_PSIO_CP_CONFIG sCmdConfig = {0};
    

  250.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  251. 

  252.     //--------------------------------------------------------------------------
    

  253.     // Enable strip setup ID control
    

  254.     //--------------------------------------------------------------------------
    

  255.     /* Slot 0 ~ 7 */
    

  256.     sCmdConfig.CKPT0SLT = PSIO_SLOT0;
    

  257.     sCmdConfig.CKPT1SLT = PSIO_SLOT1;
    

  258.     sCmdConfig.CKPT2SLT = PSIO_SLOT2;
    

  259.     sCmdConfig.CKPT3SLT = PSIO_SLOT3;
    

  260.     sCmdConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  261.     sCmdConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  262.     sCmdConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  263.     sCmdConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  264. 

  265.     /* Actions 0 ~ 7 */
    

  266.     sCmdConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  267.     sCmdConfig.CKPT1ACT = PSIO_OUT_HIGH;
    

  268.     sCmdConfig.CKPT2ACT = PSIO_OUT_HIGH;
    

  269.     sCmdConfig.CKPT3ACT = PSIO_OUT_LOW;
    

  270.     sCmdConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  271.     sCmdConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  272.     sCmdConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  273.     sCmdConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  274. 

  275.     //--------------------------------------------------------------------------
    

  276.     // send strip setup command and ID
    

  277.     //--------------------------------------------------------------------------
    

  278.     /* Slot 0 ~ 7 */
    

  279.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  280.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  281.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  282.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  283.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  284.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  285.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  286.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  287. 

  288.     /* Actions 0 ~ 7 */
    

  289.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  290.     sDataConfig.CKPT1ACT = PSIO_OUT_BUFFER;
    

  291.     sDataConfig.CKPT2ACT = PSIO_OUT_LOW;
    

  292.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  293.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  294.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  295.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  296.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  297. 

  298.     //first reset
    

  299.     PSIO_StripReset();
    


  300. 

  301.     /* Set out data width as u32DataSize bit */
    

  302.     PSIO_SET_WIDTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, 0, u32DataSize);
    


  303. 

  304.     /* Set check point configuration */
    

  305.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sCmdConfig);
    


  306. 

  307.     /* Set slot 0 tick count as 4, slot 1 tick count as 4, slot 2 tick count as 7 */
    

  308.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 4);
    

  309.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 4);
    

  310.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 7);
    

  311.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT3, 12);
    


  312. 

  313.     /* Enable repeat slot 0 ~ slot 2 u32DataSize - 1 times*/
    

  314.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT2, u32DataSize - 1, PSIO_REPEAT_DISABLE);
    


  315. 

  316.     /* Trigger slot controller */
    

  317.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  318. 

  319.     /* Wait for slot controller is not busy */
    

  320.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  321. 

  322.     /* Stop slot controller */
    

  323.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  324. 

  325.     /* Set check point configuration */
    

  326.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  327. 

  328.     /* Set slot count */
    

  329.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 1);
    

  330.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 2);
    

  331.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 1);
    


  332. 

  333.     /* Set output data to buffer */
    

  334.     PSIO_SET_OUTPUT_DATA(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, u32Data);
    


  335. 

  336.     /* Trigger slot controller */
    

  337.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  338. 

  339.     /* Wait for slot controller is not busy */
    

  340.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  341. 

  342.     /* Stop slot controller */
    

  343.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  344. 

  345.     /* Disable repeat slot0 ~ slot2 */
    

  346.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  347. }
    


  348. 

  349. /**
    

  350.   * @brief Receive response pulse for Y-Cable check ID function
    

  351.   * @param  None
    

  352.   * @retval None
    

  353.   */
    

  354. uint16_t PSIO_StripCheckIDFeedback(uint16_t u16WaitTime)
    

  355. {
    

  356.     uint16_t u16LEDCnt = 0;
    

  357.     uint32_t u32BitIndex = 0;
    

  358.     int32_t i32UsTimeout = 0;
    

  359.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  360. 

  361.     i32UsTimeout = TimeoutUsInit(u16WaitTime);
    


  362. 

  363.     PSIO_Strip_OpenInput(PSIO_PIN_ENABLE);
    


  364. 

  365.     /* Slot 0 ~ 7 */
    

  366.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  367.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  368.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  369.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  370.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  371.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  372.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  373.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  374. 

  375.     /* Actions 0 ~ 7 */
    

  376.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  377.     sDataConfig.CKPT1ACT = PSIO_IN_BUFFER;
    

  378.     sDataConfig.CKPT2ACT = PSIO_OUT_LOW;
    

  379.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  380.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  381.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  382.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  383.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  384. 

  385.     /* Set check point configuration */
    

  386.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  387. 

  388.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 15);
    

  389.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 15);
    

  390.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 3);
    


  391. 

  392.     /* Enable repeat slot0 ~ slot0 26 times */
    

  393.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT2, 63, PSIO_REPEAT_DISABLE);
    


  394. 

  395.     /* Trigger slot controller */
    

  396.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  397. 

  398.     /* Wait data buffer is full */
    

  399.     while ((!PSIO_GET_TRANSFER_STATUS(PSIO, PSIO_TRANSTS_INFULL0_Msk)) && (i32UsTimeout-- >= 0));
    


  400. 

  401.     if (i32UsTimeout <= 0)
    

  402.     {
    

  403.         /* Stop slot controller */
    

  404.         PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  405. 

  406.         /* Disable repeat slot0 ~ slot0 */
    

  407.         PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    


  408. 

  409.         PSIO_Strip_OpenOutput(PSIO_PIN_ENABLE);
    

  410.         return 0;
    

  411.     }
    


  412. 

  413.     /* Read data from device */
    

  414.     u16LEDCnt = PSIO_GET_INPUT_DATA(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin);
    


  415. 

  416.     /* Stop slot controller */
    

  417.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  418. 

  419.     /* Disable repeat slot0 ~ slot0 */
    

  420.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    


  421. 

  422.     PSIO_Strip_OpenOutput(PSIO_PIN_ENABLE);
    


  423. 

  424.     return u16LEDCnt;
    

  425. }
    


  426. 

  427. void PSIO_SpecifyStripID(uint8_t u8ID)
    

  428. {
    

  429.     uint8_t u8Cmd = (0x40 | (u8ID & 0x0F));
    


  430. 

  431.     PSIO_StripSetupID(8, u8Cmd);
    


  432. 

  433.     PSIO_StripReset();
    

  434. }
    


  435. 

  436. void PSIO_CheckStripkID(uint8_t u8ID)
    

  437. {
    

  438.     uint8_t u8GetPulse = 0;
    

  439.     uint8_t u8Cmd = (0x30 | (u8ID & 0x0F));
    


  440. 

  441.     PSIO_StripSetupID(8, u8Cmd);
    


  442. 

  443.     u8GetPulse = PSIO_StripCheckIDFeedback(160);
    


  444. 

  445.     if (u8GetPulse != 0)
    

  446.     {
    

  447.         printf("Get %d strip ID\r\n", u8ID);
    

  448.     }
    

  449.     else
    

  450.     {
    

  451.         printf("Not get %d strip ID\r\n", u8ID);
    

  452.     }
    


  453. 

  454.     PSIO_StripReset();
    

  455. }
    


  456. 

  457. void PSIO_ClearStripID(uint8_t u8ID)
    

  458. {
    

  459.     uint8_t u8Cmd = (0x20 | (u8ID & 0x0F));
    


  460. 

  461.     PSIO_StripSetupID(8, u8Cmd);
    


  462. 

  463.     PSIO_StripReset();
    

  464. }
    


  465. 

  466. void PSIO_SetStripID(uint8_t u8ID)
    

  467. {
    

  468.     uint8_t u8Cmd = (0x10 | (u8ID & 0x0F));
    


  469. 

  470.     PSIO_StripSetupID(8, u8Cmd);
    


  471. 

  472.     PSIO_StripReset();
    

  473. }
    


  474. 

  475. void PSIO_StripWakeupMode(void)
    

  476. {
    

  477.     uint8_t u8StripCnt = 0;
    


  478. 

  479.     PSIO_StripReset();
    


  480. 

  481.     for (u8StripCnt = 0; u8StripCnt < PIXEL_NUM; u8StripCnt++)
    

  482.     {
    

  483.         PSIO_SendDataWithSize(24, TH20_24bits);
    

  484.         DelayMs(1);
    

  485.     }
    

  486. }
    


  487. 

  488. void PSIO_StripSleepMode(void)
    

  489. {
    

  490.     uint8_t u8StripCnt = 0;
    


  491. 

  492.     for (u8StripCnt = 0; u8StripCnt < PIXEL_NUM; u8StripCnt++)
    

  493.     {
    

  494.         PSIO_SendDataWithSize(24, 0x000000);
    

  495.     }
    


  496. 

  497.     PSIO_SendDataWithSize(8, 0x5A);
    


  498. 

  499.     PSIO_StripReset();
    

  500. }
    


  501. 

  502. void PSIO_StripHighLevelCMDTh20(void)
    

  503. {
    

  504.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  505. 

  506.     /* Slot 0 ~ 7 */
    

  507.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  508.     sDataConfig.CKPT1SLT = PSIO_SLOT_DISABLE;
    

  509.     sDataConfig.CKPT2SLT = PSIO_SLOT_DISABLE;
    

  510.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  511.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  512.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  513.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  514.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  515. 

  516.     /* Actions 0 ~ 7 */
    

  517.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  518.     sDataConfig.CKPT1ACT = PSIO_NO_ACTION;
    

  519.     sDataConfig.CKPT2ACT = PSIO_NO_ACTION;
    

  520.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  521.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  522.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  523.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  524.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  525. 

  526.     /* Set check point configuration */
    

  527.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  528. 

  529.     /* Set slot 0 tick count as 15, slot 1 tick count as 15 */
    

  530.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 15);
    


  531. 

  532.     /* Enable repeat slot 0 ~ slot 2 */
    

  533.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT0, 3, PSIO_REPEAT_DISABLE);
    


  534. 

  535.     /* Trigger slot controller */
    

  536.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  537. 

  538.     /* Wait for slot controller is not busy */
    

  539.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  540. 

  541.     /* Stop slot controller */
    

  542.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  543. 

  544.     /* Disable repeat slot0 ~ slot0 */
    

  545.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  546. }
    


  547. 

  548. void PSIO_StripHighLevelSetup(void)
    

  549. {
    

  550.     uint8_t u8StripCnt = 0;
    

  551.     uint32_t u32Data[PIXEL_NUM] = {TH20_24bits};
    


  552. 

  553.     for (u8StripCnt = 0; u8StripCnt < PIXEL_NUM; u8StripCnt++)
    

  554.     {
    

  555.         u32Data[u8StripCnt] = TH20_24bits;
    

  556.     }
    


  557. 

  558.     PSIO_StripHighLevelCMDTh20();
    


  559. 

  560.     PSIO_StripReset();
    


  561. 

  562.     PSIO_StripSendBurstData(24, &u32Data[0], PIXEL_NUM);
    


  563. 

  564.     PSIO_StripReset();
    

  565. }
    


  566. 

  567. /**
    

  568.   * @brief  Send Trst
    

  569.   * @param  None
    

  570.   * @retval None
    

  571.   */
    

  572. uint16_t PSIO_StripReadFeedBack(uint16_t u16WaitTime)
    

  573. {
    

  574.     uint16_t u16LEDCnt = 0;
    

  575.     uint32_t u32BitIndex = 0;
    

  576.     int32_t i32UsTimeout = 0;
    

  577.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  578. 

  579.     PSIO_Strip_OpenInput(PSIO_PIN_ENABLE);
    


  580. 

  581.     /* Slot 0 ~ 7 */
    

  582.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  583.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  584.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  585.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  586.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  587.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  588.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  589.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  590. 

  591.     /* Actions 0 ~ 7 */
    

  592.     sDataConfig.CKPT0ACT = PSIO_NO_ACTION;
    

  593.     sDataConfig.CKPT1ACT = PSIO_IN_BUFFER;
    

  594.     sDataConfig.CKPT2ACT = PSIO_NO_ACTION;
    

  595.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  596.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  597.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  598.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  599.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  600. 

  601.     /* Set check point configuration */
    

  602.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  603. 

  604.     /* Set slot 0 tick count as 15, slot 1 tick count as 15, slot 2 tick count as 3*/
    

  605.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 9);
    

  606.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 15);
    

  607.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 7);
    


  608. 

  609.     /* Enable repeat slot0 ~ slot2 */
    

  610.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT2, 63, PSIO_REPEAT_DISABLE);
    


  611. 

  612.     for (u32BitIndex = 0; u32BitIndex < 512; u32BitIndex++)
    

  613.     {
    

  614.         /* Set wait pulse timeout counter */
    

  615.         i32UsTimeout = TimeoutUsInit(u16WaitTime);
    


  616. 

  617.         /* Trigger slot controller */
    

  618.         PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  619. 

  620.         /* Wait data buffer is full */
    

  621.         while ((!PSIO_GET_TRANSFER_STATUS(PSIO, PSIO_TRANSTS_INFULL0_Msk)) && (i32UsTimeout-- >= 0));
    


  622. 

  623.         if (i32UsTimeout <= 0)
    

  624.         {
    

  625.             break;
    

  626.         }
    


  627. 

  628.         /* Read data from device */
    

  629.         u16LEDCnt += PSIO_GET_INPUT_DATA(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin);
    

  630.     }
    


  631. 

  632.     /* Wait for slot controller is not busy */
    

  633.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  634. 

  635.     /* Stop slot controller */
    

  636.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  637. 

  638.     /* Disable repeat slot0 ~ slot2 */
    

  639.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    


  640. 

  641.     PSIO_Strip_OpenOutput(PSIO_PIN_ENABLE);
    


  642. 

  643.     return u16LEDCnt;
    

  644. }
    


  645. 

  646. /**
    

  647.   * @brief  Send Trst
    

  648.   * @param  None
    

  649.   * @retval None
    

  650.   */
    

  651. void PSIO_StripFeedBackCMDTh50(void)
    

  652. {
    

  653.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  654. 

  655.     /* Slot 0 ~ 7 */
    

  656.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  657.     sDataConfig.CKPT1SLT = PSIO_SLOT1;
    

  658.     sDataConfig.CKPT2SLT = PSIO_SLOT2;
    

  659.     sDataConfig.CKPT3SLT = PSIO_SLOT3;
    

  660.     sDataConfig.CKPT4SLT = PSIO_SLOT4;
    

  661.     sDataConfig.CKPT5SLT = PSIO_SLOT5;
    

  662.     sDataConfig.CKPT6SLT = PSIO_SLOT6;
    

  663.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  664. 

  665.     /* Actions 0 ~ 7 */
    

  666.     sDataConfig.CKPT0ACT = PSIO_OUT_HIGH;
    

  667.     sDataConfig.CKPT1ACT = PSIO_OUT_HIGH;
    

  668.     sDataConfig.CKPT2ACT = PSIO_OUT_HIGH;
    

  669.     sDataConfig.CKPT3ACT = PSIO_OUT_HIGH;
    

  670.     sDataConfig.CKPT4ACT = PSIO_OUT_LOW;
    

  671.     sDataConfig.CKPT5ACT = PSIO_OUT_LOW;
    

  672.     sDataConfig.CKPT6ACT = PSIO_OUT_HIGH;
    

  673.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  674. 

  675.     /* Set check point configuration */
    

  676.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  677. 

  678.     /* Set slot tick count */
    

  679.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 15);
    

  680.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT1, 15);
    

  681.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT2, 15);
    

  682.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT3, 15);
    

  683.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT4, 15);
    

  684.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT5, 15);
    

  685.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT6, 15);
    


  686. 

  687.     /* Enable repeat slot6 ~ slot7 */
    

  688.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT6, PSIO_SLOT6, 9, PSIO_REPEAT_DISABLE);
    


  689. 

  690.     /* Trigger slot controller */
    

  691.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  692. 

  693.     /* Wait for slot controller is not busy */
    

  694.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  695. 

  696.     /* Stop slot controller */
    

  697.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  698. 

  699.     /* Disable repeat slot0 ~ slot0 */
    

  700.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  701. }
    


  702. 

  703. /**
    

  704.   * @brief  Send Trst
    

  705.   * @param  None
    

  706.   * @retval None
    

  707.   */
    

  708. uint16_t PSIO_StripFeedBackMode(void)
    

  709. {
    

  710.     uint16_t u16LEDCnt = 0;
    

  711.     uint32_t u32BitIndex = 0;
    

  712.     uint32_t u32DelayCnt = 0;
    


  713. 

  714.     PSIO_StripReset();
    


  715. 

  716.     PSIO_StripFeedBackCMDTh50();
    


  717. 

  718.     u16LEDCnt = PSIO_StripReadFeedBack(160);
    


  719. 

  720.     PSIO_StripReset();
    

  721.     PSIO_ResetAllSlotSetting();
    

  722.     return u16LEDCnt;
    

  723. }
    


  724. 

  725. /**
    

  726.   * @brief  Send Trst
    

  727.   * @param  None
    

  728.   * @retval None
    

  729.   */
    

  730. void PSIO_StripReset(void)
    

  731. {
    

  732.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  733. 

  734.     /* Slot 0 ~ 7 */
    

  735.     sDataConfig.CKPT0SLT = PSIO_SLOT0;
    

  736.     sDataConfig.CKPT1SLT = PSIO_SLOT_DISABLE;
    

  737.     sDataConfig.CKPT2SLT = PSIO_SLOT_DISABLE;
    

  738.     sDataConfig.CKPT3SLT = PSIO_SLOT_DISABLE;
    

  739.     sDataConfig.CKPT4SLT = PSIO_SLOT_DISABLE;
    

  740.     sDataConfig.CKPT5SLT = PSIO_SLOT_DISABLE;
    

  741.     sDataConfig.CKPT6SLT = PSIO_SLOT_DISABLE;
    

  742.     sDataConfig.CKPT7SLT = PSIO_SLOT_DISABLE;
    


  743. 

  744.     /* Actions 0 ~ 7 */
    

  745.     sDataConfig.CKPT0ACT = PSIO_OUT_LOW;
    

  746.     sDataConfig.CKPT1ACT = PSIO_NO_ACTION;
    

  747.     sDataConfig.CKPT2ACT = PSIO_NO_ACTION;
    

  748.     sDataConfig.CKPT3ACT = PSIO_NO_ACTION;
    

  749.     sDataConfig.CKPT4ACT = PSIO_NO_ACTION;
    

  750.     sDataConfig.CKPT5ACT = PSIO_NO_ACTION;
    

  751.     sDataConfig.CKPT6ACT = PSIO_NO_ACTION;
    

  752.     sDataConfig.CKPT7ACT = PSIO_NO_ACTION;
    


  753. 

  754.     /* Set check point configuration */
    

  755.     PSIO_SET_CP_CONFIG(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, &sDataConfig);
    


  756. 

  757.     /* Set slot 0 tick count as 15, slot 1 tick count as 15 */
    

  758.     PSIO_SCSLOT_SET_SLOT(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, 15);
    


  759. 

  760.     /* Enable repeat slot1 ~ slot1 */
    

  761.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT0, PSIO_SLOT0, 47, PSIO_REPEAT_DISABLE);
    


  762. 

  763.     /* Trigger slot controller */
    

  764.     PSIO_START_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  765. 

  766.     /* Wait for slot controller is not busy */
    

  767.     while (PSIO_GET_BUSY_FLAG(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl));
    


  768. 

  769.     /* Stop slot controller */
    

  770.     PSIO_STOP_SC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl);
    


  771. 

  772.     /* Disable repeat slot0 ~ slot0 */
    

  773.     PSIO_SET_SCCTL(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SLOT_DISABLE, PSIO_SLOT_DISABLE, 0, PSIO_REPEAT_DISABLE);
    

  774. }
    


  775. 

  776. static void PSIO_Strip_OpenInput(uint32_t u32Switch)
    

  777. {
    

  778.     /* PSIO UART TX PIN general setting */
    

  779.     PSIO_SET_GENCTL(PSIO,
    

  780.                     gsPSIO_ARGB2_Cfg.u8DataPin,
    

  781.                     u32Switch,//PSIO_PIN_ENABLE,
    

  782.                     gsPSIO_ARGB2_Cfg.u8SlotCtrl,
    

  783.                     PSIO_INPUT_MODE,
    

  784.                     PSIO_LOW_LEVEL,
    

  785.                     PSIO_LOW_LEVEL);
    


  786. 

  787.     /* Set output data buffer width as 8 bit, input data width as 1 bit*/
    

  788.     PSIO_SET_WIDTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, 1, 8);
    


  789. 

  790.     /* Set input data buffer depth as 1 */
    

  791.     PSIO_SET_INPUT_DEPTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, PSIO_DEPTH1);
    

  792. }
    


  793. 

  794. static void PSIO_Strip_OpenOutput(uint32_t u32Switch)
    

  795. {
    

  796.     /* PSIO UART TX PIN general setting */
    

  797.     PSIO_SET_GENCTL(PSIO,
    

  798.                     gsPSIO_ARGB2_Cfg.u8DataPin,
    

  799.                     u32Switch, //PSIO_PIN_ENABLE
    

  800.                     gsPSIO_ARGB2_Cfg.u8SlotCtrl,
    

  801.                     PSIO_OUTPUT_MODE,
    

  802.                     PSIO_LOW_LEVEL,
    

  803.                     PSIO_LOW_LEVEL);
    


  804. 

  805.     /* Set data order ad MSB */
    

  806.     PSIO_SET_ORDER(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, PSIO_MSB);
    


  807. 

  808.     /* Set output data buffer width as 8 bit, input data width as 1 bit*/
    

  809.     PSIO_SET_WIDTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, 1, 8);
    


  810. 

  811.     /* Set output data buffer depth as 1 */
    

  812.     PSIO_SET_OUTPUT_DEPTH(PSIO, gsPSIO_ARGB2_Cfg.u8DataPin, PSIO_DEPTH1);
    


  813. 

  814.     /* Set slot controller trigger source as software trigger */
    

  815.     PSIO_SET_TRIGSRC(PSIO, gsPSIO_ARGB2_Cfg.u8SlotCtrl, PSIO_SW_TRIGGER);
    

  816. }
    


  817. 

  818. /**
    

  819.   * @brief  initialize ARGB2 PSIO PIN
    

  820.   * @param  None
    

  821.   * @retval None
    

  822.   */
    

  823. void PSIO_StripInit(uint8_t u8SlotCtrl, uint8_t u8DataPin)
    

  824. {
    

  825.     gsPSIO_ARGB2_Cfg.u8SlotCtrl = u8SlotCtrl;
    

  826.     gsPSIO_ARGB2_Cfg.u8DataPin = u8DataPin;
    


  827. 

  828.     PSIO_Strip_OpenOutput(PSIO_PIN_ENABLE);
    

  829. }
    


  830. 

  831. //------------------------------------------------------------------------------
    

  832. /**
    

  833.   * @brief  Fill ALL LEDs with (0,0,0)
    

  834.     * @param  24 bits data (Range: 0x000000 to 0xffffff)
    

  835.   * @retval None
    

  836.   */
    

  837. void PSIO_StripClear(void)
    

  838. {
    

  839.     uint8_t u8i = 0;
    


  840. 

  841.     for (u8i = 0; u8i < PIXEL_NUM; u8i++)
    

  842.     {
    

  843.         PSIO_SendDataWithSize(24, 0x000000);
    

  844.     }
    

  845. }
    


  846. 

  847. /**
    

  848.   * @brief  Digital output to all LED which in ARGB2 strip
    

  849.   * @param  None
    

  850.   * @retval None
    

  851.   */
    

  852. void PSIO_StripShow(void)
    

  853. {
    

  854.     uint16_t i, j;
    

  855.     int32_t i32Data[PIXEL_NUM] = {0};
    

  856.     S_PSIO_CP_CONFIG sDataConfig = {0};
    


  857. 

  858.     for (i = 0; i < PIXEL_NUM; ++i)
    

  859.     {
    

  860.         for (j = 0; j < GRB; ++j)
    

  861.         {
    

  862.             i32Data[i] |= (gsPSIO_ARGB2_Cfg.au8PixelBuffer[i][j] << (23 - j));
    

  863.             //if (gsPSIO_ARGB2_Cfg.au8PixelBuffer[i][j] == BIT1_HIGH) {
    

  864.             //    PSIO_SendStripBit1();
    

  865.             //} else {
    

  866.             //    PSIO_SendStripBit0();
    

  867.             //}
    

  868.         }
    

  869.     }
    


  870. 

  871.     for (i = 0; i < PIXEL_NUM; ++i)
    

  872.     {
    

  873.         PSIO_SendDataWithSize(24, i32Data[i]);
    

  874.     }
    

  875. }
    


  876. 

  877. /**
    

  878.   * @brief  RGB color bitwise operation
    

  879.   * @param  red     0-255
    

  880.     *                   green   0-255
    

  881.     *                   blue    0-255
    

  882.   * @retval None
    

  883.   */
    

  884. uint32_t Strip_color(uint8_t u8Red, uint8_t u8Green, uint8_t u8Blue)
    

  885. {
    

  886.     return u8Green << 16 | u8Red << 8 | u8Blue;
    

  887. }
    


  888. 

  889. /**
    

  890.   * @brief  Input a value 0 to 255 to get a color value.
    

  891.                         The colours are a transition r - g - b - back to r.
    

  892.   * @param  None
    

  893.   * @retval None
    

  894.   */
    

  895. uint32_t PSIO_StripWheel(uint8_t u8WheelPos)
    

  896. {
    

  897.     u8WheelPos = 255 - u8WheelPos;
    


  898. 

  899.     if (u8WheelPos < 85)
    

  900.     {
    

  901.         return Strip_color(255 - u8WheelPos * 3, 0, u8WheelPos * 3);
    

  902.     }
    


  903. 

  904.     if (u8WheelPos < 170)
    

  905.     {
    

  906.         u8WheelPos -= 85;
    

  907.         return Strip_color(0, u8WheelPos * 3, 255 - u8WheelPos * 3);
    

  908.     }
    


  909. 

  910.     u8WheelPos -= 170;
    


  911. 

  912.     return Strip_color(u8WheelPos * 3, 255 - u8WheelPos * 3, 0);
    

  913. }
    


  914. 

  915. /**
    

  916.   * @brief  RGB setting to all LED
    

  917.     * @param  n:                    Specify a LED
    

  918.                         GRBColor:       Set BIT1 or BIT0
    

  919.   * @retval None
    

  920.   */
    

  921. void PSIO_StripSetPixelColor(uint16_t u16Num, uint32_t u32RGBColor)
    

  922. {
    

  923.     uint8_t i = 0;
    


  924. 

  925.     if (u16Num < PIXEL_NUM)
    

  926.     {
    

  927.         for (i = 0; i < GRB; i++)
    

  928.         {
    

  929.             gsPSIO_ARGB2_Cfg.au8PixelBuffer[u16Num][i] = ((u32RGBColor << i) & 0x800000) ? BIT1_HIGH : BIT0_LOW;
    

  930.         }
    

  931.     }
    

  932. }
    


  933. 

  934. /**
    

  935.  * @brief Set GLOBAL LED brightness
    

  936.  * @param[in] br Brightness [0..255]
    

  937.  * [url=home.php?mod=space&uid=266161]@return[/url] #ARGB_STATE enum
    

  938.  */
    

  939. void PSIO_StripSetBrightness(uint8_t u8Brightness)
    

  940. {
    

  941.     gsPSIO_ARGB2_Cfg.u8Brightness = u8Brightness;
    

  942. }
    


  943. 

  944. /**
    

  945.   * @brief  Send one data to a LED
    

  946.     * @param  24 bits data (Range: 0x000000 to 0xffffff)
    

  947.   * @retval None
    

  948.   */
    

  949. void PSIO_StripSetRGBColor(uint8_t u8Red, uint8_t u8Green, uint8_t u8Blue)
    

  950. {
    

  951.     int32_t i32Data = 0;
    


  952. 

  953.     u8Red   /= (256 / ((uint16_t) gsPSIO_ARGB2_Cfg.u8Brightness + 1));
    

  954.     u8Green /= (256 / ((uint16_t) gsPSIO_ARGB2_Cfg.u8Brightness + 1));
    

  955.     u8Blue  /= (256 / ((uint16_t) gsPSIO_ARGB2_Cfg.u8Brightness + 1));
    


  956. 

  957.     i32Data |= (u8Green << 16);
    

  958.     i32Data |= (u8Red << 8);
    

  959.     i32Data |= u8Blue;
    


  960. 

  961.     PSIO_SendDataWithSize(24, i32Data);
    

  962. }
回复

收藏 举报

 楼主| 小灵通2018 发表于 2024-5-20 21:35 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00
    

  4.  * @brief    Show how to use PSIO input/output to control ARGB2 strip.
    

  5.  *
    

  6.  * SPDX-License-Identifier: Apache-2.0
    

  7.  * [url=home.php?mod=space&uid=17282]@CopyRight[/url] (C) 2022 Nuvoton Technology Corp. All rights reserved.
    

  8.  ******************************************************************************/
    

  9. #include "stdio.h"
    

  10. #include "NuMicro.h"
    

  11. #include "PSIO_ARGB2_Driver.h"
    


  12. 

  13. //------------------------------------------------------------------------------
    

  14. uint32_t sysGetNum(void)
    

  15. {
    

  16.     uint8_t cInputTemp = 0x00, InputString[16] = {0};
    

  17.     uint32_t nLoop = 0;
    


  18. 

  19.     while (cInputTemp != 0x0D)
    

  20.     {
    

  21.         cInputTemp = getchar();
    


  22. 

  23.         if (cInputTemp == 27)   /* 27: ESC key */
    

  24.         {
    

  25.             return cInputTemp;
    

  26.         }
    


  27. 

  28.         if (cInputTemp == 'x' || cInputTemp == 'X' || cInputTemp == 'f' ||
    

  29.                 cInputTemp == 'F' || cInputTemp == 'r' || cInputTemp == 'R')
    

  30.         {
    

  31.             return cInputTemp;
    

  32.         }
    


  33. 

  34.         if (cInputTemp == '-')
    

  35.         {
    

  36.             InputString[nLoop] = cInputTemp;
    

  37.             printf("%c", cInputTemp);
    

  38.             nLoop++;
    

  39.         }
    

  40.         else if (cInputTemp >= '0' && cInputTemp <= '9')
    

  41.         {
    

  42.             InputString[nLoop] = cInputTemp;
    

  43.             printf("%c", cInputTemp);
    

  44.             nLoop++;
    

  45.         }
    

  46.     }
    


  47. 

  48.     printf("\n");
    


  49. 

  50.     //return atoi(InputString);
    

  51.     return atoi((const char *)InputString);
    

  52. }
    


  53. 

  54. //------------------------------------------------------------------------------
    

  55. /**
    

  56.   * @brief  Specify a Strip ID in Y cable mode
    

  57.     * @param  tmpID: Specify a ID
    

  58.   * @retval None
    

  59.   */
    

  60. int Strip_SpecifyIDTest(void)
    

  61. {
    

  62.     PSIO_SpecifyStripID(0x05);
    


  63. 

  64.     return 0;
    

  65. }
    


  66. 

  67. /**
    

  68.   * @brief  Check a strip ID in Y cable function
    

  69.   * @param  count: Check ID count
    

  70.   * @retval None
    

  71.   */
    

  72. int Strip_CheckIDTest(void)
    

  73. {
    

  74.     uint8_t u8i = 0;
    


  75. 

  76.     for (u8i = 1; u8i < 16; u8i++)
    

  77.     {
    

  78.         PSIO_CheckStripkID(u8i);
    

  79.     }
    


  80. 

  81.     return 0;
    

  82. }
    


  83. 

  84. /**
    

  85.   * @brief  Clear a Strip ID in Y cable function
    

  86.   * @param  count: Clear ID count
    

  87.   * @retval None
    

  88.   */
    

  89. int Strip_ClearIDTest(void)
    

  90. {
    

  91.     uint8_t u8i = 0;
    


  92. 

  93.     for (u8i = 1; u8i < 16; u8i++)
    

  94.     {
    

  95.         PSIO_ClearStripID(u8i);
    

  96.     }
    


  97. 

  98.     return 0;
    

  99. }
    


  100. 

  101. /**
    

  102.   * @brief  Set a strip ID in Y cable function
    

  103.     * @param  count: Set ID count
    

  104.   * @retval None
    

  105.   */
    

  106. int Strip_SetIDTest(void)
    

  107. {
    

  108.     uint32_t u32ID = 0;
    


  109. 

  110.     printf("Please set ID, then press the ENTER.: (Range: 1 ~ 15): ");
    

  111.     u32ID = sysGetNum();
    


  112. 

  113.     if (u32ID > 15)
    

  114.     {
    

  115.         printf("Setting ID is over range. (1 ~ 15)\r\n");
    

  116.         printf("Leave Y Cable mode.\r\n\r\n");
    

  117.         return -1;
    

  118.     }
    


  119. 

  120.     PSIO_SetStripID(u32ID);
    


  121. 

  122.     return 0;
    

  123. }
    


  124. 

  125. /**
    

  126.   * @brief  Set a strip ID in Y cable menu function
    

  127.     * @param  count: Set ID count
    

  128.   * @retval None
    

  129.   */
    

  130. int Strip_YCableSetupMenu(void)
    

  131. {
    

  132.     uint8_t u8Index = 0;
    

  133.     struct
    

  134.     {
    

  135.         char *chName;
    

  136.         int (*funcptr)(void);
    

  137.     } sSetStripIDMenu[] =
    

  138.     {
    

  139.         {"", NULL},
    

  140.         {"Set strip ID", &Strip_SetIDTest},
    

  141.         {"Clean strip ID", &Strip_ClearIDTest},
    

  142.         {"Check strip ID", &Strip_CheckIDTest},
    

  143.         {"Specify strip ID", &Strip_SpecifyIDTest},
    

  144.     };
    


  145. 

  146.     while (1)
    

  147.     {
    

  148.         printf("\r\n\r\n");
    

  149.         printf("=============================================\r\n");
    

  150.         printf("\tEnter the select setup strip ID test: \r\n");
    

  151.         printf("=============================================\r\n");
    


  152. 

  153.         for (u8Index = 1; u8Index < sizeof(sSetStripIDMenu) / sizeof(sSetStripIDMenu[0]); u8Index++)
    

  154.         {
    

  155.             printf("[%02d] %s\r\n",
    

  156.                    u8Index,
    

  157.                    sSetStripIDMenu[u8Index].chName);
    

  158.         }
    


  159. 

  160.         printf("\r\n");
    


  161. 

  162.         u8Index = sysGetNum();
    


  163. 

  164.         if ((u8Index == 0) || (u8Index >= sizeof(sSetStripIDMenu) / sizeof(sSetStripIDMenu[0])))
    

  165.         {
    

  166.             return 0;
    

  167.         }
    


  168. 

  169.         if (sSetStripIDMenu[u8Index].funcptr != NULL)
    

  170.         {
    

  171.             sSetStripIDMenu[u8Index].funcptr();
    

  172.         }
    

  173.     }
    


  174. 

  175.     return 0;
    

  176. }
    


  177. 

  178. /**
    

  179.   * @brief  Set a strip sleep or wakeup menu function
    

  180.     * @param  count: Set ID count
    

  181.   * @retval None
    

  182.   */
    

  183. int Strip_SleepWakeupTest(void)
    

  184. {
    

  185.     uint8_t u8Index = 0;
    

  186.     struct
    

  187.     {
    

  188.         char *chName;
    

  189.         void (*funcptr)(void);
    

  190.     } sSleepWakeupTest[] =
    

  191.     {
    

  192.         {"", NULL},
    

  193.         {"Strip Sleep", &PSIO_StripSleepMode},
    

  194.         {"strip Wakeup", &PSIO_StripWakeupMode},
    

  195.     };
    


  196. 

  197.     while (1)
    

  198.     {
    

  199.         printf("\r\n\r\n");
    

  200.         printf("=============================================\r\n");
    

  201.         printf("\tEnter the select sleep or wakeup test: \r\n");
    

  202.         printf("=============================================\r\n");
    


  203. 

  204.         for (u8Index = 1; u8Index < sizeof(sSleepWakeupTest) / sizeof(sSleepWakeupTest[0]); u8Index++)
    

  205.         {
    

  206.             printf("[%02d] %s\r\n",
    

  207.                    u8Index,
    

  208.                    sSleepWakeupTest[u8Index].chName);
    

  209.         }
    


  210. 

  211.         printf("\r\n");
    


  212. 

  213.         u8Index = sysGetNum();
    


  214. 

  215.         if ((u8Index == 0) || (u8Index >= sizeof(sSleepWakeupTest) / sizeof(sSleepWakeupTest[0])))
    

  216.         {
    

  217.             return 0;
    

  218.         }
    


  219. 

  220.         if (sSleepWakeupTest[u8Index].funcptr != NULL)
    

  221.         {
    

  222.             sSleepWakeupTest[u8Index].funcptr();
    

  223.         }
    

  224.     }
    


  225. 

  226.     return 0;
    

  227. }
    


  228. 

  229. /**
    

  230.   * @brief  Enable TH20 SET mode
    

  231.   * @param  None
    

  232.   * @retval None
    

  233.   */
    

  234. int Strip_Th20SetMode(void)
    

  235. {
    

  236.     PSIO_StripHighLevelSetup();
    


  237. 

  238.     return 0;
    

  239. }
    


  240. 

  241. /**
    

  242.   * @brief  Theatre-style crawling lights with rainbow effect
    

  243.   * @param  None
    

  244.   * @retval None
    

  245.   */
    

  246. int Strip_FeedbackMode(void)
    

  247. {
    

  248.     printf("There are %d pcs LED in the strip\n", PSIO_StripFeedBackMode());
    


  249. 

  250.     return 0;
    

  251. }
    


  252. 

  253. /**
    

  254.   * @brief  Theatre-style crawling lights with rainbow effect
    

  255.   * @param  None
    

  256.   * @retval None
    

  257.   */
    

  258. int Strip_TheaterChaseRainbow(void)
    

  259. {
    

  260.     uint16_t u16i = 0, u16j = 0;
    

  261.     uint8_t u8q = 0;
    


  262. 

  263.     for (u16j = 0; u16j < 256; u16j++)   // cycle all 256 colors in the wheel
    

  264.     {
    

  265.         for (u8q = 0; u8q < 3; u8q++)
    

  266.         {
    

  267.             for (u16i = 0; u16i < PIXEL_NUM; u16i = u16i + 3)
    

  268.             {
    

  269.                 PSIO_StripSetPixelColor(u16i + u8q, PSIO_StripWheel((u16i + u16j) % 255));
    

  270.             }
    


  271. 

  272.             PSIO_StripShow();
    


  273. 

  274.             PSIO_StripReset();
    


  275. 

  276.             for (u16i = 0; u16i < PIXEL_NUM; u16i = u16i + 3)
    

  277.             {
    

  278.                 PSIO_StripSetPixelColor(u16i + u8q, 0);      //turn every third pixel off
    

  279.             }
    

  280.         }
    

  281.     }
    


  282. 

  283.     PSIO_StripClear();
    


  284. 

  285.     return 0;
    

  286. }
    


  287. 

  288. /**
    

  289.   * @brief  This makes the rainbow equally distributed throughout
    

  290.   * @param  None
    

  291.   * @retval None
    

  292.   */
    

  293. int Strip_RainbowCycle(void)
    

  294. {
    

  295.     uint16_t u16i = 0, u16j = 0;
    


  296. 

  297.     for (u16j = 0; u16j < (256 * 5); u16j++)   // 5 cycles of all colors on wheel
    

  298.     {
    

  299.         for (u16i = 0; u16i < PIXEL_NUM; u16i++)
    

  300.         {
    

  301.             PSIO_StripSetPixelColor(u16i, PSIO_StripWheel(((u16i * 256 / PIXEL_NUM) + u16j) & 255));
    

  302.         }
    


  303. 

  304.         PSIO_StripShow();
    


  305. 

  306.         PSIO_StripReset();
    

  307.     }
    


  308. 

  309.     PSIO_StripClear();
    


  310. 

  311.     return 0;
    

  312. }
    


  313. 

  314. /**
    

  315.   * @brief  Set strip brightness.
    

  316.   * @param  None
    

  317.   * @retval None
    

  318.   */
    

  319. int Strip_SetBrightness(void)
    

  320. {
    

  321.     uint16_t u16Biighness = 0;
    


  322. 

  323.     printf("\nEnter a brightness level of 0 - 255: ");
    

  324.     u16Biighness = sysGetNum();
    


  325. 

  326.     if (u16Biighness > 255)
    

  327.     {
    

  328.         u16Biighness = 255;
    

  329.     }
    


  330. 

  331.     printf("%d\r\n", u16Biighness);
    


  332. 

  333.     PSIO_StripSetBrightness((uint8_t)u16Biighness & 0xFF);
    


  334. 

  335.     return 0;
    

  336. }
    


  337. 

  338. /**
    

  339.   * @brief  GRB Loop (Red -> Green -> Blue)
    

  340.   * @param  None
    

  341.   * @retval None
    

  342.   */
    

  343. int Strip_RGBLoop(void)
    

  344. {
    

  345.     uint8_t u8i = 0;
    


  346. 

  347.     while (kbhit())
    

  348.     {
    

  349.         for (u8i = 0; u8i < PIXEL_NUM; u8i++)
    

  350.         {
    

  351.             PSIO_StripSetRGBColor(0xFF, 0x00, 0x00);
    

  352.         }
    


  353. 

  354.         TIMER_Delay(TIMER0, 100000);
    


  355. 

  356.         for (u8i = 0; u8i < PIXEL_NUM; u8i++)
    

  357.         {
    

  358.             PSIO_StripSetRGBColor(0x00, 0xFF, 0x00);
    

  359.         }
    


  360. 

  361.         TIMER_Delay(TIMER0, 100000);
    


  362. 

  363.         for (u8i = 0; u8i < PIXEL_NUM; u8i++)
    

  364.         {
    

  365.             PSIO_StripSetRGBColor(0x00, 0x00, 0xFF);
    

  366.         }
    


  367. 

  368.         TIMER_Delay(TIMER0, 100000);
    

  369.     }
    


  370. 

  371.     PSIO_StripClear();
    


  372. 

  373.     return 0;
    

  374. }
    


  375. 

  376. /**
    

  377.   * @brief  ARGB2 Strip test menu for selecting test functions
    

  378.   * @param  None
    

  379.   * @retval None
    

  380.   */
    

  381. void ARGB2StripTestMenu(void)
    

  382. {
    

  383.     uint8_t u8Index = 0;
    

  384.     struct
    

  385.     {
    

  386.         char *chName;
    

  387.         int (*funcptr)(void);
    

  388.     } sMainMenu[] =
    

  389.     {
    

  390.         {"", NULL},
    

  391.         {"RGB Loop", &Strip_RGBLoop},
    

  392.         {"Rainbow cycle", &Strip_RainbowCycle},
    

  393.         {"Theater chase rainbow", &Strip_TheaterChaseRainbow},
    

  394.         {"Feedback mode", &Strip_FeedbackMode},
    

  395.         {"Th20 set mode", &Strip_Th20SetMode},
    

  396.         //{"Strip Sleep Wakeup Test", &Strip_SleepWakeupTest},
    

  397.         {"Y cable mode", &Strip_YCableSetupMenu},
    

  398.         {"Set RGB Brightness", &Strip_SetBrightness},
    

  399.     };
    


  400. 

  401.     while (1)
    

  402.     {
    

  403.         printf("\r\n\r\n");
    

  404.         printf("=============================================\r\n");
    

  405.         printf("\tEnter the select test function: \r\n");
    

  406.         printf("=============================================\r\n");
    


  407. 

  408.         for (u8Index = 1; u8Index < sizeof(sMainMenu) / sizeof(sMainMenu[0]); u8Index++)
    

  409.         {
    

  410.             printf("[%02d] %s\r\n",
    

  411.                    u8Index,
    

  412.                    sMainMenu[u8Index].chName);
    

  413.         }
    


  414. 

  415.         printf("\r\n");
    


  416. 

  417.         u8Index = sysGetNum();
    


  418. 

  419.         if ((u8Index == 0) || (u8Index >= sizeof(sMainMenu) / sizeof(sMainMenu[0])))
    

  420.         {
    

  421.             continue;
    

  422.         }
    


  423. 

  424.         if (sMainMenu[u8Index].funcptr != NULL)
    

  425.         {
    

  426.             sMainMenu[u8Index].funcptr();
    

  427.         }
    

  428.     }
    

  429. }
    


  430. 

  431. void SYS_Init(void)
    

  432. {
    

  433.     /*---------------------------------------------------------------------------------------------------------*/
    

  434.     /* Init System Clock                                                                                       */
    

  435.     /*---------------------------------------------------------------------------------------------------------*/
    


  436. 

  437.     /* Enable HIRC clock (Internal RC 48 MHz) */
    

  438.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  439. 

  440.     /* Wait for HIRC clock ready */
    

  441.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  442. 

  443.     /* Select HCLK clock source as HIRC and and HCLK clock divider as 1 */
    

  444.     CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1));
    


  445. 

  446.     /* Set XT1_OUT(PF.2) and XT1_IN(PF.3) to input mode */
    

  447.     PF->MODE &= ~(GPIO_MODE_MODE2_Msk | GPIO_MODE_MODE3_Msk);
    


  448. 

  449.     /* Disable digital input path of analog pin XT1_OUT to prevent leakage */
    

  450.     GPIO_DISABLE_DIGITAL_PATH(PF, (1ul << 2));
    


  451. 

  452.     /* Disable digital input path of analog pin XT1_IN to prevent leakage */
    

  453.     GPIO_DISABLE_DIGITAL_PATH(PF, (1ul << 3));
    


  454. 

  455.     /* Set PCLK1 clock divider as 4 */
    

  456.     CLK->PCLKDIV = (CLK->PCLKDIV & ~CLK_PCLKDIV_APB1DIV_Msk) | CLK_PCLKDIV_APB1DIV_DIV4;
    


  457. 

  458.     /* Set both PCLK0 and PCLK1 as HCLK */
    

  459.     //CLK->PCLKDIV = CLK_PCLKDIV_APB0DIV_DIV1 | CLK_PCLKDIV_APB1DIV_DIV1;
    


  460. 

  461.     /* Select IP clock source */
    

  462.     /* Select UART0 clock source is HIRC */
    

  463.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART0SEL_HIRC, CLK_CLKDIV0_UART0(1));
    


  464. 

  465.     /* Enable IP clock */
    

  466.     CLK_EnableModuleClock(GPB_MODULE);
    

  467.     CLK_EnableModuleClock(UART0_MODULE);
    

  468.     CLK_EnableModuleClock(TMR0_MODULE);
    

  469.     CLK_EnableModuleClock(PSIO_MODULE);
    


  470. 

  471.     /* Select IP clock source */
    

  472.     CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0SEL_PCLK0, 0);
    


  473. 

  474.     /* Select PSIO module clock source as PCLK1(48Mhz/4) and PSIO module clock divider as 0x4 = 0.3125us */
    

  475.     CLK_SetModuleClock(PSIO_MODULE, CLK_CLKSEL2_PSIOSEL_PCLK1, CLK_CLKDIV1_PSIO(0x04));
    


  476. 

  477.     /* Update System Core Clock */
    

  478.     /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */
    

  479.     SystemCoreClockUpdate();
    


  480. 

  481.     /* PSIO multi-function pin CH0(PB.15) */
    

  482.     SYS->GPB_MFPH = (SYS->GPB_MFPH & ~SYS_GPB_MFPH_PB15MFP_Msk) | SYS_GPB_MFPH_PB15MFP_PSIO0_CH0;
    


  483. 

  484.     /*----------------------------------------------------------------------*/
    

  485.     /* Init I/O Multi-function                                              */
    

  486.     /*----------------------------------------------------------------------*/
    

  487.     /* Set PB multi-function pins for UART0 RXD and TXD */
    

  488.     Uart0DefaultMPF();
    

  489. }
    


  490. 

  491. /*---------------------------------------------------------------------------------------------------------*/
    

  492. /* Init UART0                                                                                             */
    

  493. /*---------------------------------------------------------------------------------------------------------*/
    

  494. void UART0_Init(void)
    

  495. {
    

  496.     /* Configure UART0 and set UART0 baud rate */
    

  497.     UART_Open(UART0, 115200);
    

  498. }
    


  499. 

  500. /*---------------------------------------------------------------------------------------------------------*/
    

  501. /* Init TIMER0                                                                                             */
    

  502. /*---------------------------------------------------------------------------------------------------------*/
    

  503. void TIMER0_Init(void)
    

  504. {
    

  505.     /* Configure and set TIMER0 */
    

  506.     // Give a dummy target frequency here. Will over write prescale and compare value with macro
    

  507.     TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 48000000);
    


  508. 

  509.     // Update prescale and compare value to what we need in event counter mode.
    

  510.     TIMER_SET_PRESCALE_VALUE(TIMER0, 0);
    

  511.     TIMER_SET_CMP_VALUE(TIMER0, 160);
    


  512. 

  513.     // Counter increase on rising edge
    

  514.     TIMER_EnableEventCounter(TIMER0, TIMER_COUNTER_EVENT_RISING);
    

  515. }
    


  516. 

  517. /*---------------------------------------------------------------------------------------------------------*/
    

  518. /*  Main Function                                                                                          */
    

  519. /*---------------------------------------------------------------------------------------------------------*/
    

  520. int main(void)
    

  521. {
    

  522.     /* Unlock protected registers */
    

  523.     SYS_UnlockReg();
    


  524. 

  525.     /* Init System, peripheral clock and multi-function I/O */
    

  526.     SYS_Init();
    


  527. 

  528.     /* Init UART0 for printf and test */
    

  529.     UART0_Init();
    


  530. 

  531.     /* Lock protected registers */
    

  532.     SYS_LockReg();
    


  533. 

  534.     Delay_Init();
    


  535. 

  536.     /* Use slot control 0 and PIN 0 */
    

  537.     PSIO_StripInit(PSIO_SC0, PSIO_PIN0);
    


  538. 

  539.     PSIO_StripSetBrightness(255);
    


  540. 

  541.     ARGB2StripTestMenu();
    

  542. }
    


  543. 

  544. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
回复

收藏 举报

wahahaheihei 发表于 2024-5-20 23:09 | 显示全部楼层
这是一种新的单片机外设？
回复

收藏 举报

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

本版积分规则

小灵通2018

158

主题

1732

帖子

4

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