FreeRTOS记录（十、FreeRTOS实现带 I2C 通讯的 ModbusRTU 协议从机实例）（完成）
还是一个FreeRTOS的例子，这次不是裸机工程转的，没有大部分复制的代码，
所以会把步骤会记录详细一点，这应该也是博文中 FreeRTOS 最后一个例子了
平台： STM32L051C8T6
欧姆龙 D6T 红外测温传感器 I2C 协议
设备作为485从机
目录
- 一、STM32CubeMX 创建工程
-
- 1.1 芯片基本设置
- 1.2 FreeRTOS基本设置
- 二、基本框架代码添加
-
- 2.1 一些习惯的typedef 和 宏定义
- 2.2 各外设相关代码
-
- 2.2.1 定时器（逻辑处理和按键驱动计时）
- 2.2.2 串口（调试串口和485通讯串口）
- 2.2.3 按键
- 三、各外设函数代码
-
- 3.1 485从机驱动（ModbusRTU协议）
-
- 3.1.1 寄存器地址的疑问
- 3.1.2 485 驱动测试
- 3.2 D6T传感器驱动（I2C协议）
-
- 3.2.1 通用I2C驱动
- 3.2.2 I2C传感器数据读取
- 3.3 任务调整、任务通讯
-
- 3.3.1 任务栈说明
- 3.3.2 任务间通信
本产品的功能就是通过红外测温传感器定时测量温度保存，设备通过RS484接口，使用ModbusRTU协议进行传输，设备作为从机接收主机的查询上报温度等其他数据。
具体的理论分析请参考博文 MODBUS RTU 485 部分：总线协议记录（I2C，SPI, Modbus 485, CAN…）
一、STM32CubeMX 创建工程
第一步创建工程，这个以前博文中就提到过很多次了，实在不会去看一下我FreeRTOS记录（九、一个裸机工程转FreeRTOS的实例）中的说明，里面的 2.1 基本框架搭建 有所有相关的博文地址。
这里我就简单放一个步骤，说明一下我的基本设置：
1.1 芯片基本设置
- GPIO口，按键，LED，一个I2C传感器；
- 系统时钟源，使用外部高速时钟：
- 基础时钟源和调试方式，不勾选 Debug Serial Wire 烧录一次就会锁死，不能正常烧录，需要手动操作：
- 系统时钟频率，使用的STM32L051 ，最大支持32MHz，这里就选32MHz：
- 定时器设置，根据自己的使用习惯，两个定时器，一个定时器做基本逻辑时间管理，一个用于按键驱动的定时器：
- 串口设置，2个串口，一个用于打印的调试串口1，一个用于485通讯的串口：
1.2 FreeRTOS基本设置
- 任务和消息队列的创建，要考虑到设备的主要功能有哪些，传感器读取，485通讯，按键用来做一些观察测试（按键其实可以不用，但是考虑也可以通过按键来设置485的地址，这个想法再看）：
- 打开任务运行情况查询功能，确保实施观察任务运行状态，这个东西熟悉了以后或者等系统稳定以后可以去掉：
- 然后就可以生成代码了，用什么环境选什么，我用的是 gcc 环境，这里选用的是 Makefile ，这里最后我还有个小操作，把堆空间改小了一点：
二、基本框架代码添加
2.1 一些习惯的typedef 和 宏定义
根据个人习惯，把数据类型的名称命名头文件加入工程，在main.h文件中包含，这样在写代码的时候一些就可以根据个人习惯使用数据类型了：
接下来对LED灯，和I2C引脚进行需要的宏定义：
2.2 各外设相关代码
2.2.1 定时器（逻辑处理和按键驱动计时）
定义两个全局变量，分别计算 定时器2 和 定时器 21的次数：
对于定时器21，直接计数就可以，后面在按键驱动中使用Timer21_count的值：
对于定时器2，在stm32l0xx_it.c文件中，进入定时器中断就处理，因为这里可能需要在中断中发送FreeRTOS任务通知或者消息等：
2.2.2 串口（调试串口和485通讯串口）
首先打印串口使用USART1，printf重定义，然后就能直接使用printf了：
接下来485通讯串口 USRAT2，我们需要使用 FreeRTOS 消息队列来发送通讯消息，需要在中断处理函数中操作：
上面是把串口接收到的消息放入消息队列，我们在 freertos.c文件中，把对应的接收消息队列的部分框架搭建好，同时自己要建立一个缓存用来保存消息队列的数据：
在StartModbusTask任务中：
完成上面的框架，别忘了打开串口接收中断，但是要注意，因为使用了消息队列接收，打开中断需要等FreeRTOS 初始化完了以后，否者会出现问题！
如下图，我们在MX_FREERTOS_Init函数中结尾处，打开串口2 接收中断：
2.2.3 按键
按键的话，我还是使用以前的那个驱动代码，就直接复制过来，修改一下定时器源：
几个实用的按键驱动
增加了.c 文件记得在Makefile中也添加一下：
三、各外设函数代码
3.1 485从机驱动（ModbusRTU协议）
具体的理论分析请参考博文 MODBUS RTU 485 部分：总线协议记录（I2C，SPI, Modbus 485, CAN…）
先把CRC16校验的文件包含进来，这个网上查一下就有，这里是我一直用的：ModBus-check.zip
然后写一下命令处理函数：
最后实现一下Modbus_03_ack函数。
3.1.1 寄存器地址的疑问
在写驱动代码的时候，忽然想到一个问题，寄存器地址该如何定义？
假如我们就从 0x0000 开始，然后依次+1 的定义寄存器，通过一个数组 test[n]是可以一一对应的，这个没问题。
| 寄存器地址 | 数组 |
|---|---|
| 0000H | test[0] |
| 0001H | test[1] |
| 0002H | test[2] |
| … | … |
| 00XY | test[XY] |
但是看各厂家有些设备，地址不是连续的，而且有小的有大的，比如：
上面这种情况总不能定义一个这么大的数组 test[0x0101]
(后续补充说明后来想想这个好像也不大，257，作为一款产品，肯定是厂家会保证产品地址在一定的范围内，然后可以用一个数组顺序对应寄存器地址，即便有多个通道，也是会用不同的数组表示，在一定的范围内可以离散，但是差距太大的话就得分不同数组)
当然，即使这样，我们依旧可以按照如下对应：
| 寄存器地址 | 数组 |
|---|---|
| 0000H | test[0] |
| 0001H | test[1] |
| 0006H | test[2] |
| 0100H | test[3] |
| 0101H | test[4] |
但是问题是，看到设备的说明里面，从地址0000H 开始读取数据，读取7个长度的数据，0001H 到 0006H 的数据都会返回 0，这样子的话，单单用一个数组就不好处理了：
暂时想不出来 一个数组如何才能知道 他是否是连续的寄存器地址呢？不确定是不是还有其他的设定？（答案应该是上面红色部分）
当然，我考虑过使用 结构体，因为结构体的话，可以先针对的判断寄存器的ID，然后再处理数据，比如：
但是使用结构体数据处理相对来说 就没有数组那么简单，其实最主要的，关键还是在于产品定义的寄存区是否连续，如果连续的话，处理起来都没问题。
所以目前这个示例我还是把地址设置为连续的，通过一个数组，人为的定义好对应关系。
这里就直接上源码，把Modbus_rtu.c的源码都放上来：
#include "Modbus_rtu.h"
#include "stdio.h"
void Modbus_check()
{
u16 crc;
u16 receivecrc1;
u16 receivecrc2;
u8 sendbuff[5];
crc = Checksum_CRC16(USART2_BUF,USART2_Data - 2);
printf("crc is :0x%x\r\n",crc);
/*No matter the high bits before or the low bits before*/
receivecrc1 = (USART2_BUF[USART2_Data - 2]<<8) + USART2_BUF[USART2_Data - 1];
receivecrc2 = (USART2_BUF[USART2_Data - 1]<<8) + USART2_BUF[USART2_Data - 2];
// if((lrc == receivelrc2)||(lrc == receivelrc1)){
// if(USART2_BUF[0] == mymodbus_add){
//这里说明一下，先判断地址，然后返回错误，如果先判断校验，如果出错了，那么总线上所有都同时返回就有问题了
if(USART2_BUF[0] == mymodbus_add){
if((crc == receivecrc2)||(crc == receivecrc1)){
switch (USART2_BUF[1]){
case 3:
Modbus_03_ack();
break;
case 6:
Modbus_06_ack();
break;
default:
printf("An unsupported command!\r\n");//for test
break;
}
}
else{ //校验错误，返回异常
sendbuff[0] = mymodbus_add;
sendbuff[1] = 0x80 | USART2_BUF[1];
sendbuff[2] = 0;
crc = Checksum_CRC16(sendbuff,3);
sendbuff[3] = (u8)(crc >> 8);
sendbuff[4] = (u8)crc;
Uart2_sendBuffer(sendbuff,5);
}
}
}
void Modbus_03_ack(){
u16 Register_add; // 2,3
u16 Register_len; // 4,5
u16 crc;
u8 i;
u8 j;
Register_add = (USART2_BUF[2]<<8) + USART2_BUF[3]; //get add;
Register_len = (USART2_BUF[4]<<8) + USART2_BUF[5]; //get len;
u8 sendbuff[Register_len*2 + 5];
/*
如果读取的地址写错了，或者读取长度超过规定的长度
返回错误
*/
if(( 0x0010 <= Register_add)&&( Register_add <= 0x0014 )&&(Register_len < 6)){
i = 0;
sendbuff[i++] = mymodbus_add;
sendbuff[i++] = 0x03;
sendbuff[i++] = Register_len<<1;
switch(Register_add){
case 0x0010:
for(j=0;j<Register_len;j++){
sendbuff[i++]= (u8)(Register_value[0+j]>>8); //发送读取数据字节数的高位
sendbuff[i++]= (u8)Register_value[0+j]; //发送读取数据字节数的低位
}
break;
case 0x0011:
for(j=0;j<Register_len;j++){
sendbuff[i++]= (u8)(Register_value[1+j]>>8);
sendbuff[i++]= (u8)Register_value[1+j];
}
break;
case 0x0012:
for(j=0;j<Register_len;j++){
sendbuff[i++]= (u8)(Register_value[2+j]>>8);
sendbuff[i++]= (u8)Register_value[2+j];
}
break;
case 0x0013:
for(j=0;j<Register_len;j++){
sendbuff[i++]= (u8)(Register_value[3+j]>>8);
sendbuff[i++]= (u8)Register_value[3+j];
}
break;
case 0x0014:
for(j=0;j<Register_len;j++){
sendbuff[i++]= (u8)(Register_value[4+j]>>8);
sendbuff[i++]= (u8)Register_value[4+j];
}
break;
default:break;
}
crc = Checksum_CRC16(sendbuff,i);
sendbuff[i++] = (u8)(crc >> 8);
sendbuff[i++] = (u8)crc;
Uart2_sendBuffer(sendbuff,i);
}
else{//地址不在规定返回或者长度太长，返回错误
sendbuff[0] = mymodbus_add;
sendbuff[1] = 0x80 | USART2_BUF[1];
sendbuff[2] = 0;
crc = Checksum_CRC16(sendbuff,3);
sendbuff[3] = (u8)(crc >> 8);
sendbuff[4] = (u8)crc;
Uart2_sendBuffer(sendbuff,5);
}
}
void Modbus_06_ack(){
}
3.1.2 485 驱动测试
485接收部分驱动完成，这里需要测试一下，测试过程确实发现了问题，但是都是小问题，整体框架逻辑是正常的，在处理校验位的时候，数据位数处理有点大意了（上面贴出的程序是已经修改过的）：
把第一个寄存器设置一个值：
测试结果，一切正常：
测完了还是把 06 写单个寄存器的函数给补充一下，目前只开放一个数据，就是设备ID的写入，直接上代码：
void Modbus_06_ack(){
u16 Register_add; //
u16 val; //
u16 crc;
u8 i;
u8 sendbuff[8] = {0};
if(USART2_Data < 9){
Register_add = (USART2_BUF[2]<<8) + USART2_BUF[3]; //get add;
val = (USART2_BUF[4]<<8) + USART2_BUF[5]; //
if(Register_add == 0x0013){
mymodbus_add = val;
Register_value[3] = mymodbus_add;
i = 0;
sendbuff[i++] = mymodbus_add;
sendbuff[i++] = 0x06;
sendbuff[i++] = (u8)(Register_add>>8);
sendbuff[i++] = (u8)Register_add;
sendbuff[i++] = (u8)(val>>8);
sendbuff[i++] = (u8)val;
crc = Checksum_CRC16(sendbuff,i);
sendbuff[i++] = (u8)(crc >> 8);
sendbuff[i++] = (u8)crc;
Uart2_sendBuffer(sendbuff,i);
}
else{//写地址不在规定范围
sendbuff[0] = mymodbus_add;
sendbuff[1] = 0x80 | USART2_BUF[1];
sendbuff[2] = 3;
crc = Checksum_CRC16(sendbuff,3);
sendbuff[3] = (u8)(crc >> 8);
sendbuff[4] = (u8)crc;
Uart2_sendBuffer(sendbuff,5);
}
}
else{//写地址不在规定范围
sendbuff[0] = mymodbus_add;
sendbuff[1] = 0x80 | USART2_BUF[1];
sendbuff[2] = 1;
crc = Checksum_CRC16(sendbuff,3);
sendbuff[3] = (u8)(crc >> 8);
sendbuff[4] = (u8)crc;
Uart2_sendBuffer(sendbuff,5);
}
}
测试一下效果，如下图，看上去OK：
想了一下，不对啊？
修改地址应该有个限制，从机的地址应该在： 1~ 247 （0XF7）
所以以代码里面还得加一个限制（按理来说应该是先判断地址，如果是写ID的寄存器，才需要限制从机地址大小，其他寄存器，是可以写其他数值的，因为示例中只开放ID寄存器的写操作，所以这里问题不大，但是在完善自己的从机代码的时候这里得注意一下逻辑！！！）：
3.2 D6T传感器驱动（I2C协议）
I2C的基础知识这里就不多介绍了，网上很多，我那个总线协议记录里面也介绍了。
3.2.1 通用I2C驱动
I2C协议需要用到 us 延时，HAL库里面没有， FreeRTOS里面也没，这里我们还是用以前常用的自己写一个：
我们使用的是软件的I2C，所以要把通用的 I2C 驱动写一下，新建一个i2c.c和一个i2c.h文件作为软件 I2C的通用驱动，这里直接上源码：
#include "i2c.h"
// ------------------------------------------------------------------
void i2c_init(void) {
// the SDA and SCL pins are defined as input with pull up enabled
// pins are initialized as inputs, ext. pull => SDA and SCL = high
}
// ------------------------------------------------------------------
// send start sequence (S)
void i2c_start(void)
{
sda_high;
delay_us(5);
scl_high;
delay_us(10);
sda_low;
delay_us(10);
scl_low; //使SCL置低，准备发送或者接受数据
delay_us(10);
}
// ------------------------------------------------------------------
// send stop sequence (P)
void i2c_stop(void)
{
sda_low;
delay_us(5);
scl_low;
delay_us(10);
scl_high;
delay_us(5);
sda_high;
delay_us(10);
}
// ------------------------------------------------------------------
// returns the ACK or NACK
uint8 i2c_write(uint8 u8Data)
{
uint8 u8Bit;
uint8 u8AckBit;
// write 8 data bits
u8Bit = 0x80; //msb first
while(u8Bit) {
if(u8Data&u8Bit) {
sda_high;
delay_us(20);
}
//& compare every bit
else{
sda_low;
delay_us(20);
}
scl_high;
delay_us(30);
u8Bit >>= 1;
//next bit
scl_low;
delay_us(30);
}
// read acknowledge (9th bit)
sda_high;
delay_us(10);
scl_high;
delay_us(10);
u8AckBit= sda_read; //#define sda_read() (sda_port & sda_pin)? 1 :0 ack on bus is low -> u8AckBit = 1 sda_port gpio0 sda_pin SCSEDIO0
delay_us(10);
scl_low;
delay_us(10);
return u8AckBit;
}
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK
u8 i2c_read_byte(unsigned char ack)
{
unsigned char i,receive=0;
// MYSDA_IN;//SDA设置为输入
for(i=0;i<8;i++ )
{
scl_low; //SCL为由低变高，在SCL高的时候去读 SDA的数据
delay_us(10);
scl_high;
receive<<=1; //第一次这里还是0，第二次开始每次接收的数据做移动一位，从高位开始接收
if(sda_read)receive++; //如果数据为1，++以后就是1，数据为0，不执行就是0；
delay_us(10);
}
if (!ack)
IIC_NAck();//发送nACK
else
IIC_Ack(); //发送ACK
return receive;
}
// ------------------------------------------------------------------
// pass the ack/nack
// returns the read data
uint8 i2c_read(uint8 u8Ack)
{
uint8 u8Bit;
uint8 u8Data;
u8Bit = 0x80; // msb first
u8Data = 0;
while(u8Bit){
scl_high;
delay_us(20);
u8Bit >>= 1; //next bit
u8Data <<= 1;
u8Data |= sda_read; //(sda_port & sda_pin)? 1 :0 sda_port gpio0 sda_pin SCSEDIO0
delay_us(20);
scl_low;
delay_us(50);
}
// 9th bit acknowledge
if(u8Ack==I2C_ACK) {
sda_low;
delay_us(20);
}
//I2C_ACK=0
else {
sda_high;
delay_us(20);
}
scl_high;
delay_us(20);
scl_low;
delay_us(20);
sda_high;
delay_us(20);
return u8Data;
}
u8 i2c_wait_ack(void)
{
u8 ucErrTime=0;
delay_us(5);
sda_high;delay_us(5); //MCU DATA 置高，外面高就是高，外面低就是低
scl_high; delay_us(5); //CLK 高电平期间数据有效
while(sda_read) //低电平为有应答，高电平无应答
{
ucErrTime++;
if(ucErrTime>250)
{
i2c_stop();
return 1;
}
}
delay_us(10);
scl_low;
return 0;
}
void IIC_Ack(void)
{
scl_low; //SCL为低，SDA为低，SCL为高，SDA为低，应答低电平有效，SCL为低，产生应答信号
// MYSDA_OUT;
sda_low;
delay_us(10);
scl_high;
delay_us(10);
scl_low;
delay_us(10);
sda_high;
}
void IIC_NAck(void)
{
scl_low; //SCL为低，SDA为高，SCL为高，SCL为低
// MYSDA_OUT;
sda_high;
delay_us(10);
scl_high;
delay_us(10);
scl_low;
}
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答
void i2c_send_byte(u8 txd)
{
u8 t;
// MYSDA_OUT;
scl_low; //拉低时钟开始数据传输 ，SCL为低，SDA变高或者变低（数据位），SCL变高，SCL变低，期间SDA为1既1，为0既0
for(t=0;t<8;t++) //一个字节8位，一位一位发送
{
scl_low;
if((txd&0x80)>>7) //从最高位开始发送，如果是1，发送高电平
sda_high;
else
sda_low;
txd<<=1; //SDA处理完毕，此时可以将SCL拉高接受数据，拉高以后延时拉低
delay_us(10); //对TEA5767这三个延时都是必须的
scl_high;
delay_us(10);
scl_low;
delay_us(5);
}
}
3.2.2 I2C传感器数据读取
对于欧姆龙的这个传感器，主要的时序图如下：
根据时序图，设计代码，源码如下（当然要根据自己的传感器型号进行细节修改）：
void D6T_Measure()
{
u8 D6Tbuff[20];
u8 D6T_Data=0;
// u16 tPEC;
i2c_start();
i2c_send_byte(0X14); //地址，和读写指令
i2c_wait_ack();
delay_us(150); //这里必须加
i2c_send_byte(0X4C);
i2c_wait_ack();
delay_us(150);
i2c_start();
i2c_send_byte(0X15); //地址，读指令
i2c_wait_ack();
delay_us(120);
// D6T44L_ReadLenByte(5); //D6T-1A-02 只有5个数值
u8 t;
D6T_Data=0;
for(t=0;t<(5-1);t++)
{
D6Tbuff[D6T_Data++] = i2c_read_byte(1);
delay_us(120);
}
D6Tbuff[D6T_Data] = i2c_read_byte(0);
delay_us(120);
i2c_stop();
// tPTAT = 256 * D6Tbuff[1] + D6Tbuff[0];
tP = 256 * D6Tbuff[3] + D6Tbuff[2];
}
然后在任务里面调用温度读取函数，做一个简单的测试：
驱动OK，测试结果（结果是温度 * 10）：
3.3 任务调整、任务通讯
驱动都已经设计完成，那么就到了最后的地方，任务间的通讯了，什么时候读取数据，读取的数据放入对应的 485 的寄存器。
3.3.1 任务栈说明
当然，不要忘了各个任务的栈空间调整，还要考虑到使用的STM32L051 单片机只有8K的 RAM，要注意内存的使用情况：
不看不知道，一看吓一跳 = =！：
如果打开了堆栈溢出钩子函数，估计一直在报溢出，测试一下：
测试方式见博文：FreeRTOS记录（四、FreeRTOS任务堆栈溢出问题和临界区）
上面我们看到，按键任务和 RTU接收任务的 栈不够了，D6Tread 也不是很够，因为后期还需要做逻辑处理，也有调用关系，所以必须对各任务的大小进行一定的调整。
KeyTask：
前面我们说到，按钮目前只是为了测试，所以按钮把里面定义的数组改小一点，其实只要能够满足完全打印任务状态的大小就行了，以前设置500并没有仔细的去计算。
任务大小：
任务运行：
在后期的完善过程中，考虑到一个问题，作为485设备，如果拿到一个设备，并不知道他的 ID ，怎么办，所以正好可以通过按钮操作，使得设备恢复默认ID。所以将按键任务加了一个长按操作：
RTUreceived：
串口接收任务会溢出是开始没想打的，但是仔细想想还是不应该，看了一下，开始测试的时候加了一句 printf 函数，把printf后 RTUreceived 就正常不会溢出了：
加个printf就占用那么大空间？这个怎么理解呢，虽然知道使用 printf 会占用栈空间，但是这么大还是有点诧异的
任务大小：
任务运行：
D6TRead：
通过上文可以看到 D6TRead 只剩下 21 的栈空间，在该任务中，我们调用了 I2C 的驱动，读取传感器数据，考虑到后面还可能进行数据计算操作，此任务估计得放大一点空间（为什么数据保存不能新建一个任务，因为内存空间不够，给FreeRTOS分配的总栈空间已经不够我再新建一个任务了，当然，实际应用，可以对keyTask任务进行缩减来换取其他任务更多的空间）。
当然，我还是改大了一点：
任务大小：
任务运行：
3.3.2 任务间通信
其实示例做到上面，整体上已经没什么大问题了，最主要的还是示例还是比较简单的，没有太多的任务，所以到这里其实基本上大问题就没有了。余下的就是细节处理。
最初构思的时候，对于任务之间，什么时候读取传感器的数据，是想使用TIM2 定时 ，在定时器中断中给D6TRead 任务通知来实现，但是因为整体结构简单，这里直接使用延时就可以达到效果= =！这里就不再折腾了，因为具体的使用可以参考博文，也是任务中读取传感器：
FreeRTOS记录（五、FreeRTOS任务通知）
然后针对实际应用，可能需要对采集的温度进行一定的数据处理，直接根据需求修改即可。
最后整体测试一下，没有问题：
