21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › ML51驱动WS2812
返回列表 发新帖我要提问

[DemoCode下载] ML51驱动WS2812

[复制链接]
1023|1
 楼主| xuanhuanzi 发表于 2023-11-28 19:13 | 显示全部楼层 |阅读模式
ws2812
ML51_RGBLED-main.zip (1.33 MB, 下载次数: 4)
复制
  1. /*_____ I N C L U D E S ____________________________________________________*/
    

  2. #include "ML51.h"
    


  3. 

  4. #include "project_config.h"
    

  5. #include "LED_stripe.h"
    


  6. 

  7. /*_____ D E C L A R A T I O N S ____________________________________________*/
    

  8. // xdata volatile uint8_t u8TH0_Tmp = 0;
    

  9. // xdata volatile uint8_t u8TL0_Tmp = 0;
    


  10. 

  11. #define TH0_INIT                                                        (HIBYTE(TIMER_DIV12_VALUE_1ms_FOSC_240000)) 
    

  12. #define TL0_INIT                                                        (LOBYTE(TIMER_DIV12_VALUE_1ms_FOSC_240000))
    


  13. 

  14. //UART 0
    

  15. bit BIT_UART;
    

  16. bit uart0_receive_flag=0;
    

  17. unsigned char uart0_receive_data;
    


  18. 


  19. 

  20. uint16_t counter = 0;
    

  21. /*_____ D E F I N I T I O N S ______________________________________________*/
    

  22. volatile uint32_t BitFlag = 0;
    

  23. volatile uint32_t counter_tick = 0;
    


  24. 

  25. /*_____ M A C R O S ________________________________________________________*/
    

  26. #define SYS_CLOCK                                                                 (24000000ul)
    


  27. 


  28. 

  29. /*_____ F U N C T I O N S __________________________________________________*/
    


  30. 


  31. 

  32. void tick_counter(void)
    

  33. {
    

  34.         counter_tick++;
    

  35. }
    


  36. 

  37. uint32_t get_tick(void)
    

  38. {
    

  39.         return (counter_tick);
    

  40. }
    


  41. 

  42. void set_tick(uint32_t t)
    

  43. {
    

  44.         counter_tick = t;
    

  45. }
    


  46. 

  47. //void compare_buffer(uint8_t *src, uint8_t *des, int nBytes)
    

  48. //{
    

  49. //    uint16_t i = 0;        
    

  50. //        
    

  51. //    for (i = 0; i < nBytes; i++)
    

  52. //    {
    

  53. //        if (src[i] != des[i])
    

  54. //        {
    

  55. //            printf("error idx : %4d : 0x%2X , 0x%2X\r\n", i , src[i],des[i]);
    

  56. //                        set_flag(flag_error , Enable);
    

  57. //        }
    

  58. //    }
    


  59. 

  60. //        if (!is_flag_set(flag_error))
    

  61. //        {
    

  62. //            printf("compare_buffer finish \r\n");        
    

  63. //                set_flag(flag_error , Disable);
    

  64. //        }
    


  65. 

  66. //}
    


  67. 

  68. //void reset_buffer(void *dest, unsigned int val, unsigned int size)
    

  69. //{
    

  70. //    uint8_t *pu8Dest;
    

  71. ////    unsigned int i;
    

  72. //    
    

  73. //    pu8Dest = (uint8_t *)dest;
    


  74. 

  75. //        #if 1
    

  76. //        while (size-- > 0)
    

  77. //                *pu8Dest++ = val;
    

  78. //        #else
    

  79. //        memset(pu8Dest, val, size * (sizeof(pu8Dest[0]) ));
    

  80. //        #endif
    

  81. //        
    

  82. //}
    


  83. 

  84. //void copy_buffer(void *dest, void *src, unsigned int size)
    

  85. //{
    

  86. //    uint8_t *pu8Src, *pu8Dest;
    

  87. //    unsigned int i;
    

  88. //    
    

  89. //    pu8Dest = (uint8_t *)dest;
    

  90. //    pu8Src  = (uint8_t *)src;
    


  91. 


  92. 

  93. //        #if 0
    

  94. //          while (size--)
    

  95. //            *pu8Dest++ = *pu8Src++;
    

  96. //        #else
    

  97. //    for (i = 0; i < size; i++)
    

  98. //        pu8Dest[i] = pu8Src[i];
    

  99. //        #endif
    

  100. //}
    


  101. 

  102. //void dump_buffer(uint8_t *pucBuff, int nBytes)
    

  103. //{
    

  104. //    uint16_t i = 0;
    

  105. //    
    

  106. //    printf("dump_buffer : %2d\r\n" , nBytes);    
    

  107. //    for (i = 0 ; i < nBytes ; i++)
    

  108. //    {
    

  109. //        printf("0x%2X," , pucBuff[i]);
    

  110. //        if ((i+1)%8 ==0)
    

  111. //        {
    

  112. //            printf("\r\n");
    

  113. //        }            
    

  114. //    }
    

  115. //    printf("\r\n\r\n");
    

  116. //}
    


  117. 

  118. //void  dump_buffer_hex(uint8_t *pucBuff, int nBytes)
    

  119. //{
    

  120. //    int     nIdx, i;
    


  121. 

  122. //    nIdx = 0;
    

  123. //    while (nBytes > 0)
    

  124. //    {
    

  125. //        printf("0x%04X  ", nIdx);
    

  126. //        for (i = 0; i < 16; i++)
    

  127. //            printf("%02X ", pucBuff[nIdx + i]);
    

  128. //        printf("  ");
    

  129. //        for (i = 0; i < 16; i++)
    

  130. //        {
    

  131. //            if ((pucBuff[nIdx + i] >= 0x20) && (pucBuff[nIdx + i] < 127))
    

  132. //                printf("%c", pucBuff[nIdx + i]);
    

  133. //            else
    

  134. //                printf(".");
    

  135. //            nBytes--;
    

  136. //        }
    

  137. //        nIdx += 16;
    

  138. //        printf("\n");
    

  139. //    }
    

  140. //    printf("\n");
    

  141. //}
    


  142. 

  143. void delay(uint16_t dly)
    

  144. {
    

  145. /*
    

  146.         delay(100) : 14.84 us
    

  147.         delay(200) : 29.37 us
    

  148.         delay(300) : 43.97 us
    

  149.         delay(400) : 58.5 us        
    

  150.         delay(500) : 73.13 us        
    

  151.         
    

  152.         delay(1500) : 0.218 ms (218 us)
    

  153.         delay(2000) : 0.291 ms (291 us)        
    

  154. */
    


  155. 

  156.         while( dly--);
    

  157. }
    


  158. 


  159. 

  160. //void send_UARTString(uint8_t* Data)
    

  161. //{
    

  162. //        #if 1
    

  163. //        uint16_t i = 0;
    


  164. 

  165. //        while (Data[i] != '\0')
    

  166. //        {
    

  167. //                #if 1
    

  168. //                SBUF = Data[i++];
    

  169. //                #else
    

  170. //                UART_Send_Data(UART0,Data[i++]);                
    

  171. //                #endif
    

  172. //        }
    


  173. 

  174. //        #endif
    


  175. 

  176. //        #if 0
    

  177. //        uint16_t i = 0;
    

  178. //        
    

  179. //        for(i = 0;i< (strlen(Data)) ;i++ )
    

  180. //        {
    

  181. //                UART_Send_Data(UART0,Data[i]);
    

  182. //        }
    

  183. //        #endif
    


  184. 

  185. //        #if 0
    

  186. //    while(*Data)  
    

  187. //    {  
    

  188. //        UART_Send_Data(UART0, (unsigned char) *Data++);  
    

  189. //    } 
    

  190. //        #endif
    

  191. //}
    


  192. 

  193. //void send_UARTASCII(uint16_t Temp)
    

  194. //{
    

  195. //    uint8_t print_buf[16];
    

  196. //    uint16_t i = 15, j;
    


  197. 

  198. //    *(print_buf + i) = '\0';
    

  199. //    j = (uint16_t)Temp >> 31;
    

  200. //    if(j)
    

  201. //        (uint16_t) Temp = ~(uint16_t)Temp + 1;
    

  202. //    do
    

  203. //    {
    

  204. //        i--;
    

  205. //        *(print_buf + i) = '0' + (uint16_t)Temp % 10;
    

  206. //        (uint16_t)Temp = (uint16_t)Temp / 10;
    

  207. //    }
    

  208. //    while((uint16_t)Temp != 0);
    

  209. //    if(j)
    

  210. //    {
    

  211. //        i--;
    

  212. //        *(print_buf + i) = '-';
    

  213. //    }
    

  214. //    send_UARTString(print_buf + i);
    

  215. //}
    


  216. 

  217. void WS2812C_Init(void)
    

  218. {
    

  219.         #if defined (ENABLE_SPI)
    


  220. 

  221.         #if 1
    

  222.     /* Set LED output */
    

  223.     P00 = 1;
    

  224.     P00_INPUT_MODE;
    

  225.     ENABLE_P00_PULLDOWN;
    

  226.         #endif
    


  227. 


  228. 

  229.     MFP_P00_SPI0_MOSI;
    

  230.     // P00_QUASI_MODE;
    


  231. 

  232.     MFP_P02_SPI0_CLK;       /*define  SPI0 CLK pin */
    

  233.     P02_QUASI_MODE;        
    

  234.         #if 0
    

  235.     MFP_P01_SPI0_MISO;      /*define  SPI0 MISO pin */
    

  236.     P01_QUASI_MODE;
    


  237. 

  238.     MFP_P03_GPIO;           /*define  SPI0 SS pin as normal GPIO*/
    

  239.     P03_PUSHPULL_MODE;
    

  240.         #endif
    


  241. 

  242.     set_SPI0SR_DISMODF;                                        // SS General purpose I/O ( No Mode Fault )
    

  243.     clr_SPI0CR0_SSOE;
    


  244. 

  245.     clr_SPI0CR0_LSBFE;                                  // MSB first
    


  246. 

  247.     clr_SPI0CR0_CPOL;                                   // The SPI clock is low in idle mode
    

  248.     clr_SPI0CR0_CPHA;                                   // The data is sample on the second edge of SPI clock
    


  249. 

  250.     set_SPI0CR0_MSTR;                                   // SPI in Master mode
    

  251.     SPI0_CLOCK_DIV_3;                                        // Select SPI clock
    

  252.     set_SPI0CR0_SPIEN;                                  // Enable SPI function
    

  253.     clr_SPI0SR_SPIF;
    


  254. 

  255.         #elif defined (ENABLE_GPIO_EMULATE)
    

  256.         P00_PUSHPULL_MODE;
    

  257.         P02_PUSHPULL_MODE;        // for debug
    

  258.         #endif
    

  259. }
    


  260. 


  261. 

  262. void loop(void)
    

  263. {
    

  264.         static uint8_t flag_first_pwr_on = 1;
    


  265. 

  266.         if (is_flag_set(flag_1000ms))
    

  267.         {
    

  268.                 set_flag(flag_1000ms , FALSE);
    

  269.                 P32 ^= 1;                
    

  270.                 SFRS = 0;printf("log :%d\r\n" , counter++);                
    

  271.         }
    


  272. 

  273.     if (RI)
    

  274.     {   
    

  275.                 clr_SCON_RI;                                         // Clear RI (Receive Interrupt).
    


  276. 

  277.                 if (flag_first_pwr_on)
    

  278.                 {
    

  279.                         DemoState = state_Rainbow;
    

  280.                         flag_first_pwr_on = 0;
    

  281.                 }
    

  282.                 else
    

  283.                 {
    

  284.                         DemoState = SBUF - 0x30;
    

  285.                 }
    


  286. 

  287.                 SFRS = 0;printf("DemoState = %bu,%bc\r\n" , DemoState, SBUF);
    

  288.     }
    


  289. 

  290.         if (!trans_finish_flag)
    

  291.         {
    

  292.                 #if defined (ENABLE_DEBUG_WS2812_PROTOCOL)
    

  293.                 setLED_ColorWipe(0xFF, 0x00, 0x00);
    

  294.                 setLED_delayms(1);
    

  295.                 #else
    


  296. 

  297.                 StateMachine();
    

  298.                 #endif
    

  299.         }        
    

  300. }
    


  301. 


  302. 

  303. void GPIO_Init(void)
    

  304. {
    

  305.     MFP_P32_GPIO;
    

  306.     P32_PUSHPULL_MODE;        
    

  307.                 
    


  308. 

  309. //        P30_PUSHPULL_MODE;        
    

  310. }
    


  311. 

  312. void Timer0_IRQHandler(void)
    

  313. {
    

  314.         tick_counter();
    


  315. 

  316.         if ((get_tick() % 1000) == 0)
    

  317.         {
    

  318.                 set_flag(flag_1000ms , TRUE);
    

  319.         }
    


  320. 

  321.         if ((get_tick() % 50) == 0)
    

  322.         {
    


  323. 

  324.         }                
    


  325. 

  326. }
    


  327. 

  328. void Timer0_ISR(void) interrupt 1        // Vector [url=home.php?mod=space&uid=72445]@[/url]  0x0B
    

  329. {
    

  330.         _push_(SFRS);        
    

  331.         SFRS = 0;
    


  332. 

  333.         clr_TCON_TF0;                
    

  334.         TH0 = TH0_INIT;
    

  335.         TL0 = TL0_INIT;
    


  336. 

  337.         Timer0_IRQHandler();
    

  338.         _pop_(SFRS);        
    

  339. }
    


  340. 

  341. void Timer0_Init(void)
    

  342. {
    

  343.         ENABLE_TIMER0_MODE1;
    

  344.         TIMER0_FSYS_DIV12;
    


  345. 

  346.         TH0 = TH0_INIT;
    

  347.         TL0 = TL0_INIT;
    

  348.         clr_TCON_TF0;
    


  349. 

  350.         set_TCON_TR0;                                  //Timer0 run
    

  351.         
    

  352.         ENABLE_TIMER0_INTERRUPT;                       //enable Timer0 interrupt
    

  353.         ENABLE_GLOBAL_INTERRUPT;                       //enable interrupts        
    

  354. }
    


  355. 


  356. 

  357. // void Serial_ISR (void) interrupt 4 
    

  358. // {
    

  359. //     _push_(SFRS);
    


  360. 

  361. //     if (RI)
    

  362. //     {   
    

  363. //       uart0_receive_flag = 1;
    

  364. //       uart0_receive_data = SBUF;
    

  365. //       clr_SCON_RI;                                         // Clear RI (Receive Interrupt).
    

  366. //     }
    

  367. //     if  (TI)
    

  368. //     {
    

  369. //                 clr_SCON_TI;
    

  370. //                 //      if(!BIT_UART)
    

  371. //                 //      {
    

  372. //                 //          TI = 0;
    

  373. //                 //      }
    

  374. //     }
    


  375. 

  376. //     _pop_(SFRS);        
    

  377. // }
    


  378. 


  379. 

  380. void UART0_Init(void)
    

  381. {
    

  382.         MFP_P31_UART0_TXD;                              
    

  383.         P31_QUASI_MODE;                                 
    

  384.         MFP_P30_UART0_RXD;
    

  385.         P30_QUASI_MODE;        
    


  386. 

  387.         SFRS = 0x00;
    

  388.         SCON = 0x50;                    /*UART0 Mode1,REN=1,TI=1*/
    

  389.         set_PCON_SMOD;                  /*UART0 Double Rate Enable*/
    

  390.         T3CON &= 0xF8;                   /*T3PS2=0,T3PS1=0,T3PS0=0(Prescale=1)*/
    

  391.         set_T3CON_BRCK;                  /*UART0 baud rate clock source = Timer3*/
    

  392.         RH3    = 0xFF;                                           /* HIBYTE(65536 - 13)*/
    

  393.         RL3    = 0xF3;                                           /* LOBYTE(65536 - 13); */
    

  394.         set_T3CON_TR3;                  /*Trigger Timer3*/
    


  395. 

  396.         set_SCON_RI;
    

  397.         set_SCON_TI;
    

  398.         BIT_UART = 1;
    


  399. 

  400.         // ENABLE_UART0_INTERRUPT;                                   /* Enable UART0 interrupt */
    

  401.         // ENABLE_GLOBAL_INTERRUPT;                                  /* Global interrupt enable */
    


  402. 

  403.         SFRS = 0;printf("\r\n\r\n\r\n\r\nUART0_Init\r\n");
    

  404. }
    


  405. 

  406. void SYS_Init(void)
    

  407. {
    

  408. //        FsysSelect(FSYS_HIRC);
    


  409. 

  410.     ALL_GPIO_QUASI_MODE;
    

  411. //    ENABLE_GLOBAL_INTERRUPT;                // global enable bit        
    

  412. }
    


  413. 

  414. void main (void) 
    

  415. {
    

  416.         SYS_Init();
    


  417. 

  418.         UART0_Init();
    

  419.         GPIO_Init();
    


  420. 

  421.     WS2812C_Init();
    

  422.         // setLED_ColorWipe(0, 0, 0);
    


  423. 

  424.         Timer0_Init();
    


  425. 

  426.         while(1)
    

  427.         {
    

  428.                 loop();
    


  429. 

  430.         }
    

  431. }
    


  432. 


  433. 


  434.


回复

收藏 举报

相关帖子
gejigeji521 发表于 2023-11-28 22:15 | 显示全部楼层
492946565f5e6bb7dd.png
回复

收藏 举报

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

本版积分规则

xuanhuanzi

183

主题

2331

帖子

3

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