STM32 RS485 modbus通讯

Modbus 一个工业上常用的通讯协议、一种通讯约定。Modbus协议包括RTU、ASCII、TCP。其中MODBUS-RTU最常用,比较简单,在单片机上很容易实现。modbus协议简单解析如下:
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主机就完成了一次对从机数据的读操作,实现了通讯。
 

#include "rs485.h"
#include "SysTick.h"
#include "crc16.h"
#include "led.h"

/*******************************************************************************
* 函 数 名         : RS485_Init
* 函数功能                   : USART2初始化函数
* 输    入         : bound:波特率
* 输    出         : 无
*******************************************************************************/  
u8 USART2_RX_BUF[64];                   //接收缓冲,最大64字节
u8 USART2_RX_CNT=0;                       //接收字节计数器
u8 flagFrame=0;                         //帧接收完成标志,即接收到一帧新数据
unsigned char regGroup[5];  //Modbus寄存器组,地址为0x00~0x04

void RS485_Init(u32 bound)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
       
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG|RCC_APB2Periph_GPIOA,ENABLE); //使能GPIOA\G时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟
       
        /*  配置GPIO的模式和IO口 */
        GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;        //TX-485        //串口输出PA2
        GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;                  //复用推挽输出
        GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;       
        GPIO_Init(GPIOA,&GPIO_InitStructure);                /* 初始化串口输入IO */
       
        GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;        //RX-485           //串口输入PA3
        GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;            //模拟输入
        GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
        GPIO_Init(GPIOA,&GPIO_InitStructure);
       
        GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;        //CS-485
        GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;           //推挽输出
        GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
        GPIO_Init(GPIOG,&GPIO_InitStructure);
       
        //USART2 初始化设置
        USART_InitStructure.USART_BaudRate = bound;//波特率设置
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
        USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
        USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
        USART_Init(USART2, &USART_InitStructure); //初始化串口2
       
        USART_Cmd(USART2, ENABLE);  //使能串口 2
       
        USART_ClearFlag(USART2, USART_FLAG_TC);
               
        USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启接受中断

        //Usart2 NVIC 配置
        NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =2;                //子优先级2
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器、
       
        RS485_TX_EN=0;                                //默认为接收模式       
}

       

//1ms定时

void TIM2_Init()
{
        TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
       
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);//使能TIM4时钟
       
        TIM_TimeBaseInitStructure.TIM_Period=1000;   //自动装载值
        TIM_TimeBaseInitStructure.TIM_Prescaler=72-1; //分频系数
        TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
        TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //设置向上计数模式
        TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);
       
        TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE); //开启定时器中断
        TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
       
        NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;//定时器中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;//抢占优先级
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;                //子优先级
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);       
       
        TIM_Cmd(TIM2,ENABLE); //使能定时器       
}


//计算发送的数据长度,并且将数据放到*buf数组中                     
u8 UartRead(u8 *buf, u8 len)  
{
         u8 i;
        if(len>USART2_RX_CNT)  //指定读取长度大于实际接收到的数据长度时
        {
                len=USART2_RX_CNT; //读取长度设置为实际接收到的数据长度
        }
        for(i=0;i<len;i++)  //拷贝接收到的数据到接收指针中
        {
                *buf=USART2_RX_BUF[i];  //将数据复制到buf中
                buf++;
        }
        USART2_RX_CNT=0;              //接收计数器清零
        return len;                   //返回实际读取长度
}


u8 rs485_UartWrite(u8 *buf ,u8 len)                                                                                 //发送
{
        u8 i=0;
   GPIO_SetBits(GPIOG,GPIO_Pin_3);                                            //发送模式
   delay_ms(3);                                                               //3MS延时
    for(i=0;i<=len;i++)
    {
        USART_SendData(USART2,buf[i]);                                              //通过USARTx外设发送单个数据
        while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==RESET);             //检查指定的USART标志位设置与否,发送数据空位标志
    }
    GPIO_ResetBits(GPIOG,GPIO_Pin_3);                                         //设置为接收模式

}





//串口驱动函数,检测数据帧的接收,调度功能函数,需在主循环中调用
void UartDriver()
{
        unsigned char i=0,cnt;
        unsigned int crc;
        unsigned char crch,crcl;
        static u8 len;
        static u8 buf[60];
        if(flagFrame)            //帧接收完成标志,即接收到一帧新数据
        {
                flagFrame=0;           //帧接收完成标志清零
                len = UartRead(buf,sizeof(buf));   //将接收到的命令读到缓冲区中
                if(buf[0]==0x01)                   //判断地址是不是0x01
                {
                        crc=GetCRC16(buf,len-2);       //计算CRC校验值,出去CRC校验值
                        crch=crc>>8;                                    //crc高位
                        crcl=crc&0xFF;                                        //crc低位
                        if((buf[len-2]==crch)&&(buf[len-1]==crcl))  //判断CRC校验是否正确
                        {
                                switch (buf[1])  //按功能码执行操作
                                {
                                        case 0x03:     //读数据
                                                if((buf[2]==0x00)&&(buf[3]<=0x05))  //寄存器地址支持0x0000~0x0005
                                                {
                                                       
                                                        if(buf[3]<=0x04)
                                                        {
                                                                i=buf[3];//提取寄存器地址
                                                                cnt=buf[5];  //提取待读取的寄存器数量
                                                                buf[2]=cnt*2;  //读取数据的字节数,为寄存器*2,因modbus定义的寄存器为16位
                                                                len=3;                                                       
                                                                while(cnt--)
                                                                {
                                                                        buf[len++]=0x00;                                //寄存器高字节补0
                                                                        buf[len++]=regGroup[i++];                //低字节
                                                        }
                                                       
                                                }
                                                        break;
                                        }
                                                else  //寄存器地址不被支持时,返回错误码
                                                {   
                                                        buf[1]=0x83;  //功能码最高位置1
                                                        buf[2]=0x02;  //设置异常码为02-无效地址
                                                        len=3;
                                                        break;
                                                }
                                        case 0x06:           //写入单个寄存器
                                                if((buf[2]==0x00)&&(buf[3]<=0x05))   //寄存器地址支持0x0000-0x0005
                                                {
                                                        if(buf[3]<=0x04)
                                                        {
                                                                i=buf[3];                                //提取寄存器地址
                                                                regGroup[i]=buf[5];                //保存寄存器数据
                                                                led3=0;
                                                        }
                                                        len -=2;                 //长度-2以重新计算CRC并返回原帧
                                                        break;
                                                }
                                                else  
                                                {                                                        //寄存器地址不被支持,返回错误码
                                                        buf[1]=0x86;           //功能码最高位置1
                                                        buf[2]=0x02;           //设置异常码为02-无效地址
                                                        len=3;
                                                        break;
                                        }
                                        default:    //其他不支持的功能码
                                                    buf[1]=0x80;     //功能码最高位置1
                                                        buf[2]=0x01;     //设置异常码为01—无效功能
                                                        len=3;
                                                        break;
                                }
                            crc=GetCRC16(buf,len);           //计算CRC校验值
                                buf[len++]=crc>>8;           //CRC高字节
                                buf[len++]=crc&0xff;        //CRC低字节
                                rs485_UartWrite(buf,len);  //发送响应帧
                        }
                }
        }
}


                               
void UartRxMonitor(u8 ms) //串口接收监控
{
        static u8 USART2_RX_BKP=0;  //定义USART2_RC_BKP暂时存储诗句长度与实际长度比较
        static u8 idletmr=0;        //定义监控时间
        if(USART2_RX_CNT>0)//接收计数器大于零时,监控总线空闲时间
        {
                if(USART2_RX_BKP!=USART2_RX_CNT) //接收计数器改变,即刚接收到数据时,清零空闲计时
                {
                        USART2_RX_BKP=USART2_RX_CNT;  //赋值操作,将实际长度给USART2_RX_BKP
                        idletmr=0;                    //将监控时间清零
                }
                else                              接收计数器未改变,即总线空闲时,累计空闲时间
                {
                        //如果在一帧数据完成之前有超过3.5个字节时间的停顿,接收设备将刷新当前的消息并假定下一个字节是一个新的数据帧的开始
                        if(idletmr<5)                  //空闲时间小于1ms时,持续累加
                        {
                                idletmr +=ms;
                                if(idletmr>=5)             //空闲时间达到1ms时,即判定为1帧接收完毕
                                {
                                        flagFrame=1;//设置命令到达标志,帧接收完毕标志
                                }
                        }
                }
        }
        else
        {
                USART2_RX_BKP=0;
        }
}
                                                       
                                               
                                                       
                       
               
/*******************************************************************************
* 函 数 名         : USART2_IRQHandler
* 函数功能                   : USART2中断函数
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void USART2_IRQHandler(void)
……………………

  • 2
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STM32 RS485 Modbus通讯是一种常用的工业通信协议,用于实现微控制器与其他设备之间的数据传输。以下是一个简单的源程序示例,用于在STM32微控制器上实现RS485 Modbus通信: 1. 首先,需要初始化串口和GPIO端口,用于通信和控制RS485转换器的发送和接收模式。 2. 设置RS485的发送和接收使能引脚,例如将RS485的RE(Receiver Enable)引脚连接到MCU的一个GPIO引脚上,将DE(Driver Enable)引脚连接到另一个GPIO引脚上。 3. 配置USART(Universal Synchronous/Asynchronous Receiver/Transmitter)串口的参数,例如波特率、停止位、数据位等。 4. 在主程序循环中,使用Modbus协议的函数来进行数据的读写和处理。 5. 根据Modbus协议规定的地址和功能码等信息,通过串口发送数据帧到目标设备,例如发送读取寄存器的数据帧。 6. 接收目标设备返回的应答数据帧,并进行解析和处理,例如提取寄存器中的数据或状态信息。 7. 根据需求进行错误处理和异常处理,例如检测通信超时、校验错误等。 8. 根据实际应用需要,可以添加其他功能,例如多设备的通信、数据记录与分析等。 需要注意的是,以上只是一个简单的源程序示例,实际应用中还需要根据具体的硬件和软件环境进行相应的配置和调试。此外,由于RS485 Modbus通信协议相对复杂,还需要对Modbus协议有一定的了解和掌握,以正确地实现通信功能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值