ROBOT基于Slam算法_Ros环境_Stm32f1遥控_Nrf无线传输_Stm32f4下位机_Jetson nano上位机_Robosence激光雷达. 008 车子底层运动搭建（基于遥感控制）

最新推荐文章于 2024-10-30 18:53:05 发布
最新推荐文章于 2024-10-30 18:53:05 发布
阅读量517 收藏 10
点赞数 9
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63861827/article/details/142642171
版权

实现功能：通过摇杆基于stm32f103c8t6通过nrf24l01进行无线传输至stm32f407并进一步实时控制小车的运动（并基于oled和lcd进行实时显示小车的速度）（后续可以进一步加入视觉和语音模块，总体基于任务导向式思考完成该项目）

遥控模块（摇杆接线5v(按理讲可以，但是实际配置时其摇杆值就不再是0-4096而是0-3780)or3.3

v和oled接线3.3v）

无线传输模块(nrf24l01接线) 

发送端引脚配置：（stm32f103c8t6）

接收端引脚配置 ：（开发板外设直插式）

接下来关键任务就是将其无线传输和oled以及摇杆和lcd结合到一起 

 

 成功将摇杆数据值正确接受并传输到开发板上（具体思路即通过adc接受遥感数据并用oled显示接着将其转成字符数组并进一步通过nrf24l01转到单片机上并在对应的lcd上显示）

接着需要根据接受到的数组通过逆运动学解算 （通过其摇杆两轴数据可获知其运动方向以及对应的速度，进而在套用麦克纳姆轮小车执行逆运动学解算方可知其四个轮子的角速度进而可以控制小车的运动-这里和上位机通过ros往下传数据不同，其是基于两轴实际速度而这里摇杆数据可以视作比例速度（0-1也即至最大速度，这里的两轴速度可视作基于最大转速速和初始pwm波限制下的情况））

接下来需要将pwm波程序融合到开发板的无线通信程序上并以此驱动四个电机根据其摇杆发送的数据转换成对应的比例并进一步通过pwm控制其电机的运行 

#include <stdio.h>  // 用于 sprintf
#include <math.h>
#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/LCD/lcd.h"
#include "./BSP/KEY/key.h"
#include "./BSP/TIM_PWM/gtim.h"
#include "./BSP/NRF24L01/nrf24l01.h"

//float value_x = 0;
//float value_y = 0;
float x = 0;
float y = 0;
//int x = 0;
//int y = 0;
int X = 0;
int Y = 0;
//float w1 = 0;
//float w2 = 0;
//float w3 = 0;
//float w4 = 0;

extern TIM_HandleTypeDef g_tim1_pwm_chy_handle; /* 定时器x句柄 */
extern TIM_HandleTypeDef g_tim2_pwm_chy_handle; /* 定时器x句柄 */
extern TIM_HandleTypeDef g_tim3_pwm_chy_handle; /* 定时器x句柄 */
extern TIM_HandleTypeDef g_tim4_pwm_chy_handle; /* 定时器x句柄 */

//float x1,float y1,
void display_float(float x1,float y1,int X1,int Y1) {
    char buffer1[32];  // 用于存储转换后的字符串
    sprintf(buffer1, "%.2f", x1);  // 将浮点数转换为带两位小数的字符串
    lcd_show_string(30, 185, 200, 16, 16, buffer1,BLUE);  // 在LCD上显示转换后的字符串
    char buffer2[32];  // 用于存储转换后的字符串
    sprintf(buffer2, "%.2f", y1);  // 将浮点数转换为带两位小数的字符串
    lcd_show_string(30, 200, 200, 16, 16, buffer2,BLUE);  // 在LCD上显示转换后的字符串
//    char buffer3[32];  // 用于存储转换后的字符串
//    sprintf(buffer3, "%d", X1);  // 将浮点数转换为带两位小数的字符串
//    lcd_show_string(30, 215, 200, 16, 16, buffer3,BLUE);  // 在LCD上显示转换后的字符串
//    char buffer4[32];  // 用于存储转换后的字符串
//    sprintf(buffer4, "%d", Y1);  // 将浮点数转换为带两位小数的字符串
//    lcd_show_string(30, 230, 200, 16, 16, buffer4,BLUE);  // 在LCD上显示转换后的字符串
    char buffer3[32];  // 用于存储转换后的字符串
    sprintf(buffer3, "%.1f", (float)X1);  // 将浮点数转换为带两位小数的字符串
    lcd_show_string(30, 215, 200, 16, 16, buffer3,BLUE);  // 在LCD上显示转换后的字符串
    char buffer4[32];  // 用于存储转换后的字符串
    sprintf(buffer4, "%.1f", (float)Y1);  // 将浮点数转换为带两位小数的字符串
    lcd_show_string(30, 230, 200, 16, 16, buffer4,BLUE);  // 在LCD上显示转换后的字符串
}

union Transfer
{
    /*定义union，方便进行
     整型和浮点型的转换*/
    float   Float_data;//stm32中float占4个字节32位
    int Byte[4];   //4个uint8_t类型元素，占32位
}transunion,*transptr=&transunion;

/*******************************************************************************
* Function Name  : Float_To_Int
* Description    : 浮点数转化为整形
* Parameters     : 浮点数
* Return         : 32位整型
* Notice         : None
*******************************************************************************/
int Float_To_Int(float data)
{
        int Flash_uInt=0;
    /*将float的数据分别按字节存放在地址内*/
        transptr->Byte[0]=((uint8_t *)&data)[0]; 
        transptr->Byte[1]=((uint8_t *)&data)[1];
        transptr->Byte[2]=((uint8_t *)&data)[2];
        transptr->Byte[3]=((uint8_t *)&data)[3];
        Flash_uInt=*(int*)transptr->Byte;//用uint32_t类型读取该32位地址的数据
        return Flash_uInt;
}

/*******************************************************************************
* Function Name  : Int_To_Float
* Description    : 整形转化为浮点数
* Parameters     : 32位整形
* Return         : 浮点数
* Notice         : None
*******************************************************************************/
float Int_To_Float(uint32_t data)
{
        double Flash_flt=0.0;
        //分解32位整形为4个8位整形
        transptr->Byte[0]=data&0xff;
        transptr->Byte[1]=(data>>8)&0xff;
        transptr->Byte[2]=(data>>16)&0xff;
        transptr->Byte[3]=(data>>24)&0xff;
        Flash_flt=transptr->Float_data;//利用float类型读取出该32位地址的数据
        return Flash_flt;
}

int main(void)
{
//    uint16_t ledrpwmval = 0;
//    uint8_t dir = 1;
    uint8_t key, mode;
    uint16_t t = 0;
    uint8_t tmp_buf[33];
    
    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟, 168Mhz */
    delay_init(168);                    /* 延时初始化 */
    usart_init(115200);                 /* 串口初始化为115200 */
    led_init();                         /* 初始化LED */
    lcd_init();                         /* 初始化LCD */
    key_init();                         /* 初始化按键 */
    nrf24l01_init();                    /* 初始化NRF24L01 */
    //通过四路pwm波驱动四路电机
    gtim_tim1_pwm_chy_init(500 - 1,168 - 1);    /* 168 000 000 / 168 = 1 000 000 1Mhz的计数频率，2Khz的PWM */
    gtim_tim2_pwm_chy_init(500 - 1,168 - 1);    /* 168 000 000 / 168 = 1 000 000 1Mhz的计数频率，2Khz的PWM */
    gtim_tim3_pwm_chy_init(500 - 1,168 - 1);    /* 168 000 000 / 168 = 1 000 000 1Mhz的计数频率，2Khz的PWM */
    gtim_tim4_pwm_chy_init(500 - 1,168 - 1);    /* 168 000 000 / 168 = 1 000 000 1Mhz的计数频率，2Khz的PWM */
    
    lcd_show_string(30, 50, 200, 16, 16, "STM32", RED);
    lcd_show_string(30, 70, 200, 16, 16, "NRF24L01 TEST", RED);
    lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
    
    GPIO_InitTypeDef  gpio_init_struct;
    __HAL_RCC_GPIOF_CLK_ENABLE();
    //由于PF8、9、10均和现有硬件资源冲突故8、9换到12、13
    gpio_init_struct.Pin = GPIO_PIN_2;                   /* 引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;          /* 高速 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化LED0引脚 */

    gpio_init_struct.Pin = GPIO_PIN_3;                   /* 引脚 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化引脚 */

    gpio_init_struct.Pin = GPIO_PIN_4;                   /* 引脚 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化引脚 */
    
    gpio_init_struct.Pin = GPIO_PIN_5;                   /* 引脚 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化引脚 */
    
    gpio_init_struct.Pin = GPIO_PIN_6;                   /* 引脚 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化引脚 */

    gpio_init_struct.Pin = GPIO_PIN_7;                   /* 引脚 */
    HAL_GPIO_Init(GPIOF, &gpio_init_struct);       /* 初始化引脚 */
    
    gpio_init_struct.Pin = GPIO_PIN_8;                   /* 引脚 */
    HAL_GPIO_Init(GPIOB, &gpio_init_struct);       /* 初始化引脚 */
    
    gpio_init_struct.Pin = GPIO_PIN_9;                   /* 引脚 */
    HAL_GPIO_Init(GPIOB, &gpio_init_struct);       /* 初始化引脚 */
    
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_4, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_5, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_6, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_7, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
    while (nrf24l01_check()) /* 检查NRF24L01是否在线 */
    {
        lcd_show_string(30, 110, 200, 16, 16, "NRF24L01 Error", RED);
        delay_ms(200);
        lcd_fill(30, 110, 239, 130 + 16, WHITE);
        delay_ms(200);
    }

    lcd_show_string(30, 110, 200, 16, 16, "NRF24L01 OK", RED);

    while (1)           /* 提醒用户选择模式 */
    {
        key = key_scan(0);
        if (key == KEY0_PRES)
        {
            mode = 0;   /* 接收模式 */
            break;
        }
        else if (key == KEY1_PRES)
        {
            mode = 1;   /* 发送模式 */
            break;
        }

        t++;
        if (t == 100)   /* 显示提示信息 */
        {
            lcd_show_string(10, 130, 230, 16, 16, "KEY0:RX_Mode  KEY1:TX_Mode", RED);
        }

        if (t == 200)   /* 关闭提示信息 */
        {
            lcd_fill(10, 130, 230, 150 + 16, WHITE);
            t = 0;
        }

        delay_ms(5);
    }

    lcd_fill(10, 130, 240, 166, WHITE); /* 清空上面的显示 */

    if (mode == 0)          /* RX模式 */
    {
        lcd_show_string(30, 130, 200, 16, 16, "NRF24L01 RX_Mode", BLUE);
        lcd_show_string(30, 150, 200, 16, 16, "Received DATA:", BLUE);
        nrf24l01_rx_mode(); /* 进入RX模式 */

        //程序编写关键代码、无线通信、遥感数据值逆动力学解算、pwm驱动电机
        while (1)
        {
            if (nrf24l01_rx_packet(tmp_buf) == 0) /* 一旦接收到信息,则显示出来. */
            {
                tmp_buf[32] = 0;    /* 加入字符串结束符 */
                lcd_show_string(30, 170, lcddev.width - 1, 32, 16, (char *)tmp_buf, BLUE);
            }
            //else
            //{
                //delay_us(100);
            //}
            x = (float)(tmp_buf[0]-48)*1000+(float)(tmp_buf[1]-48)*100+(float)(tmp_buf[2]-48)*10+(float)(tmp_buf[3]-48);
            y = (float)(tmp_buf[5]-48)*1000+(float)(tmp_buf[6]-48)*100+(float)(tmp_buf[7]-48)*10+(float)(tmp_buf[8]-48);
//            x = (int)(tmp_buf[0]-48)*1000+(int)(tmp_buf[1]-48)*100+(int)(tmp_buf[2]-48)*10+(int)(tmp_buf[3]-48);
//            y = (int)(tmp_buf[5]-48)*1000+(int)(tmp_buf[6]-48)*100+(int)(tmp_buf[7]-48)*10+(int)(tmp_buf[8]-48);
            //            x = value_x;
//            y = value_y;            
            //规范在几何约束最大值但不考虑其长方形值域特点
            x = (x-1930)*400/(1930*2);//[-1/2,+1/2]
            y = (1880-y)*400/(1880*2);//[-1/2,+1/2]
//            X = x;
//            Y = y;
            //关键bug点。。。
            //。。。。。。。。
            //。。。。。。。。
//            X = (int)(round(x));//X+Y对应2、4路
//            Y = (int)(round(y));//Y-X对应1、3路
            X = (int)(x);//X+Y对应2、4路
            Y = (int)(y);//Y-X对应1、3路
            //X = Float_To_Int(x);
            //Y = Float_To_Int(y);
//            X = (int)(round(x*200));//X+Y对应2、4路
//            Y = (int)(round(y*200));//Y-X对应1、3路
            display_float(x,y,X,Y);  // 显示浮点数
            //2、3控制第一轮；3、4控制第二轮；4、5控制第三轮；5、6控制第四轮
//            HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_SET);//1
//            HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_RESET);//0
//            __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, 150);
//            if (dir)ledrpwmval++;                   /* dir==1 ledrpwmval递增 */
//            else ledrpwmval--;                      /* dir==0 ledrpwmval递减 */

//            if (ledrpwmval > 3000)dir = 0;           /* ledrpwmval到达300后，方向为递减 */
//            if (ledrpwmval == 0)dir = 1;            /* ledrpwmval递减到0后，方向改为递增 */

//            /* 修改比较值控制占空比 */
//            __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, ledrpwmval/10);
//            if(X>=0){
//                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_SET);//1
//                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_RESET);//0
//                __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, X);
//            }else{
//                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_RESET);//0
//                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_SET);//1
//                __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, X*(-1));
//            }
            //涉及1、3轮
            if((Y-X)>=0){
                //对应1、3轮正向顺时针转动（对应引脚PF2、PF3、PF6、PF7）
                //1轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_SET);//1
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_RESET);//0
                //3轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_6, GPIO_PIN_SET);//1
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_7, GPIO_PIN_RESET);//0
                //根据遥感数据实时调整其占空比进而调整其转速
                __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, Y-X);
                __HAL_TIM_SET_COMPARE(&g_tim3_pwm_chy_handle, GTIM_TIM3_PWM_CHY, Y-X);
            }else{
                //对应1、3轮负向逆时针转动（对应引脚PF2、PF3、PF6、PF7）
                //1轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_2, GPIO_PIN_RESET);//0
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_3, GPIO_PIN_SET);//1
                //3轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_6, GPIO_PIN_RESET);//0
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_7, GPIO_PIN_SET);//1
                //根据遥感数据实时调整其占空比进而调整其转速
                __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, X-Y);
                __HAL_TIM_SET_COMPARE(&g_tim3_pwm_chy_handle, GTIM_TIM3_PWM_CHY, X-Y);
            }
            
            //涉及2、4轮
            if((X+Y)>=0){
                //对应2、4轮正向顺时针转动（对应引脚PF4、PF5、PF8、PF9）
                //2轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_4, GPIO_PIN_SET);//1
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_5, GPIO_PIN_RESET);//0
                //4轮
                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);//1
                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);//0
                //根据遥感数据实时调整其占空比进而调整其转速
                __HAL_TIM_SET_COMPARE(&g_tim2_pwm_chy_handle, GTIM_TIM2_PWM_CHY, X+Y);
                __HAL_TIM_SET_COMPARE(&g_tim4_pwm_chy_handle, GTIM_TIM4_PWM_CHY, X+Y);
            }else{
                //对应2、4轮负向逆时针针转动（对应引脚PF4、PF5、PF8、PF9）
                //2轮
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_4, GPIO_PIN_RESET);//0
                HAL_GPIO_WritePin(GPIOF, GPIO_PIN_5, GPIO_PIN_SET);//1
                //4轮
                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);//0
                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_SET);//1
                //根据遥感数据实时调整其占空比进而调整其转速
                __HAL_TIM_SET_COMPARE(&g_tim2_pwm_chy_handle, GTIM_TIM2_PWM_CHY, (X+Y)*(-1));
                __HAL_TIM_SET_COMPARE(&g_tim4_pwm_chy_handle, GTIM_TIM4_PWM_CHY, (X+Y)*(-1));
            }
//            /* 修改比较值控制占空比 */
//            __HAL_TIM_SET_COMPARE(&g_tim1_pwm_chy_handle, GTIM_TIM1_PWM_CHY, Y-X);
//            /* 修改比较值控制占空比 */
//            __HAL_TIM_SET_COMPARE(&g_tim2_pwm_chy_handle, GTIM_TIM2_PWM_CHY, X+Y);
//            /* 修改比较值控制占空比 */
//            __HAL_TIM_SET_COMPARE(&g_tim3_pwm_chy_handle, GTIM_TIM3_PWM_CHY, Y-X);
//            /* 修改比较值控制占空比 */
//            __HAL_TIM_SET_COMPARE(&g_tim4_pwm_chy_handle, GTIM_TIM4_PWM_CHY, X+Y);
            //程序正常执行标志
            t++;
            if (t == 1000)         /* 大约1s钟改变一次状态 */
            {
                t = 0;
                LED0_TOGGLE();
            }
        }
    }
    else /* TX模式 */
    {
        lcd_show_string(30, 130, 200, 16, 16, "NRF24L01 TX_Mode", BLUE);
        nrf24l01_tx_mode(); /* 进入TX模式 */
        mode = ' ';         /* 从空格键开始发送 */

        while (1)
        {
            if (nrf24l01_tx_packet(tmp_buf) == 0) /* 发送成功 */
            {
                lcd_show_string(30, 150, 239, 32, 16, "Sended DATA:", BLUE);
                lcd_show_string(0, 170, lcddev.width - 1, 32, 16, (char *)tmp_buf, BLUE);
                key = mode;

                for (t = 0; t < 32; t++)
                {
                    key++;

                    if (key > ('~'))
                        key = ' ';

                    tmp_buf[t] = key;
                }

                mode++;
                if (mode > '~')
                {
                    mode = ' ';
                }

                tmp_buf[32] = 0; /* 加入结束符 */
            }
            else
            {
                lcd_fill(0, 150, lcddev.width, 170 + 16 * 3, WHITE); /* 清空显示 */
                lcd_show_string(30, 150, lcddev.width - 1, 32, 16, "Send Failed ", BLUE);
            }

            LED0_TOGGLE();
            delay_ms(200);
        }
    }
}

有待进一步优化。。。

鬼刃sf
关注
ROBOT基于Slam算法_Ros环境_Stm32f1遥控_Nrf无线传输_Stm32f4下位机_Jetson nano上位机_Robosence激光雷达. 007 Cartographer算法
m0_63861827的博客
09-01 271
ROBOT基于Slam算法_Ros环境_Stm32f1遥控_Nrf无线传输_Stm32f4下位机_Jetson nano上位机_Robosence激光雷达. 007 Cartographer 激光雷达建图
ros_client-stm32--master.zip_ROS stm32_ros与STM32通信_stm32 ros_stm
07-13
标题"ros_client-stm32--master.zip_ROS stm32_ros与STM32通信_stm32 ros_stm"表明这个压缩包包含了一个项目或库，其目标是实现ROS与STM32F407之间的通信。STM32F407是一款高性能的微控制器，拥有丰富的外设接口和...
stm32f103rc_rosserial-master.zip_ROS_ROS stm32_ros-stm32_ros_stm
09-23
本项目"stm32f103rc_rosserial-master.zip"的目标是在Ubuntu操作系统下，利用rosserial库实现在STM32和ROS之间进行通信。 首先，让我们深入了解rosserial。rosserial是一个ROS子项目，它允许ROS节点与嵌入式处理器...
Robot.rar_AHRS STM32_STM32 ROBOT_mpu6050卡尔曼_stm32倾角仪_陀螺仪 电机
07-13
利用STM32主控单元与三轴陀螺仪MPU6050。MPU6050进行倾角测量，对测得的加速度和角速度数据进行AHRS数据融合，最终得到姿态角，姿态角再进行卡尔曼滤波。STM32单片机控制步进电机运动，对检测到的姿态角做最优控制。
基于ros--stm32的人脸追踪项目_人脸跟踪stm32_ROS_stm32人脸追踪_STM32F4XX_stm32人脸_源码
10-04
在这个基于ROS（Robot Operating System）和STM32的人脸追踪项目中，我们探索了一种智能技术，它能够识别和追踪人脸，并通过舵机调整摄像头的角度，以保持人脸始终处于视野中心。这一技术在安防监控、人机交互以及...
detectobjects.rar_opencv robot_opencv 训练_opencv正样本_stm32 opencv_
07-15
opencv 正样本采集 训练分类器 目标检测 串口通信 下位机stm32控制 机器人追着目标行走
4. STM32之TIM实验--输出比较（PWM输出，电机，四轴飞行器，智能车，机器人）--（实验2：PWM驱动舵机）
qq_58662017的博客
10-29 370
总结:其实舵机(齿轮控制减速机,直流电机,驱动器)就是一个山寨般的伺服电机(伺服电机可以说是一个系统:一个伺服电机包括控制器,编码器,电机,传感器等),其实很多单片机都配置了控制电机的GPIO,这个控制也很简单,只需要一个信号线即可,由图可知:通过调节占空比,来改变输出角度.
STM32 HAL库 SPI驱动1.3寸 OLED屏幕
Kasen‘s experience on reserch & study
10-29 606
中景园1.3OLED。
STM32 第20章 USART--串口通信2
2201_75297369的博客
10-30 1478
9.printf函数底层会调用一个fputc固件库函数//重定向c库函数printf到串口，重定向后可使用printf函数/*发送一个字节数据到串口*//*等待发送完毕*/return(ch);//为了方便移植，定义的宏//串口1-USART//USART GPIO引脚宏定义。
STM32 SRAM写入16位数据时死机问题
AZhi
10-29 318
STM32 SRAM写入16位数据时死机问题
【STM32】GPIO通用输入输出口
m0_74209563的博客
10-29 1412
用于单独操作输出数据寄存器的某一位而不影响其他位（因为输出数据寄存器同时控制16个端口，并且该寄存器只能整体读写，所以如果想单独控制器中某一个端口而不影响其他端口的话，就需要通过设置 位设置/清除寄存器 ）（由于STM32是32位的单片机，所以STM32内部的寄存器都是32位的，但是每个GPIO的端口只有16位，所以寄存器只有低16位有对应端口，高16位是没有用到的）复用功能输入：连接到其他需要读取端口的外设上，比如串口的输入引脚等，所以这根线接收的是数字量，所以接在施密特触发器后面。
STM32FreeRTOS 使用QSPI驱动nandFlash
最新发布
AZhi
10-30 262
QSPI驱动NandFlash
STM32之看门狗
Xiao_Xue_Seng的博客
10-28 439
在程序while(1)里喂狗，防止程序跑飞，HAL_IWDG_Refresh(&hiwdg1);当窗口定时器被初始化启动后，如果在0ms—239ms之间没有进行喂狗操作，那么窗口看门狗将超时复位程序。假设LSI是32KHz,超时时间等于 预分频系数（4）乘重装值（4095），除以LSI频率（32K）采用窗口看门狗（WWDG），有一个死前中断，可以用来作一个报警的功能。STM32有独立看门狗（IWDG）和窗口看门狗(WWDG)。超过512毫秒不喂狗，stm32复位重启。设置PCLK1为140MHz。
STM32 从0开始系统学习4 编写LED驱动
charlie114514191的博客
10-29 1104
编写一个LED驱动可以认为是搞嵌入式的一个Hello, World. 点亮一个LED于笔者看来就算是具备了一个驱动一个GPIO口输出的能力了。看完这篇教程，你应该会编写一个简单的基于HAL库的点亮LED的程序，或者更近一步的完成一个简单的对GPIO输出封装的自己的库。
Diving into the STM32 HAL-----Interrupts
maxiumII的专栏
10-29 962
但是，一段时间后，A 中断再次触发，由于它具有更高的优先级，因此 B 中断被暂停（变为非活动状态），并立即开始执行 A。这将为我们执行所有与中断相关的活动，并且它将调用 HAL_GPIO_EXTI_Callback（） 例程，该例程传递生成 IRQ 的实际 GPIO（请记住，PC12 和 PC13 连接到同一条外线中断线）。中断 A 在时间 t0 触发，由于 CPU 没有为另一个中断提供服务，因此其待处理位被清除，其执行立即开始⁸（中断变为活动状态）。其余的异常和外设中断被禁用，并且必须根据请求启用它们。
嵌入式——STM32外设应用
speaking_me的博客
10-27 1364
STM32 微控制器高性能、低功耗和丰富的外设资源。
如何为STM32的ADC外设编写中断服务程序
weixin_42300449的博客
10-30 285
确保你已经正确配置了ADC和NVIC，并且在中断服务函数中处理ADC转换结果。这样，每当ADC完成转换时，你的程序都能够响应中断并执行相应的操作。这通常在`MX_ADC_Init()`函数中完成，该函数由STM32CubeMX生成，或者你可以手动编写。在`stm32f1xx_it.c`文件中（或相应的中断服务文件），编写ADC中断服务函数。这个函数会在ADC转换完成时被调用。接下来，配置中断控制器NVIC，以确保ADC中断被正确处理。最后，在主函数或相应的初始化代码中，启动ADC中断。
STM32之串口字库更新
weixin_44453694的博客
10-29 788
串口通讯（Serial Communications）是一种通过串口进行数据传输的通讯方式，通过串行口每次传输一个字节的数据，按照约定的协议进行数据的传输和接收。串口通讯的原理是利用串行口的发送和接收线路，将需要传输的数据逐位传输到接收端，然后接收端再将这些数据组合成完整的信息。在传输过程中，数据是按照位（bit）进行发送和接收的，而不是按字节（byte）进行并行传输。串口通讯早期就定义了一套标准的串口规约，常见的接口标准包括RS-232、RS-485等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值