stm32f4 IO模拟uart通信

已于 2024-06-06 12:03:46 修改
阅读量265 收藏 5
点赞数 10
文章标签： stm32 单片机
于 2024-05-30 11:25:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45858810/article/details/139319105
版权

最近工作中需要用到单片机与外接模块通信，因为串口都被占用，所以需要使用普通io口模拟uart实现通信，使用到PF0（tx）、PF1（rx）、TIM12（微秒延时）、TIM13IT（信号线电平检测）、TIM14IT（数据结束判断）,特此做了demo进行测试，实测运行正常，用cubemx生成代码移植到rt-thread studio使用。如有遗漏或者存在bug的地方，请多指正！！

gpio配置在board.c

void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  /*Configure GPIO pin : PF0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
  HAL_GPIO_WritePin(GPIOF, GPIO_PIN_0, GPIO_PIN_SET);

  /*Configure GPIO pin : PF1 */	//rx配置为外部中断下降沿触发
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
  HAL_NVIC_SetPriority(EXTI1_IRQn,2,0);
  HAL_NVIC_EnableIRQ(EXTI1_IRQn);
}

stm32f4xx_hal_conf.h

#define HAL_MODULE_ENABLED  
#define HAL_TIM_MODULE_ENABLED
#define HAL_UART_MODULE_ENABLED
#define HAL_EXTI_MODULE_ENABLED
#define HAL_GPIO_MODULE_ENABLED
#define HAL_DMA_MODULE_ENABLED
#define HAL_RCC_MODULE_ENABLED
#define HAL_FLASH_MODULE_ENABLED
#define HAL_PWR_MODULE_ENABLED
#define HAL_CORTEX_MODULE_ENABLED

tim.c 定时配置为104us对应9600波特率，高波特率会乱码，9600刚刚好。TIM13、TIM14的中断服务函数和TIM8的部分中断共用一个：TIM8_UP_TIM13_IRQn、TIM8_TRG_COM_TIM14_IRQn。cv的时候注意mspinit中定时器时钟是否对应开启，中断优先级视情况而定

TIM_HandleTypeDef htim12;    //用作us级延时，104us对应波特率9600
TIM_HandleTypeDef htim13;
TIM_HandleTypeDef htim14;

void MX_TIM12_Init(void)
{
    TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    htim12.Instance = TIM12;
    htim12.Init.Prescaler = 84 - 1;
    htim12.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim12.Init.Period = 0xFFFF -1 ;
    htim12.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim12.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    if (HAL_TIM_Base_Init(&htim12) != HAL_OK)
    {
        Error_Handler();
    }
    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    if (HAL_TIM_ConfigClockSource(&htim12, &sClockSourceConfig) != HAL_OK)
    {
        Error_Handler();
    }
    HAL_TIM_Base_Start(&htim12);
}

void MX_TIM13_Init(void)
{
    htim13.Instance = TIM13;
    htim13.Init.Prescaler = 84 - 1;
    htim13.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim13.Init.Period = 104 - 1;
    htim13.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim13.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    if (HAL_TIM_Base_Init(&htim13) != HAL_OK)
    {
        Error_Handler();
    }
    __HAL_TIM_CLEAR_FLAG(&htim13,TIM_FLAG_UPDATE);   //清除溢出中断标志
    __HAL_TIM_ENABLE_IT(&htim13,TIM_FLAG_UPDATE);
    HAL_TIM_Base_Stop_IT(&htim13);
}

void MX_TIM14_Init(void)
{
    htim14.Instance = TIM14;
    htim14.Init.Prescaler = 84 - 1;
    htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim14.Init.Period = 104 - 1;
    htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
    {
    Error_Handler();
    }
    __HAL_TIM_CLEAR_FLAG(&htim14,TIM_FLAG_UPDATE);   //清除溢出中断标志
    __HAL_TIM_ENABLE_IT(&htim14,TIM_FLAG_UPDATE);
    HAL_TIM_Base_Stop_IT(&htim14);
}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

    if(tim_baseHandle->Instance==TIM12)
    {
        __HAL_RCC_TIM12_CLK_ENABLE();
    }
    else if(tim_baseHandle->Instance==TIM13)
    {
        __HAL_RCC_TIM13_CLK_ENABLE();
        HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 2, 0);
        HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
    }
    else if(tim_baseHandle->Instance==TIM14)
    {
        __HAL_RCC_TIM14_CLK_ENABLE();
        HAL_NVIC_SetPriority(TIM8_TRG_COM_TIM14_IRQn, 1, 0);
        HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);
    }
}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{

    if(tim_baseHandle->Instance==TIM12)
    {
        __HAL_RCC_TIM12_CLK_DISABLE();
    }
    else if(tim_baseHandle->Instance==TIM13)
    {
        __HAL_RCC_TIM13_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM8_UP_TIM13_IRQn);
    }
    else if(tim_baseHandle->Instance==TIM14)
    {
        __HAL_RCC_TIM14_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM8_TRG_COM_TIM14_IRQn);
    }
}

// 微秒延时
void delay_us(uint16_t us)
{
    uint16_t tp1;
    uint16_t tp2;
    uint16_t dif;
    tp1 = TIM12->CNT;
    while(1){
        tp2 = TIM12->CNT;
        if(tp2 < tp1){
           dif = tp2 + 0xffff - tp1;
        }else{
           dif = tp2 - tp1;
        }
        if(dif >= us)
            break;
    }
}

void delay_ms(uint16_t ms)
{
    for(uint32_t i = 0 ;i < ms ;i++){
        delay_us(1000);
    }
}

it.h

#define UART_REC_LEN 32

enum {
    UART_START_BIT, //停止位
    UART_D0_BIT, //bit0
    UART_D1_BIT, //bit1
    UART_D2_BIT, //bit2
    UART_D3_BIT, //bit3
    UART_D4_BIT, //bit4
    UART_D5_BIT, //bit5
    UART_D6_BIT, //bit6
    UART_D7_BIT, //bit7
    UART_STOP_BIT,  //结束位
};

extern uint8_t recvStat;
extern uint8_t recvData;
extern uint8_t UART_RX_BUF[UART_REC_LEN];
extern uint8_t UART_RX_STA;
extern uint8_t send_flag;
extern uint8_t data_cnt;

it.c

uint8_t recvStat = UART_STOP_BIT;
uint8_t recvData = 0x00;
uint8_t UART_RX_BUF[UART_REC_LEN];
uint8_t UART_RX_STA = 0;
uint8_t cnt = 0;
uint8_t data_cnt = 0;

void EXTI1_IRQHandler(void)
{
    rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
    rt_interrupt_leave();
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if(GPIO_Pin == GPIO_PIN_1){
        if(!UART_RD_RX){
           if(recvStat == UART_STOP_BIT){
               recvStat = UART_START_BIT;
               HAL_TIM_Base_Stop_IT(&htim14);
               __HAL_TIM_SET_COUNTER(&htim14,0);
               HAL_TIM_Base_Start_IT(&htim13);
           }
        }
    }
    __HAL_GPIO_EXTI_CLEAR_FLAG(EXTI_LINE_1);
}

void TIM8_UP_TIM13_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim13);
}

void TIM8_TRG_COM_TIM14_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim14);
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM13){
          recvStat++;
          if(recvStat == UART_STOP_BIT){
              HAL_TIM_Base_Stop_IT(&htim13);
              __HAL_TIM_SET_COUNTER(&htim13,0);
              UART_RX_BUF[UART_RX_STA] = recvData;  //将当前处理完的字节存入数组
			  recvData = 0;
              UART_RX_STA++;
              data_cnt++;    //判断接收到的字节数
              HAL_TIM_Base_Start_IT(&htim14);
          }else{
              if(UART_RD_RX)
                  recvData |= 1 << (recvStat - 1);
              else
                  recvData &= ~(1 << (recvStat - 1));
          }
    }else if(htim->Instance == TIM14){
        if((recvStat == UART_STOP_BIT) && UART_RD_RX){
           cnt++;
           if(cnt > 11){
               cnt = 0;
               uart_transmit_str(UART_RX_BUF);
               buf_clear();
               HAL_TIM_Base_Stop_IT(&htim14);
               __HAL_TIM_SET_COUNTER(&htim14,0);
           }
        }
    }
}

iouart.h

#include "main.h"

#define delay_time   104        //波特率9600,1s传输9600bit

#define UART_SET_TX(x)      HAL_GPIO_WritePin(GPIOF, GPIO_PIN_0, x)
#define UART_SET_RX(x)      HAL_GPIO_WritePin(GPIOF, GPIO_PIN_1, x)
#define UART_RD_RX          HAL_GPIO_ReadPin(GPIOF, GPIO_PIN_1)


void uart_start(void);
void uart_stop(void);
void uart_transmit_byte(uint8_t cmd);
void uart_transmit_str(uint8_t *str);
void uart_transmit_buf(uint8_t *str);
void buf_clear(void);

iouart.c

#include "iouart.h"

void uart_start(void)
{
    UART_SET_TX(0); //拉低tx线，作为起始信号
}

void uart_stop(void)
{
    UART_SET_TX(1); //拉高tx线，作为结束信号
}

/*
 * io模拟串口发送单个字节
 * cmd:对应ascii码
 * 低位在前
 * */
void uart_transmit_byte(uint8_t cmd)
{
    uart_start();
    delay_us(delay_time);
    for(uint8_t i = 0; i < 8 ; i++){
        if(cmd & (0x01 << i)){
            UART_SET_TX(1);
        }else{
            UART_SET_TX(0);
        }
        delay_us(delay_time); //波特率9600
    }
    uart_stop();
    delay_us(delay_time);
}

/*
 * io模拟串口发送字符串
 * str：指针，指向字符串首地址
 * */
void uart_transmit_str(uint8_t *str)
{
    while(*str != '\0'){
        uart_transmit_byte(*str);
        str++;
    }
}

/*
 * io模拟串口发送数组
 * str：指针，指向数组首地址
 * */
void uart_transmit_buf(uint8_t *str)
{
    while(data_cnt --){
        uart_transmit_byte(*str);
        str++;
    }
}

/*清空接收数组*/
void buf_clear(void)
{
    memset(UART_RX_BUF,0,sizeof(UART_RX_BUF));
    UART_RX_STA = 0;
    send_flag = 0;
    data_cnt = 0;
}

main.h

#include <rtthread.h>
#include <stdio.h>
#include <string.h>
#include "drv_common.h"
#include "stm32f4xx_hal.h"
#include "tim.h"
#include "it.h"
#include "iouart.h"

main.c

#include "main.h"

int main(void)
{
    MX_GPIO_Init();
    MX_TIM12_Init();
    MX_TIM13_Init();
    MX_TIM14_Init();
    uart_transmit_str("for test...");
    while (1){
        if(send_flag){
//            uart_transmit_buf(UART_RX_BUF);
            rt_kprintf("%s\r\n",UART_RX_BUF);
            buf_clear();
    }
    return RT_EOK;
}

 中断部分在实际应用时因为rt-thread studio有设备驱动的回调函数，就懒省事直接写了中断服务函数

void EXTI1_IRQHandler(void)
{
    rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
    rt_interrupt_leave();
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if(GPIO_Pin == GPIO_PIN_1){
        if(!IOUART_RD_RX){
           if(recvStat == UART_STOP_BIT){
               recvStat = UART_START_BIT;
               UART_RX_END = 1;
               HAL_TIM_Base_Stop_IT(&htim14);
               __HAL_TIM_SET_COUNTER(&htim14,0);
               HAL_TIM_Base_Start_IT(&htim13);
           }
        }
    }
    __HAL_GPIO_EXTI_CLEAR_FLAG(EXTI_LINE_1);
}

void TIM8_UP_TIM13_IRQHandler(void)
{
    if (__HAL_TIM_GET_FLAG(&htim13, TIM_FLAG_UPDATE) != RESET){
        if (__HAL_TIM_GET_IT_SOURCE(&htim13, TIM_IT_UPDATE) != RESET){
            __HAL_TIM_CLEAR_IT(&htim13, TIM_IT_UPDATE);
            recvStat++;
            if(recvStat == UART_STOP_BIT){
                UART_RX_END = 0;
                HAL_TIM_Base_Stop_IT(&htim13);
                __HAL_TIM_SET_COUNTER(&htim13,0);
//              delay_us(7);
                UART_RX_BUF[UART_RX_STA] = recvData;
                recvData = 0;
                UART_RX_STA++;
                if(UART_RX_STA > (UART_REC_LEN - 1))
                    UART_RX_STA = 0;
                HAL_TIM_Base_Start_IT(&htim14);
            }else{
            if(IOUART_RD_RX)
                recvData |= 1 << (recvStat - 1);
            else
                recvData &= ~(1 << (recvStat - 1));
            }
        }
    }
    HAL_TIM_IRQHandler(&htim13);
}

void TIM8_TRG_COM_TIM14_IRQHandler(void)
{
    if (__HAL_TIM_GET_FLAG(&htim14, TIM_FLAG_UPDATE) != RESET){
        if (__HAL_TIM_GET_IT_SOURCE(&htim14, TIM_IT_UPDATE) != RESET){
            __HAL_TIM_CLEAR_IT(&htim14, TIM_IT_UPDATE);
            if((recvStat == UART_STOP_BIT) && IOUART_RD_RX && !UART_RX_END){
                cnt++;
                if(cnt > 10){
                    cnt = 0;
                    send_flag = 1;
                    HAL_TIM_Base_Stop_IT(&htim14);
                    __HAL_TIM_SET_COUNTER(&htim14,0);
                }
            }
        }
    }
    HAL_TIM_IRQHandler(&htim14);
}

模拟串口发送字节里调用了失能中断和使能中断，避免在发送数据时被其他中断打断造成乱码，或者把该线程优先级调高，可能都会有bug

void iouart_transmit_byte(uint8_t cmd)
{
    __disable_irq();
    iouart_start();
    delay_us(delay_time);
    for(uint8_t i = 0; i < 8 ; i++){
        if(cmd & (0x01 << i)){
            IOUART_SET_TX(1);
        }else{
            IOUART_SET_TX(0);
        }
        delay_us(delay_time);
    }
    iouart_stop();
    delay_us(delay_time);
    __enable_irq();
}

yxy不会嵌入式
关注
  • 10
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IO口模拟UART串口
曾先生的博客
02-09 3万+
     由于博主近期参与了合泰芯片的项目开发，所以此次就用合泰单片机来测试（具体型号为HT66F70A),IDE为HT-IDE3000（合泰官方）。      首先需要了解两个概念：      1.帧      是串行通讯的数据单元，其中各位的意义如下：起始位：先发出一个逻辑”0”的信号，表示传输数据的开始。数据位：紧接着起始位之后，数据位的个数可以是4、5、6、7、8等，（通常使用8位）构成一...
通过GPIO来实现单片机的模拟UART通信
weixin_43417388的博客
04-27 1144
在发送数据时，将数据编码成UART格式，然后通过GPIO口一位一位地输出，根据波特率控制输出的速度和时间间隔。接收数据时，同样需要按照UART格式从GPIO口连续读取一定时间的电平值，然后进行解码，解析出实际的数据。首先，需要设计GPIO引脚功能的配置，包括配置引脚为输入或输出模式以及电平电平的设置。确定通信协议中的波特率，然后计算出每位数据所需要的发送或接收时间。在发送或接收完毕后，需要将GPIO口恢复到原来的输入或输出模式。
STM32F103C8 GPIO口模拟串口 PA1_PA0模拟UART_可收发 单个字符
05-29
STM32F103C8 IO口模拟串口 PA1_PA0模拟UART_可收发 单个字符,自己编写的实验通过，可直接用，只能是单个十六进制。
STM32G0系列 IO模拟UART通信
weixin_42401119的博客
12-30 1802
本文用stm32G0的GPIO模拟串口通信，使用定时器和外部中断，不用延时等待，用完定时器中断立刻失能，拒绝浪费CPU资源。 使用资源：一个定时器，一个普通IO口(TX)，一个带外部中断的IO口(RX)。
单片机IO口模拟串口实现原理
最新发布
梅山
06-24 793
确保同步：为了确保发送和接收的同步性，可以在发送和接收的开头和结尾添加起始位和停止位。发送时在数据的起始位置输出一个低电平的起始位，接收时检测到低电平的起始位后开始接收数据，接收完毕后检测到高电平的停止位表示接收完成。单片机IO口模拟串口的实现原理相对简单，但通信速率可能受到单片机性能和IO口速度的限制，因此在高速通信或实时性要求较高的场景下，可能需要选择硬件串口或其他更高级的通信方式。根据通信参数，将要发送的数据进行位的切换操作，逐位通过发送引脚发送出去。：顾名思义就是没有校验位，数据位后面接停止位。
使用GPIO来模拟UART
weixin_56646002的博客
06-28 5641
本文使用32的两个IO口来模拟串口，可以缓解芯片串口外设紧张的问题。
模拟串口UART的实现
dianqicyuyan的博客
06-21 731
模拟串口
GPIO模拟UART串口发送和接收
weixin_43504224的博客
06-07 9777
GPIO模拟UART串口发送和接收
GPIO模拟UART串口时序
热门推荐
timewh的专栏
05-03 1万+
GPIO模拟UART串口时序模拟时序：平台：Cortex-M0与FPGA UART的区别：  FPGA发送、接收使用的是独立的时序，并行处理易于实现。而单片机只能使用定时器来模拟时序，并通过外部下降沿中断触发启动，实时性受到限制；对于实时性要求较高的应用，需要同时处理发送和接收时（全双工）1路UART需要使用2个定时器；而半双工应用可以只使用一个定时器即可实现。基于50MHZ的M0一般9600是可...
51单片机IO模拟UART
Mr_liu_JC的博客
11-15 2811
IO模拟UART 一、 IO模拟UART发送 串口通信属于 串行 异步 半双工的通信模式 1、 最近在调试一个IO模拟UART的程序，把调试过程中遇到的问题总结一下。对于UART的发送部分（主机模式）还是比较容易实现的。比较麻烦的做从机时，UART接收还在调试，可以接收数据，但还存在很多问题。 (1) 起始位：总线没通信是高电平状态，要进行通信时，总线拉低发出“逻辑0”信号，表示开始传输数据 (2) 数据位：通常以1byte数据为标准，从低位开始传输，通过时钟频率来定位数据的传输 (3) 奇偶校验位：通过在
S32K312 IO模拟串口UART接收数据
lnniyunlong99的专栏
01-25 893
工程中S32K312的8个串口资源均已使用，需要使用一个IO来模拟串口UART接收数据。 IO模拟串口接收数据，首先需要了解串口的理论知识。一帧数据从下降沿的起始位开始，上升沿的停止位结束。起始位后有8个bit的数据位，数据位低位（bit0）先传，数据位高位(bit7)后传，数据位后跟着奇偶校验位。校验位：用于确保传输数据的正确性，可分为奇校验和偶校验。奇校验时数据位和校验位中1的总数应为奇数；同理，偶校验时数据位和校验位中1的总数应为偶数。
STM32F4开发板原理图
05-27
4. **GPIO扩展**：STM32F4的IO引脚分配表列出了每个引脚的功能，如LED驱动、按键输入、串口通信等，开发者可以根据需求分配和配置这些引脚。 5. **模拟电路**：如ADC（Analog-to-Digital Converter）输入电路，用于...
STM32F4xxHAL库（GPIO外设及函数）中文使用指南
07-07
STM32F4xxHAL库（GPIO外设及函数）中文使用指南 在STM32F4xx微控制器中，GPIO（General Purpose Input/Output）外设是最基本的外设之一，负责输入/输出操作。下面是GPIO外设的特性和函数： 1. 输入模式：在输入...
stm32f4工程模板
07-29
深入理解STM32F4的寄存器结构、中断机制、定时器、ADC、GPIO、串口通信等基本外设的使用，有助于更好地利用STM32F4工程模板进行项目开发。 总之，STM32F4工程模板是嵌入式开发中的重要资源，它极大地简化了项目的...
STM32IO口中断
10-29
- `Stm32f10x_usart.c/h`: UART/USART驱动文件，虽然本示例不涉及串口通信，但这些文件通常也会被包含在项目中。 - `stm32f10x_rcc.h`: 包含了系统时钟配置函数以及相关外设时钟使能函数。 为了更好地组织代码，...
使用VSCode+PlatformIO+CMSIS开发STM32F407ZGT6
02-18
在本文中，我们将深入探讨如何使用Visual Studio Code (VSCode) 配合PlatformIO和CMSIS库来开发STM32F407ZGT6微控制器。STM32F407ZGT6是一款高性能、低功耗的ARM Cortex-M4内核微控制器，广泛应用于各种嵌入式系统...
软件模拟串行通信——UART协议实现
独小乐的博客
12-05 7470
双单片机通信，MCU资源受限，无法使用片上UART通道，只可用普通I/O 使用2个普通I/O端口，通过软件实现UART协议的数据全双工收发，可移植其它单片机
STM32 freertos 使用软件模拟串口uart
mainbanp
01-23 1800
通过上面学习使用方法与故障排除，STM32 freertos 使用软件模拟串口uart已经正常可以使用了。通过这个测试也对freertos 有了进一步认识。
单片机IO口模拟串口UART
weixin_43908815的博客
08-15 2691
模拟串口
STM32F4寄存器开发全面指南
"STM32F4寄存器开发指南，主要涵盖了ALIENTEK探索者STM32F407开发板的硬件资源详解和软件开发的相关知识，旨在帮助开发者进行基于寄存器级别的STM32F4编程。" STM32F4系列微控制器是意法半导体（STMicroelectronics...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值