面向对象也可以搞单片机！

冷不防 2022-08-28 02:58 187阅读 0赞

**摘要**：在看别人单片机程序时，你也许是奔溃的，因为全局变量满天飞，不知道哪个在哪用了，哪个表示什么，而且编写极其不规范。自己写单片机程序时，也许你也是奔溃的。

总感觉重新开启一个项目，之前的写过相似的代码也无法使用，得重新敲，代码重用度不高，编程效率低下，代码无法积累。

而且感觉写这个代码没有思想，没有灵魂，没有框架，只是一个一个功能代码的堆砌，很空泛。

那么这个时候，你也许应该在单片机中引入面向对象的思想了，使代码更规范。

# 一、单片机程序框架 #

## 1、轮流执行 ##

int main (void)
    {
     while(1)
     {
      sing();
      dance();
      play();
     }
    }

函数`sing`执行的时间比较长的话，函数`dance`就不能很快的被执行。任何一个函数死掉的话就会影响整个系统。

## 2、前后台 ##

在使用 51、AVR、STM32 单片机裸机的时候一般都是在`main`函数里面用`while(1)`做一个大循环来完成所有的处理，即应用程序是一个无限的循环，循环中调用相应的函数完成所需的处理。

有时候我们也需要中断中完成一些处理。相对于多任务系统而言，这个就是单任务系统，也称作前后台系统，中断服务函数作为前台程序，大循环`while(1)`作为后台程序。

![994426a6595d029edf59cd051ded5611.png][]

对应的编程代码大概是这样的:

void EXTI_IRQHandler()
    {
        flag = 1;
    }
    int main (void)
    {
        while(1)
        {
            if (flag = 1)
            {
                do_something();
                flag = 0;
            }
        }
    }

有什么问题？

前后台系统的实时性差，前后台系统各个任务(应用程序)都是排队等着轮流执行，不管你这个程序现在有多紧急，没轮到你就只能等着！

相当于所有任务(应用程序)的优先级都是一样的。但是前后台系统简单啊，资源消耗也少啊！在稍微大一点的嵌入式应用中前后台系统就明显力不从心了。

## 3、多任务 ##

void first_task()
    {
        while (1)
        {
            if(has_data())
                put_data();
        }
    }
    void second_task()
    {
        while (1)
        {
            if(get_data())
                do_something();
        }
    }
    
    int main(void)
    {
        create_task(first_task);
        create_task(second_task);
        start_scheduler();
    }

多任务系统会把一个大问题“分而治之”，把大任务划分成很多个小问题，逐步的把小任务解决掉，大任务也就随之解决了，这些任务是并发处理的。

注意，并不是说同一时刻一起执行很多个任务，而是由于每个任务执行的时间很短，导致看起来像是同一时刻执行了很多个任务一样。

# 二、执行的程序怎么写？ #

以按键为例，点亮一个小灯！

![55bd3b70e061a7232987646e8b3f9238.png][]

## 1.常规写法 ##

int mian(void)
    {
        while (1)
        {
            if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_3) == GPIO_PIN_SET)
            {
                printf("按键按下\r\n");
            }
        }
    }

## 2.面向对象的写法 ##

首先我们把每一个按键都看成一个对象，既然是对象就肯定有属性和行为，比如我们定义一个学生，那么这个学生有什么属性呢？

肯定有姓名、年龄、身高、体重对吧，这些是一些基本的属性，我们可以用一些单独的变量来定义它，比如：

typedef struct
    {
     uint8_t  *name; //姓名(变量)
     uint8_t  age;   //年龄(变量)
      uint8_t  height;//身高(变量)
      uint8_t  weight;//体重(变量)
    } student_t;

但是一个学生还有很多行为对吧，它会唱歌、跳舞、打篮球、**也会关注果果小师弟的公众号对吧**，于是我们就可以这样定义：

typedef struct
    {
     uint8_t  *name;  //姓名(变量)
     uint8_t  age;    //年龄(变量)
      uint8_t  height; //身高(变量)
      uint8_t  weight; //体重(变量)
     void (*Sing_song)(void); //会唱歌(函数指针)
     void (*Dance_latin)(void); //会跳舞(函数指针)
      void (*Wechat_zhiguoxin)(void); //会关注果果的公众号(函数指针)
    } student_t;

好了，这里我们提到了函数指针，所以就来说一说函数指针。

函数指针，顾名思义它就是一个指针，只不过它是一个函数指针，所以指向的是一个函数。类比一般的变量指针，指针变量，实质上是一个变量，只不过这个变量存放的是一个地址，在32位单片机中，任何类型的指针变量都存放的是一个大小为4字节的地址。

**重要的话说三遍！牢记在心**！！！

为什要记住函数指针，因为在单片机面向对象编程中，结构体的成员不是变量就是函数指针这两种类型。变量就不用说了，函数指针理解就好。

其实函数指针可以类比一般的变量，看下面：

int   a; < = > void Sing_song(void);
    int * p; < = > void (*zhiguoxin)(void);
    p=&a;   < = > zhiguoxin = &Sing_song;

1.  左边走义变量`a`，右边定义函数`Sing_song`;
2.  左边定义`int`指针，右边定义函数指针;
3.  左边赋值指针，右边赋值函数指针;

那么函数指针怎么用呢？我们还是以单片机为例，把按键类比为一个对象，这个按键有按键标志位，有长按或者短按，按键还有行为：按键初始化、按键循环检测等。

所以我们创建下面这样一个结构体，当然这个结构体不一定仅仅有这些变量和函数，这完全取决于你自己的定义，你想怎么定义就怎么定义，你甚至可以定义按键的颜色都。

typedef struct
    {
     uint8_t  KEY_Flag;  //标志位(变量)
     uint8_t  Click;//按下(变量)
     void (*KEY_Init)(void); //按键初始化(函数指针)
     void (*KEY_Detect)(void); //按键检测(函数指针)
    } KEY_t;

现在已经定义了`KEY_t`这种类型的结构体，处理器还没有分配给这个结构体内存，因为我们只是声明这样一个类型，而类型是不占用内存的，**只有我们定义对应的结构体类型的变量时才会在占用内存空间**。

那么怎么定义一个结构体类型的变量呢？

KEY_t   KEY1;

然后就要初始化结构体的成员变量了。

KEY_t  KEY1 = {0,0,KEY_init,KEY_detect};

这里要注意了现在结构体有四个成员，前两个普通的变量，我们初始化为0，还有两个函数指针，我们是不是要把我们想写得函数的函数名字放在这里啊。

那么聪明的你肯定知道还要定义`KEY_init();`和`KEY_detect();`这两个函数。这两个函数可以这样写。

static void KEY_init()
    {
      GPIO_InitTypeDef GPIO_InitStruct;
      GPIO_InitStruct.Pin = GPIO_PIN_3;
      GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }
    static void KEY_detect() 
    {
     uint8_t i = 0; 
     if(KEY1.KEY_Flag == 1)
     {
      HAL_Delay(100);
      if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_3) == GPIO_PIN_SET)
      {
        printf("按键按下\r\n");
      }
      KEY1.KEY_Flag = 0;
     }
    }

好了具体函数中的代码我就不需要解释了。这样一个按键的对象我们就定义好了，**这个按键我们赋予了"他"生命，有属性(变量)有行为(函数)**。

这样我们在主函数就可以这样的调用，来实现相应的功能了。按键使用了中断，这里并没有讲解。

void main(void)
    {
      KEY1.KEY_Init();//初始化按键
      while(1) 
       {  
      KEY1.KEY_Detect();//按键检测
     }
    }

如果理解了这些，那么面向对象的精髓你基本已经掌握了，接下来就是不断地去练习和实践了。

# 三、为什么要面向对象？ #

我们知道，**现有的编程范式主要是：面向过程编程、面向对象编程、函数式编程。**

对于流程清晰的简单程序，一般只有一条流程主线，很容易被划分成顺序执行的几个步骤，面向对象编程和面向过程编程没有太大差别，并且面向过程编程常常比面向对象编程更加直观高效。

但当我们面对一个大型的复杂程序，由于其错综复杂的流程和交互关系，很难将其简单地拆分成一条主线串成的简单步骤，而通常表现为一个网状关系结构。

这个时候，面向过程编程的这种流程化和线性化的思维方式就会显得比较吃力，而面向对象编程的优势就比较明显了。

面向对象编程风格的代码更容易复用、扩展和维护、更高级、更人性化、更适合大规模复杂程序的开发。在Linux中就是用的面向对象编程，里面有很多的结构体、指针、链表等等。如果还没有接触到面向对象编程只能说明你做的东西还不够复杂。

在单片机举一个例子，一块开发板可能会适配不同的屏幕:

![4d05cf81061065830fe38f6630ea5fef.png][] 一块板子，三个屏幕

那么每一块板子肯定有不同的代码适配，在程序中我们可以读出屏幕的ID，然后通过`if`判断来执行不同的指令，就行这样。

![db58c11acf40c083315000bacb87ac9b.png][] 果果小师弟

如果使用面向对象编程，那么就可以这样写代码。

typedef struct lcd{
     uint8_t type;
     void (*LCD_Init)(void)
    }lcd_t, *plcd_t;
    
    int Read_id()
    {
     /* 0: LCDA
      * 1: LCDB
      */
     return 0; 
    }
    
    int Get_Lcd_Type(void)
    {
     return Read_id();
    }
    
    void LCDA_Init(void)//屏幕A初始化
    {
        LCD_WR_REG(0xCF);  
        LCD_WR_DATA(0x00); 
        LCD_WR_DATA(0xC1); 
        LCD_WR_DATA(0X30); 
    }
    
    void LCDB_Init(void)//屏幕B初始化
    {
        LCD_WR_REG(0X11);
        delay_ms(20);
        LCD_WR_REG(0XD0);
        LCD_WR_DATA(0X07); 
    }
    
    lcd_t openedv_com_lcds[] = {
     {0, LCDA_Init},
     {1, LCDB_Init},
    };
    
    plcd_t get_lcd(void)//获取到屏幕类型
    {
     int type = Get_Lcd_Type();
     return &openedv_com_lcds[type];
    }
    
    int main(void )
    {
     plcd_t lcd; 
     lcd = get_lcd();//获取到屏幕类型
     lcd-> LCD_Init();//初始化对应屏幕
     while (1)
      {} 
    }

这里只是伪代码处理办法，原理就和上面所讲的一样，在结构体中使用变量和函数。

到这里你应该掌握了面向对象得单片机编程方法，一起来试验几个例子：

## LED灯 ##

typedef struct
    { 
     void (*LED_ON)(uint8_t LED_Num);     //打开
     void (*LED_OFF)(uint8_t LED_Num);    //关闭
     void (*LED_Flip)(uint8_t LED_Num);   //翻转
    } LED_t;

## 按键KEY ##

typedef struct
    {
     uint8_t  KEY_Flag;        //标志位(变量)
     uint8_t  Click;           //按下(变量)
     void (*KEY_Init)(void);   //按键初始化(函数指针)
     void (*KEY_Detect)(void); //按键检测(函数指针)
    } KEY_t;

## 蜂鸣器BEEP ##

typedef struct
    {
     uint8_t Status;      //状态
     void (*ON)(void);     //打开
     void (*OFF)(void);    //关闭
    } BEEP_t;

## 串口UART ##

typedef struct
    {
     USART_TypeDef *uart;/* STM32内部串口设备指针 */
     uint8_t *pTxBuf;   /* 发送缓冲区 */
     uint8_t *pRxBuf;   /* 接收缓冲区 */
     
     uint16_t usTxBufSize;  /* 发送缓冲区大小 */
     uint16_t usRxBufSize;  /* 接收缓冲区大小 */
     
      uint16_t usTxWrite; /* 发送缓冲区写指针 */
      uint16_t usTxRead;  /* 发送缓冲区读指针 */
      uint16_t usTxCount; /* 等待发送的数据个数 */
    
      uint16_t usRxWrite; /* 接收缓冲区写指针 */
      uint16_t usRxRead;  /* 接收缓冲区读指针 */
      uint16_t usRxCount; /* 还未读取的新数据个数 */
      
      void (*RS485_Set_SendMode)(void);  //RS-485接口设置为发送模式
      void (*RS485_Set_RecMode)(void);   //RS-485接口设置为接收模式
    }UART_T;

![71288c490b5d6994eb38b6533152a768.png][] 面向对象的单片机编程

--------------------

**往期推荐：点击图片即可跳转阅** **-END-**

我是张巧龙，一名教电子的大学老师，欢迎关注！

[994426a6595d029edf59cd051ded5611.png]: /images/20220828/322cbf1c993d4fc9ba387e1fad8fafdd.png
[55bd3b70e061a7232987646e8b3f9238.png]: /images/20220828/bdf57ffd14eb491e831ab1f7f3eb8892.png
[4d05cf81061065830fe38f6630ea5fef.png]: /images/20220828/c724dac727e34bcfbdfe3b2c37a73712.png
[db58c11acf40c083315000bacb87ac9b.png]: /images/20220828/6322088fba00424e83ee3940c3e5273b.png
[71288c490b5d6994eb38b6533152a768.png]: /images/20220828/172963aae0524a77be9eef4dc83dee29.png