AI8051U教学视频课后小练 | 高质量打卡

乐***

香河英*** 发表于 2025-2-28 10:52
不是听课15集后可以申请实验箱吗？

不是听课15集后可以申请实验箱，是发表学习心得 七集 以上，赠送 Ai8051U实验箱。

乐***

第17集  串口简单应用  课后小练

这次的视频没加声音😊


程序只要在冲哥的DEMO  Usart2_RunTask中加一段即可

void Usart2_RunTask(void)
{
        if( Rec_Num >= 6 )                //是否接收到了6位以上的数据
        {
                if(( Rec_Dat[Rec_Num-1] == '\n' ) && ( Rec_Dat[Rec_Num-2] == '\r' ) )        //末尾判断
                {
                        if( ( Rec_Dat[Rec_Num-6] == 'O' ) && ( Rec_Dat[Rec_Num-5] == 'P' ) && ( Rec_Dat[Rec_Num-4] == 'E' ) && ( Rec_Dat[Rec_Num-3] == 'N' )  )
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                Uart2_SendStr( "打开成功！\r\n" );
                        }
                        else if( ( Rec_Dat[Rec_Num-7] == 'C' ) && ( Rec_Dat[Rec_Num-6] == 'L' ) && ( Rec_Dat[Rec_Num-5] == 'O' ) && ( Rec_Dat[Rec_Num-4] == 'S' ) && ( Rec_Dat[Rec_Num-3] == 'E' )  )
                        {
                                passward[0] = 17;
                                passward[1] = 17;
                                passward[2] = 17;
                                passward[3] = 17;
                                Uart2_SendStr( "关闭成功！\r\n" );
                        }
                        else if( ( Rec_Dat[Rec_Num-9] == 'D' ) && ( Rec_Dat[Rec_Num-8] == 'A' ) &&( Rec_Dat[Rec_Num-7] == 'T' ) && ( Rec_Dat[Rec_Num-6] == '+' ) && ( Rec_Dat[Rec_Num-5] == '1' ) && ( Rec_Dat[Rec_Num-4] == '2' ) && ( Rec_Dat[Rec_Num-3] == '3' )  )
                        {
                                passward[0] = 17;
                                passward[1] = 1;
                                passward[2] = 2;
                                passward[3] = 3;
                                Uart2_SendStr( "123\r\n" );
                        }
                        Rec_Num = 0;
                }
        }
}
复制代码

如果字符比较长，采用与的方式比较两组字符串看起来比较冗长，可以采用字符串比较函数memcmp()来简化，需要包含"string.h"头文件。

#include "string.h"
char *S1 = "OPEN\r\n";
char *S2 = "CLOSE\r\n";
char *S3 = "DAT+123\r\n";
void Usart2_RunTask(void)
{
        if( Rec_Num >= 6 )                //是否接收到了6位以上的数据
        {
                if(( Rec_Dat[Rec_Num-1] == '\n' ) && ( Rec_Dat[Rec_Num-2] == '\r' ) )        //末尾判断
                {
                        if(!memcmp(Rec_Dat,S1,6))
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                Uart2_SendStr( "打开成功！\r\n" );
                        }
                        else if(!memcmp(Rec_Dat,S2,7))
                        {
                                passward[0] = 17;
                                passward[1] = 17;
                                passward[2] = 17;
                                passward[3] = 17;
                                Uart2_SendStr( "关闭成功！\r\n" );
                        }
                        else if(!memcmp(Rec_Dat,S3,9))
                        {
                                passward[0] = 17;
                                passward[1] = 1;
                                passward[2] = 2;
                                passward[3] = 3;
                                Uart2_SendStr( "123\r\n" );
                        }
                        Rec_Num = 0;
                }
        }
}
复制代码

demo.zip (208.91 KB, 下载次数: 92)

2025-3-1 11:10 上传

点击文件名下载附件

乐***

对单片机的modbus RTU的详细解释(转载)
Modbus 一个工业上常用的通讯协议、一种通讯约定。Modbus协议包括RTU、ASCII、TCP。其中MODBUS-RTU最常用，比较简单，在单片机上很容易实现。虽然RTU比较简单，但是看协议资料、手册说得太专业了，起初很多内容都很难理解。
    所谓的协议是什么？就是互相之间的约定嘛，如果不让别人知道那就是暗号。现在就来定义一个新的最简单协议。例如，

协议： “A” --“LED灭”
           “B” --“报警”
           “C” --“LED亮”
单片机接收到“A”控制一个LED灭，单片机接收到“B”控制报警，单片机接收到“C”控制一个LED亮。那么当收到对应的信息就执行相应的动作，这就是协议，很简单吧。

  先来简单分析一条MODBUS-RTU报文，例如：01  06  00 01  00 17  98 04
    01                06                 00 01                00 17          98 04
  从机地址        功能号          数据地址          数据            CRC校验

这一串数据的意思是：把数据 0x0017(十进制23) 写入 1号从机地址 0x0001数据地址。

先弄明白下面的东西。

1、报文
   一个报文就是一帧数据，一个数据帧就一个报文： 指的是一串完整的指令数据，就像上面的一串数据。

2、CRC校验
意义：例如上面的  98 04  是它前面的数据（01 06 00 01 00 17）通过一算法（见附录2，很简单的）计算出来的结果，其实就像是计算累加和那样。（累加和：就是010600010017加起来的值，然后它的算法就是加法）。
作用：在数据传输过程中可能数据会发生错误，CRC检验检测接收的数据是否正确。比如主机发出01 06 00 01 00 17 98 04，那么从机接收到后要根据01 06 00 01 00 17 再计算CRC校验值，从机判断自己计算出来的CRC校验是否与接收的CRC校验（98 04主机计算的）相等，如果不相等那么说明数据传输有错误这些数据不能要。

3、功能号
  意义：modbus 定义。见附录1。
  作用：指示具体的操作。

MODBUS-RTU
一、一个报文分析
先声明下我们的目的，我们是要两个设备通讯，用的是MODBUS协议。上面简单介绍了：“报文”“CRC校验”“功能号”。

在单片机中拿出一部分内存（RAM）进行两个设备通讯，例如：

数组后面的注释，说明
OX[20]   代表是输出线圈，用功能码 0x01，0x05，0x0F 访问， 开头地址是 0 （这个后续说明）
IX[20]    代表是输入线圈，用功能码 0x02 访问，             开头地址是 1 （这个后续说明）
另外两个一样的道理。
注意：所谓的“线圈”“寄存器”就是“位变量”“16位变量”，不要被迷惑。之所以称“线圈”我觉得应该是对于应用的设备，MODBUS协议是专门针对485总线设备（例PLC）开发的。

1、主机对从机写数据操作
如果单片机接收到一个报文那么就对报文进行解析执行相应的处理，如上面报文：
    01             06            00 01           00 17          98 04
  从机地址        功能号          数据地址          数据         CRC校验

假如本机地址是 1 ，那么单片机接收到这串数据根据数据计算CRC校验判断数据是否正确，如果判断数据无误，则结果是：
            HoldDataReg[1]  =  0x0017;
MODBUS主机就完成了一次对从机数据的写操作，实现了通讯。

2、主机对从机读数据操作
主机进行读HoldDataReg[1] 操作，则报文是：
    01               03                 00 01           00 01                    D5 CA
从机地址        功能号          数据地址      读取数据个数       CRC校验
那么单片机接收到这串数据根据数据计算CRC校验判断数据是否正确，如果判断数据无误，则结果是：返回信息给主机，返回的信息也是有格式的：
返回内容：  
    01            03            02                     0017                 F8 4A
  从机地址   功能号     数据字节个数    两个字节数据    CRC校验
MODBUS主机就完成了一次对从机数据的读操作，实现了通讯。

乐***

二、MODBUS报文模型
以上了解到了MODBUS的一帧报文是如何通讯的，其实每个报文的格式都基本一样的。

这里两个缩略词以前不知道，但是现在要明白指的是什么，“ADU”“PDU”
ADU： 应用数据单元
PDU： 协议数据单元

三、MODBUS数据模型


四、MODBUS事务处理
  下列状态图描述了在服务器侧MODBUS事务处理的一般处理过程。

五、MODBUS请求与响应
  看MODBUS协议手册，中文第 10 页开始，英文第 24 页开始。
手册非常详细举例说明了MODBUS协议各个功能号的请求与响应。

乐***

               modbus协议在单片机上实现过程

MODBUS 任务处理函数

函数中，RcvBuf 为串口接收缓冲区，如果接收了一个报文则，RcvBuf[0] 为从机地址，RcvBuf[1] 为MODBUS功能号。根据功能号做出响应，而具体的操作根据功能号在各自的函数中执行，相当于解析接收到的数据。

附录1：MODBUS-RTU功能码
最常用功能码：
下面“线圈”“寄存器”其实分别直的就是“位变量”“16位变量”
        01 (0x01)        读线圈
        02 (0x02)        读离散量输入
        03 (0x03)        读保持寄存器
        04(0x04)         读输入寄存器
        05 (0x05)        写单个线圈
        06 (0x06)        写单个寄存器
        15 (0x0F)        写多个线圈
        16 (0x10)        写多个寄存器

附录2：CRC Generation

转载于:https://www.cnblogs.com/skl374199080/p/3411830.html

乐***

第18集  串口高级应用  课后小练
本人愚钝，MODBUS-RTU 花了整整一个星期的时间才初步完成了此集课后小练，而且还是照搬了梁工的示例程序。
8H/8G/8C/8A系列4组串口同时通信的程序，Modbus 演示程序；可共享T2做波特率发生器 - 串行口，DMA支持的4组串口，RS232，RS485，Modbus, CRC16 国芯技术交流网站 - AI32位8051交流社区
本程序使用USB不间断下载接口，频率选择24M。实验箱J18跳线帽切换到C, D。串口助手更多设置选择“CRC-16 MODBUS协议，发送的数据包结尾增加校验数据”，串口发送接收都选择HEX模式。

u8        MODBUS_RTU(void)
{
        u8        i,j,k;
        u16        reg_addr;                                                                //寄存器地址
        u8        reg_len;                                                                //写入寄存器个数
        u16        crc;

        if(RX1_Buffer[1] == 0x10)                                        //写多寄存器
        {
                if(RX1_cnt < 9)                return 0x91;                //命令长度错误
                if((RX1_Buffer[4] != 0) || ((RX1_Buffer[5] *2) != RX1_Buffer[6]))        return 0x92;        //写入寄存器个数与字节数错误
                if((RX1_Buffer[5]==0) || (RX1_Buffer[5] > REG_LENGTH))        return 0x92;        //写入寄存器个数错误

                reg_addr = ((u16)RX1_Buffer[2] << 8) + RX1_Buffer[3];        //寄存器地址
                reg_len = RX1_Buffer[5];                                                                //写入寄存器个数
                if((reg_addr+(u16)RX1_Buffer[5]) > (REG_ADDRESS1+REG_LENGTH))        return 0x93;        //寄存器地址错误
                if(reg_addr < REG_ADDRESS1)                return 0x93;                        //寄存器地址错误
                if((reg_len*2+7) != RX1_cnt)        return 0x91;                        //命令长度错误

                j = reg_addr - REG_ADDRESS1;        //寄存器数据下标
                for(k=7, i=0; i<reg_len; i++,j++)
                {
                        modbus_reg[j] = ((u16)RX1_Buffer[k] << 8) + RX1_Buffer[k+1];        //写入数据, 大端模式
                        k += 2;
                }

                if(RX1_Buffer[0] != 0)        //非广播地址则应答
                {
                        for(i=0; i<6; i++)        TX1_Buffer[i] = RX1_Buffer[i];        //要返回的应答
                        crc = MODBUS_CRC16(TX1_Buffer, 6);
                        TX1_Buffer[6] = (u8)crc;        //CRC是小端模式, 先发低字节，后发高字节。
                        TX1_Buffer[7] = (u8)(crc>>8);
                        B_TX1_Busy = 1;                //标志发送忙
                        TX1_cnt    = 0;                //发送字节计数
                        TX1_number = 8;                //要发送的字节数
                        TI = 1;                                //启动发送
                        
                }
        }
         else if(RX1_Buffer[1] == 0x06)        //写单寄存器
        {
                if(RX1_cnt < 6)                return 0x91;                //命令长度错误
                //if((RX1_Buffer[4] != 0) || ((RX1_Buffer[5] *2) != RX1_Buffer[6]))        return 0x92;        //写入寄存器个数与字节数错误
                //if((RX1_Buffer[5]==0) || (RX1_Buffer[5] > REG_LENGTH))        return 0x92;        //写入寄存器个数错误

                reg_addr = ((u16)RX1_Buffer[2] << 8) + RX1_Buffer[3];        //寄存器地址
                //reg_len = RX1_Buffer[5];        //写入寄存器个数
                //if((reg_addr+(u16)RX1_Buffer[5]) > (REG_ADDRESS+REG_LENGTH))        return 0x93;        //寄存器地址错误
                //if(reg_addr != REG_ADDRESS)                return 0x93;        //寄存器地址错误
                if( RX1_cnt !=6)        return 0x91;        //命令长度错误

                j = reg_addr - REG_ADDRESS;        //寄存器数据下标
                modbus_reg[j] = ((u16)RX1_Buffer[4]<<8)+ RX1_Buffer[5];        //写入数据, 大端模式        
                num = modbus_reg[j];

                if(RX1_Buffer[0] != 0)        //非广播地址则应答
                {
                        for(i=0; i<6; i++)        TX1_Buffer[i] = RX1_Buffer[i];        //要返回的应答
                        crc = MODBUS_CRC16(TX1_Buffer, 6);
                        TX1_Buffer[6] = (u8)crc;        //CRC是小端模式, 先发低字节，后发高字节。
                        TX1_Buffer[7] = (u8)(crc>>8);
                        B_TX1_Busy = 1;                //标志发送忙
                        TX1_cnt    = 0;                //发送字节计数
                        TX1_number = 8;                //要发送的字节数
                        TI = 1;                                //启动发送
                }
        }
        
        else if(RX1_Buffer[1] == 0x03)        //读多寄存器
        {
                if(RX1_Buffer[0] != 0)        //非广播地址则应答
                {
                        if(RX1_cnt != 6)                return 0x91;                //命令长度错误
                        if(RX1_Buffer[4] != 0)        return 0x92;        //读出寄存器个数错误
                        if((RX1_Buffer[5]==0) || (RX1_Buffer[5] > REG_LENGTH))        return 0x92;        //读出寄存器个数错误

                        reg_addr = ((u16)RX1_Buffer[2] << 8) + RX1_Buffer[3];        //寄存器地址
                        reg_len = RX1_Buffer[5];        //读出寄存器个数
                        if((reg_addr+(u16)RX1_Buffer[5]) > (REG_ADDRESS1+REG_LENGTH))        return 0x93;        //寄存器地址错误
                        //if(reg_addr < REG_ADDRESS1)                return 0x93;        //寄存器地址错误

                        j = reg_addr - REG_ADDRESS1;        //寄存器数据下标
                        TX1_Buffer[0] = SL_ADDR;        //站号地址
                        TX1_Buffer[1] = 0x03;                //读功能码
                        TX1_Buffer[2] = reg_len*2;        //返回字节数

                        for(k=3, i=0; i<reg_len; i++,j++)
                        {
                                TX1_Buffer[k++] = (u8)(modbus_reg[j] >> 8);        //数据为大端模式
                                TX1_Buffer[k++] = (u8)modbus_reg[j];
                        }
                        crc = MODBUS_CRC16(TX1_Buffer, k);
                        TX1_Buffer[k++] = (u8)crc;        //CRC是小端模式, 先发低字节，后发高字节。
                        TX1_Buffer[k++] = (u8)(crc>>8);
                        B_TX1_Busy = 1;                //标志发送忙
                        TX1_cnt    = 0;                //发送字节计数
                        TX1_number = k;                //要发送的字节数
                        TI = 1;                                //启动发送
                }
        }
        else        return 0x90;        //功能码错误

        return 0;        //解析正确
}
复制代码

示例代码.zip (131.49 KB, 下载次数: 117)

2025-3-8 10:13 上传

点击文件名下载附件

  示例代码把数码管数据前的无效零位消隐了。
     

乐***

第十九集  ADC     课间思考


冲哥的意思是不是要求按下按键松开后，数码管显示键值保持不变，直到下一次按键按下？我的理解是这样的。
程序中增加KEY_Task(void)函数。

void KEY_Task(void)
{
        u8 temp;        
        temp =ADC_KEY_READ(ADC_Read(0));
        if(temp)
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        key = temp;
                }
        }
                else
        {
                Key_Vol = 0;
        }
}        
复制代码

demo1.zip (229.74 KB, 下载次数: 108)

2025-3-8 14:20 上传

点击文件名下载附件

乐***

第十九集  ADC  课后小练


定义P10引脚电压就是ADC按键端的电压为V_key，按键端ADC读取数值为value，MCU的电源电压为VCC（来自ME6231C33M5G稳压管，输出电压3.3V），MCU内部参考信号为BGV

根据反推工作电压计算公式得到：VCC=4096*BGV/ADC_Read(15)；VCC/4096=V_key/value；V_key=VCC*value/4096。

u16 BGV_Read(void)
{
        u16 bgv = 0;
        
        
        bgv = (((u16)CHIPID7) << 8) + (CHIPID8);        //获取内部参考信号源值
        
        return bgv;
}
复制代码

void KEY_Task(void)
{
        u8 temp;        
        temp =ADC_KEY_READ(ADC_Read(0));
        if(temp)
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        key = temp;
                        value = ADC_Read(0);
                }
        }
                else
        {
                Key_Vol = 0;
        }
          VCC = 4096l*BGV_Read()/ADC_Read(15);
          V_key = (u32)VCC*value/4096;
          SEG_Show_U32( key,V_key);
                //SEG_Show_U32( key,VCC);
                //SEG_Show_U32( key,value);        
                //SEG_Show_U32( key,ADC_Read(15));        
                //SEG_Show_U32( key,BGV_Read());
}        
复制代码

demo.zip (225.92 KB, 下载次数: 118)

2025-3-9 12:02 上传

点击文件名下载附件

乐***

第十九集  ADC  课后小练   程序修正

在上一个程序中，数码管显示的P10端口电压一直在跳动，排查发现是ADC_Read(15)的数值一直在变化，如果电源电压稳定，这应该是一个相对固定的值。
我考虑在程序开始的时候就把它读出来，采用连续读取20次求取平均值。修改后的结果数码管显示稳定。程序中4096后面是小写的“L”，不是数字“1”，用来转换后面的U16为U32长整型。

/*  鉴于前所写程序中ADC_Read(15)的数值一直在跳动，而这个数值应该是一个相对固定值，
        所以在程序运行的开始就把它读取出来，连续读取20次，求其平均值*/        
        Delay10ms();
        Delay10ms();
        for( i=0;i<20;i++)                                                
        {
           BGV_ADC_Read += ADC_Read(15);
           Delay10ms();
        }
        BGV_ADC_Read =BGV_ADC_Read/20;
        VCC = 4096l*BGV_Read()/BGV_ADC_Read;
复制代码

demo2.zip (222.2 KB, 下载次数: 95)

2025-3-9 20:24 上传

点击文件名下载附件

乐***

第20集  ADC_NTC测温  课后小练


NTC温度读取采用冲哥STC32G视频教程第19集NTC温度采集程序。 程序下载运行IRC频率24M，插上测温跳帽JUP2。

void KEY_Task(void)
{

        u8 temp;
        temp = ADC_KEY_READ(ADC_Read(0));        
        if(temp)
        {
                Key_Vol++;

                if( Key_Vol==5 )
                {
                        key = temp;
                        if(key==8)                        //“设置”按键
                                Set_t = 1;                //按下设置键，标志位Set_t置一
                        if(key==16)                        //“确认退出”按键
                                Set_t = 0;
                        if(Set_t)
                        {
                                switch(key)     
                                {        
                                        //温度增减按键
                                        case 1:   if(baojing[0]<9)  baojing[0]++; break;       
                                        case 2:   if(baojing[1]<9)  baojing[1]++; break; 
                                        case 3:   if(baojing[2]<9)  baojing[2]++; break; 
                                        case 4:   if(baojing[3]<9)  baojing[3]++; break; 
                                        case 9:   if(baojing[0]>0)  baojing[0]--; break; 
                                        case 10:  if(baojing[1]>0)  baojing[1]--; break; 
                                        case 11:  if(baojing[2]>0)  baojing[2]--; break; 
                                        case 12:  if(baojing[3]>0)  baojing[3]--; break;
                                        default: break;
                                }                        
                        }
                }
        }
                else
        {
                Key_Vol = 0;
        }
        BJ_wendu = baojing[3]*1000+baojing[2]*100+baojing[1]*10+baojing[0];   //报警温度放在数组baojing[]内
}

void NTC_Task(void)    //间隔500ms读取一次NTC值，兼作后四位数码管闪烁计时来源
{
        NTC_wendu = Temp_Cal( ADC_Read(3));    //NTC温度读取采用冲哥STC32G视频教程第19集NTC温度采集程序
        VCC = 4096l*BGV_Read()/BGV_ADC_Read;   //MCU电压计算
        SEG_Show(VCC,NTC_wendu);        //数码管显示，前四位显示电压，后四位显示NTC温度
        if(Set_t)                                //按下设置键，标志位Set_t置一，后四位数码管闪烁
                blink = ~blink;
}
复制代码

void SEG_Task(void)
{

        if( Seg_no ==0 )                                                                
        {
                Display_Seg( SEG_NUM[passward[0]]+0x80 , ~T_NUM[0]); //+0x80是为了添加小数点，编译会出现警告C188，可忽略
        }
        else if( Seg_no ==1 )                                                        
        {
                Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                
        }        
        else if( Seg_no ==2 )                                                        
        {
                Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                
        }        
        else if( Seg_no ==3 )                                                        
        {
                Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                
        }
        else if( Seg_no ==4 )
        {
                if(passward[4]==0)
                        Display_Seg( SEG_NUM[17] , ~T_NUM[0]);      //第一位如果是零，则消隐        
                else
                        Display_Seg( SEG_NUM[passward[4]], ~T_NUM[4]);                
        }        
        else if( Seg_no ==5 )
        {
                Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                
        }        
        else if( Seg_no ==6 )
        {
                if(Set_t )                                                          //按下设置键，后四位数码管闪烁
                {
                        if(!blink)
                                Display_Seg( 0 , ~T_NUM[6]);
                        else
                                Display_Seg( SEG_NUM[passward[6]]+0x80 , ~T_NUM[6]);
                }
                else if(NTC_wendu < BJ_wendu )                                                                
                        Display_Seg( SEG_NUM[passward[6]]+0x80 , ~T_NUM[6]);
                else
                        Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);
        }
        else if( Seg_no ==7 )
        {
                Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                
        }        
        else
        {
                
        }
        Seg_no ++;
        if( Seg_no>7 )
                Seg_no=0;
}


void SEG_Show(u16 vol,u16 wendu)
{
        u8 i;
        for(i=0;i<4;i++)
        {
                if(Set_t)                                                       //按下设置键，后四位数码管闪烁
                {
                        if(blink)
                                passward[7-i] = 17;
                        else
                                passward[7-i] = baojing[i];
                        
                }
                else
                {
                        
                        if(wendu > BJ_wendu)                      //如果温度高于预警温度值，则显示“----”
                                passward[7-i] = 16;
                        else
                        {
                                passward[7-i] = wendu%10;;
                                wendu /= 10;
                        }
                }
        }
        for(i=4;i<8;i++)
        {
                passward[7-i] = vol%10;
                vol /= 10;
        }        
}
复制代码

demo.zip (252.02 KB, 下载次数: 135)

2025-3-12 16:25 上传

点击文件名下载附件