STM32

分享一个595点灯程序

2019-12-17 21:34发布

站内问答 / STM32/STM8
14977 5 6
两片595级联，可控制16路灯，只用了十路。
灯的状态，有常亮，灭，快闪，慢闪
1、初始化IO
2、设定灯状态
  1.         gIO[LEDALM].status = IO_SLOW;       
  2.         gIO[LED1].status = IO_SLOW;
  3.         gIO[LED2].status = IO_FAST;
  4.         gIO[LED2].status = IO_FAST;
  5.         gIO[LED3].status = IO_FAST;
  6.         gIO[LED4].status = IO_FAST;
  7.         gIO[LED5].status = IO_FAST;               
复制代码
               
3、定时调用
led_display()

  1. #ifndef _595_H
  2. #define _595_H


  5. //#include "stm32f0xx_hal.h"
  6. #include "stm32f10x.h"

  8. #define SLOW_SUM_TIME 30
  9. #define SLOW_ON_TIME  15

  11. #define FAST_SUM_TIME 4
  12. #define FAST_ON_TIME  1



  16. #define IONUM 11

  18. #define LED1MASK                                        (0x0001<<11)
  19. #define LED2MASK                                        (0x0001<<10)
  20. #define LED3MASK                                        (0x0001<<9)                       
  21. #define LED4MASK                                        (0x0001<<8)
  22. #define LED5MASK                                        (0x0001<<15)
  23. #define LED6MASK                                        (0x0001<<14)
  24. #define LED7MASK                                        (0x0001<<13)
  25. #define LED8MASK                                        (0x0001<<12)

  27. #define LEDPOWERMASK                        (0x0001<<0)
  28. #define LEDALMMASK                                (0x0001<<3)

  30. #define BEEPMASK                                        (0x0001<<7)

  32. #define LED1                                        0
  33. #define LED2                                        1
  34. #define LED3                                        2
  35. #define LED4                                        3
  36. #define LED5                                        4
  37. #define LED6                                        5
  38. #define LED7                                        6
  39. #define LED8                                        7

  41. #define LEDPOWER                        8
  42. #define LEDALM                                9
  43. #define BEEP                                  10



  47. typedef enum
  48. {
  49.         IO_OFF = 0,
  50.         IO_ON,                       
  51.         IO_FAST,                //¿ìÉÁ
  52.         IO_SLOW                //ÂýÉÁ
  53. }IO_STUTAS;

  55. typedef struct
  56. {
  57.         const uint16_t        mask;
  58.         IO_STUTAS status;
  59.         uint8_t  onCnt;
  60. }io_t;


  63. #define _595_RCLK_PORT                 GPIOC
  64. #define _595_RCLK_PIN                        GPIO_Pin_10         //´æ´¢¼Ä´æÆ÷ʱÖÓ

  66. #define _595_SRCLK_PORT         GPIOC
  67. #define _595_SRCLK_PIN                GPIO_Pin_11                //ÒÆλ¼Ä´æÆ÷ʱÖÓ

  69. #define _595_SER_PORT                 GPIOA
  70. #define _595_SER_PIN                        GPIO_Pin_11                 //´®ÐÐÊý¾ÝÊäÈë

  72. //#define _595_SER_PORT                 GPIOA
  73. //#define _595_SER_PIN                        GPIO_Pin_0                 //´®ÐÐÊý¾ÝÊäÈë


  76. //#define LED_Write(X) X>0?                 GPIO_WriteBit(LED_PORT,LED_PIN,GPIO_PIN_SET) : GPIO_WriteBit(LED_PORT,LED_PIN,GPIO_PIN_RESET)

  78. #define _595_RCLK_Write(X)          X>0? GPIO_WriteBit(_595_RCLK_PORT,_595_RCLK_PIN,Bit_SET) : GPIO_WriteBit(_595_RCLK_PORT,_595_RCLK_PIN,Bit_RESET)
  79. #define _595_SRCLK_Write(X)   X>0? GPIO_WriteBit(_595_SRCLK_PORT,_595_SRCLK_PIN,Bit_SET) : GPIO_WriteBit(_595_SRCLK_PORT,_595_SRCLK_PIN,Bit_RESET)
  80. #define _595_SER_Write(X)                  X>0? GPIO_WriteBit(_595_SER_PORT,_595_SER_PIN,Bit_SET) : GPIO_WriteBit(_595_SER_PORT,_595_SER_PIN,Bit_RESET)


  83. extern io_t  gIO[IONUM];


  86. void _595_GPIO_Init(void);
  87. void _595_WriteByte(uint8_t byte);
  88. void _595_WriteMultiByte(uint16_t multibyte);

  90. void led_display(void);
  91. void led_runTogle();

  93. void delay(uint16_t t);

  95. #endif
复制代码

  1. #include "595.h"

  3. #define DELAY 10000

  5. io_t  gIO[IONUM] =
  6. {
  7.         {LED1MASK,IO_OFF,0},
  8.         {LED2MASK,IO_OFF,0},
  9.         {LED3MASK,IO_OFF,0},
  10.         {LED4MASK,IO_OFF,0},
  11.         {LED5MASK,IO_OFF,0},
  12.         {LED6MASK,IO_OFF,0},
  13.         {LED7MASK,IO_OFF,0},
  14.         {LED8MASK,IO_OFF,0},
  15.         {LEDPOWERMASK,IO_ON,0},
  16.         {LEDALMMASK,IO_OFF,0},
  17.         {BEEPMASK,IO_OFF,0}       
  18. };


  21. void _595_GPIO_Init()
  22. {
  23.        
  24.         GPIO_InitTypeDef  GPIO_InitStructure;

  26.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);         //ʹÄÜPC¶Ë¿ÚʱÖÓ
  27.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);         //ʹÄÜPA¶Ë¿ÚʱÖÓ
  28.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);         //ʹÄÜPA¶Ë¿ÚʱÖÓ
  29.        
  30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10|GPIO_Pin_11;                                 
  31.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //ÍÆÍìÊä³ö
  32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO¿ÚËÙ¶ÈΪ50MHz
  33.         GPIO_Init(GPIOC, &GPIO_InitStructure);                                                          //¸ù¾ÝÉ趨²ÎÊý³õʼ»¯

  35.         GPIO_InitStructure.GPIO_Pin = _595_SER_PIN;                                 
  36.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //ÍÆÍìÊä³ö
  37.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO¿ÚËÙ¶ÈΪ50MHz
  38.         GPIO_Init(_595_SER_PORT, &GPIO_InitStructure);                         //¸ù¾ÝÉ趨²ÎÊý³õʼ»¯       

  40.         GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0;                                 
  41.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //ÍÆÍìÊä³ö
  42.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO¿ÚËÙ¶ÈΪ50MHz
  43.         GPIO_Init(GPIOE, &GPIO_InitStructure);                                                          //¸ù¾ÝÉ趨²ÎÊý³õʼ»¯       
  44.        
  45.         GPIO_WriteBit(GPIOE,GPIO_Pin_0,Bit_SET);
  46.        
  47.         _595_SER_Write(0);       
  48.         _595_SRCLK_Write(0);
  49.         _595_RCLK_Write(0);                       
  50. }



  54. void _595_WriteByte(uint8_t byte)
  55. {
  56.         uint8_t i;
  57.         for(i=0;i<8;i++)
  58.         {
  59.                 if(byte&0x80)
  60.                         _595_SER_Write(1);
  61.                 else
  62.                         _595_SER_Write(0);
  63.                 _595_SRCLK_Write(0);
  64.                 delay(DELAY);
  65.                 _595_SRCLK_Write(1);               
  66.                 delay(DELAY);
  67.                 byte <<= 1;
  68.         }
  69. }
  70. void _595_WriteMultiByte(uint16_t multibyte)
  71. {
  72.         uint16_t temp = 0;
  73.         temp = multibyte&0x00ff;
  74.         _595_WriteByte(temp);
  75.         temp = (multibyte>>8)&0x00ff;
  76.         _595_WriteByte(temp);
  77.         _595_RCLK_Write(0);
  78.         delay(DELAY);
  79.         _595_RCLK_Write(1);       
  80.         delay(DELAY);               
  81. }

  83. void led_display()
  84. {
  85.         uint8_t i;
  86.         uint16_t iobuff = 0;
  87.        
  88.         for(i = 0 ;i<IONUM;i++)
  89.         {
  90.                 if(gIO[i].status == IO_ON)
  91.                 {
  92.                         iobuff &= (~gIO[i].mask);                               
  93.                 }
  94.                 else if(gIO[i].status == IO_OFF)
  95.                 {
  96.                         iobuff |= gIO[i].mask;                       
  97.                 }
  98.                 else if(gIO[i].status == IO_FAST)
  99.                 {               
  100.                         if(gIO[i].onCnt < FAST_ON_TIME)
  101.                         {
  102.                                 iobuff &= (~gIO[i].mask);                                               
  103.                         }
  104.                         else
  105.                         {
  106.                                 iobuff |= gIO[i].mask;                               
  107.                         }
  108.                         gIO[i].onCnt++;       
  109.                         if(gIO[i].onCnt >= FAST_SUM_TIME)
  110.                                 gIO[i].onCnt = 0;                       
  111.                 }
  112.                 else if(gIO[i].status == IO_SLOW)
  113.                 {                       
  114.                         if(gIO[i].onCnt < SLOW_ON_TIME)
  115.                         {
  116.                                 iobuff &= (~gIO[i].mask);                                                       
  117.                         }
  118.                         else
  119.                         {
  120.                                 iobuff |= gIO[i].mask;                       
  121.                         }
  122.                         gIO[i].onCnt++;       
  123.                         if(gIO[i].onCnt >= SLOW_SUM_TIME)
  124.                                 gIO[i].onCnt = 0;                       
  125.                 }
  126.         }
  127.         _595_WriteMultiByte(iobuff);
  128. }

  130. void led_runTogle()
  131. {
  132.         uint8_t flag = 0;
  133.        
  134.         if(flag == 0)
  135.         {
  136.                 flag = 1        ;       
  137.                 GPIO_WriteBit(GPIOE,GPIO_Pin_0,Bit_RESET);               
  138.         }
  139.         else
  140.         {
  141.                 flag = 0        ;                       
  142.                 GPIO_WriteBit(GPIOE,GPIO_Pin_0,Bit_SET);               
  143.         }
  144. }

  146. void delay(uint16_t t)
  147. {
  148.         for(;t!=0;t--);
  149. }
复制代码

友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
5条回答
qq635274216
2019-12-18 07:55
为什么用595 LED驱动芯片多了去了

一周热门 更多>