STM32 Modbus RTU 通讯从站程序

以下是基于STM32的Modbus RTU通讯从站程序的示例代码：

/* Includes */
#include "stm32f10x.h"

/* Private typedef */
typedef struct {
  uint16_t address;
  uint8_t function;
  uint16_t starting_address;
  uint16_t quantity;
  uint16_t crc;
} modbus_request_t;

typedef struct {
  uint8_t address;
  uint8_t function;
  uint8_t byte_count;
  uint16_t data[128];
  uint16_t crc;
} modbus_response_t;

/* Private define */
#define SLAVE_ADDRESS 0x01
#define BUFFER_SIZE 256

/* Private variables */
uint8_t buffer[BUFFER_SIZE];
uint16_t buffer_index = 0;
modbus_request_t request;
modbus_response_t response;

/* Private function prototypes */
void USART1_IRQHandler(void);
void process_request(void);
uint16_t calculate_crc(uint8_t* data, uint16_t length);

/* Private functions */
void USART1_IRQHandler(void) {
  if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
    uint8_t data = USART_ReceiveData(USART1);
    buffer[buffer_index++] = data;
    if (buffer_index >= BUFFER_SIZE) {
      buffer_index = 0;
    }
    if (buffer_index >= 4) {
      if (buffer[0] == SLAVE_ADDRESS) {
        uint16_t crc = calculate_crc(buffer, buffer_index - 2);
        if (crc == (buffer[buffer_index - 2] << 8 | buffer[buffer_index - 1])) {
          process_request();
        }
      }
    }
  }
}

void process_request(void) {
  request.address = buffer[0];
  request.function = buffer[1];
  request.starting_address = buffer[2] << 8 | buffer[3];
  request.quantity = buffer[4] << 8 | buffer[5];
  response.address = request.address;
  response.function = request.function;
  response.byte_count = request.quantity * 2;
  for (uint16_t i = 0; i < request.quantity; i++) {
    response.data[i] = i;
  }
  uint16_t crc = calculate_crc((uint8_t*)&response, 3 + response.byte_count);
  response.crc = crc;
  USART_SendData(USART1, response.address);
  USART_SendData(USART1, response.function);
  USART_SendData(USART1, response.byte_count);
  for (uint16_t i = 0; i < response.byte_count / 2; i++) {
    USART_SendData(USART1, response.data[i] >> 8);
    USART_SendData(USART1, response.data[i] & 0xFF);
  }
  USART_SendData(USART1, response.crc >> 8);
  USART_SendData(USART1, response.crc & 0xFF);
  buffer_index = 0;
}

uint16_t calculate_crc(uint8_t* data, uint16_t length) {
  uint16_t crc = 0xFFFF;
  for (uint16_t i = 0; i < length; i++) {
    crc ^= data[i];
    for (uint16_t j = 0; j < 8; j++) {
      if (crc & 0x0001) {
        crc >>= 1;
        crc ^= 0xA001;
      } else {
        crc >>= 1;
      }
    }
  }
  return crc;
}

int main(void) {
  /* USART1 initialization */
  USART_InitTypeDef USART_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  /* Enable USART1 and GPIOA clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
  /* Configure USART1 Tx (PA.9) as alternate function push-pull */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  /* Configure USART1 Rx (PA.10) as input floating */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  /* USART1 configuration */
  USART_InitStructure.USART_BaudRate = 9600;
  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(USART1, &USART_InitStructure);
  /* Enable USART1 interrupt */
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  /* Enable USART1 */
  USART_Cmd(USART1, ENABLE);
  /* NVIC configuration */
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  /* Infinite loop */
  while (1) {
  }
}

该示例代码使用STM32的USART1模块实现Modbus RTU通讯从站功能。在程序中，首先定义了两个结构体modbus_request_t和modbus_response_t，用于存储Modbus请求和响应数据。然后定义了USART1_IRQHandler()函数，该函数用于处理USART1接收中断，将接收到的数据存储到缓冲区中。如果接收到的数据符合Modbus RTU协议格式，则调用process_request()函数处理请求并发送响应数据。process_request()函数将请求数据解析成request结构体，然后根据请求数据生成响应数据并存储到response结构体中，最后将响应数据发送回主机。calculate_crc()函数用于计算Modbus RTU协议中的CRC校验码。在main()函数中，首先配置USART1模块和GPIO口，然后进入无限循环等待中断。