基于江科大STM32的桌宠小狗

已于 2024-10-21 14:34:34 修改
阅读量5.5k 收藏 150
点赞数 30
分类专栏： 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微控制器的架构、特性及其在嵌入式系统中的...
25/2/17 ＜嵌入式笔记＞ 桌宠代码解析
yyyy2711的博客
02-17 908
这个寒假跟着做了一个开源的桌宠，我们来解析下代码，加深理解。
STM32单片机的桌面宠物机器人（基于HAL库）
最新发布
m0_61279136的博客
03-29 1412
ASR PRO获取到语音后通过串口通信把数据发送到STM32，在单片机内使用中断的方式获取语音数据,，然后根据语音指令判断当前的动作。初始化代码，使用TIM3定时器的四个通道输出PWM驱动舵机，控制腿部的运动。语音模块：ASR PRO，通过天问block软件烧录语音指令。对应动作实现，分别设置对应腿的角度，通过延时达到效果。主控芯片：STM32F103C8T6 使用HAL库。分别展示对应的表情和动作，OLED直接用的现成的库。屏幕：0.96寸OLED屏，用来显示表情。4个舵机，用来当作四只腿。
基于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 9346
某天在刷视频的时候，刷到有博主使用STM32制作了一个桌面宠物，刚好手边有需要用到的东西，于是就找到了开源的桌宠来复刻。谁会拒绝放一个小宠物在办公桌上呢。
自制一个桌面宠物小狗（STM32hal库+ADC+IIC+DMA+PWM输出波）
2302_80169672的博客
07-05 8908
基础所需：基础电路认识，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显示
STM32单片机智能桌面宠物
2402_83438920的博客
01-17 1万+
本项目是基于STM32单片机的智能小桌宠，具有简单的与人交互功能，支持语音与蓝牙同时控制。文件已在立创开源硬件平台进行了开源，并在哔哩哔哩出了一期详细的开源教程。【开源】STM32智能桌面宠物总教程。
江科大STM32入门资料
04-03
江科大STM32入门资料是一套全面的教程，旨在帮助初学者快速掌握STM32的开发与应用。 首先，STM32的Cortex-M内核是ARM公司设计的低功耗、高性能的微处理器系列，适用于实时操作系统（RTOS）和嵌入式应用。Cortex-M...
基于江科大教程stm32f103c8t6最小系统板u8g2库移植
01-30
在这个教程中，我们将深入探讨如何将U8g2库移植到基于江科大教程的STM32F103C8T6最小系统板上，以实现图形显示功能。 U8g2是一个开源的C++图形库，专为各种单色液晶显示器（LCD）和 OLED 显示屏设计，支持包括SPI、...
项目综合：stm32机械臂完整程序
03-26
综合项目：一个完整舵机控制器的源码实现（同时支持PWM舵机和总线舵机）
基于STM32四足控制.zip
05-20
基于STM32F427四足移动机器人开发程序代码，包含蓝牙通信以及稳定的通信协议。蜘蛛型四足机器人。可载重，运动灵活
基于3D打印与STM32的四足教学用机械狗.pdf
06-30
基于3D打印与STM32的四足教学用机械狗.pdf
江科大STM32入门-TIM编码器接口
04-03
STM32是由意法半导体（STMicroelectronics）推出的基于ARM Cortex-M内核的微控制器系列，广泛应用在嵌入式系统设计中。STM32的TIM（Timer Interface）编码器接口是其众多功能之一，用于处理各种编码器信号，如增量式...
Nwatch-基于江协科大STM32版本
02-26
在本文中，我们将深入探讨“Nwatch-基于江协科大STM32版本”的相关知识点，以及如何利用它进行开发。 1. STM32微控制器：STM32家族涵盖了一系列具有不同性能、存储器大小和外设集的MCU，广泛应用于工业控制、消费...
用K210和stm32做一只桌面小机器人
m0_57870458的博客
05-22 4294
使用K210作为主控，用stm32作为协处理器，K210自带的屏幕做机器人的脸，其摄像头可直接作为机器人的眼睛。能够实现简单的人机交互，如让机器人盯着人看，让它对人撒娇卖萌等。
基于STM32的智能宠物看护喂养系统（程序源码+原理图+PCB+Boom表+实物操作说明）
2301_79246489的博客
09-04 1万+
基于STM32的智能宠物看护喂养系统（程序源码+原理图+PCB+Boom表+实物操作说明）随着我国经济的快速发展，人们的生活水平不断提高，饲养宠物已经成为成为一种潮流。目前，市场上出现了很多类似智能宠物屋的产品，但大多数功能比较单一，不能很好地解决宠物喂食和居住环境等相关方面的问题。针对这些问题，本文设计了基于 STM32 单片机的智能宠物管理系统。
stm32小狗
03-16
### 关于STM32的小狗示例程序或外设驱动 在嵌入式开发领域，尤其是针对初学者的学习过程中，“小狗”作为一个有趣的案例可能会被用于教学目的。然而，在现有的引用资料中并未提及任何关于“小狗”的具体示例程序或外设驱动[^1]。 尽管如此，可以推测这种类型的项目通常会围绕以下几个方面展开： #### 1. **定时器中断模拟小狗行为** 通过使用STM32的定时器模块，可以实现周期性的动作触发，比如控制LED灯闪烁或者蜂鸣器发声来模仿小狗的动作或叫声。这可以通过配置TIMx定时器并编写相应的中断服务函数完成。 ```c void TIM3_IRQHandler(void) { if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) { // 清除更新标志位 TIM_ClearITPendingBit(TIM3, TIM_IT_Update); // 控制GPIO口状态改变（如点亮/熄灭LED） GPIO_ToggleBits(GPIOA, GPIO_Pin_5); } } ``` #### 2. **ADC采集外部信号** 如果希望感知环境变化（例如温度、光线强度等），并通过这些数据影响“小狗”的反应，则可利用STM32内置的模数转换器(ADC)[^2]。例如读取光敏电阻值决定是否开启灯光照明功能。 ```c uint16_t ADC_ReadValue() { uint16_t adc_value; /* 启动指定通道上的规则组中的转换 */ ADC_SoftwareStartConvCmd(ADC1, ENABLE); while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC)); adc_value = ADC_GetConversionValue(ADC1); return adc_value; } ``` #### 3. **串口通信传输指令** 为了使用户能够远程发送命令给设备从而操控虚拟宠物的行为模式，UART接口显得尤为重要。它可以接收来自PC端或其他微控制器的信息流，并依据接收到的数据执行特定操作[^3]。 ```c void USART_SendString(char *str){ while(*str != '\0'){ USART_SendData(USART1,*str++); while(USART_GetFlagStatus(USART1, USART_FLAG_TXE)==RESET); } } // 接收字符直到遇到回车键为止 char USART_ReceiveByte(){ char ch=0; do{ while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE)==RESET); ch=USART_ReceiveData(USART1); }while(ch!='\r'); return ch; } ``` 虽然上述代码片段展示了如何基于不同硬件单元构建基础框架，但实际应用中小狗的具体表现形式还需依赖开发者创意设计以及软件逻辑编排。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值