基于江科大STM32的桌宠小狗

已于 2024-10-21 14:34:34 修改
阅读量5.2k 收藏 149
点赞数 28
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件
于 2024-10-16 16:18:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85186852/article/details/142904125
版权

基于STM32C8T6的桌宠小狗

接线图

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

PWM部分

PWM.c

#include "stm32f10x.h"                  // Device header

void PWM_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;//GPIO初始化
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//复用推挽（控制权给片上外设）
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	TIM_InternalClockConfig(TIM2);//定时器2初始化
	
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInitStructure.TIM_Period = 2000-1;   //ARR
	TIM_TimeBaseInitStructure.TIM_Prescaler = 720-1;  //PSC
	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
	TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);
	
	TIM_OCInitTypeDef TIM_OCInitTypeDefStructure1; 
	TIM_OCStructInit(&TIM_OCInitTypeDefStructure1);
	TIM_OCInitTypeDefStructure1.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitTypeDefStructure1.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitTypeDefStructure1.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitTypeDefStructure1.TIM_Pulse = 0;  //CCR值
	TIM_OC1Init(TIM2,&TIM_OCInitTypeDefStructure1);	
	
	TIM_OCInitTypeDef TIM_OCInitTypeDefStructure2;
	TIM_OCStructInit(&TIM_OCInitTypeDefStructure2);
	TIM_OCInitTypeDefStructure2.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitTypeDefStructure2.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitTypeDefStructure2.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitTypeDefStructure2.TIM_Pulse = 0;
	TIM_OC2Init(TIM2,&TIM_OCInitTypeDefStructure2);
	
	
	TIM_OCInitTypeDef TIM_OCInitTypeDefStructure3;
	TIM_OCStructInit(&TIM_OCInitTypeDefStructure3);
	TIM_OCInitTypeDefStructure3.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitTypeDefStructure3.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitTypeDefStructure3.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitTypeDefStructure3.TIM_Pulse = 0;
	TIM_OC3Init(TIM2,&TIM_OCInitTypeDefStructure3);	
	
	
	TIM_OCInitTypeDef TIM_OCInitTypeDefStructure4;
	TIM_OCStructInit(&TIM_OCInitTypeDefStructure4);
	TIM_OCInitTypeDefStructure4.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitTypeDefStructure4.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitTypeDefStructure4.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitTypeDefStructure4.TIM_Pulse = 0;
	TIM_OC4Init(TIM2,&TIM_OCInitTypeDefStructure4);		
	
	TIM_Cmd(TIM2,ENABLE); //开启定时器
}

void PWM_SetCompare1(uint16_t Compare)
{
	TIM_SetCompare1(TIM2, Compare);		//设置CCR1的值
}

void PWM_SetCompare2(uint16_t Compare)
{
	TIM_SetCompare2(TIM2, Compare);		//设置CCR2的值
}

void PWM_SetCompare3(uint16_t Compare)
{
	TIM_SetCompare3(TIM2, Compare);		//设置CCR3的值
}

void PWM_SetCompare4(uint16_t Compare)
{
	TIM_SetCompare4(TIM2, Compare);		//设置CCR4的值
}

可以参考江科大的：PWM驱动舵机

舵机角度的封装

void Servo_SetAngle1(float Angle)		
{
	PWM_SetCompare1(Angle / 180 * 2000 + 500);   
	
}

void Servo_SetAngle2(float Angle)		
{
	PWM_SetCompare2(Angle / 180 * 2000 + 500);   
	
}

void Servo_SetAngle3(float Angle)		
{
	PWM_SetCompare3(Angle / 180 * 2000 + 500);   
	
}

void Servo_SetAngle4(float Angle)		
{
	PWM_SetCompare4(Angle / 180 * 2000 + 500);   
	
}

写舵机运动状态

在这里插入图片描述

具体的步态可以观看【步态详解】人人都可制作的WiFi遥控迷你四足机器人
可以根据他的步态来进行运动，下面是我按照我自己的连线以及代码来实现的状态

前进

void servo_advance(void)//前进
{
	static uint8_t advanceFlag = 1;
	if (advanceFlag == 1)
	{
		Servo_SetAngle1(135);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 2)
	{
		Servo_SetAngle1(135);
		Servo_SetAngle2(45);
		Servo_SetAngle3(135);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 3)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(45);
		Servo_SetAngle3(135);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 4)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);	
		advanceFlag++;
	}
	else if(advanceFlag == 5)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(135);
		Servo_SetAngle3(45);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 6)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(135);
		Servo_SetAngle3(45);
		Servo_SetAngle4(135);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 7)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(135);	
		Delay_ms(speed);
		advanceFlag++;
	}
	else if(advanceFlag == 8)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		advanceFlag = 1;
	}

}

后退

void servo_retreat(void)//后退
{
	static uint8_t retreatFlag = 1;
	if (retreatFlag == 1)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(135);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 2)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(135);
		Servo_SetAngle3(45);
		Servo_SetAngle4(135);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 3)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(135);
		Servo_SetAngle3(45);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 4)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);	
		retreatFlag++;
	}
	else if(retreatFlag == 5)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(45);
		Servo_SetAngle3(135);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 6)
	{
		Servo_SetAngle1(135);
		Servo_SetAngle2(45);
		Servo_SetAngle3(135);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 7)
	{
		Servo_SetAngle1(135);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		retreatFlag++;
	}
	else if(retreatFlag == 8)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		retreatFlag = 1;
	}

}

右转

void servo_trunright(void)//右转
{
	static uint8_t trunrightFlag = 1;
	if (trunrightFlag == 1)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		trunrightFlag++;
	}
	else if(trunrightFlag == 2)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(135);
		Servo_SetAngle3(135);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		trunrightFlag++;
	}
	else if(trunrightFlag == 3)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(135);
		Servo_SetAngle3(135);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		trunrightFlag++;
	}
	else if(trunrightFlag == 4)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);	
		trunrightFlag++;
		trunrightFlag = 1;
	}

}

左转

void servo_trunleft(void)//左转
{
	static uint8_t trunleftFlag = 1;
	if (trunleftFlag == 1)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(135);
		Servo_SetAngle3(135);
		Servo_SetAngle4(90);	
		Delay_ms(speed);
		trunleftFlag++;
	}
	else if(trunleftFlag == 2)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(135);
		Servo_SetAngle3(135);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		trunleftFlag++;
	}
	else if(trunleftFlag == 3)
	{
		Servo_SetAngle1(45);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(45);	
		Delay_ms(speed);
		trunleftFlag++;
	}
	else if(trunleftFlag == 4)
	{
		Servo_SetAngle1(90);
		Servo_SetAngle2(90);
		Servo_SetAngle3(90);
		Servo_SetAngle4(90);	
		Delay_ms(speed);	
		trunleftFlag++;
		trunleftFlag = 1;
	}

}

跳舞

void servo_dance(void)//跳舞
{
	static uint8_t danceFlag = 1;
	if (danceFlag == 1)
	{
		Servo_SetAngle1(130);
		Servo_SetAngle2(130);
		Servo_SetAngle3(50);
		Servo_SetAngle4(50);
		Delay_ms(400);
		danceFlag++;
	}
	else if(danceFlag == 2)
	{
		Servo_SetAngle1(50);
		Servo_SetAngle2(50);
		Servo_SetAngle3(130);
		Servo_SetAngle4(130);
		Delay_ms(400);
		danceFlag = 1;
	}
}

USART

#include "stm32f10x.h"
#include <stdio.h>
#include <stdarg.h>

char Serial_RxPacket[100];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_Init(USART1, &USART_InitStructure);
	
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1, ENABLE);
}

void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Array[i]);
	}
}

void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --)
	{
		Result *= X;
	}
	return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

void Serial_Printf(char *format, ...)
{
	char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	Serial_SendString(String);
}

void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;
	static uint8_t pRxPacket = 0;
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
	{
		uint8_t RxData = USART_ReceiveData(USART1);
		
		if (RxState == 0)
		{
			if (RxData == '@' && Serial_RxFlag == 0)
			{
				RxState = 1;
				pRxPacket = 0;
			}
		}
		else if (RxState == 1)
		{
			if (RxData == '\r')
			{
				RxState = 2;
			}
			else
			{
				Serial_RxPacket[pRxPacket] = RxData;
				pRxPacket ++;
			}
		}
		else if (RxState == 2)
		{
			if (RxData == '\n')
			{
				RxState = 0;
				Serial_RxPacket[pRxPacket] = '\0';
				Serial_RxFlag = 1;
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}

USART可以观看江科大的串口收发HEX数据包&串口收发文本数据包
（建议从9-3开始观看，有利于了解USART代码的各部分含义）

main.c

#include "stm32f10x.h"                 
#include "delay.h"
#include "Servo.h"
#include "PWM.h"
#include "control.h"
#include "UART.h"
#include <string.h>


float Angle;
uint8_t statu_falg=0;

int main (void)
{
	
	Servo_Init();
	Serial_Init();
	
	servo_up();
//	servo_down();

	while(1)
	{	

			if(Serial_RxFlag == 1)
		{
			if (strcmp(Serial_RxPacket, "advance") == 0)
			{

				statu_falg=1;
			}
			
			 if (strcmp(Serial_RxPacket,"fast") == 0)
			{
				statu_falg=2;
			}	
			
			 if (strcmp(Serial_RxPacket, "ret") == 0)
			{
				statu_falg=3;
			}
			

			 if (strcmp(Serial_RxPacket, "right") == 0)
			{
				statu_falg=4;
			}
			if (strcmp(Serial_RxPacket, "left") == 0)
			{
				statu_falg=5;
			}
			if (strcmp(Serial_RxPacket, "down") == 0)
			{
				statu_falg=6;
			}
			if (strcmp(Serial_RxPacket, "up") == 0)
			{
				statu_falg=7;
			}
			if (strcmp(Serial_RxPacket, "hard") == 0)
			{
				statu_falg=8;
			}
			if (strcmp(Serial_RxPacket, "dance") == 0)
			{
				statu_falg=9;
			}
			if (strcmp(Serial_RxPacket, "sit") == 0)
			{
				statu_falg=10;
			}
			if (strcmp(Serial_RxPacket, "sithard") == 0)
			{
				statu_falg=11;
			}
				
			Serial_RxFlag = 0;
		}
		switch(statu_falg)
		{
			case 1: servo_advance();break;
			case 2: servo_fastadvance();break;
			case 3: servo_retreat();break;
			case 4: servo_trunright();break;
			case 5: servo_trunleft();break;
			case 6: servo_down();break;
			case 7: servo_up();break;
			case 8: servo_hard();break;
			case 9: servo_dance();break;
			case 10: servo_sitdown();break;
			case 11: servo_sithard();break;

		}
		
	}

}

在开始我写代码的时候，没有配置单独的关于小狗行动的标志位，直接运行行为，导致蓝牙控制下的小狗不能在指令下连续运动，经过高人指点，定义一个标志位，将持续运动的用标志位取代，用switch函数查询标志位，执行程序。（我犯了同志们就能避开了）
在这里插入图片描述

连接蓝牙

我使用的蓝牙是JDY-3x，蓝牙APP是B站上一位up的开源【蓝牙调试器App开源】，使用什么蓝牙APP无所谓。
连接线路如下：
RX-----P9;
TX-----P10;
GND—GND;
VCC----3.3V;
在这里插入图片描述
手机蓝牙app：

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
配置好后就可以试试能不能用蓝牙控制小狗了。我的小狗属于有线款，不能脱离面包板，条件允许，同志们可以购买这份材料清单，来源于B站up：这个橙子好辣【【教程】如何做一个可爱的桌面机器小猫小狗】

材料清单

在这里插入图片描述
到这个地方，一个桌面宠物就算做好了。。。如果可以也能加入智能语音控制模块，对宠物进行语音控制，我尚在摸索当中，感谢。

基于stm32桌面宠物
11-06
主要是通过单片机来控制舵机运行达到宠物行动的一个效果。这里是主要代码，使用时可以根据自己的需求进行改写。还可以通过智能公元对宠物添加语音控制功能。
江科大stm32课程程序源码.zip
12-14
这份资源由江苏科技大学提供，是一份全面的STM32入门教程资料，旨在为嵌入式系统爱好者和学习者提供学习指南。资源内容主要包括以下几个方面 ： STM32基础知识：介绍STM32微控制器的架构、特性及其在嵌入式系统中的...
STM32桌宠
2402_86265887的博客
02-14 428
STM32单片机桌宠，人生首焊，也是成功复刻，哈哈哈哈。
25/2/17 ＜嵌入式笔记＞ 桌宠代码解析
yyyy2711的博客
02-17 874
这个寒假跟着做了一个开源的桌宠，我们来解析下代码，加深理解。
STM32单片机智能桌面宠物
2402_83438920的博客
01-17 1万+
本项目是基于STM32单片机的智能小桌宠，具有简单的与人交互功能，支持语音与蓝牙同时控制。文件已在立创开源硬件平台进行了开源，并在哔哩哔哩出了一期详细的开源教程。【开源】STM32智能桌面宠物总教程。
基于STM32的智能桌面宠物设计.zip，含设计文档
12-17
以stm32为核心，将四个舵机，OLED屏幕以及电源模块直接连接到stm32上，可以完成前后左右的运动，并通过OLED显示表情。 嵌入式系统部分：分层架构（Layered Architecture） 主要包括stm32芯片，语音识别模块，蓝牙模块，语音合成模块，舵机模块，屏幕和红外超声波模块。 除了上述的蓝牙通信控制方式外，使用者还可以直接通过硬件部分的语音识别模块进行控制，语音识别 判别出相应的指令后便会控制stm32芯片或是直接控制红外超声波模块，进而协同控制舵机的运动，屏 幕的显示或是语音合成，共同完成一个完整的动作。 HAL 硬件抽象层 内核驱动，由各个硬件的生产厂商提供，主要是对SFR（特殊功能寄存器）的配置，例如分配引脚等， 并将其封装起来，提供接口供上层使用。 OLED : SSD1315 、 DX2002 : 封装程序 、 TP4056充电模块 ：出厂文件 HDL 硬件驱动层 对HAL层进行封装，因为HAL层一般是厂家提供，在开发时不是特别方便直接使用。 为方便我们后续代码编写，需要对这些HDL层的内核驱动代码进行二次封装。 同时有些硬件设备厂家没有提供相应的内核驱动，
基于STM32F103C8T6制作桌面宠物
weixin_67887035的博客
12-11 8544
某天在刷视频的时候，刷到有博主使用STM32制作了一个桌面宠物，刚好手边有需要用到的东西，于是就找到了开源的桌宠来复刻。谁会拒绝放一个小宠物在办公桌上呢。
自制一个桌面宠物小狗（STM32hal库+ADC+IIC+DMA+PWM输出波）
2302_80169672的博客
07-05 8532
基础所需：基础电路认识，C语言，STM32开发，STM32CUBEIDE或CUBEMX和Keil使用（重要），一点点艺术细胞、一点点耐心。此小项目可以用于刚学完STM32hal库，用于巩固自己的以及和助于自己灵活运用hal库。不一定要按照我的I/O口配置，我的因为刚开始DIY#D打印没有到，所以没有配置的很合理，分布不是很好，大家可以按照自己的3D打印区布置，让自己的更美观！
开源！自制一个桌面宠物（STM32CUBEMX HAL库 PWM波 小项目）
热门推荐
Huooer的博客
11-27 6万+
应网友回复，开源！ 平台：STM32CUBEIDE（等效STM32CUBEMX+Keil） 提纲： 1.定时器pwm波输出 2.串口信息交互 3.OLED显示
用K210和stm32做一只桌面小机器人
m0_57870458的博客
05-22 4194
使用K210作为主控，用stm32作为协处理器，K210自带的屏幕做机器人的脸，其摄像头可直接作为机器人的眼睛。能够实现简单的人机交互，如让机器人盯着人看，让它对人撒娇卖萌等。
项目综合：stm32机械臂完整程序
03-26
综合项目：一个完整舵机控制器的源码实现（同时支持PWM舵机和总线舵机）
基于STM32四足控制.zip
05-20
基于STM32F427四足移动机器人开发程序代码，包含蓝牙通信以及稳定的通信协议。蜘蛛型四足机器人。可载重，运动灵活
基于3D打印与STM32的四足教学用机械狗.pdf
06-30
基于3D打印与STM32的四足教学用机械狗.pdf
RobotDog:小型四足机器人
03-23
RobotDog机器狗 小型四足机器人源码 资源总览 机械设计：SolidWorks 2016 结构材料：PLA 3D打印 电机：飞特SCS0009舵机 电池：12V锂电池 控制芯片：遥控器：STM32F103C8T6；机器狗：STM32F405RGT6 无线通信模块：NRF24L01 陀螺仪：MPU6050 开发环境：STM32CubeMX + Keil 5 代码库：遥控器：HAL库；机器狗：HAL库+ FreeRTOS 文件说明 RobotDog是四足机器人的代码， RobotDog_Remote是四足机器人的RobotDog_Remote的代码。每个文件夹里面都有一个.ioc文件，可以使用STM32CubeMX打开重新生成工程文件。 机器人功能展示 全向移动 狗头稳定 更多细节待你发现 代码详解 参见以下文章：
江科大STM32入门资料
04-03
江科大STM32入门资料是一套全面的教程，旨在帮助初学者快速掌握STM32的开发与应用。 首先，STM32的Cortex-M内核是ARM公司设计的低功耗、高性能的微处理器系列，适用于实时操作系统（RTOS）和嵌入式应用。Cortex-M...
基于江科大教程stm32f103c8t6最小系统板u8g2库移植
01-30
在这个教程中，我们将深入探讨如何将U8g2库移植到基于江科大教程的STM32F103C8T6最小系统板上，以实现图形显示功能。 U8g2是一个开源的C++图形库，专为各种单色液晶显示器（LCD）和 OLED 显示屏设计，支持包括SPI、...
江科大STM32入门-TIM编码器接口
04-03
STM32是由意法半导体（STMicroelectronics）推出的基于ARM Cortex-M内核的微控制器系列，广泛应用在嵌入式系统设计中。STM32的TIM（Timer Interface）编码器接口是其众多功能之一，用于处理各种编码器信号，如增量式...
Nwatch-基于江协科大STM32版本
02-26
在本文中，我们将深入探讨“Nwatch-基于江协科大STM32版本”的相关知识点，以及如何利用它进行开发。 1. STM32微控制器：STM32家族涵盖了一系列具有不同性能、存储器大小和外设集的MCU，广泛应用于工业控制、消费...
stm32小狗结合ai小智
最新发布
03-22
### STM32结合AI小狗小智的开发方案 #### 1. 系统架构设计 为了实现STM32与AI技术（如小狗小智）的集成，可以采用分层模块化的设计方法。整个系统可分为硬件部分和软件部分。 - **硬件部分**：主要由STM32单片机为核心控制器，外接传感器、语音识别模块以及蓝牙通信模块组成[^1]。 - **软件部分**：通过固件编程实现数据采集、处理逻辑以及与云端AI服务的交互功能。 #### 2. 主要组件选型 以下是几个关键组件的选择建议： - **微控制器单元 (MCU)** 使用高性能版本的STM32系列芯片作为核心处理器，例如STM32F4或STM32H7，这些型号具备足够的计算能力和内存资源来运行复杂的算法。 - **语音识别模块** 集成专用的离线/在线语音识别模组，用于解析用户的命令并触发相应的动作响应。可以选择市场上成熟的解决方案，比如科大讯飞提供的SDK或者百度DuerOS平台接口。 - **无线通讯模块** 蓝牙模块负责短距离内的设备连接；Wi-Fi模块则允许访问互联网从而调用远程服务器上的深度学习模型来进行更高级别的图像分类或其他形式的人工智能运算。 #### 3. 功能实现细节 具体到“小狗小智”的应用场景下，可能涉及以下几个方面的功能开发： - **运动控制** 编写程序使机械结构能够模仿真实动物的动作行为模式，这通常涉及到步态规划算法的研究应用。 - **情感表达** 利用人脸表情合成技术和声音变化调节机制让虚拟角色展现出不同的情绪状态给用户带来更加生动有趣的互动体验效果。 - **环境感知能力增强** 安装多种类型的传感装置如温度湿度计、光线强度探测仪等收集周围物理参数信息反馈至中央控制系统以便做出及时调整适应当前状况下的最佳表现方式。 ```c // 示例代码片段展示如何初始化I2C总线以读取外部传感器的数据 void I2C_Init(void){ GPIO_InitTypeDef GPIO_InitStruct = {0}; __HAL_RCC_GPIOB_CLK_ENABLE(); HAL_NVIC_SetPriority(I2Cx_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2Cx_IRQn); /* Configure SCL pin as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB,&GPIO_InitStruct); /* Configure SDA pin as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_9; HAL_GPIO_Init(GPIOB,&GPIO_InitStruct); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值