21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › 基于MM32实现的通用段码液晶显示屏程序架构 ...
返回列表 发新帖我要提问本帖赏金: 60.00元(功能说明)

[MM32生态] 基于MM32实现的通用段码液晶显示屏程序架构

[复制链接]
3491|7
 楼主| xld0932 发表于 2024-8-5 12:18 | 显示全部楼层 |阅读模式
pi, 液晶显示屏, 段码屏, SLCD, MM32
本帖最后由 xld0932 于 2024-8-5 12:20 编辑

#申请原创#   @21小跑堂

1.概述
从之前分享的《解析SLCD例程设计思路，加速终端产品应用开发》一文中得到启发，在产品功能需求丰富的情况下，我们可以选择/评估MM32L0130这个集成了SLCD段码液晶显示屏驱动的系列MCU；但对于功能简单，对芯片成本要求又比较高时，选择分立器件或者是一个不错的选择；MM32推出的高性价比的MCU如MM32G0001系列，超值系列的MM32F0010\MM32F0020都是一个不错的选择；再结合当前SLCD显示驱动芯片的价格优势，整体成本可以做到1块钱以内。市面主比较应用的SLCD驱动芯片品牌有合泰的、深圳天微、无锡中微的等等，客户可以依据自己的功能需要，选择性价高的驱动芯片型号。

针对不同厂家的SLCD段码液晶显示屏的驱动芯片，其控制原理及接线方式都大同小异；为了方便程序移植、实现方便，我们基于MM32上面介绍到的3款芯片实现了一个通用的段码液晶显示屏程序架构，下面我们一起来详细的讲解一下。

2、硬件设计
2.1.基于MM32G0001的SLCD原理图
Schematic_MM32G0001_LCD.png

2.2.基于MM32F0010的SLCD原理图
Schematic_MM32F0010_LCD.png

2.3.基于MM32F0020的SLCD原理图
Schematic_MM32F0020_LCD.png

3.硬件实物
4.jpg
5.jpg

4.程序架构
6.png

5.程序实现（以MM32F0010为例）
5.1.SLCD驱动程序设计
复制
  1. #ifndef __SLCD_DRIVER_H
    

  2. #define __SLCD_DRIVER_H
    


  3. 

  4. #ifdef __cplusplus
    

  5. extern "C" {
    

  6. #endif
    


  7. 

  8. #include <string.h>
    

  9. #include "hal_conf.h"
    


  10. 

  11. #define SLCD_DRIVER_COM         (4)
    

  12. #define SLCD_DRIVER_SEG         (32)
    


  13. 

  14. #define SLCD_DRIVER_CS_RCC      RCC_AHBENR_GPIOA
    

  15. #define SLCD_DRIVER_CS_GPIO     GPIOA
    

  16. #define SLCD_DRIVER_CS_PIN      GPIO_Pin_7
    


  17. 

  18. #define SLCD_DRIVER_WR_RCC      RCC_AHBENR_GPIOA
    

  19. #define SLCD_DRIVER_WR_GPIO     GPIOA
    

  20. #define SLCD_DRIVER_WR_PIN      GPIO_Pin_5
    


  21. 

  22. #define SLCD_DRIVER_DATA_RCC    RCC_AHBENR_GPIOA
    

  23. #define SLCD_DRIVER_DATA_GPIO   GPIOA
    

  24. #define SLCD_DRIVER_DATA_PIN    GPIO_Pin_4
    


  25. 

  26. #define SLCD_DRIVER_CS_H()      GPIO_WriteBit(SLCD_DRIVER_CS_GPIO, SLCD_DRIVER_CS_PIN, Bit_SET)
    

  27. #define SLCD_DRIVER_CS_L()      GPIO_WriteBit(SLCD_DRIVER_CS_GPIO, SLCD_DRIVER_CS_PIN, Bit_RESET)
    


  28. 

  29. #define SLCD_DRIVER_WR_H()      GPIO_WriteBit(SLCD_DRIVER_WR_GPIO, SLCD_DRIVER_WR_PIN, Bit_SET)
    

  30. #define SLCD_DRIVER_WR_L()      GPIO_WriteBit(SLCD_DRIVER_WR_GPIO, SLCD_DRIVER_WR_PIN, Bit_RESET)
    


  31. 

  32. #define SLCD_DRIVER_DATA_H()    GPIO_WriteBit(SLCD_DRIVER_DATA_GPIO, SLCD_DRIVER_DATA_PIN, Bit_SET)
    

  33. #define SLCD_DRIVER_DATA_L()    GPIO_WriteBit(SLCD_DRIVER_DATA_GPIO, SLCD_DRIVER_DATA_PIN, Bit_RESET)
    


  34. 

  35. void SLCD_DRIVER_UpdateRAM(void);
    

  36. void SLCD_DRIVER_ModifyRAM(uint8_t COMn, uint8_t SEGn, uint8_t State);
    

  37. void SLCD_DRIVER_Fill(uint8_t Data);
    

  38. void SLCD_DRIVER_Init(void);
    


  39. 

  40. #ifdef __cplusplus
    

  41. }
    

  42. #endif
    


  43. 

  44. #endif
复制
  1. #include "slcd_driver.h"
    


  2. 

  3. uint8_t SLCD_DRIVER_RAM[SLCD_DRIVER_SEG];
    


  4. 

  5. void SLCD_DRIVER_InitGPIO(void)
    

  6. {
    

  7.     GPIO_InitTypeDef GPIO_InitStruct;
    


  8. 

  9.     /* CS */
    

  10.     RCC_AHBPeriphClockCmd(SLCD_DRIVER_CS_RCC, ENABLE);
    


  11. 

  12.     GPIO_StructInit(&GPIO_InitStruct);
    

  13.     GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_CS_PIN;
    

  14.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    

  15.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  16.     GPIO_Init(SLCD_DRIVER_CS_GPIO, &GPIO_InitStruct);
    


  17. 

  18.     GPIO_WriteBit(SLCD_DRIVER_CS_GPIO, SLCD_DRIVER_CS_PIN, Bit_SET);
    


  19. 

  20.     /* WR */
    

  21.     RCC_AHBPeriphClockCmd(SLCD_DRIVER_WR_RCC, ENABLE);
    


  22. 

  23.     GPIO_StructInit(&GPIO_InitStruct);
    

  24.     GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_WR_PIN;
    

  25.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    

  26.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  27.     GPIO_Init(SLCD_DRIVER_WR_GPIO, &GPIO_InitStruct);
    


  28. 

  29.     GPIO_WriteBit(SLCD_DRIVER_WR_GPIO, SLCD_DRIVER_WR_PIN, Bit_SET);
    


  30. 

  31.     /* DATA */
    

  32.     RCC_AHBPeriphClockCmd(SLCD_DRIVER_DATA_RCC, ENABLE);
    


  33. 

  34.     GPIO_StructInit(&GPIO_InitStruct);
    

  35.     GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_DATA_PIN;
    

  36.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    

  37.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  38.     GPIO_Init(SLCD_DRIVER_DATA_GPIO, &GPIO_InitStruct);
    


  39. 

  40.     GPIO_WriteBit(SLCD_DRIVER_DATA_GPIO, SLCD_DRIVER_DATA_PIN, Bit_SET);
    

  41. }
    


  42. 

  43. void SLCD_DRIVER_Write(uint16_t Data, uint8_t Bits)
    

  44. {
    

  45.     SLCD_DRIVER_CS_L();                /* CS--->L */
    


  46. 

  47.     for (uint8_t i = 0; i < Bits; i++)
    

  48.     {
    

  49.         SLCD_DRIVER_WR_L();            /* WR--->L */
    


  50. 

  51.         if ((Data << i) & 0x8000)
    

  52.         {
    

  53.             SLCD_DRIVER_DATA_H();      /* DATA->H */
    

  54.         }
    

  55.         else
    

  56.         {
    

  57.             SLCD_DRIVER_DATA_L();      /* DATA->L */
    

  58.         }
    


  59. 

  60.         SLCD_DRIVER_WR_H();            /* WR--->H */
    

  61.     }
    


  62. 

  63.     SLCD_DRIVER_CS_H();                /* CS--->H */
    

  64. }
    


  65. 

  66. void SLCD_DRIVER_UpdateRAM(void)
    

  67. {
    

  68.     uint16_t Data = 0;
    


  69. 

  70.     for (uint8_t i = 0; i < SLCD_DRIVER_SEG; i++)
    

  71.     {
    

  72.         /*Write RAM : 101 a5a4a3a2a1a0 d0d1d2d3*/
    

  73.         Data   = 0x05;
    

  74.         Data <<= 0x06;
    


  75. 

  76.         Data  |= (i & 0x3F);
    

  77.         Data <<= 0x04;
    


  78. 

  79.         Data  |= (SLCD_DRIVER_RAM[i] & 0x0F);
    

  80.         Data <<= 0x03;
    


  81. 

  82.         SLCD_DRIVER_Write(Data, 0x0D);
    

  83.     }
    

  84. }
    


  85. 

  86. void SLCD_DRIVER_ModifyRAM(uint8_t COMn, uint8_t SEGn, uint8_t State)
    

  87. {
    

  88.     if (State)
    

  89.     {
    

  90.         SLCD_DRIVER_RAM[SEGn] |=  (0x01 << COMn);
    

  91.     }
    

  92.     else
    

  93.     {
    

  94.         SLCD_DRIVER_RAM[SEGn] &= ~(0x01 << COMn);
    

  95.     }
    

  96. }
    


  97. 

  98. void SLCD_DRIVER_Fill(uint8_t Data)
    

  99. {
    

  100.     memset(SLCD_DRIVER_RAM, Data, sizeof(SLCD_DRIVER_RAM));
    


  101. 

  102.     SLCD_DRIVER_UpdateRAM();
    

  103. }
    


  104. 

  105. void SLCD_DRIVER_Init(void)
    

  106. {
    

  107.     SLCD_DRIVER_InitGPIO();
    


  108. 

  109.     memset(SLCD_DRIVER_RAM, 0, sizeof(SLCD_DRIVER_RAM));
    


  110. 

  111.     SLCD_DRIVER_Write(0x8020 /*0b 1000 0000 0010 0000*/, 0x0C); // SYS_EN
    

  112.     SLCD_DRIVER_Write(0x8060 /*0b 1000 0000 0110 0000*/, 0x0C); // LCD_ON
    

  113.     SLCD_DRIVER_Write(0x8300 /*0b 1000 0011 0000 0000*/, 0x0C); // RC256K
    

  114.     SLCD_DRIVER_Write(0x8520 /*0b 1000 0101 0010 0000*/, 0x0C); // BIAS 1/3
    

  115.     SLCD_DRIVER_Write(0x9C60 /*0b 1001 1100 0110 0000*/, 0x0C); // NORMAL
    


  116. 

  117.     SLCD_DRIVER_UpdateRAM();
    

  118. }
    


  119.

5.2.SLCD共用函数设计
复制
  1. #ifndef __SLCD_H
    

  2. #define __SLCD_H
    


  3. 

  4. #ifdef __cplusplus
    

  5. extern "C" {
    

  6. #endif
    


  7. 

  8. #include <stdint.h>
    


  9. 

  10. typedef struct
    

  11. {
    

  12.     char    ch;             /*字符索引*/
    

  13.     uint8_t Segment[8];     /*字符对应的段编码*/
    

  14. } SLCD_8SEG_TypeDef;
    


  15. 

  16. #define SLCD_8SEG_NUM       (38)
    


  17. 

  18. int SLCD_Search8Segment(const char   ch, uint8_t *Segment);
    

  19. int SLCD_SearchCOMnSEGn(const char *str, uint8_t *COMn, uint8_t *SEGn);
    


  20. 

  21. #ifdef __cplusplus
    

  22. }
    

  23. #endif
    


  24. 

  25. #endif
复制
  1. #include "slcd.h"
    

  2. #include "slcd_driver.h"
    


  3. 

  4. const SLCD_8SEG_TypeDef SLCD_8SEG_Table[SLCD_8SEG_NUM] =
    

  5. {
    

  6.     {' ', {0, 0, 0, 0, 0, 0, 0, 0}},
    

  7.     {'0', {1, 1, 1, 1, 1, 1, 0, 0}},
    

  8.     {'1', {0, 1, 1, 0, 0, 0, 0, 0}},
    

  9.     {'2', {1, 1, 0, 1, 1, 0, 1, 0}},
    

  10.     {'3', {1, 1, 1, 1, 0, 0, 1, 0}},
    

  11.     {'4', {0, 1, 1, 0, 0, 1, 1, 0}},
    

  12.     {'5', {1, 0, 1, 1, 0, 1, 1, 0}},
    

  13.     {'6', {1, 0, 1, 1, 1, 1, 1, 0}},
    

  14.     {'7', {1, 1, 1, 0, 0, 0, 0, 0}},
    

  15.     {'8', {1, 1, 1, 1, 1, 1, 1, 0}},
    

  16.     {'9', {1, 1, 1, 1, 0, 1, 1, 0}},
    

  17.     {'A', {1, 1, 1, 0, 1, 1, 1, 0}},
    

  18.     {'b', {0, 0, 1, 1, 1, 1, 1, 0}},
    

  19.     {'c', {0, 0, 0, 1, 1, 0, 1, 0}},
    

  20.     {'C', {1, 0, 0, 1, 1, 1, 0, 0}},
    

  21.     {'d', {0, 1, 1, 1, 1, 0, 1, 0}},
    

  22.     {'E', {1, 0, 0, 1, 1, 1, 1, 0}},
    

  23.     {'F', {1, 0, 0, 0, 1, 1, 1, 0}},
    

  24.     {'g', {1, 1, 1, 1, 0, 1, 1, 0}},
    

  25.     {'H', {0, 1, 1, 0, 1, 1, 1, 0}},
    

  26.     {'h', {0, 0, 1, 0, 1, 1, 1, 0}},
    

  27.     {'i', {0, 0, 1, 0, 0, 0, 0, 0}},
    

  28.     {'I', {0, 0, 0, 0, 1, 1, 0, 0}},
    

  29.     {'J', {0, 1, 1, 1, 1, 0, 0, 0}},
    

  30.     {'l', {0, 0, 0, 0, 1, 1, 0, 0}},
    

  31.     {'L', {0, 0, 0, 1, 1, 1, 0, 0}},
    

  32.     {'n', {0, 0, 1, 0, 1, 0, 1, 0}},
    

  33.     {'o', {0, 0, 1, 1, 1, 0, 1, 0}},
    

  34.     {'O', {1, 1, 1, 1, 1, 1, 0, 0}},
    

  35.     {'P', {1, 1, 0, 0, 1, 1, 1, 0}},
    

  36.     {'q', {1, 1, 1, 0, 0, 1, 1, 0}},
    

  37.     {'r', {0, 0, 0, 0, 1, 0, 1, 0}},
    

  38.     {'S', {1, 0, 1, 1, 0, 1, 1, 0}},
    

  39.     {'t', {0, 0, 0, 1, 1, 1, 1, 0}},
    

  40.     {'u', {0, 0, 1, 1, 1, 0, 0, 0}},
    

  41.     {'U', {0, 1, 1, 1, 1, 1, 0, 0}},
    

  42.     {'y', {0, 1, 1, 1, 0, 1, 1, 0}},
    

  43.     {'-', {0, 0, 0, 0, 0, 0, 1, 0}},
    

  44. };
    


  45. 

  46. int SLCD_Search8Segment(const char ch, uint8_t *Segment)
    

  47. {
    

  48.     uint8_t i = 0, j = 0;
    


  49. 

  50.     for (i = 0; i < SLCD_8SEG_NUM; i++)
    

  51.     {
    

  52.         if (SLCD_8SEG_Table[i].ch == ch)
    

  53.         {
    

  54.             for (j = 0; j < 8; j++)
    

  55.             {
    

  56.                 Segment[j] = SLCD_8SEG_Table[i].Segment[j];
    

  57.             }
    


  58. 

  59.             return (i);
    

  60.         }
    

  61.     }
    


  62. 

  63.     return (-1);
    

  64. }
    


  65. 

  66. const char SLCD_TruthTable[SLCD_DRIVER_COM][SLCD_DRIVER_SEG][5] =
    

  67. {
    

  68.     {"L4  ","W2  ","W1  ","4A  ","4F  ","3A  ","3F  ","2A  ","1F  ","1A  ","2F  ","5D  ","DP5 ","6D  ","DP6 ","7D  ","DP7 ","S1  ","S8  ","8D  ","DP8 ","9D  ","DP9 ","10D ","S9  ","    ","    ","    ","    ","    ","    ","    "},
    

  69.     {"L3  ","W3  ","T1  ","4B  ","4G  ","3B  ","3G  ","2B  ","1G  ","1B  ","2G  ","5E  ","5C  ","6E  ","6C  ","7E  ","7C  ","S2  ","S7  ","8E  ","8C  ","9E  ","9C  ","10E ","10C ","    ","    ","    ","    ","    ","    ","    "},
    

  70.     {"L2  ","W4  ","COL3","4C  ","4E  ","3C  ","3E  ","2C  ","1E  ","1C  ","2E  ","5G  ","5B  ","6G  ","6B  ","7G  ","7B  ","S3  ","S6  ","8G  ","8B  ","9G  ","9B  ","10G ","10B ","    ","    ","    ","    ","    ","    ","    "},
    

  71.     {"L1  ","W5  ","COL2","COL1","4D  ","DP3 ","3D  ","DP2 ","1D  ","DP1 ","2D  ","5F  ","5A  ","6F  ","6A  ","7F  ","7A  ","S4  ","S5  ","8F  ","8A  ","9F  ","9A  ","10F ","10A ","    ","    ","    ","    ","    ","    ","    "},
    

  72. };
    


  73. 

  74. int SLCD_SearchCOMnSEGn(const char *str, uint8_t *COMn, uint8_t *SEGn)
    

  75. {
    

  76.     uint8_t i = 0, j = 0;
    


  77. 

  78.     for (i = 0; i < SLCD_DRIVER_COM; i++)
    

  79.     {
    

  80.         for (j = 0; j < SLCD_DRIVER_SEG; j++)
    

  81.         {
    

  82.             if (strcmp(str, SLCD_TruthTable[i][j]) == 0)
    

  83.             {
    

  84.                 *COMn = i;
    

  85.                 *SEGn = j;
    


  86. 

  87.                 return (0);
    

  88.             }
    

  89.         }
    

  90.     }
    


  91. 

  92.     *COMn = 0xFF;
    

  93.     *SEGn = 0xFF;
    


  94. 

  95.     return (-1);
    

  96. }

5.3.SLCD API功能设计
复制
  1. #ifndef __SLCD_API_H
    

  2. #define __SLCD_API_H
    


  3. 

  4. #ifdef __cplusplus
    

  5. extern "C" {
    

  6. #endif
    


  7. 

  8. #include <stdint.h>
    


  9. 

  10. void SLCD_DisplayDigit(uint8_t Index, char ch);
    

  11. void SLCD_DisplayPoint(uint8_t Index, uint8_t State);
    

  12. void SLCD_DisplayCOL(uint8_t Index, uint8_t State);
    

  13. void SLCD_DisplayW(uint8_t Index, uint8_t State);
    

  14. void SLCD_DisplayL(uint8_t Index, uint8_t State);
    

  15. void SLCD_DisplayS(uint8_t Index, uint8_t State);
    

  16. void SLCD_DisplayT(uint8_t Index, uint8_t State);
    

  17. void SLCD_DisplayALL(void);
    

  18. void SLCD_DisplayCLR(void);
    


  19. 

  20. #ifdef __cplusplus
    

  21. }
    

  22. #endif
    


  23. 

  24. #endif
复制
  1. #include "slcd_api.h"
    

  2. #include "slcd.h"
    

  3. #include "slcd_driver.h"
    


  4. 

  5. const char DigitTable[10][7][5] =
    

  6. {
    

  7.     {"1A  ", "1B  ", "1C  ", "1D  ", "1E  ", "1F  ", "1G  "},
    

  8.     {"2A  ", "2B  ", "2C  ", "2D  ", "2E  ", "2F  ", "2G  "},
    

  9.     {"3A  ", "3B  ", "3C  ", "3D  ", "3E  ", "3F  ", "3G  "},
    

  10.     {"4A  ", "4B  ", "4C  ", "4D  ", "4E  ", "4F  ", "4G  "},
    

  11.     {"5A  ", "5B  ", "5C  ", "5D  ", "5E  ", "5F  ", "5G  "},
    

  12.     {"6A  ", "6B  ", "6C  ", "6D  ", "6E  ", "6F  ", "6G  "},
    

  13.     {"7A  ", "7B  ", "7C  ", "7D  ", "7E  ", "7F  ", "7G  "},
    

  14.     {"8A  ", "8B  ", "8C  ", "8D  ", "8E  ", "8F  ", "8G  "},
    

  15.     {"9A  ", "9B  ", "9C  ", "9D  ", "9E  ", "9F  ", "9G  "},
    

  16.     {"10A ", "10B ", "10C ", "10D ", "10E ", "10F ", "10G "}
    

  17. };
    


  18. 

  19. void SLCD_DisplayDigit(uint8_t Index, char ch)
    

  20. {
    

  21.     uint8_t i = 0,  Segment[8];
    

  22.     uint8_t COMn = 0, SEGn = 0;
    


  23. 

  24.     if ((Index >= 1) && (Index <= 10))
    

  25.     {
    

  26.         Index--;
    


  27. 

  28.         if (SLCD_Search8Segment(ch, Segment) != -1)
    

  29.         {
    

  30.             for (i = 0; i < 7; i++)
    

  31.             {
    

  32.                 if (SLCD_SearchCOMnSEGn(DigitTable[Index][i], &COMn, &SEGn) != -1)
    

  33.                 {
    

  34.                     SLCD_DRIVER_ModifyRAM(COMn, SEGn, Segment[i]);
    

  35.                 }
    

  36.             }
    


  37. 

  38.             SLCD_DRIVER_UpdateRAM();
    

  39.         }
    

  40.     }
    

  41. }
    


  42. 

  43. const char DP_Table[9][5] =
    

  44. {
    

  45.     "DP1 ", "DP2 ", "DP3 ", "DP4 ","DP5 ","DP6 ","DP7 ","DP8 ","DP9 "
    

  46. };
    


  47. 

  48. void SLCD_DisplayPoint(uint8_t Index, uint8_t State)
    

  49. {
    

  50.     uint8_t COMn = 0, SEGn = 0;
    


  51. 

  52.     if ((Index >= 1) && (Index <= 9))
    

  53.     {
    

  54.         Index--;
    


  55. 

  56.         if (SLCD_SearchCOMnSEGn(DP_Table[Index], &COMn, &SEGn) != -1)
    

  57.         {
    

  58.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  59.         }
    


  60. 

  61.         SLCD_DRIVER_UpdateRAM();
    

  62.     }
    

  63. }
    


  64. 

  65. const char COL_Table[3][5] =
    

  66. {
    

  67.     "COL1", "COL2", "COL3"
    

  68. };
    


  69. 

  70. void SLCD_DisplayCOL(uint8_t Index, uint8_t State)
    

  71. {
    

  72.     uint8_t COMn = 0, SEGn = 0;
    


  73. 

  74.     if ((Index >= 1) && (Index <= 3))
    

  75.     {
    

  76.         Index--;
    


  77. 

  78.         if (SLCD_SearchCOMnSEGn(COL_Table[Index], &COMn, &SEGn) != -1)
    

  79.         {
    

  80.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  81.         }
    


  82. 

  83.         SLCD_DRIVER_UpdateRAM();
    

  84.     }
    

  85. }
    


  86. 

  87. const char W_Table[5][5] =
    

  88. {
    

  89.     "W1  ", "W2  ", "W3  ", "W4  ", "W5  "
    

  90. };
    


  91. 

  92. void SLCD_DisplayW(uint8_t Index, uint8_t State)
    

  93. {
    

  94.     uint8_t COMn = 0, SEGn = 0;
    


  95. 

  96.     if ((Index >= 1) && (Index <= 5))
    

  97.     {
    

  98.         Index--;
    


  99. 

  100.         if (SLCD_SearchCOMnSEGn(W_Table[Index], &COMn, &SEGn) != -1)
    

  101.         {
    

  102.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  103.         }
    


  104. 

  105.         SLCD_DRIVER_UpdateRAM();
    

  106.     }
    

  107. }
    


  108. 

  109. const char L_Table[4][5] =
    

  110. {
    

  111.     "L1  ", "L2  ", "L3  ", "L4  "
    

  112. };
    


  113. 

  114. void SLCD_DisplayL(uint8_t Index, uint8_t State)
    

  115. {
    

  116.     uint8_t COMn = 0, SEGn = 0;
    


  117. 

  118.     if ((Index >= 1) && (Index <= 4))
    

  119.     {
    

  120.         Index--;
    


  121. 

  122.         if (SLCD_SearchCOMnSEGn(L_Table[Index], &COMn, &SEGn) != -1)
    

  123.         {
    

  124.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  125.         }
    


  126. 

  127.         SLCD_DRIVER_UpdateRAM();
    

  128.     }
    

  129. }
    


  130. 

  131. const char S_Table[9][5] =
    

  132. {
    

  133.     "S1  ", "S2  ", "S3  ", "S4  ", "S5  ", "S6  ", "S7  ", "S8  ", "S9  "
    

  134. };
    


  135. 

  136. void SLCD_DisplayS(uint8_t Index, uint8_t State)
    

  137. {
    

  138.     uint8_t COMn = 0, SEGn = 0;
    


  139. 

  140.     if ((Index >= 1) && (Index <= 9))
    

  141.     {
    

  142.         Index--;
    


  143. 

  144.         if (SLCD_SearchCOMnSEGn(S_Table[Index], &COMn, &SEGn) != -1)
    

  145.         {
    

  146.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  147.         }
    


  148. 

  149.         SLCD_DRIVER_UpdateRAM();
    

  150.     }
    

  151. }
    


  152. 

  153. const char T_Table[1][5] =
    

  154. {
    

  155.     "T1  "
    

  156. };
    


  157. 

  158. void SLCD_DisplayT(uint8_t Index, uint8_t State)
    

  159. {
    

  160.     uint8_t COMn = 0, SEGn = 0;
    


  161. 

  162.     if (Index == 1)
    

  163.     {
    

  164.         Index--;
    


  165. 

  166.         if (SLCD_SearchCOMnSEGn(T_Table[Index], &COMn, &SEGn) != -1)
    

  167.         {
    

  168.             SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);
    

  169.         }
    


  170. 

  171.         SLCD_DRIVER_UpdateRAM();
    

  172.     }
    

  173. }
    


  174. 

  175. void SLCD_DisplayALL(void)
    

  176. {
    

  177.     SLCD_DRIVER_Fill(0xFF);
    

  178. }
    


  179. 

  180. void SLCD_DisplayCLR(void)
    

  181. {
    

  182.     SLCD_DRIVER_Fill(0x00);
    

  183. }

5.4.Protocol自定义控制协议
复制
  1. #ifndef __PROTOCOL_H
    

  2. #define __PROTOCOL_H
    


  3. 

  4. #ifdef __cplusplus
    

  5. extern "C" {
    

  6. #endif
    


  7. 

  8. #include <stdint.h>
    


  9. 

  10. void ProtocolAnalyzing(uint8_t *Buffer, uint8_t Length);
    


  11. 

  12. #ifdef __cplusplus
    

  13. }
    

  14. #endif
    


  15. 

  16. #endif
复制
  1. #include "protocol.h"
    

  2. #include "slcd_api.h"
    


  3. 

  4. uint8_t Protocol_ASCII_TO_Hex(char ch)
    

  5. {
    

  6.     char HEX_Table[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    


  7. 

  8.     for (uint8_t i = 0; i < 16; i++)
    

  9.     {
    

  10.         if (ch == HEX_Table[i])
    

  11.         {
    

  12.             return (i);
    

  13.         }
    

  14.     }
    


  15. 

  16.     return (0xFF);
    

  17. }
    


  18. 

  19. void ProtocolAnalyzing(uint8_t *Buffer, uint8_t Length)
    

  20. {
    

  21.     if (Length == 3)
    

  22.     {
    

  23.         if (Buffer[1] == 'F')
    

  24.         {
    

  25.             SLCD_DisplayALL();
    

  26.         }
    

  27.         else if (Buffer[1] == 'E')
    

  28.         {
    

  29.             SLCD_DisplayCLR();
    

  30.         }
    

  31.         else
    

  32.         {
    

  33.         } 
    

  34.     }
    


  35. 

  36.     /* @T[T1]# */
    

  37.     if (Length == 4)
    

  38.     {
    

  39.         if ((Buffer[0] == '@') && (Buffer[3] == '#'))
    

  40.         {
    

  41.             if (Buffer[1] == 'T')
    

  42.             {
    

  43.                 SLCD_DisplayT(1, Buffer[2] - 0x30);
    

  44.             }           
    

  45.         }
    

  46.     }
    


  47. 

  48.     /* @D[Index][ch]# */
    

  49.     /* @P[Index][State]# */
    

  50.     /* @C[Index][State]# */
    

  51.     /* @W[Index][State]# */
    

  52.     /* @L[Index][State]# */
    

  53.     /* @S[Index][State]# */
    

  54.     /* @T[Index][State]# */
    

  55.     if (Length == 5)
    

  56.     {
    

  57.         if ((Buffer[0] == '@') && (Buffer[4] == '#'))
    

  58.         {
    

  59.             if (Buffer[1] == 'D')
    

  60.             {
    

  61.                 SLCD_DisplayDigit(Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3]);
    

  62.             }
    

  63.             else if (Buffer[1] == 'P')
    

  64.             {
    

  65.                 SLCD_DisplayPoint(Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  66.             }
    

  67.             else if (Buffer[1] == 'C')
    

  68.             {
    

  69.                 SLCD_DisplayCOL(  Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  70.             }
    

  71.             else if (Buffer[1] == 'W')
    

  72.             {
    

  73.                 SLCD_DisplayW(    Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  74.             }
    

  75.             else if (Buffer[1] == 'L')
    

  76.             {
    

  77.                 SLCD_DisplayL(    Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  78.             }
    

  79.             else if (Buffer[1] == 'S')
    

  80.             {
    

  81.                 SLCD_DisplayS(    Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  82.             }
    

  83.             else if (Buffer[1] == 'T')
    

  84.             {
    

  85.                 SLCD_DisplayT(    Protocol_ASCII_TO_Hex(Buffer[2]), Buffer[3] - 0x30);
    

  86.             }
    

  87.             else
    

  88.             {
    

  89.             }
    

  90.         }
    

  91.     }
    


  92. 

  93.     /* @C[COL1][COL2][COL3]# */
    

  94.     if (Length == 6)
    

  95.     {
    

  96.         if ((Buffer[0] == '@') && (Buffer[5] == '#'))
    

  97.         {
    

  98.             if (Buffer[1] == 'C')
    

  99.             {
    

  100.                 SLCD_DisplayCOL(1, Buffer[2] - 0x30);
    

  101.                 SLCD_DisplayCOL(2, Buffer[3] - 0x30);
    

  102.                 SLCD_DisplayCOL(3, Buffer[4] - 0x30);
    

  103.             }
    

  104.         }
    

  105.     }
    


  106. 

  107.     /* @L[L1][L2][L3][L4]# */
    

  108.     if (Length == 7)
    

  109.     {
    

  110.         if ((Buffer[0] == '@') && (Buffer[6] == '#'))
    

  111.         {
    

  112.             if (Buffer[1] == 'L')
    

  113.             {
    

  114.                 SLCD_DisplayL(1, Buffer[2] - 0x30);
    

  115.                 SLCD_DisplayL(2, Buffer[3] - 0x30);
    

  116.                 SLCD_DisplayL(3, Buffer[4] - 0x30);
    

  117.                 SLCD_DisplayL(4, Buffer[5] - 0x30);
    

  118.             }
    

  119.         }
    

  120.     }
    


  121. 

  122.     /* @W[W1][W2][W3][W4][W5]# */
    

  123.     if (Length == 8)
    

  124.     {
    

  125.         if ((Buffer[0] == '@') && (Buffer[7] == '#'))
    

  126.         {
    

  127.             if (Buffer[1] == 'W')
    

  128.             {
    

  129.                 SLCD_DisplayW(1, Buffer[2] - 0x30);
    

  130.                 SLCD_DisplayW(2, Buffer[3] - 0x30);
    

  131.                 SLCD_DisplayW(3, Buffer[4] - 0x30);
    

  132.                 SLCD_DisplayW(4, Buffer[5] - 0x30);
    

  133.                 SLCD_DisplayW(5, Buffer[6] - 0x30);
    

  134.             }
    

  135.         }
    

  136.     }
    


  137. 

  138.     /* @P[DP1][DP2][DP3][DP4][DP5][DP6][DP7][DP8][DP9]# */
    

  139.     /* @S[S1][S2][S3][S4][S5][S6][S7][S8][S9]# */
    

  140.     if (Length == 12)
    

  141.     {
    

  142.         if ((Buffer[0] == '@') && (Buffer[11] == '#'))
    

  143.         {
    

  144.             if (Buffer[1] == 'P')
    

  145.             {
    

  146.                 SLCD_DisplayPoint(1, Buffer[2]  - 0x30);
    

  147.                 SLCD_DisplayPoint(2, Buffer[3]  - 0x30);
    

  148.                 SLCD_DisplayPoint(3, Buffer[4]  - 0x30);
    

  149.                 SLCD_DisplayPoint(4, Buffer[5]  - 0x30);
    

  150.                 SLCD_DisplayPoint(5, Buffer[6]  - 0x30);
    

  151.                 SLCD_DisplayPoint(6, Buffer[7]  - 0x30);
    

  152.                 SLCD_DisplayPoint(7, Buffer[8]  - 0x30);
    

  153.                 SLCD_DisplayPoint(8, Buffer[9]  - 0x30);
    

  154.                 SLCD_DisplayPoint(9, Buffer[10] - 0x30);
    

  155.             }
    

  156.             else if (Buffer[1] == 'S')
    

  157.             {
    

  158.                 SLCD_DisplayS(1, Buffer[2]  - 0x30);
    

  159.                 SLCD_DisplayS(2, Buffer[3]  - 0x30);
    

  160.                 SLCD_DisplayS(3, Buffer[4]  - 0x30);
    

  161.                 SLCD_DisplayS(4, Buffer[5]  - 0x30);
    

  162.                 SLCD_DisplayS(5, Buffer[6]  - 0x30);
    

  163.                 SLCD_DisplayS(6, Buffer[7]  - 0x30);
    

  164.                 SLCD_DisplayS(7, Buffer[8]  - 0x30);
    

  165.                 SLCD_DisplayS(8, Buffer[9]  - 0x30);
    

  166.                 SLCD_DisplayS(9, Buffer[10] - 0x30);
    

  167.             }
    

  168.             else
    

  169.             {
    

  170.             }
    

  171.         }
    

  172.     }
    


  173. 

  174.     /* @D[1][2][3][4][5][6][7][8][9][10]# */
    

  175.     if (Length == 13)
    

  176.     {
    

  177.         if ((Buffer[0] == '@') && (Buffer[12] == '#'))
    

  178.         {
    

  179.             if (Buffer[1] == 'D')
    

  180.             {
    

  181.                 SLCD_DisplayDigit(1,  Buffer[2]);
    

  182.                 SLCD_DisplayDigit(2,  Buffer[3]);
    

  183.                 SLCD_DisplayDigit(3,  Buffer[4]);
    

  184.                 SLCD_DisplayDigit(4,  Buffer[5]);
    

  185.                 SLCD_DisplayDigit(5,  Buffer[6]);
    

  186.                 SLCD_DisplayDigit(6,  Buffer[7]);
    

  187.                 SLCD_DisplayDigit(7,  Buffer[8]);
    

  188.                 SLCD_DisplayDigit(8,  Buffer[9]);
    

  189.                 SLCD_DisplayDigit(9,  Buffer[10]);
    

  190.                 SLCD_DisplayDigit(10, Buffer[11]);
    

  191.             }
    

  192.         }
    

  193.     }
    

  194. }

6.显示效果
6.1.MM32G0001驱动SLCD显示效果
1.jpg

6.2.MM32F0010驱动SLCD显示效果
2.jpg

6.3.MM32F0020驱动SLCD显示效果
3.jpg

7.附件资料
7.1.GDC0689S(T)P10V3B显示屏： GDC0689S(T)P10V3B.pdf (309.4 KB, 下载次数: 16)
7.2.GDC04212S(T)P10V3B显示屏： GDC04212S(T)P10V3B.pdf (220.54 KB, 下载次数: 16)
7.3.GDC04362S(T)P10V3T显示屏： GDC04362S(T)P10V3T.pdf (419.84 KB, 下载次数: 17)
7.4.MM32G0001原理图： Schematic_MM32G0001_LCD.pdf (71.6 KB, 下载次数: 20)
7.5.MM32F0010原理图： Schematic_MM32F0010_LCD.pdf (71.8 KB, 下载次数: 14)
7.6.MM32F0020原理图： Schematic_MM32F0020_LCD.pdf (78.62 KB, 下载次数: 13)
7.7.MM32G0001工程源码： MM32G0001.zip (568.38 KB, 下载次数: 39)
7.8.MM32F0010工程源码： MM32F0010.zip (591.5 KB, 下载次数: 18)
7.9.MM32F0020工程源码： MM32F0020.zip (603.62 KB, 下载次数: 24)


8.扩展应用
以上实现的段码液晶显示屏程序架构同样适用于段码形式的LED显示屏上，后面会分享一个段码LED应用的多功能闹钟，期待ing……
回复

收藏1 举报

打赏榜单

21小跑堂 打赏了 60.00 元 2024-08-08
理由：恭喜通过原创审核！期待您更多的原创作品~

评论

21小跑堂
电路完整，代码详细，架构清晰，一问解决MM32上的段码液晶显示屏的使用方式。极具参考价值。  发表于 2024-8-8 15:56

相关帖子
chenqianqian 发表于 2024-8-8 08:10 来自手机 | 显示全部楼层
这个是段码液晶，显示的内容是固定的
回复

收藏1 举报

 楼主| xld0932 发表于 2024-8-8 09:27 | 显示全部楼层
chenqianqian 发表于 2024-8-8 08:10
这个是段码液晶，显示的内容是固定的

段码液晶屏，段位设计是固定的，显示的内容是通过组合可变的
回复

收藏1 举报

tpgf 发表于 2024-8-10 15:58 | 显示全部楼层
通用段码液晶显示屏是一种广泛应用于各类电子设备中的显示技术。这种屏幕通过液晶显示技术来展示数字、字符和简单图形，因其低功耗、高可靠性和长寿命等优点而被广泛采用
回复

收藏1 举报

hellobug 发表于 2024-8-11 21:07 | 显示全部楼层
不错的分享。最近在看段码屏，使用的是HT1623的驱动芯片。不过段码屏主要都要定制生产，有时候量少了不太划算。
回复

收藏1 举报

beyikyo 发表于 2024-10-31 16:56 | 显示全部楼层
详细介绍了基于 MM32 的通用段码液晶显示屏程序架构，从硬件设计到程序实现，内容全面且实用，很有收获。
回复

收藏1 举报

suncat0504 发表于 2024-11-7 18:14 | 显示全部楼层
谢谢分享！感觉段码液晶显示屏的驱动比图形的麻烦，占用IO口也多。另外图形点阵的液晶现在价格也降下来了。
回复

收藏1 举报

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

本版积分规则

xld0932 Image
个人签名：King.Xu

77

主题

3023

帖子

38

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