STM32F103学习笔记（6）——CAN通信（上）—— 波特率配置

男娘i 2023-01-01 04:57 513阅读 0赞

# 1.前言 #

为嘛要写上篇，因为今天是2020年最后一天了，晚上部门聚餐，都没机会加班了，想在写完本篇博客再学下数据结构。因此本章纯属入门内容，让读者看完之后能把CAN给通起来

因为我在学习过程中也查了很多资料，基本都是这里截个图，那里抄一点，有人把原子的教程搬上来拿到几百个收藏，然而这些教程都是可能给了某个型号单片机的代码，而没有通用型的文章，并且各种寄存器让人望而生畏，我在跑通几个板子时候特别难受，特此写下本文。

# 2.CAN简介 #

CAN的作用，大多依赖于他的优点，一个总线控制多个设备、速度快等，适用于汽车控制系统。其他资料网上已经有很多了，本节不再赘述。

# 3.预期结果 #

本次实验目的是让一个板子发送信息，另外两个板子可以接收信息。

发送方为：C8T6（中容量，后面简称小板）

接收方为：C8T6、ZET6（高容量，后面简称大板）

发送方小板发送8个字节数据，初始化8个字节的canbuffer整型数组，每次发送时候都把canbuffer\[0\]加1，这样能发送动态数据，像原子的can例程里面8个都变化，需要一个for循环，这里从简操作，改变一个数就可以了。

接收方，大板因为有屏幕，让接收的数字直接显示在屏幕上就可以了。小板通过DeBug调试查看接收缓存。

# 4.三个板子连接 #

我最初拿到小板发现他的can口有三个排针，以为需要接地，后来看到can相关文档发现只需要CANH、CANL连接就可以了。

CANH、CANL并接就可以了，不需要其他线，原理如下

![20201231160852983.png][]

最开始总是通信不成功，一直以为是接地什么的原因，后来两个小板通信成功直接把接地线剪掉发现没影响哈哈。

连接如下图（黄色线CANH、红色线CANL）：

![两个小板连线][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70] 两个小板连线（中间黑线已断开）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 1][] 大板（精英板子）连线

# 5.CAN初始化 #

查看中容量和大容量发现他们的can通信的GPIO口都是PA11、PA12，并且没有重映射，因此在初始化配置时候用一样的配置就可以了，就是直接把can.c和can.h直接复制过去。（所谓通用）

如下所示代码

u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
    {
        GPIO_InitTypeDef GPIO_InitStructure;
        CAN_InitTypeDef        CAN_InitStructure;
        CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能PORTA时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);//使能CAN1时钟
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽
        GPIO_Init(GPIOA, &GPIO_InitStructure);		//初始化IO
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//上拉输入
        GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化IO
    
        //CAN单元设置
        CAN_InitStructure.CAN_TTCM=DISABLE;						 //非时间触发通信模式  //
        CAN_InitStructure.CAN_ABOM=DISABLE;						 //软件自动离线管理	 //
        CAN_InitStructure.CAN_AWUM=DISABLE;						 //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)//
        CAN_InitStructure.CAN_NART=ENABLE;						 	//禁止报文自动传送 //
        CAN_InitStructure.CAN_RFLM=DISABLE;						 //报文不锁定,新的覆盖旧的 //
        CAN_InitStructure.CAN_TXFP=DISABLE;						 //优先级由报文标识符决定 //
        CAN_InitStructure.CAN_Mode= mode;	         //模式设置： mode:0,普通模式;1,回环模式; //
        //设置波特率
        CAN_InitStructure.CAN_SJW=tsjw;				//重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位  CAN_SJW_1tq	 CAN_SJW_2tq CAN_SJW_3tq CAN_SJW_4tq
        CAN_InitStructure.CAN_BS1=tbs1; //Tbs1=tbs1+1个时间单位CAN_BS1_1tq ~CAN_BS1_16tq
        CAN_InitStructure.CAN_BS2=tbs2;//Tbs2=tbs2+1个时间单位CAN_BS2_1tq ~	CAN_BS2_8tq
        CAN_InitStructure.CAN_Prescaler=brp;            //分频系数(Fdiv)为brp+1	//
        CAN_Init(CAN1, &CAN_InitStructure);            // 初始化CAN1
    
        CAN_FilterInitStructure.CAN_FilterNumber=0;	  //过滤器0
        CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
        CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //32位
        CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;32位ID
        CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
        CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
        CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
        CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
        CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //激活过滤器0
    
        CAN_FilterInit(&CAN_FilterInitStructure);//滤波器初始化
    
        return 0;
    }

本节初始化只讲波特率相关，过滤器和CAN单元设置后面再来看看。

实际上只要波特率相同，can两边都有个120Ω的电阻就可以通信了，过滤器什么的是为了让通信更有效率。要不然其实可以在总线上接收方一直接收，发送方一直发送，这样的话can会接收所有的信息，这所有的信息最后还是要cpu来处理，会增加cpu的负担，占用CPU资源，can也就没有起多大作用了。

关于波特率，在原子的教程里面有个公式，我今天在这个波特率设置上卡了好一会儿。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 2][]

这里给一个查看系统波特率的方法

RCC_ClocksTypeDef get_rcc_clock;   //这行设置为全局变量
    RCC_GetClocksFreq(&get_rcc_clock); //这行放在main函数初始化里面

调试时候就可以得到时钟频率了

![20201231173056343.png][]![20201231173046212.png][]

从上图我们可以看到c8t6的CAN接口频率PCLK1为8M，zet6的CAN接口时钟频率为36M

根据上面的公式我们计算波特率让两个板子的CAN口波特率相等

36/(1+4+5)/9=8/(1+4+5)/2

CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_4tq,CAN_BS1_5tq,9,0);//大板
    CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_4tq,CAN_BS1_5tq,2,0);//小板

如上面代码，把两个板子波特率设置相同就可以通信了。不过要注意这里好像不能设置为（1,1,1,9,0）这种，就是前面三个都不能是1，具体的我还不清楚，这里只说下成功经验，后续的在CAN通信下篇讲解。

本小节，主要是对CAN进行初始化，STM32F103系列可以直接用上面的代码，不同容量的芯片只要改一下波特率就可以了。至于其他的过滤器、邮箱报文什么的暂时不用管，我们要先跑通才能继续进行详细设置，

# 6.发送相关 #

发送主要是调用这一行代码，第一个参数是选哪个CAN口，有的芯片有两个CAN口，我们这里直接用CAN1就可以了，至于具体怎么发，我们后面再看。

CAN_Transmit(CAN1, &TxMessage)

代码如下，这个代码也是通用的，我的三个板子都可以用，不需要修改什么

u8 Can_Send_Msg(u8* msg,u8 len)
    {
    
        u16 i=0;
        u8 mbox;
        CanTxMsg TxMessage;
        TxMessage.StdId=0x13;			// 标准标识符
        TxMessage.ExtId=0x12;			// 设置扩展标示符
        TxMessage.IDE=CAN_Id_Standard; // 标准帧
        TxMessage.RTR=CAN_RTR_Data;		 // 数据帧
        TxMessage.DLC=len;						// 要发送的数据长度
        for(i=0; i<len; i++)
            TxMessage.Data[i]=msg[i];
        mbox= CAN_Transmit(CAN1, &TxMessage);
        i=0;
        while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
            i++;	//等待发送结束
        if(i>=0XFFF)
            return 1;
        return 0;
    }

上面代码里面的变量 i 主要是用来发送给TxMessage.Data\[i\]赋值用的

通过CAN\_TransmitStatus(CAN1, mbox)==CAN\_TxStatus\_Failed来查看是否发送成功，查看库文件发现CAN发送状态有这几个，如果是Failed应该是还没发完，如果是OK应该就是发完了，具体的后面再看吧。

![20201231175720388.png][]

CanTxMsg是在固件库里面定义好的，我们直接拿来用就可以了，因此他一帧确实只能传输8个字节的信息，如果要传64个字节，分8次传输就可以了。至于后面的标识符ID怎么设置下节再来讨论。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 3][]

# 7.接收相关 #

代码如下

CanRxMsg RxMessage;
    u8 Can_Receive_Msg(u8 *buf)
    {
        u32 i;
        
        if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;		//没有接收到数据,直接退出
        CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);//读取数据
        for(i=0; i<8; i++)
            buf[i]=RxMessage.Data[i];
        return RxMessage.DLC;
    }

对了，上面的全局变量主要是用在接收方小板DeBug查看数据的

从下图可以看出，他的接收应该是硬件自动接收，总线上数据对了，标识符ID对了就直接存在接收邮箱里面，然后我们通过下面这个Pending判断有邮件过来就直接取出来

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 5][]

# 8.代码逻辑 #

小板发送芯片：can初始化之后，在main函数的while里面一直发送数据

小板接收芯片：can初始化之后，在main函数的while里面调用上面的接收函数，然后存在一个接收数组里面，这个接收数组设置为全局变量，方便DeBug查看数组里面的内容。

大板接收芯片：can初始化后，在main函数的while里面一直调用接收函数，如果有收到数据就显示在屏幕上面。

# 9.效果如下 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 7][]

上图屏幕上面有些显示数据没有更改，只用看接收效果就可以了。

# 10.大板代码 #

屏幕相关代码本次就不发了，有需要的同学可以留言。

代码里面有些注释因为代码改了注释忘了改大家将就着看哈。。

大板main.c

#include "led.h"
    #include "delay.h"
    #include "key.h"
    #include "sys.h"
    #include "lcd.h"
    #include "usart.h"
    #include "can.h"
    
    
    RCC_ClocksTypeDef get_rcc_clock;   //这行设置为全局变量
    
    u8 canbuf1[8];
    int main(void)
    {
        u8 key;
        u8 i=0,t=0;
        u8 cnt=0;
        u8 canbuf[8];
        u8 res;
        u8 mode=CAN_Mode_LoopBack;//CAN工作模式;CAN_Mode_Normal(0)：普通模式，CAN_Mode_LoopBack(1)：环回模式
    
    	RCC_GetClocksFreq(&get_rcc_clock); //这行放在main函数初始化里面，别放在while(1)里面
    	
        delay_init();	    	 //延时函数初始化
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
        uart_init(115200);	 	//串口初始化为115200
        LED_Init();		  		//初始化与LED连接的硬件接口
        LCD_Init();			   	//初始化LCD
        KEY_Init();				//按键初始化
    
        CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_4tq,CAN_BS1_5tq,9,0);
    
        POINT_COLOR=RED;//设置字体为红色
        LCD_ShowString(60,50,200,16,16,"DaJiaHao,WoShiCaiJi");
        LCD_ShowString(60,70,200,16,16,"OOCSDN");
        LCD_ShowString(60,90,200,16,16,"liu_endong@Copy");
        LCD_ShowString(60,110,200,16,16,"2020/12/21");
        LCD_ShowString(60,130,200,16,16,"LoopBack Mode");
        LCD_ShowString(60,150,200,16,16,"KEY0:Send WK_UP:Mode");//显示提示信息
        POINT_COLOR=BLUE;//设置字体为蓝色
        LCD_ShowString(60,170,200,16,16,"Count:");			//显示当前计数值
        LCD_ShowString(60,190,200,16,16,"Send Data:");		//提示发送的数据
        LCD_ShowString(60,250,200,16,16,"Receive Data:");	//提示接收到的数据
        while(1)
        {
            key=KEY_Scan(0);
    //        if(key==KEY0_PRES)//KEY0按下,发送一次数据
    		if(0)
            {
                for(i=0; i<8; i++)
                {
                    canbuf[i]=cnt+i;//填充发送缓冲区
                    if(i<4)LCD_ShowxNum(60+i*32,210,canbuf[i],3,16,0X80);	//显示数据
                    else LCD_ShowxNum(60+(i-4)*32,230,canbuf[i],3,16,0X80);	//显示数据
                }
                res=Can_Send_Msg(canbuf,8);//发送8个字节
                if(res)LCD_ShowString(60+80,190,200,16,16,"Failed");		//提示发送失败
                else LCD_ShowString(60+80,190,200,16,16,"OK    ");	 		//提示发送成功
            }
            else if(key==WKUP_PRES)//WK_UP按下，改变CAN的工作模式
            {
                mode=!mode;
                CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,mode);//CAN普通模式初始化, 波特率500Kbps
                POINT_COLOR=RED;//设置字体为红色
                if(mode==0)//普通模式，需要2个开发板
                {
                    LCD_ShowString(60,130,200,16,16,"Nnormal Mode ");
                } else //回环模式,一个开发板就可以测试了.
                {
                    LCD_ShowString(60,130,200,16,16,"LoopBack Mode");
                }
                POINT_COLOR=BLUE;//设置字体为蓝色
            }
            key=Can_Receive_Msg(canbuf1);
            if(key)//接收到有数据
            {
                LCD_Fill(60,270,130,310,WHITE);//清除之前的显示
                for(i=0; i<key; i++)
                {
                    if(i<4)LCD_ShowxNum(60+i*32,270,canbuf1[i],3,16,0X80);	//显示数据
                    else LCD_ShowxNum(60+(i-4)*32,290,canbuf1[i],3,16,0X80);	//显示数据
                }
            }
            t++;
            delay_ms(1000);
            if(1)
            {
                LED0=!LED0;//提示系统正在运行
                t=0;
                cnt++;
                LCD_ShowxNum(60+48,170,cnt,3,16,0X80);	//显示数据
            }
        }
    }

大板can.c

#include "can.h"
    #include "led.h"
    #include "delay.h"
    #include "usart.h"
    
    u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
    {
        GPIO_InitTypeDef GPIO_InitStructure;
        CAN_InitTypeDef        CAN_InitStructure;
        CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能PORTA时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);//使能CAN1时钟
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽
        GPIO_Init(GPIOA, &GPIO_InitStructure);		//初始化IO
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//上拉输入
        GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化IO
    
        //CAN单元设置
        CAN_InitStructure.CAN_TTCM=DISABLE;						 //非时间触发通信模式  //
        CAN_InitStructure.CAN_ABOM=DISABLE;						 //软件自动离线管理	 //
        CAN_InitStructure.CAN_AWUM=DISABLE;						 //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)//
        CAN_InitStructure.CAN_NART=ENABLE;						 	//禁止报文自动传送 //
        CAN_InitStructure.CAN_RFLM=DISABLE;						 //报文不锁定,新的覆盖旧的 //
        CAN_InitStructure.CAN_TXFP=DISABLE;						 //优先级由报文标识符决定 //
        CAN_InitStructure.CAN_Mode= mode;	         //模式设置： mode:0,普通模式;1,回环模式; //
        //设置波特率
        CAN_InitStructure.CAN_SJW=tsjw;				//重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位  CAN_SJW_1tq	 CAN_SJW_2tq CAN_SJW_3tq CAN_SJW_4tq
        CAN_InitStructure.CAN_BS1=tbs1; //Tbs1=tbs1+1个时间单位CAN_BS1_1tq ~CAN_BS1_16tq
        CAN_InitStructure.CAN_BS2=tbs2;//Tbs2=tbs2+1个时间单位CAN_BS2_1tq ~	CAN_BS2_8tq
        CAN_InitStructure.CAN_Prescaler=brp;            //分频系数(Fdiv)为brp+1	//
        CAN_Init(CAN1, &CAN_InitStructure);            // 初始化CAN1
    
        CAN_FilterInitStructure.CAN_FilterNumber=0;	  //过滤器0
        CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
        CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //32位
        CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;32位ID
        CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
        CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
        CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
        CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
        CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //激活过滤器0
    
        CAN_FilterInit(&CAN_FilterInitStructure);//滤波器初始化
    
        return 0;
    }
    
    //can发送一组数据(固定格式:ID为0X12,标准帧,数据帧)
    //len:数据长度(最大为8)
    //msg:数据指针,最大为8个字节.
    //返回值:0,成功;
    //其他,失败;
    u8 Can_Send_Msg(u8* msg,u8 len)
    {
        u8 mbox;
        u16 i=0;
        CanTxMsg TxMessage;
        TxMessage.StdId=0x12;			// 标准标识符
        TxMessage.ExtId=0x12;			// 设置扩展标示符
        TxMessage.IDE=CAN_Id_Standard; // 标准帧
        TxMessage.RTR=CAN_RTR_Data;		 // 数据帧
        TxMessage.DLC=len;						// 要发送的数据长度
        for(i=0; i<len; i++)
            TxMessage.Data[i]=msg[i];
        mbox= CAN_Transmit(CAN1, &TxMessage);
        i=0;
        while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
            i++;	//等待发送结束
        if(i>=0XFFF)
            return 1;
        return 0;
    }
    
    //can口接收数据查询
    //buf:数据缓存区;
    //返回值:0,无数据被收到;
    //其他,接收的数据长度;
    CanRxMsg RxMessage;
    u8 Can_Receive_Msg(u8 *buf)
    {
        u32 i;
        
        if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;		//没有接收到数据,直接退出
        CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);//读取数据
        for(i=0; i<8; i++)
            buf[i]=RxMessage.Data[i];
        return RxMessage.DLC;
    }

大板can.h

#ifndef __CAN_H
    #define __CAN_H	 
    #include "sys.h"	    
    
    #define CAN_RX0_INT_ENABLE	0		//0,不使能;1,使能.								    
    										 							 				    
    u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode);//CAN初始化
     
    u8 Can_Send_Msg(u8* msg,u8 len);						//发送数据
    
    u8 Can_Receive_Msg(u8 *buf);							//接收数据
    #endif

# 11.小板代码 #

can的代码是直接复制上面的文件

只有main函数有点区别

#include "stm32f10x.h"
    #include "delay.h"
    #include "led.h"
    #include "pwm.h"
    #include "usart.h"
    #include "timer.h"
    #include "can.h"
    
    u8 res;
    RCC_ClocksTypeDef get_rcc_clock;
    u8 canbuf1[8]= {0};
    int main(void)
    {
    //	SystemInit();
        u8 a=0;
        u8 canbuf[8]= {a,1,2,3,4,5,6,7};
        RCC_GetClocksFreq(&get_rcc_clock);
    	
        delay_init();
        ledInit();
        uart_init(115200);
        TIM2_Int_Init(7199,999);
        TIM3_CH2_PWM_Init(899,0);
        CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_4tq,CAN_BS1_5tq,2,0);
        while(1)
        {
    		canbuf[0]=a;
    		a++;
    		if(a==100)
    			a=0;
    		
            if(1)
            {
                Can_Receive_Msg(canbuf1);
    			Can_Send_Msg(canbuf,8);//发送8个字节	
            }
            delay_ms(40);
            LED0=~LED0;
        }
    }

以上。

大家新年快乐！

[20201231160852983.png]: /images/20221120/4aee96008a9440f3a36f36edfb38ca59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020123116025698.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201231160508665.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201231161841708.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[20201231173056343.png]: https://img-blog.csdnimg.cn/20201231173056343.png
[20201231173046212.png]: https://img-blog.csdnimg.cn/20201231173046212.png
[20201231175720388.png]: https://img-blog.csdnimg.cn/20201231175720388.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201231174827735.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201231180506797.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201231180723417.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20201231181357200.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20201231181557246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Njk3OTc4,size_16,color_FFFFFF,t_70