STM32F103与上位机是如何实现MODBUS通信的

Modbus是一种串行通信协议，是Modicon于1979年，为使用可编程逻辑控制器（PLC）而发表的。Modbus是工业领域通信协议的业界标准，并且现在是工业电子设备之间相当常用的连接方式。Modbus比其他通信协议使用的更广泛的主要原因有：
【1】公开发表并且无版税要求
【2】相对容易的工业网络部署
【3】对供应商来说，修改移动原生的位元或字节没有很多限制
  1、实现f103作为从机，上位机作为主机通信（从站程序）。
  1.1 配置时钟
  作为保证串口接收数据完整。
  
//通用定时器3中断初始化
//APB1为SYSCLK的2分频，即36M，因此定时器时钟为APB1的2倍频，即72M
//arr：自动重装值
//psc：时钟分频数
//这里使用的是定时器3！
void TIM3_Int_Init(u16 arr,u16 psc)
{
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
        NVIC_InitTypeDef NVIC_InitStructure;

        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //使能时钟
       
        //定时器TIM3初始化
        TIM_TimeBaseStructure.TIM_Period = arr; //自动重装载寄存器周期的值
        TIM_TimeBaseStructure.TIM_Prescaler =psc; /设置用来作为TIMx时钟频率数的预分频值
        TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
        TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
        TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位

        TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); /使能指定的TIM3中断,允许更新中断

        //中断优先级NVIC配置
        NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;  //从优先级3级
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
        NVIC_Init(&NVIC_InitStructure);  //初始化NVIC寄存器


        TIM_Cmd(TIM3, ENABLE);  //使能TIMx                                         
}
//定时器3中断服务程序，100us
void TIM3_IRQHandler(void)   //TIM3中断
{
        if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
                {
                        TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清理TIMx更新中断标志
                        if(time3_usart1<=200)
        time3_usart1++;
                        if(time3_usart2<=200)
        time3_usart2++;
                        if(time3_usart3<=5000)
        time3_usart3++;
                }
               
}
1.2 配置串口USART
  配置使用到串口，用于实际的通信端口。
  1.2.1 串口优先级配置

/**
  * @brief 配置嵌套向量中断控制器NVIC
  * @param  ÎÞ
  * @retval ÎÞ
  */
static void NVIC_usart1_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
  
  /* 嵌套向量中断控制器组选择 */
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  
  /*配置USART为中断源*/
  NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART1_IRQ;
  /* 抢断优先级*/
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  /* 子优先级 */
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  /* 使能中断 */
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  /*初始化配置NVIC */
  NVIC_Init(&NVIC_InitStructure);
}

static void NVIC_usart2_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
  
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  
  NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART2_IRQ;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);
}
  1.2.2 串口初始化

void USART1_Init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;

        // 打开串口GPIO的时钟
        DEBUG_USART1_GPIO_APBxClkCmd(DEBUG_USART1_GPIO_CLK, ENABLE);
       
        // 打开串口外设的时钟
        DEBUG_USART1_APBxClkCmd(DEBUG_USART1_CLK, ENABLE);

        // 将USART Tx的GPIO配置为推挽复用模式
        GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_TX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(DEBUG_USART1_TX_GPIO_PORT, &GPIO_InitStructure);

  // 将USART Rx的GPIO配置为浮空输入模式
        GPIO_InitStructure.GPIO_Pin = DEBUG_USART1_RX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(DEBUG_USART1_RX_GPIO_PORT, &GPIO_InitStructure);
       
        // 配置串口的工作参数
        // 配置波特率
        USART_InitStructure.USART_BaudRate = DEBUG_USART1_BAUDRATE;
        // 配置 帧数据字长
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        // 配置停止位
        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(DEBUG_USART1, &USART_InitStructure);
       
        // 串口中断优先级配置
        NVIC_usart1_Configuration();
       
        // 使能串口接收中断
        USART_ITConfig(DEBUG_USART1, USART_IT_RXNE, ENABLE);       
       
        // 使能串口
        USART_Cmd(DEBUG_USART1, ENABLE);            
}

//初始化串口2
void USART2_Init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;

        DEBUG_USART2_GPIO_APBxClkCmd(DEBUG_USART2_GPIO_CLK, ENABLE);
       
        DEBUG_USART2_APBxClkCmd(DEBUG_USART2_CLK, ENABLE);

        GPIO_InitStructure.GPIO_Pin = DEBUG_USART2_TX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(DEBUG_USART2_TX_GPIO_PORT, &GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin = DEBUG_USART2_RX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(DEBUG_USART2_RX_GPIO_PORT, &GPIO_InitStructure);

        USART_InitStructure.USART_BaudRate = DEBUG_USART2_BAUDRATE;

        USART_InitStructure.USART_WordLength = USART_WordLength_8b;

        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(DEBUG_USART2, &USART_InitStructure);
       
        NVIC_usart2_Configuration();
       
        USART_ITConfig(DEBUG_USART2, USART_IT_RXNE, ENABLE);       
       
        USART_Cmd(DEBUG_USART2, ENABLE);            
}
1.2.3 串口中断服务函数

unsigned char usart1_rx_buf[USART1_RX_LENGTH_MAX];//串口1的接收数据缓存
unsigned int usart1_rx_length=0;
unsigned char usart2_rx_buf[USART2_RX_LENGTH_MAX];//串口2的接收数据缓存
unsigned int usart2_rx_length=0;
unsigned char usart3_rx_buf[USART3_RX_LENGTH_MAX];
unsigned int usart3_rx_length=0;
unsigned int time3_usart1,time3_usart2,time3_usart3;//time3用于各个串口接收的数据计时


//串口1中断服务函数
void DEBUG_USART1_IRQHandler(void)

        if(USART_GetITStatus(DEBUG_USART1,USART_IT_RXNE)!=RESET)
        {       
                time3_usart1 =0;//每一个字节接收完都需要留出一小段时间，等待下一个字节
                usart1_rx_buf[usart1_rx_length] = USART_ReceiveData(DEBUG_USART1);

                if(usart1_rx_length < USART1_RX_LENGTH_MAX)
    usart1_rx_length++;

        }         
}
//串口2中断服务函数
void DEBUG_USART2_IRQHandler(void)
{

        if(USART_GetITStatus(DEBUG_USART2,USART_IT_RXNE)!=RESET)
        {               
                time3_usart2 =0;
                usart2_rx_buf[usart2_rx_length] = USART_ReceiveData(DEBUG_USART2);
      //   USART_SendData(DEBUG_USART1,u1_rx_buf[num]);  //可以直接发给上位机  
                if(usart2_rx_length < USART1_RX_LENGTH_MAX)
    usart2_rx_length++;
        }         
}
1.2.4 usart.h文件里的内容

#define USART1_RX_LENGTH_MAX    200
#define USART2_RX_LENGTH_MAX    200
#define USART3_RX_LENGTH_MAX    250

extern unsigned char USART2_OV_FLAG;
extern unsigned char USART1_OV_FLAG;
extern unsigned char usart1_rx_buf[USART1_RX_LENGTH_MAX];//串口1的接收数据缓存
extern unsigned int  usart1_rx_length;
extern unsigned char usart2_rx_buf[USART2_RX_LENGTH_MAX];
extern unsigned int  usart2_rx_length;
extern unsigned char usart3_rx_buf[USART3_RX_LENGTH_MAX];
extern unsigned int  usart3_rx_length;
extern unsigned int  time3_usart1,time3_usart2,time3_usart3;

//       
//串口1USART1
#define  DEBUG_USART1                    USART1
#define  DEBUG_USART1_CLK                RCC_APB2Periph_USART1
#define  DEBUG_USART1_APBxClkCmd         RCC_APB2PeriphClockCmd
#define  DEBUG_USART1_BAUDRATE           115200           ///波特率

// USART GPIO 物理引脚宏定义
#define  DEBUG_USART1_GPIO_CLK           (RCC_APB2Periph_GPIOA)
#define  DEBUG_USART1_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
   
#define  DEBUG_USART1_TX_GPIO_PORT       GPIOA   
#define  DEBUG_USART1_TX_GPIO_PIN        GPIO_Pin_9
#define  DEBUG_USART1_RX_GPIO_PORT       GPIOA
#define  DEBUG_USART1_RX_GPIO_PIN        GPIO_Pin_10

#define  DEBUG_USART1_IRQ                USART1_IRQn
#define  DEBUG_USART1_IRQHandler         USART1_IRQHandler


//串口2-USART2
#define  DEBUG_USART2                   USART2
#define  DEBUG_USART2_CLK                RCC_APB1Periph_USART2
#define  DEBUG_USART2_APBxClkCmd         RCC_APB1PeriphClockCmd
#define  DEBUG_USART2_BAUDRATE           115200

// USART GPIO 物理引脚宏定义
#define  DEBUG_USART2_GPIO_CLK           (RCC_APB2Periph_GPIOA)
#define  DEBUG_USART2_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
   
#define  DEBUG_USART2_TX_GPIO_PORT       GPIOA   
#define  DEBUG_USART2_TX_GPIO_PIN        GPIO_Pin_2
#define  DEBUG_USART2_RX_GPIO_PORT       GPIOA
#define  DEBUG_USART2_RX_GPIO_PIN        GPIO_Pin_3

#define  DEBUG_USART2_IRQ                USART2_IRQn
#define  DEBUG_USART2_IRQHandler         USART2_IRQHandler

1.3 MODBUS
  主要实现功能码03读取和06写入功能。
  1.3.1 MODBUS.c

#define ADDR 1   
#define NULL 0
#define MODBUS_LENGTH 100

//波特率列表
u32 MODBUS_BaudRate[10]={4800,9600,14400,19200,38400,56000,57600,115200,128000,256000};   
u16   Flash_Usart_BaudRate;      
u16   Flash_Modbus_ADDR;                //Modbus ID号
                       


u8 canbuf[8]={0xff,0x00,0x30,0x31,0x32,0x01,0x02,0x03};
unsigned int UsartNUM;
unsigned short modbus_reg[MODBUS_LENGTH];


unsigned int Calculate_FLAG;

const unsigned char auchCRCHi[] = /* CRC��λ�ֽڱ�*/
{          
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
} ;

const unsigned char auchCRCLo[] = /* CRC��λ�ֽڱ�*/
{
        0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC,
        0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8,
        0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14,
        0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0,
        0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C,
        0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28,
        0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4,
        0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0,
        0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C,
        0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78,
        0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4,
        0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50,
        0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C,
        0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
        0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44,
        0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40
} ;         

/******************************************************************************
                                                CRC校验
*******************************************************************************/
unsigned int CRC_Calculate(unsigned char *pdata,unsigned char num)
{
  unsigned char  uchCRCHi = 0xFF ;               
        unsigned char  uchCRCLo = 0xFF ;               
        unsigned char uIndex ;               
        while(num --)                    
        {
                uIndex = uchCRCHi^*pdata++ ;           
                uchCRCHi = uchCRCLo^auchCRCHi[uIndex];
                uchCRCLo = auchCRCLo[uIndex];
        }
        return (uchCRCHi << 8 | uchCRCLo) ;
}
/******************************************************************************
                                                        数据应答发送函数
*******************************************************************************/
void MODBUS_Send(unsigned char *buf,unsigned int length)///发送length个数据
{
        if(UsartNUM==1)
                Usart1_SendString(buf,length);
       
        if(UsartNUM==2)
        {       
                Usart2_SendString(buf,length);
        }
}

///******************************************************************************
//                                                    03功能函数
//*******************************************************************************/
void MODBUS_03_Return(unsigned int startaddr,unsigned int number)
{

    unsigned char send_length;
    unsigned char send_buf[205];
    unsigned char i;
    unsigned int crc;
       
    send_length = 0;
    send_buf[send_length++] = Flash_Modbus_ADDR;
    send_buf[send_length++] = 0x03;        //03功能码
    send_buf[send_length++] = number*2;          //
    for (i = 0;i < number;i++)
    {
        send_buf[send_length++] = modbus_reg[startaddr+i]/256;
        send_buf[send_length++] = modbus_reg[startaddr+i]%256;
    }
    crc = CRC_Calculate(send_buf,send_length);
    send_buf[send_length++] = crc/256;
    send_buf[send_length++] = crc%256;
    MODBUS_Send(send_buf,send_length);
}
///******************************************************************************
//                                                        发送MODBUS协议字符串
//*******************************************************************************/
void MODBUS_10_Return(unsigned int addr,unsigned int code)
{
    unsigned char send_buf[8];
        unsigned int crc;
        send_buf[0] = Flash_Modbus_ADDR;
        send_buf[1] = 16;
        send_buf[2] = (addr / 256);
        send_buf[3] = (addr % 256);
        send_buf[4] = (code / 256);
        send_buf[5] = (code % 256);
        crc = CRC_Calculate(send_buf,6);
        send_buf[6] = (crc / 256);
  send_buf[7] = (crc % 256);
        MODBUS_Send(send_buf,8);
}

///******************************************************************************
//                                            MODBUS数据接收处理函数
//*******************************************************************************/
void MODBUS(unsigned char *buf,unsigned int length,unsigned int NUM)
{
        unsigned int startaddr,number,code;
        unsigned int crc;
        UsartNUM=NUM;
          crc = CRC_Calculate(buf,length-2);

    if (buf[0] == Flash_Modbus_ADDR&&buf[length-2] == (crc / 256)&&buf[length-1] == (crc % 256))
    {
                        unsigned int Write_EN=0;
       
                        MODBUS_datain();
        switch(buf[1])
        {
            case 0x03:    //03 读取数据
                startaddr = buf[2]*256 + buf[3];
                number = buf[4]*256 + buf[5];
                                                                if ((startaddr+number) > MODBUS_LENGTH)
                                                                {       
                                                                        break;
                                                                }                                       
                                                                MODBUS_03_Return(startaddr,number);
                break;
            case 0x06:      //写一个数据
                startaddr = buf[2]*256 + buf[3];
                code = buf[4]*256 + buf[5];
                                                                if ((startaddr) > MODBUS_LENGTH)
                                                                {       
                                                                        break;
                                                                }
                modbus_reg[startaddr] = code;
                MODBUS_Send(buf,length);//原封不动的返回
                                                                Write_EN=1;
                                                                break;
                                                               
                                                       
                                                case 0x10:     
                                                                startaddr = buf[2]*256 + buf[3];
                                                                number = buf[4]*256 + buf[5];
                                                                if ((startaddr+number) > MODBUS_LENGTH)
                                                                {       
                                                                        break;
                                                                }
                                                                for (code = 0;code < number;code++)
                                                                {
                                                                        modbus_reg[startaddr + code] = buf[6+code*2]*256 + buf[7+code*2];
                                                                }                       
                                                                MODBUS_10_Return(startaddr,number);
                                                                SYS_DEBUG_AP_FLAG=10;
                                                               
                                                                break;       
                                               
                                               
            default:
                break;
        }
                               
    }
}

/******************************************************************************
                              串口接收事件
*******************************************************************************/
void MODBUS_event()
{
        if ((usart1_rx_length) && (time3_usart1 >= (10-Flash_Usart_BaudRate)*5)) //串口1接收到一帧数据
                {

                        MODBUS(usart1_rx_buf,usart1_rx_length,1);
                        usart1_rx_length = 0;
                        time3_usart1 = 0;
                }
        if ((usart2_rx_length) && (time3_usart2 >= (10-Flash_Usart_BaudRate)*5))
        {

                    MODBUS(usart2_rx_buf,usart2_rx_length,2);
                        usart1_rx_length = 0;
                        time3_usart1 = 0;
               
        }
}
///******************************************************************************
//                                                                MODBUS寄存器
//*******************************************************************************/
void MODBUS_datain()
{

        modbus_reg[0]=Flash_Usart_BaudRate;///0x0007
        modbus_reg[1]=Flash_Modbus_ADDR;  ///Modbus ID号
        modbus_reg[2]=0x1111;        
        modbus_reg[3]=0x2222;        
        modbus_reg[4]=0x3333;        
        ///.....
        ///modbus_reg[n]=.....;
}
1.3.2 MODBUS.h

#ifndef __MODBUS_H
#define __MODBUS_H

#include "stm32f10x.h"
#include

extern  u32 MODBUS_BaudRate[10];
extern  u16   Flash_Modbus_ADDR;   
extern  u16   Flash_Usart_BaudRate;   

void MODBUS_Send(unsigned char *buf,unsigned int length);
void MODBUS(unsigned char *buf,unsigned int length,unsigned int UsartNUM);
void MODBUS_ReadFromEEPROM(void);
void MODBUS_event(void);
void MODBUS_datain(void);
unsigned int CRC_Calculate(unsigned char *pdata,unsigned char num);
extern unsigned short modbus_reg[];

#endif       
1.4 main函数

        unsigned char send_buf[10];
    char receive_buf[205];
        unsigned char i;


int main(void)
{       

    USART1_Init();
        USART2_Init();

        TIM3_Int_Init(1,7199);//10Kh的计数频率，计数1次为500us 计算串口接收等待时间
        Flash_Modbus_ADDR=0x0001;///本设备从站地址号
        Flash_Usart_BaudRate=0x0007;
       
  while(1)
        {       
                 MODBUS_event();//串口MODBUS接收事件
        }       
}
1.5 上位机仿真结果
  
  

  

   
  2.F103做主站（程序），另外一个设备做从站
  中断、定时器、串口等配置均与上面从站一致。不同的是：
  1、主站需要发送指令代码
  2、串口中断函数需要简单的修改，将接收到的数据发给上位机，可以查看是否正常。
  如下是一个简单的main函数

        unsigned char send_buf[10];
    char receive_buf[205];
        unsigned char i;

int main(void)
{       
    USART1_Init();
        USART2_Init();
        USART4_Init();       
        TIM3_Int_Init(1,7199);
        Flash_Modbus_ADDR=0x0001;
        Flash_Usart_BaudRate=0x0007;
               
//        send_buf[0]=0x01;//从站地址
//        send_buf[1]=0x03;//功能码
//        send_buf[2]=0x00;//寄存器地址起始位高字节
//        send_buf[3]=0x00;//寄存器地址起始位低字节
//        send_buf[4]=0x00;//读取寄存器数量高字节
//        send_buf[5]=0x64;//读取寄存器数量低字节
//        send_buf[6]=0x44;///CRC高字节
//        send_buf[7]=0x21;///CRC低字节
       
        send_buf[0]=0x01;
        send_buf[1]=0x03;
        send_buf[2]=0x00;
        send_buf[3]=0x00;
        send_buf[4]=0x00;
        send_buf[5]=0x03;
        send_buf[6]=0x05;
        send_buf[7]=0xCB;
       
                for(i=0;i<8;i++)
                {
                        Usart_SendByte( DEBUG_USART2,send_buf);
                }
       
       
  while(1)
        {       
//                 MODBUS_event();//暂时不需要对接收到的数据处理
        }       
}