基于RT-Thread的CAN电机驱动板设计 （二）uart串口DMA的实现

已于 2022-06-01 21:01:38 修改
阅读量1.1k 收藏 17
点赞数 3
分类专栏： RT-Thread 文章标签： rtt uart stm32
于 2021-06-05 10:31:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42487906/article/details/117560534
版权

引言

在上一篇文章中完成了对项目的需求分析以及硬件电路的设计和制作。接下来就开始项目软件方面的实现。

  • 首先本章完成UART实现485通信的配置和调试，同时UART采用DMA方式传输，DMA控制器代替CPU完成数据传输工作，腾出时间给CPU，提高了CPU的使用的使用效率。完成PC上位机和电机驱动板的通讯。
  • 然后在下一章完成rt-thread的CAN驱动的通讯与配置，完成CAN电机和电机驱动板的通讯。
  • 最后实现按键中断，在中断中通过CAN发送电机启停信号完成电机启停控制

资料连接

本项目的所有资料全部开源：

硬件工程：https://lceda.cn/FranHawk/485tocan_motor_controller
软件工程：https://github.com/FranHawk/RT-Thread-485toCAN

程序框架

在这里插入图片描述

前期准备

  • 制作好的电机驱动板一块
  • USB转485模块一个，用来插在PC上实现485协议与电机驱动板通讯
  • rtthread studio开发环境
  • cubemx配置工具
    硬件连接图如下所示，蓝色的就是USB转485模块
    在这里插入图片描述

开发过程

创建RT-Thread工程

打开rtthread studio，根据芯片型号新建工程，根据提示，需要将时钟源改为外部晶振

在这里插入图片描述
打开cubemx，根据芯片型号创建cubemx工程，高速时钟源选择外部晶振
在这里插入图片描述
并按照如下图配置时钟树
在这里插入图片描述
最后通过这个cubemx工程生成一个MDK5的工程，打开这个MDK5工程
在这里插入图片描述
在main.c中找到时钟配置的代码如下，并且复制到rtthread studio的drv_clk.c文件的system_clock_config函数中去，覆盖掉原内容
在这里插入图片描述
复制后的system_clock_config函数如下

void system_clock_config(int target_freq_Mhz)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
      RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

      /** Initializes the CPU, AHB and APB busses clocks
      */
      RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
      RCC_OscInitStruct.HSEState = RCC_HSE_ON;
      RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
      RCC_OscInitStruct.HSIState = RCC_HSI_ON;
      RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
      RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
      RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
      if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
      {
        Error_Handler();
      }
      /** Initializes the CPU, AHB and APB busses clocks
      */
      RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                  |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
      RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
      RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
      RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
      RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

      if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
      {
        Error_Handler();
      }
}

至此rtthread studio工程创建完毕，并完成外部时钟源配置

配置带DMA功能的UART

使用板子上的485A接口，根据电路图有
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
485A芯片用的是UART3，同时由于485是一种半双工的协议，还有RE引脚控制收发，RE为低电平时为接收，高电平时为发送。
打开rtthread settings配置串口
在这里插入图片描述
在这里插入图片描述
使能串口DMA模式，保存并关闭rtthread settings,打开board.h，根据注释的提示，输入UART3的引脚信息
在这里插入图片描述
打开stm32f1xx_hal_conf.h，注释掉DMA的使能如下图
在这里插入图片描述
保存并编译。

指令定义

根据实际需求，我们需要向CAN电机发送转矩电流指令和查询转矩电流和电机编码器位置的指令。我们要做的不是简单地将上位机的指令直接由485协议换成CAN协议转发到电机，而是通过自定义一套指令，对指令进行拆分和解码，然后再向电机发送相应的控制指令。
首先查看电机的数据手册。

转矩电流控制指令

在这里插入图片描述
在这里插入图片描述

电机状态查询指令

在这里插入图片描述
发现他们的消息回复是一样的，因此收到两种消息我们可以按照同一种方式解码

上位机向驱动板指令定义

根据上面的指令，我们自定义了一套上位机向驱动板的指令
首先是转矩电流控制指令
在这里插入图片描述
然后是状态查询指令
在这里插入图片描述
最后电机驱动板收到电机上报的状态后，也需要通过解码最后拼接成一条指令传到上位机
在这里插入图片描述
在博客中可能不太清楚，这个定义指令的文件我都会开源出来

参考rtthread官网的UART设备的示例程序编写代码

https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/device/uart/uart

首先定义引脚名字和设备名称

/* RS485A串口名称和收发控制引脚定义*/
#define RS485A_UART_NAME       "uart3"
#define RS485A_RE_PIN GET_PIN(B,1)

串口设置为DMA中断接收方式，DMA接收完成串口数据后调用完成接收中断，接收中断通过一个消息队列，向串口数据处理线程发送设备句柄和消息长度。串口数据处理线程接收到消息队列传过来的数据后完成后续的数据处理工作。这里借鉴了中断要快进快出的思想，接收中断中仅向消息队列发送消息，然后退出，串口数据处理线程完成剩余的数据处理任务，相当于是中断的底半部分。参考链接如下：
https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/interrupt/interrupt
消息队列的消息定义如下

/* 串口接收消息结构*/
struct rs485_serial_rx_msg
{
    rt_device_t dev;
    rt_size_t size;
};

串口设备句柄，消息队列控制块，串口配置结构体定义如下

/* 串口设备句柄 */
static rt_device_t rs485_serial_device_handle;
/* 消息队列控制块 */
static struct rt_messagequeue rs485_serial_rx_mq;
/* 串口配置结构体 */
struct serial_configure rs485_serial_config = RT_SERIAL_CONFIG_DEFAULT;

485串口初始化配置以及数据处理线程初始化，波特率115200，8位数据位1位停止位，优先级设为6

/* rs485串口接收数据线程初始化 */
static rt_err_t uart_dma_thread_init()
{
    rt_err_t ret = RT_EOK;
    static char msg_pool[256];

    /* 初始化消息队列 */
    rt_mq_init(&rs485_serial_rx_mq, "rx_mq", msg_pool, /* 存放消息的缓冲区 */
    sizeof(struct rs485_serial_rx_msg), /* 一条消息的最大长度 */
    sizeof(msg_pool), /* 存放消息的缓冲区大小 */
    RT_IPC_FLAG_FIFO); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */

    /* 收发控制引脚使能并拉低 */
    rt_pin_mode(RS485A_RE_PIN, PIN_MODE_OUTPUT);
    rt_pin_write(RS485A_RE_PIN, PIN_LOW);

    /* 查找串口设备 */
    rs485_serial_device_handle = rt_device_find(RS485A_UART_NAME);
    if (!rs485_serial_device_handle)
    {
        rt_kprintf("find %s failed!\n", RS485A_UART_NAME);
        return RT_ERROR;
    }

    /* 修改串口配置参数 */
    rs485_serial_config.baud_rate = BAUD_RATE_115200;        //修改波特率为 115200
    rs485_serial_config.data_bits = DATA_BITS_8;           //数据位 8
    rs485_serial_config.stop_bits = STOP_BITS_1;           //停止位 1
    rs485_serial_config.bufsz = 128;                   //修改缓冲区 buff size 为 128
    rs485_serial_config.parity = PARITY_NONE;           //无奇偶校验位

    /* 控制串口设备。通过控制接口传入命令控制字，与控制参数 */
    rt_device_control(rs485_serial_device_handle, RT_DEVICE_CTRL_CONFIG, &rs485_serial_config);

    /* 以 DMA接收及轮询发送方式打开串口设备 */
    rt_device_open(rs485_serial_device_handle, RT_DEVICE_FLAG_DMA_RX);

    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(rs485_serial_device_handle, uart_input);

    /* 创建 serial 线程，优先级6 */
    rt_thread_t serial_thread_handle = rt_thread_create("rs485_serial", rs485_serial_thread_entry, RT_NULL, 2048, 6,
            10);
    /* 创建成功则启动线程 */
    if (serial_thread_handle != RT_NULL)
    {
        rt_thread_startup(serial_thread_handle);
    }
    else
    {
        ret = RT_ERROR;
    }

    return ret;
}

下面这个函数是DMA接收完成中断服务函数，本着快进快出的原则，中断函数仅将串口设备句柄和接收数据的长度发送到消息队列，数据处理线程从消息队列获取信息，完成剩下的数据处理工作。

/* 串口接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    struct rs485_serial_rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;

    /* 向消息队列发送消息 */
    result = rt_mq_send(&rs485_serial_rx_mq, &msg, sizeof(msg));
    if (result == -RT_EFULL)
    {
        /* 消息队列满 */
        rt_kprintf("message queue full！\n");
    }
    return result;
}

数据处理线程根据上面定义的指令格式，对上位机发送过来的指令进行解码，首先判断帧头帧尾是否正确，然后判断指令类型，完成校验和的计算，最后分别向8个电机通过CAN发送相应格式的指令，最后将电机上报的状态向上位机发送。数据处理线程涉及到一些CAN的部分，这部分下一篇文章会讲，在本文中可以先忽略，重点在于接收并处理串口DMA接收的数据。

/* 串口处理接收数据线程入口 */
static void rs485_serial_thread_entry(void *parameter)
{
    rt_size_t size;
    struct rs485_serial_rx_msg msg;
    struct rt_can_msg can_tx_msg = { 0 };
    rt_err_t result;
    rt_uint32_t rx_length;
    rt_uint8_t check_sum, check_index;
    static char rx_buffer[RT_SERIAL_RB_BUFSZ + 1];

    while (1)
    {
        rt_memset(&msg, 0, sizeof(msg));
        /* 从消息队列中读取消息*/
        result = rt_mq_recv(&rs485_serial_rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
        if (result == RT_EOK)
        {
            //rt_kprintf("%d\n", msg.size);
            /* 从串口读取数据*/

            rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
            
            if ((rx_buffer[0] == 0x5A) && (rx_buffer[18] == 0xA5))
            {
                //rt_kprintf("recevice success\n");
                //判断指令类型，若不为0xFF，则是转矩控制指令,否则为状态查询指令
                if ((rx_buffer[1] != 0xFF) && (rx_buffer[17] != 0xFF))
                {
                    check_sum = 0;
                    for (check_index = 1; check_index < 17; check_index++)
                    {
                        check_sum += rx_buffer[check_index];
                    }
                    if ((check_sum != rx_buffer[17]) && (rx_buffer[17] != 0x00))
                    {
                        rt_kprintf("check_sum wrong\n");
                        rt_kprintf("%02x\n", check_sum);
                    }
                    else
                    {
                        //rt_kprintf("check_sum right\n");

                        /* 向电机发送转矩电流控制数据 */
                        can_tx_msg.ide = RT_CAN_STDID; /* 标准格式 */
                        can_tx_msg.rtr = RT_CAN_DTR; /* 数据帧 */
                        can_tx_msg.len = 8; /* 数据长度为 8 */
                        can_tx_msg.data[0] = TORQUE_CURRENT_CMD;
                        can_tx_msg.data[1] = 0x00;
                        can_tx_msg.data[2] = 0x00;
                        can_tx_msg.data[3] = 0x00;
                        can_tx_msg.data[6] = 0x00;
                        can_tx_msg.data[7] = 0x00;

                        /* CAN向电机1发送数据 */
                        can_tx_msg.id = MOTOR1_ID;
                        can_tx_msg.data[4] = rx_buffer[1];
                        can_tx_msg.data[5] = rx_buffer[2];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机2发送数据 */
                        can_tx_msg.id = MOTOR2_ID;
                        can_tx_msg.data[4] = rx_buffer[3];
                        can_tx_msg.data[5] = rx_buffer[4];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机3发送数据 */
                        can_tx_msg.id = MOTOR3_ID;
                        can_tx_msg.data[4] = rx_buffer[5];
                        can_tx_msg.data[5] = rx_buffer[6];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机4发送数据 */
                        can_tx_msg.id = MOTOR4_ID;
                        can_tx_msg.data[4] = rx_buffer[7];
                        can_tx_msg.data[5] = rx_buffer[8];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机5发送数据 */
                        can_tx_msg.id = MOTOR5_ID;
                        can_tx_msg.data[4] = rx_buffer[9];
                        can_tx_msg.data[5] = rx_buffer[10];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机6发送数据 */
                        can_tx_msg.id = MOTOR6_ID;
                        can_tx_msg.data[4] = rx_buffer[11];
                        can_tx_msg.data[5] = rx_buffer[12];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机7发送数据 */
                        can_tx_msg.id = MOTOR7_ID;
                        can_tx_msg.data[4] = rx_buffer[13];
                        can_tx_msg.data[5] = rx_buffer[14];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                        /* CAN向电机8发送数据 */
                        can_tx_msg.id = MOTOR8_ID;
                        can_tx_msg.data[4] = rx_buffer[15];
                        can_tx_msg.data[5] = rx_buffer[16];
                        /* 发送一帧 CAN 数据 */
                        size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));
                        for (check_index = 1; check_index < 33; check_index++)
                        {
                            serial_tx_buffer[33] += serial_tx_buffer[check_index];
                        }
                        rt_pin_write(RS485A_RE_PIN, PIN_HIGH);/*使485处于发送模式*/
                        rt_device_write(rs485_serial_device_handle, 0, serial_tx_buffer, sizeof(serial_tx_buffer));
                        rt_pin_write(RS485A_RE_PIN, PIN_LOW);/*使485处于接收模式*/
                    }
                }
                else
                {
                    /* 向电机发送状态查询指令 */
                    can_tx_msg.ide = RT_CAN_STDID; /* 标准格式 */
                    can_tx_msg.rtr = RT_CAN_DTR; /* 数据帧 */
                    can_tx_msg.len = 8; /* 数据长度为 8 */
                    can_tx_msg.data[0] = STATE_QUEST_CMD;/* 指令类型为状态查询 */
                    can_tx_msg.data[1] = 0x00;
                    can_tx_msg.data[2] = 0x00;
                    can_tx_msg.data[3] = 0x00;
                    can_tx_msg.data[4] = 0x00;
                    can_tx_msg.data[5] = 0x00;
                    can_tx_msg.data[6] = 0x00;
                    can_tx_msg.data[7] = 0x00;

                    /* CAN向电机1发送数据 */
                    can_tx_msg.id = MOTOR1_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机2发送数据 */
                    can_tx_msg.id = MOTOR2_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机3发送数据 */
                    can_tx_msg.id = MOTOR3_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机4发送数据 */
                    can_tx_msg.id = MOTOR4_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机5发送数据 */
                    can_tx_msg.id = MOTOR5_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机6发送数据 */
                    can_tx_msg.id = MOTOR6_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机7发送数据 */
                    can_tx_msg.id = MOTOR7_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    /* CAN向电机8发送数据 */
                    can_tx_msg.id = MOTOR8_ID;
                    /* 发送一帧 CAN 数据 */
                    size = rt_device_write(can_dev, 0, &can_tx_msg, sizeof(can_tx_msg));

                    //通过485向上位机发送数据
                    for (check_index = 1; check_index < 33; check_index++)
                    {
                        serial_tx_buffer[33] += serial_tx_buffer[check_index];
                    }
                    rt_pin_write(RS485A_RE_PIN, PIN_HIGH);/*使485处于发送模式*/
                    rt_device_write(rs485_serial_device_handle, 0, serial_tx_buffer, sizeof(serial_tx_buffer));
                    rt_pin_write(RS485A_RE_PIN, PIN_LOW);/*使485处于接收模式*/
                }
            }
        }
    }
}

BUG解决（很重要）

在串口DMA接收的过程中发现一个现象，发送一个固定长度的指令，DMA中断会遇到拆包的问题，举例如下：
上位机发送数据：
0x5A 0x4C 0x04 0xB0 0x04 0x14 0x05 0x78 0x05 0xDC 0x05 0x40 0x06 0xA4 0x06 0x08 0x07 0x7A 0xA5
DMA会用两个中断接收数据，指令就被拆包了不能正确的译码：
第一次中断接收数据：0x5A 0x4C 0x04 0xB0 0x04 0x14 0x05 0x78 0x05 0xDC 0x05 0x40 0x06
第二次中断接收数据：0xA4 0x06 0x08 0x07 0x7A 0xA5

一直没能解决这个问题，最后在论坛中发现了答案，链接：
https://club.rt-thread.org/ask/article/307.html
https://club.rt-thread.org/ask/question/427511.html
在drv_usart.c中，找到以下两个函数，分别是DMA接收完成和半完成函数，将dma_isr函数注释掉编译即可
在这里插入图片描述

总结

本文完成了基于rtthread的uart应用代码的编写，实现了电机驱动板和上位机通过485协议的通讯，主要是参照了rtthread官网的文档。下一篇文章实现电机驱动板和CAN电机通过CAN协议通讯，主要完成基于rtthread的CAN驱动的配置。

张竞豪
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RT-thread+GD32F450+uart+DMA.zip
04-07
适用于兆易创新GD32F450系列MCU，适用于需要串口或者串口+DMA形式，内含底层驱动和使用例程
解决rt-thread上使用SPI+DMA
响望的博客
12-07 5275
首先阐述下遇到的问题 使用SPI读取icm20602数据，读取频率为1000hz，使用stm32f407主控，发现CPU占用率达到了70%，将此线程注释掉后CPU占用率掉到25%，看来这里要着重优化，便萌生了使用DMA的想法。 使用SPI+DMA要进行的配置 1.开启RTT设备驱动。点击自己的工程 ->RT-Thread Setting2.在board.hzhong3.在board.c文件里加入以下函数，此函数受设备框架调用 void HAL_SPI_MspInit(SPI_HandleTypeDef
Rtthread学习笔记（五）串口设备使用示例--DMA 接收及轮询发送_rt thread uart dma示例代码
最新发布
2401_85011895的博客
05-16 466
当串口接收到一批数据后会调用接收回调函数，接收回调函数会把此时缓冲区的数据大小通过消息队列发送给等待的数据处理线程。线程获取到消息后被激活，并读取数据。一般情况下 DMA 接收模式会结合 DMA 接收完成中断和串口空闲中断完成数据接收。
RT-Thread开启串口.中断和DMA接收（手把手教学）
weixin_44737233的博客
09-10 4516
串口是指数据一位一位地顺序传送，其特点是通讯线路简单，只要一对传输线就可以实现双向通信（可以直接利用电话线作为传输线），从而大大降低了成本，特别适用于远距离通信，但传送速度较慢。一条信息的各位数据被逐位按顺序传送的通讯方式称为串行通讯。串行通讯的特点是：数据位的传送，按位顺序进行，最少只需一根传输线即可完成；成本低但传送速度慢。串行通讯的距离可以从几米到几千米；根据信息的传送方向，串行通讯可以进一步分为单工、半双工和全双工三种。
RT-Thread 三步实现利用DMA进行串口发送
Bit_Dong的博客
12-05 1137
想要使用串口的DMA发送，需要在board.h打开相关宏定义在串口驱动文件drv_usart.c中可以发现关于dma操作的函数只有两个，所以只需要删除两句函数开头的static关键字。
RT-Thread系列04——串口设备
32Haozi
07-22 1574
RT-Thread使用串口收发数据
rt_thread_nano_stm32f30x
12-25
标题“rt_thread_nano_stm32f30x”指的是一个基于STM32F30x系列微控制器的实时操作系统（RTOS）实现，特别针对rt-thread nano版本进行了优化。rt-thread nano是一款轻量级的RTOS，专为资源有限的微控制器设计，以...
STM32实验工程，使用了RTThread操作系统，单片机型号STM32F103RCT6.zip
04-02
其他可能的文件如board.c/h用于板级支持包，rtconfig.h包含RTThread的配置选项，driver目录下则包含与STM32外设驱动相关的代码。 总的来说，这个实验工程涵盖了嵌入式系统开发的多个方面，包括微控制器的硬件特性、...
STM32开发方案-日常工作用到的例程集合.zip
01-22
6. **串行通信**：包括UART（通用异步收发传输器）、SPI（串行外围接口）和I2C（集成电路间通信）等，是STM32与外部设备进行数据交换的重要接口。 7. **USB通信**：STM32支持USB OTG（On-The-Go），可以作为主机或...
电子-TEST.rar
09-05
3. 强大的外设集：如定时器、串行通信接口（SPI/I2C/UART）、ADC、DMA等，满足多种应用需求。 4. 封装多样：有不同引脚数的封装选项，以适应不同尺寸和复杂度的电路板设计。 STM32-F1系列则是在F0基础上的扩展，...
STM32F103C8T6最小系统最空模板
10-05
STM32F103C8T6是意法半导体（STMicroelectronics）生产的一款基于ARM Cortex-M3内核的微控制器，属于STM32系列中的基础型产品。这款芯片具有丰富的外设接口和高性能计算能力，适用于各种嵌入式应用，如物联网设备、...
RT-Thread DMA
Bit_Dong的博客
11-15 598
这里以串口的DMA方式接收为例，串口1进行调试，串口2进行DMA接收。
RT-Thread Stm32f103开启UART2（DMA接收及轮询发送） 使用RT-Thread Studio
紫蝶侠的博客
03-07 3843
RT-Thread Stm32f103开启UART2 使用RT-Thread Studio 1. 使用RT-Thread Studio新建RT-Thread项目 2. 修改dricer->doard.h *STEP 1, define macro define related to the serial port opening based on the serial port nu...
RT-Thread uart2串口dma idle接收不断帧
Mark_md的博客
06-23 2328
STM32F407 RT-Thread uart2串口dma idle接收不断帧
玩转RT-Thread系列教程(4)--消息队列的使用（串口DMA）
Rb的工作站
06-01 6746
玩转RT-Thread系列教程(4)–消息队列的使用（串口DMA） 一、什么是消息队列 消息队列是另一种常用的线程间通讯方式，是邮箱的扩展。可以应用在多种场合：线程间的消息交换、使用串口接收不定长数据等。 二、消息队列的工作机制 消息队列能够接收来自线程或中断服务例程中不固定长度的消息，并把消息缓存在自己的内存空间中。 其他线程也能够从消息队列中读取相应的消息，而当消息队列是空的时候，可以挂起读取线程。 当有新的消息到达时，挂起的线程将被唤醒以接收并处理消息。消息队列是一种异步的通信方式。 当有多个消
RT-Thread GD32F4xx Usart 驱动之DMA接收
madao1234的博客
04-03 958
记录GD32F4xx Usart DMA驱动的调试
rt-thread+stm32 使用串口dma空闲中断接收不定长数据
gyzw_mx的博客
04-20 3670
文章目录开发环境一、工程配置二、添加代码并测试三、解决问题 开发环境 IDE: RT-Thread Studio v2.1.0 系统版本：v4.0.2 芯片: STM32F407VG 一、工程配置 工程创建完成后，双击工程目录下的 RT-Thread Setting 选择右下角的更多配置 勾选使能串口DMA模式，设置缓冲区大小，ctrl+s保存配置后自动生成代码，然后退出配置页面。 打开 drivers/board.h ，按图示添加代码，引脚配置根据图示自行修改。 二、添加代码并测试 新建一对 u
RT_THREAD 使用UART+DMA接收导致数据分包输出问题(自测)
aping_cs_dn的专栏
12-13 408
参考文章： RT-Thread 文档中心 RT-Thread-请问哪能找到utest的示范用例？RT-Thread问答社区 - RT-Thread RT_Thread的测试框架使用及分析
在rt-thread中使用串口DMA模式的思考
SeniorZ的点滴记录
02-15 3676
DMA的定义 直接存储器存取（Direct Memory Access，DMA）是计算机科学中的一种内存访问技术。它允许某些电脑内部的硬体子系统（电脑外设），可以独立地直接读写系统存储器，而不需绕道 CPU。在同等程度的CPU负担下，DMA是一种快速的数据传送方式。它允许不同速度的硬件装置来沟通，而不需要依于 CPU的大量中断请求。 DMA有什么用？ 直接存储器存取用来提供在外设和存储器之间...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值