在rt_thread中，用stm32f407，hal库实现两个串口的收发，PA9,PA10和PA2,PA3分别为串口1和串口2

好的，针对您的问题，我可以给您提供以下的代码模板，供您参考：

#include "rtthread.h"
#include "stm32f4xx_hal.h"

/* 定义串口句柄 */
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;

/* 定义串口接收缓冲区 */
#define UART1_RX_BUFFER_SIZE 128
#define UART2_RX_BUFFER_SIZE 128
static char uart1_rx_buffer[UART1_RX_BUFFER_SIZE];
static char uart2_rx_buffer[UART2_RX_BUFFER_SIZE];

/* 定义串口接收缓冲区的读写指针 */
static rt_size_t uart1_rx_index = 0;
static rt_size_t uart2_rx_index = 0;

/* 声明串口1和串口2的中断处理函数 */
void USART1_IRQHandler(void);
void USART2_IRQHandler(void);

/* 串口1的中断处理函数 */
void USART1_IRQHandler(void)
{
    rt_interrupt_enter();

    /* 判断是否是接收中断 */
    if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE) != RESET)
    {
        /* 读取接收到的数据 */
        char ch = (char)(huart1.Instance->DR & 0xFF);

        /* 将数据存入接收缓冲区 */
        uart1_rx_buffer[uart1_rx_index++] = ch;

        /* 判断是否到达缓冲区末尾 */
        if (uart1_rx_index >= UART1_RX_BUFFER_SIZE)
        {
            uart1_rx_index = 0;
        }
    }

    rt_interrupt_leave();
}

/* 串口2的中断处理函数 */
void USART2_IRQHandler(void)
{
    rt_interrupt_enter();

    /* 判断是否是接收中断 */
    if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_RXNE) != RESET)
    {
        /* 读取接收到的数据 */
        char ch = (char)(huart2.Instance->DR & 0xFF);

        /* 将数据存入接收缓冲区 */
        uart2_rx_buffer[uart2_rx_index++] = ch;

        /* 判断是否到达缓冲区末尾 */
        if (uart2_rx_index >= UART2_RX_BUFFER_SIZE)
        {
            uart2_rx_index = 0;
        }
    }

    rt_interrupt_leave();
}

int main(void)
{
    /* 初始化操作系统 */
    rt_thread_startup();

    /* 初始化串口1的GPIO口和UART口 */
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_USART1_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler();
    }

    /* 使能串口1的中断 */
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    HAL_NVIC_EnableIRQ(USART1_IRQn);

    /* 初始化串口2的GPIO口和UART口 */
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_USART2_CLK_ENABLE();

    GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart2) != HAL_OK)
    {
        Error_Handler();
    }

    /* 使能串口2的中断 */
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 2);
    HAL_NVIC_EnableIRQ(USART2_IRQn);

    /* 创建线程并启动 */
    rt_thread_t thread = rt_thread_create("uart_recv_thread", uart_recv_thread_entry, RT_NULL, 1024, 10, 10);
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }

    /* 启动操作系统 */
    rt_thread_run();
}

/* 串口接收线程的入口函数 */
void uart_recv_thread_entry(void *parameter)
{
    while (1)
    {
        /* 读取串口1的接收缓冲区 */
        if (uart1_rx_index > 0)
        {
            rt_kprintf("UART1 recv: %s\n", uart1_rx_buffer);

            /* 清空接收缓冲区 */
            memset(uart1_rx_buffer, 0, UART1_RX_BUFFER_SIZE);
            uart1_rx_index = 0;
        }

        /* 读取串口2的接收缓冲区 */
        if (uart2_rx_index > 0)
        {
            rt_kprintf("UART2 recv: %s\n", uart2_rx_buffer);

            /* 清空接收缓冲区 */
            memset(uart2_rx_buffer, 0, UART2_RX_BUFFER_SIZE);
            uart2_rx_index = 0;
        }

        rt_thread_mdelay(100);
    }
}

需要注意的是，需要在`rtconfig.h`中开启`RT_USING_UART`和`RT_USING_SERIAL`宏定义，才能使用RT-Thread的串口功能。另外，上述代码中的`uart_recv_thread_entry`函数是一个线程入口函数，用于循环读取串口接收缓冲区的数据，并进行处理。具体的数据处理逻辑可以根据您的需求进行修改。