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

于 2024-09-28 23:03:08 发布
阅读量52 收藏
点赞数
分类专栏： 嵌入式基础知识 文章标签： 架构
原文链接：https://bbs.21ic.com/icview-3394322-1-1.html
版权

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

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

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



2.2.基于MM32F0010的SLCD原理图
 



2.3.基于MM32F0020的SLCD原理图
 



3.硬件实物
 


 



4.程序架构
 



5.程序实现（以MM32F0010为例）
5.1.SLCD驱动程序设计

复制 
#ifndef __SLCD_DRIVER_H

#define __SLCD_DRIVER_H



#ifdef __cplusplus

extern "C" {

#endif



#include <string.h>

#include "hal_conf.h"



#define SLCD_DRIVER_COM         (4)

#define SLCD_DRIVER_SEG         (32)



#define SLCD_DRIVER_CS_RCC      RCC_AHBENR_GPIOA

#define SLCD_DRIVER_CS_GPIO     GPIOA

#define SLCD_DRIVER_CS_PIN      GPIO_Pin_7



#define SLCD_DRIVER_WR_RCC      RCC_AHBENR_GPIOA

#define SLCD_DRIVER_WR_GPIO     GPIOA

#define SLCD_DRIVER_WR_PIN      GPIO_Pin_5



#define SLCD_DRIVER_DATA_RCC    RCC_AHBENR_GPIOA

#define SLCD_DRIVER_DATA_GPIO   GPIOA

#define SLCD_DRIVER_DATA_PIN    GPIO_Pin_4



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

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



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

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



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

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



void SLCD_DRIVER_UpdateRAM(void);

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

void SLCD_DRIVER_Fill(uint8_t Data);

void SLCD_DRIVER_Init(void);



#ifdef __cplusplus

}

#endif



#endif
复制 
#include "slcd_driver.h"



uint8_t SLCD_DRIVER_RAM[SLCD_DRIVER_SEG];



void SLCD_DRIVER_InitGPIO(void)

{

    GPIO_InitTypeDef GPIO_InitStruct;



    /* CS */

    RCC_AHBPeriphClockCmd(SLCD_DRIVER_CS_RCC, ENABLE);



    GPIO_StructInit(&GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_CS_PIN;

    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;

    GPIO_Init(SLCD_DRIVER_CS_GPIO, &GPIO_InitStruct);



    GPIO_WriteBit(SLCD_DRIVER_CS_GPIO, SLCD_DRIVER_CS_PIN, Bit_SET);



    /* WR */

    RCC_AHBPeriphClockCmd(SLCD_DRIVER_WR_RCC, ENABLE);



    GPIO_StructInit(&GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_WR_PIN;

    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;

    GPIO_Init(SLCD_DRIVER_WR_GPIO, &GPIO_InitStruct);



    GPIO_WriteBit(SLCD_DRIVER_WR_GPIO, SLCD_DRIVER_WR_PIN, Bit_SET);



    /* DATA */

    RCC_AHBPeriphClockCmd(SLCD_DRIVER_DATA_RCC, ENABLE);



    GPIO_StructInit(&GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Pin   = SLCD_DRIVER_DATA_PIN;

    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_Out_PP;

    GPIO_Init(SLCD_DRIVER_DATA_GPIO, &GPIO_InitStruct);



    GPIO_WriteBit(SLCD_DRIVER_DATA_GPIO, SLCD_DRIVER_DATA_PIN, Bit_SET);

}



void SLCD_DRIVER_Write(uint16_t Data, uint8_t Bits)

{

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



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

    {

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



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

        {

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

        }

        else

        {

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

        }



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

    }



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

}



void SLCD_DRIVER_UpdateRAM(void)

{

    uint16_t Data = 0;



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

    {

        /*Write RAM : 101 a5a4a3a2a1a0 d0d1d2d3*/

        Data   = 0x05;

        Data <<= 0x06;



        Data  |= (i & 0x3F);

        Data <<= 0x04;



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

        Data <<= 0x03;



        SLCD_DRIVER_Write(Data, 0x0D);

    }

}



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

{

    if (State)

    {

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

    }

    else

    {

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

    }

}



void SLCD_DRIVER_Fill(uint8_t Data)

{

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



    SLCD_DRIVER_UpdateRAM();

}



void SLCD_DRIVER_Init(void)

{

    SLCD_DRIVER_InitGPIO();



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



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

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

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

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

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



    SLCD_DRIVER_UpdateRAM();

}


5.2.SLCD共用函数设计

复制 
#ifndef __SLCD_H

#define __SLCD_H



#ifdef __cplusplus

extern "C" {

#endif



#include <stdint.h>



typedef struct

{

    char    ch;             /*字符索引*/

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

} SLCD_8SEG_TypeDef;



#define SLCD_8SEG_NUM       (38)



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

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



#ifdef __cplusplus

}

#endif



#endif
复制 
#include "slcd.h"

#include "slcd_driver.h"



const SLCD_8SEG_TypeDef SLCD_8SEG_Table[SLCD_8SEG_NUM] =

{

    {' ', {0, 0, 0, 0, 0, 0, 0, 0}},

    {'0', {1, 1, 1, 1, 1, 1, 0, 0}},

    {'1', {0, 1, 1, 0, 0, 0, 0, 0}},

    {'2', {1, 1, 0, 1, 1, 0, 1, 0}},

    {'3', {1, 1, 1, 1, 0, 0, 1, 0}},

    {'4', {0, 1, 1, 0, 0, 1, 1, 0}},

    {'5', {1, 0, 1, 1, 0, 1, 1, 0}},

    {'6', {1, 0, 1, 1, 1, 1, 1, 0}},

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

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

    {'9', {1, 1, 1, 1, 0, 1, 1, 0}},

    {'A', {1, 1, 1, 0, 1, 1, 1, 0}},

    {'b', {0, 0, 1, 1, 1, 1, 1, 0}},

    {'c', {0, 0, 0, 1, 1, 0, 1, 0}},

    {'C', {1, 0, 0, 1, 1, 1, 0, 0}},

    {'d', {0, 1, 1, 1, 1, 0, 1, 0}},

    {'E', {1, 0, 0, 1, 1, 1, 1, 0}},

    {'F', {1, 0, 0, 0, 1, 1, 1, 0}},

    {'g', {1, 1, 1, 1, 0, 1, 1, 0}},

    {'H', {0, 1, 1, 0, 1, 1, 1, 0}},

    {'h', {0, 0, 1, 0, 1, 1, 1, 0}},

    {'i', {0, 0, 1, 0, 0, 0, 0, 0}},

    {'I', {0, 0, 0, 0, 1, 1, 0, 0}},

    {'J', {0, 1, 1, 1, 1, 0, 0, 0}},

    {'l', {0, 0, 0, 0, 1, 1, 0, 0}},

    {'L', {0, 0, 0, 1, 1, 1, 0, 0}},

    {'n', {0, 0, 1, 0, 1, 0, 1, 0}},

    {'o', {0, 0, 1, 1, 1, 0, 1, 0}},

    {'O', {1, 1, 1, 1, 1, 1, 0, 0}},

    {'P', {1, 1, 0, 0, 1, 1, 1, 0}},

    {'q', {1, 1, 1, 0, 0, 1, 1, 0}},

    {'r', {0, 0, 0, 0, 1, 0, 1, 0}},

    {'S', {1, 0, 1, 1, 0, 1, 1, 0}},

    {'t', {0, 0, 0, 1, 1, 1, 1, 0}},

    {'u', {0, 0, 1, 1, 1, 0, 0, 0}},

    {'U', {0, 1, 1, 1, 1, 1, 0, 0}},

    {'y', {0, 1, 1, 1, 0, 1, 1, 0}},

    {'-', {0, 0, 0, 0, 0, 0, 1, 0}},

};



int SLCD_Search8Segment(const char ch, uint8_t *Segment)

{

    uint8_t i = 0, j = 0;



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

    {

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

        {

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

            {

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

            }



            return (i);

        }

    }



    return (-1);

}



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

{

    {"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  ","    ","    ","    ","    ","    ","    ","    "},

    {"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 ","    ","    ","    ","    ","    ","    ","    "},

    {"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 ","    ","    ","    ","    ","    ","    ","    "},

    {"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 ","    ","    ","    ","    ","    ","    ","    "},

};



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

{

    uint8_t i = 0, j = 0;



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

    {

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

        {

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

            {

                *COMn = i;

                *SEGn = j;



                return (0);

            }

        }

    }



    *COMn = 0xFF;

    *SEGn = 0xFF;



    return (-1);

}


5.3.SLCD API功能设计

复制 
#ifndef __SLCD_API_H

#define __SLCD_API_H



#ifdef __cplusplus

extern "C" {

#endif



#include <stdint.h>



void SLCD_DisplayDigit(uint8_t Index, char ch);

void SLCD_DisplayPoint(uint8_t Index, uint8_t State);

void SLCD_DisplayCOL(uint8_t Index, uint8_t State);

void SLCD_DisplayW(uint8_t Index, uint8_t State);

void SLCD_DisplayL(uint8_t Index, uint8_t State);

void SLCD_DisplayS(uint8_t Index, uint8_t State);

void SLCD_DisplayT(uint8_t Index, uint8_t State);

void SLCD_DisplayALL(void);

void SLCD_DisplayCLR(void);



#ifdef __cplusplus

}

#endif



#endif
复制 
#include "slcd_api.h"

#include "slcd.h"

#include "slcd_driver.h"



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

{

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

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

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

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

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

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

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

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

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

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

};



void SLCD_DisplayDigit(uint8_t Index, char ch)

{

    uint8_t i = 0,  Segment[8];

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

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

            {

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

                {

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

                }

            }



            SLCD_DRIVER_UpdateRAM();

        }

    }

}



const char DP_Table[9][5] =

{

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

};



void SLCD_DisplayPoint(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



const char COL_Table[3][5] =

{

    "COL1", "COL2", "COL3"

};



void SLCD_DisplayCOL(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



const char W_Table[5][5] =

{

    "W1  ", "W2  ", "W3  ", "W4  ", "W5  "

};



void SLCD_DisplayW(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



const char L_Table[4][5] =

{

    "L1  ", "L2  ", "L3  ", "L4  "

};



void SLCD_DisplayL(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



const char S_Table[9][5] =

{

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

};



void SLCD_DisplayS(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



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

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



const char T_Table[1][5] =

{

    "T1  "

};



void SLCD_DisplayT(uint8_t Index, uint8_t State)

{

    uint8_t COMn = 0, SEGn = 0;



    if (Index == 1)

    {

        Index--;



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

        {

            SLCD_DRIVER_ModifyRAM(COMn, SEGn, State);

        }



        SLCD_DRIVER_UpdateRAM();

    }

}



void SLCD_DisplayALL(void)

{

    SLCD_DRIVER_Fill(0xFF);

}



void SLCD_DisplayCLR(void)

{

    SLCD_DRIVER_Fill(0x00);

}


5.4.Protocol自定义控制协议

复制 
#ifndef __PROTOCOL_H

#define __PROTOCOL_H



#ifdef __cplusplus

extern "C" {

#endif



#include <stdint.h>



void ProtocolAnalyzing(uint8_t *Buffer, uint8_t Length);



#ifdef __cplusplus

}

#endif



#endif
复制 
#include "protocol.h"

#include "slcd_api.h"



uint8_t Protocol_ASCII_TO_Hex(char ch)

{

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



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

    {

        if (ch == HEX_Table[i])

        {

            return (i);

        }

    }



    return (0xFF);

}



void ProtocolAnalyzing(uint8_t *Buffer, uint8_t Length)

{

    if (Length == 3)

    {

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

        {

            SLCD_DisplayALL();

        }

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

        {

            SLCD_DisplayCLR();

        }

        else

        {

        } 

    }



    /* @T[T1]# */

    if (Length == 4)

    {

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

        {

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

            {

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

            }           

        }

    }



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

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

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

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

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

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

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

    if (Length == 5)

    {

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

        {

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

            {

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

            }

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

            {

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

            }

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

            {

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

            }

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

            {

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

            }

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

            {

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

            }

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

            {

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

            }

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

            {

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

            }

            else

            {

            }

        }

    }



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

    if (Length == 6)

    {

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

        {

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

            {

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

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

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

            }

        }

    }



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

    if (Length == 7)

    {

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

        {

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

            {

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

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

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

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

            }

        }

    }



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

    if (Length == 8)

    {

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

        {

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

            {

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

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

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

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

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

            }

        }

    }



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

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

    if (Length == 12)

    {

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

        {

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

            {

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

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

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

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

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

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

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

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

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

            }

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

            {

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

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

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

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

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

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

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

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

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

            }

            else

            {

            }

        }

    }



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

    if (Length == 13)

    {

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

        {

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

            {

                SLCD_DisplayDigit(1,  Buffer[2]);

                SLCD_DisplayDigit(2,  Buffer[3]);

                SLCD_DisplayDigit(3,  Buffer[4]);

                SLCD_DisplayDigit(4,  Buffer[5]);

                SLCD_DisplayDigit(5,  Buffer[6]);

                SLCD_DisplayDigit(6,  Buffer[7]);

                SLCD_DisplayDigit(7,  Buffer[8]);

                SLCD_DisplayDigit(8,  Buffer[9]);

                SLCD_DisplayDigit(9,  Buffer[10]);

                SLCD_DisplayDigit(10, Buffer[11]);

            }

        }

    }

}


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



6.2.MM32F0010驱动SLCD显示效果
 



6.3.MM32F0020驱动SLCD显示效果
 



7.附件资料
7.1.GDC0689S(T)P10V3B显示屏： 

 GDC0689S(T)P10V3B.pdf (309.4 KB)
7.2.GDC04212S(T)P10V3B显示屏： 

 GDC04212S(T)P10V3B.pdf (220.54 KB)
7.3.GDC04362S(T)P10V3T显示屏： 

 GDC04362S(T)P10V3T.pdf (419.84 KB)
7.4.MM32G0001原理图： 

 Schematic_MM32G0001_LCD.pdf (71.6 KB)
7.5.MM32F0010原理图： 

 Schematic_MM32F0010_LCD.pdf (71.8 KB)
7.6.MM32F0020原理图： 

 Schematic_MM32F0020_LCD.pdf (78.62 KB)
7.7.MM32G0001工程源码： 

 MM32G0001.zip (568.38 KB)
7.8.MM32F0010工程源码： 

 MM32F0010.zip (591.5 KB)
7.9.MM32F0020工程源码： 

 MM32F0020.zip (603.62 KB)


8.扩展应用
以上实现的段码液晶显示屏程序架构同样适用于段码形式的LED显示屏上，后面会分享一个段码LED应用的多功能闹钟，期待ing……。
---------------------
作者：xld0932
链接：https://bbs.21ic.com/icview-3394322-1-1.html
来源：21ic.com
此文章已获得原创/原创奖标签，著作权归21ic所有，任何人未经允许禁止转载。

21ic电子工程师
关注
专栏目录
MM32在系统编程ISP下载工具和mcuisp(用于STM32串口下载程序)
08-11
文档说明:MM32在系统编程工具通过串口UART1TX，RX，并结合上电时硬件上的BOOT引I脚配置可实现目标程序的更新下载。适配系列: MM32L3xx，MM32LOxx，MM32SPINO5,MM32SPIN2x MM32F103xx_n, MM32F031xx_n mcuisp(用于STM...
基于mm32f3270的空气净化器
07-30
空气净化器通过OLED显示屏显示室内温度、湿度、TVOC、二氧化碳浓度、烟雾报警等各项信息，程序控制加湿器等装置的运行。自动控制加湿器，窗户，风扇等的开启以达到空气质量改善的目的。系统通过MM32主控控制并运用rt...
[MM32生态]如何使用不带SLCD控制器的MCU IO直接驱动段码屏
ic2121的博客
02-20 2958
若要不显示，通常给电极两端加的电压差接近0V。COM口的引脚通过电阻在不同的模式下分压分别输出0.5V，2.5V，4.5V，其中在高阻态的时候输出2.5V的电压。当COM进行扫描时设置COM为推挽输出，如果此时与此相连接的SEG不显示，则说明COM与SEG为同相，如果显示为反相，当此COM扫描完成以后，这个COM的IO就设置为高阻态，这样COM就通过4.7K的电阻得到2.5V的电压，此时SEG继续输出方波，这样加在LCD上的显示电压，显示时为+-3.0V，不显示时为+-1.0V，满足LCD的扫描的要求。
[MM32生态]EVB-L0136开发学习分享
ic2121的博客
03-15 233
3、EVB-L0130开发板上有4个切换开关，是用来切换MCU的GPIO是用来控制LCD显示的，还是用来操作I2S播放音频的，所以在做LCD和I2S实验时，需要将这4个切换开关拨正确，这两个功能的实验也不能同时完成；9. 结合段位LCD显示屏的真值表、MCU与LCD的硬件连接，实现对板载LCD的显示驱动，通过查表方式，实现灵活显示，便程序更具有可读性、更便于移植和功能实现。5、我手上的EVB-L0130是初代的版本，暂时还做不了低功耗的测试，这个官方应该会地后面的硬件版本上更新过来吧。
集成段码LCD驱动低功耗系列MM32L0130
EVERSPIN的博客
01-30 672
灵动微集成段码LCD驱动低功耗系列MM32L0130搭载了最高主频为48MHz的Arm Cortex-M0+处理器;提供至多64KB的Flash存储空间和8KB的SRAM空间。
带SLCD屏驱动的低功耗单片机MM32L0130
EVERSPIN的博客
11-21 536
SLCD是LCD的一个高档衍生品种，采用世界最先进的工业级的液晶面板，使用寿命长达6万小时。SLCD是一个完整的拼接显示单元，既能单独作为显示器使用，又可以拼接成超大屏幕使用。
分享血氧仪方案主控32位单片机MM32L0130
EVERSPIN的博客
02-23 225
家用指压血氧仪一般采用MCU，存储芯片、两个控制LED的数模转换器和两个发光二极管驱动器。
华大HC32L136开发板——按键控制笔段式段码LCD显示
阿昌
12-01 2830
华大HC32L136开发板——按键控制笔段式段码LCD显示HC32L136入门 HC32L136入门 华大HC32L136开发板准备工作: 国产超低功耗华大单片机HC32L136开发板上手入门. 笔段式段码LCD显示原理介绍: 华大单片机HC32L136笔段式段码LCD显示. ...
[MM32软件]解析SLCD例程设计思路，加速终端产品应用开发
ic2121的博客
02-07 123
支持多种占空比和偏压模式的配置，适用于更多类型的段码LCD；段码LCD显示时，不管是通过驱动芯片驱动段码LCD显示的，还是使用带有驱动段码LCD能力的MCU，在实际应用中都需要实现硬件原理图、段码LCD真值表、显示缓存这三者之间的对应关系，只有这些对应一致了，应用程序才能够随心所欲的显示需求内容，而这三者的对应关系一直是应用设计中一个很头疼的问题，有些时候可能会因为PCB布线的方便，使得连接段码LCD的COM/SEG顺序变得错乱，这样在找对应关系的时候，会更加的复杂！LCD_COMm这样的顺序编写。
灵动微低功耗单片机MM32L0136C6P替换STM32L053C8
EVERSPIN的博客
12-08 227
灵动微电子MM32L0136C6P内置段码式液晶驱动SLCD，可驱动8x36或4x40个段码，支持COM和SEG引脚重映射，占空比、偏压、帧率和对比度等灵活可调，内置电荷泵可实现在电压下降时依然保持液晶屏清晰。
灵动微电子MM32L0130系列MCU具有出色的低功耗表现
EVERSPIN的博客
08-17 181
灵动微低功耗MM32L0130系列MCU产品搭载ArmCortex-M0+处理器，集成段码LCD驱动，功耗可低至100nA，适用于多种低功耗应用场景。
MM32F031K8T6 ADC KEY USART 综合案例_key_USART_MM32F031K8T6_adc_Mm32f
10-04
本文将深入探讨基于MM32F031K8T6微控制器的ADC（模拟数字转换器）、KEY（按键）以及USART（通用同步/异步收发传输器）的综合应用案例。MM32F031K8T6是一款高性能、低成本的32位微控制器，广泛应用于嵌入式系统设计中...
MM32F5277E9P核心板原理图
05-26
6. SWD接口：MM32F5277E9P核心板原理图中，SWD接口用于与外部调试器进行连接，实现微控制器的调试和编程。 7. OSC系统：MM32F5277E9P核心板原理图中，OSC系统包括OSC32_IN和OSC32_OUT，用于提供微控制器的时钟信号...
MM32F0010 库函数和例程.rar
09-07
MM32F0010是一款基于ARM Cortex-M内核的微控制器，由兆易创新（Gigadevice）公司设计，广泛应用于嵌入式系统、物联网设备、智能家居等领域。这款微控制器以其高效能、低功耗和丰富的外设接口而受到开发者的青睐。在...
架构面试题
最新发布
weixin_41545189的博客
09-24 628
架构基础 如何理解架构的演进？ 架构的演进指的是随着技术、业务和需求的不断发展，架构在设计和实施上的变化和进化过程。这包括从单体应用向微服务架构的过渡、从传统的服务器部署向云原生架构的转变，以及在数据处理、安全性和性能优化等方面的不断改进。架构的演进是为了适应不断变化的业务需求和技术发展，提高系统的灵活性、可扩展性和可维护性。 如何理解架构的服务化趋势？ 架构的服务化趋势指的是将系统拆分为多个相对独立、可独立部署和扩展的服务。这种趋势使得系统更易于开发、部署和维护，同时也更好地适应了快速变化的业务需
《AI系统：原理与架构》于华为HC大会2024正式发布
m0_37046057的博客
09-22 1126
（ZOMI 酱, 苏统华编著. 北京 : 科学出版社, 2024. 9）主要围绕AI 系统的理论基础与技术基础知识展开，结合实例进行介绍，旨在让读者了解AI 系统的来龙去脉，形成对AI 系统的系统化与层次化的初步理解，掌握AI 系统基本理论、技术、实际应用及研究方向，为后续从事具体的学习研究工作和项目开发工作奠定基础。ZOMI因为低估了录制的正式程度，没带正装，发生了“赤诚相见”的热辣场面，此处省略一段话，最后就是他穿了我的衣服，我穿了他的衣服。目前，这些视频已经通过了教育部的验收，后续将在高校推广。
构建高可用和高防御力的云服务架构第二部分：SLB负载均衡（2/5）
小相探索IT世界
09-22 1401
负载均衡是一种计算机网络技术，用于将工作任务（例如传输流量或请求）均匀地分配到多个服务器或其他资源上。这种技术能够提升网络服务的响应速度、可用性和可靠性，同时降低单个服务器的负载压力。SLB（Server Load Balancer）是一种云服务提供商提供的负载均衡服务，它允许用户将流量分配到多个服务器上，以提高应用的可用性和扩展性。SLB通常作为软件服务在云环境中运行，它可以是公网或私网的，支持TCP/UDP和HTTP/HTTPS等协议。阿里云负载均衡（SLB）
LMAP 架构极简理解
weixin_52173250的博客
09-24 266
LMAP 架构是一种广泛使用的开源软件组合，用于构建 Web 应用服务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值