Stm32c8t6制作遥控器

已于 2024-10-21 08:11:33 修改
阅读量613 收藏 5
点赞数 4
文章标签： stm32 嵌入式硬件 单片机
于 2024-07-03 09:57:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81069762/article/details/140142572
版权

 

 

 

基本概述

硬件组成

摇杆 RKJXV1224005     OLED屏    STLINK    

功能

传输和接收数据

硬件部分

摇杆 RKJXV1224005

1f31158687c68cd0f826b9c5c90f0f79.jpeg

摇杆中有6个引脚来读取电路板的AD值，分别用摇杆上下左右的偏移程度得到不同的AD值，以达到读取摇杆状态的目的

NPF24L01

4ecd72700a1c6e6cf90243d0699f05ee.jpeg

传输和接收数据

 

代码模块

传输模块

NPF24L01.c

 

# include "NRF24L01.h"
#include "NRF24L01_Ins.h"
#include "stm32f10x.h"                  // Device header
#include "Delay.h"

/***************************************************************************

׷Ҫگ˽ʹԃ˵ķú

NRF24L01_Pin_Init()		ӽޅԵʼۯ, Ϟӎ˽ìϞ׵ܘֵìһѣһַԃìԵʼۯֱޓַԃNRF24L01_Init()ܴࠉ

*---------------------------------------------------------------------------*
NRF24L01_Write_Reg(uint8_t Reg, uint8_t Value)		дNRF24L01݄զǷ

ӎ˽úReg, ݄զǷַ֘
	  ValueúҪдɫք˽ߝ
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_Read_Reg(uint8_t Reg)		ׁNRF24L01݄զǷ

ӎ˽úRegú݄զǷַ֘
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_Read_Buf(uint8_t Reg, uint8_t *Buf, uint8_t Len)	һՎׁNRF24L01݄զǷנٶؖޚ

ӎ˽úRegú݄զǷַ֘û*Bufú݄զǷؖޚׁԶ۳զԢք˽ةûLenúҪׁԶքؖޚٶ˽
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_Write_Buf(uint8_t Reg, uint8_t *Buf, uint8_t Len)		һՎдNRF24L01݄զǷנٶؖޚ

ӎ˽úRegú݄զǷַ֘û*Bufú݄զǷдɫؖޚքզ؅˽ةûLenúҪׁԶքؖޚٶ˽
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_GetRxBuf(uint8_t *Buf)		ׁԶޓ˕սք˽ߝìΪנٶؖޚ

ӎ˽ú*Bufנٶؖޚզ؅ք˽ة
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_SendTxBuf(uint8_t *Buf)	ע̍נٶؖޚ

ӎ˽ú*BufҪע̍քؖޚզ؅ք˽ة
׵ܘֵú״ֵ̬
*---------------------------------------------------------------------------*
NRF24L01_Check(void)				ݬҩNRF24L01ˇرզ՚

׵ܘֵú1úһզ՚ì0úզ՚
*---------------------------------------------------------------------------*
NRF24L01_Init()						NRF24L01ԵʼۯìѼڬݬҩNRF24L01ˇرզ՚b˕עƤ׃ԵʼۯìԵʼۯֱޓַԃكگ˽ܴࠉ

*---------------------------------------------------------------------------*
NRF24L01_RT_Init(void) 				NRF24L01˕עƤ׃Եʼۯ
*---------------------------------------------------------------------------*
NRF24L01_SendBuf(uint8_t *Buf)		NRF24L01ע̍נٶؖޚ˽ߝ

ӎ˽úҪע̍ؖޚզ؅ք˽ة
*---------------------------------------------------------------------------*
uint8_t NRF24L01_Get_Value_Flag()	ܱȡא׏Ҫ־ìһթޓ˕ս˽ߝì׵ܘ0

׵ܘֵú0úޓ˕ս˽ߝû1úδޓ˕ս˽ߝ

**************************     By:ǕǕͨͨOrdinary    **********************************/


/***************    ݇փɽl֧ԖһЂŶáQAQ  *******************************************/


#define TX_ADR_WIDTH    5     //5ؖޚַ֘࠭׈
#define RX_ADR_WIDTH    5     //5ؖޚַ֘࠭׈
#define TX_PLOAD_WIDTH  32    //32ؖޚԐЧ˽ߝ࠭׈
#define RX_PLOAD_WIDTH  32    //32ؖޚԐЧ˽ߝ࠭׈

const uint8_t TX_ADDRESS[TX_ADR_WIDTH]={0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 
const uint8_t RX_ADDRESS[RX_ADR_WIDTH]={0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 


void W_SS(uint8_t BitValue)
{
	GPIO_WriteBit(CSN_Port, CSN_Pin, (BitAction)BitValue);//A4
} 

void W_CE(uint8_t BitValue)
{
	GPIO_WriteBit(CE_Port, CE_Pin, (BitAction)BitValue);//B0
} 

void W_SCK(uint8_t BitValue)
{
	GPIO_WriteBit(SCK_Port, SCK_Pin, (BitAction)BitValue);//A5
} 

void W_MOSI(uint8_t BitValue)
{
	GPIO_WriteBit(MOSI_Port, MOSI_Pin,(BitAction)BitValue);//A7
} 

uint8_t R_MISO(void)
{
	return GPIO_ReadInputDataBit(MISO_Port, MISO_Pin);//A6
}

uint8_t R_IRQ(void)
{
	return GPIO_ReadInputDataBit(IRQ_Port, IRQ_Pin);//B1
}

void NRF24L01_Pin_Init(void)	
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB,ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = CSN_Pin;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(CSN_Port, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = SCK_Pin;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(SCK_Port, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = MOSI_Pin;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(MOSI_Port, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = CE_Pin;  
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(CE_Port, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = MISO_Pin;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(MISO_Port, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = IRQ_Pin;  			
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(IRQ_Port, &GPIO_InitStructure);
	
}
		


uint8_t SPI_SwapByte(uint8_t Byte)  
{
	uint8_t i;
	for(i = 0; i < 8; i ++) 
	{
		if((uint8_t)(Byte & 0x80) == 0x80)
		{
			W_MOSI(1);
		} 		
		else 
		{
			W_MOSI(0);
		}			
		Byte = (Byte << 1);			
		W_SCK(1);					
		Byte |= R_MISO();	        
		W_SCK(0);					
	}
	return Byte;
}
uint8_t NRF24L01_Write_Reg(uint8_t Reg, uint8_t Value)
{
	uint8_t Status;

	W_SS(0);                  
  	Status = SPI_SwapByte(Reg);
	SPI_SwapByte(Value);	
	W_SS(1);                 

	return Status;
}

uint8_t NRF24L01_Read_Reg(uint8_t Reg)
{
 	uint8_t Value;

	W_SS(0);              
  	SPI_SwapByte(Reg);		
	Value = SPI_SwapByte(NOP);
	W_SS(1);             	

	return Value;
}




uint8_t NRF24L01_Read_Buf(uint8_t Reg, uint8_t *Buf, uint8_t Len)
{
	uint8_t Status, i;
	W_SS(0);                    	
	Status =SPI_SwapByte(Reg);		
 	for(i = 0; i < Len; i ++)
	{
		Buf[i] = SPI_SwapByte(NOP);	
	}
	W_SS(1);                 		
	return Status;        			
}

uint8_t NRF24L01_Write_Buf(uint8_t Reg, uint8_t *Buf, uint8_t Len)
{
	uint8_t Status, i;
	W_SS(0); 
	Status = SPI_SwapByte(Reg);		
	for(i = 0; i < Len; i ++)
	{
		SPI_SwapByte(*Buf ++); 		
	}
	W_SS(1); 
	return Status;          		
}							  					   

uint8_t NRF24L01_GetRxBuf(uint8_t *Buf)
{
	uint8_t State;
	State = NRF24L01_Read_Reg(STATUS);  			
	NRF24L01_Write_Reg(nRF_WRITE_REG + STATUS, State);
	if(State & RX_OK)								
	{                                                       
		W_CE(1);											
		NRF24L01_Read_Buf(RD_RX_PLOAD, Buf, RX_PLOAD_WIDTH);
		NRF24L01_Write_Reg(FLUSH_RX, NOP);					
		W_CE(1);				
		Delay_us(150);
		return 0; 
	}	   
	return 1;
}
uint8_t NRF24L01_SendTxBuf(uint8_t *Buf)
{
	uint8_t State;
   
	W_CE(0);												
  	NRF24L01_Write_Buf(WR_TX_PLOAD, Buf, TX_PLOAD_WIDTH);	
 	W_CE(1);												
	while(R_IRQ() == 1);									
	State = NRF24L01_Read_Reg(STATUS);  					
	NRF24L01_Write_Reg(nRF_WRITE_REG + STATUS, State); 		
	if(State&MAX_TX)				 						
	{
		NRF24L01_Write_Reg(FLUSH_TX, NOP);					
		return MAX_TX; 
	}
	if(State & TX_OK)	
	{
		return TX_OK;
	}
	return NOP;	
}

uint8_t NRF24L01_Check(void)
{
	uint8_t check_in_buf[5] = {0x11 ,0x22, 0x33, 0x44, 0x55};
	uint8_t check_out_buf[5] = {0x00};

	W_SCK(0);
	W_SS(1);   
	W_CE(0);	

	NRF24L01_Write_Buf(nRF_WRITE_REG + TX_ADDR, check_in_buf, 5);

	NRF24L01_Read_Buf(nRF_READ_REG + TX_ADDR, check_out_buf, 5);

	if((check_out_buf[0] == 0x11) && (check_out_buf[1] == 0x22) && (check_out_buf[2] == 0x33) && (check_out_buf[3] == 0x44) && (check_out_buf[4] == 0x55))
	{
		return 0;
	}
	else 
	{
		return 1;
	}
}			


void NRF24L01_RT_Init(void) 
{	
	W_CE(0);		  
  	NRF24L01_Write_Reg(nRF_WRITE_REG+RX_PW_P0, RX_PLOAD_WIDTH);
	NRF24L01_Write_Reg(FLUSH_RX, NOP);									
  	NRF24L01_Write_Buf(nRF_WRITE_REG + TX_ADDR, (uint8_t*)TX_ADDRESS, TX_ADR_WIDTH);
  	NRF24L01_Write_Buf(nRF_WRITE_REG + RX_ADDR_P0, (uint8_t*)RX_ADDRESS, RX_ADR_WIDTH);   
  	NRF24L01_Write_Reg(nRF_WRITE_REG + EN_AA, 0x01);     
  	NRF24L01_Write_Reg(nRF_WRITE_REG + EN_RXADDR, 0x01); 
  	NRF24L01_Write_Reg(nRF_WRITE_REG + SETUP_RETR, 0x1A);
  	NRF24L01_Write_Reg(nRF_WRITE_REG + RF_CH, 0);        
  	NRF24L01_Write_Reg(nRF_WRITE_REG + RF_SETUP, 0x0F);  
  	NRF24L01_Write_Reg(nRF_WRITE_REG + CONFIG, 0x0F);    
	W_CE(1);									  
}

void NRF24L01_Init()
{
	NRF24L01_Pin_Init();
	while(NRF24L01_Check());
	NRF24L01_RT_Init();
	
}

void NRF24L01_SendBuf(uint8_t *Buf)
{
	W_CE(0);									
	NRF24L01_Write_Reg(nRF_WRITE_REG + CONFIG, 0x0E);   
	W_CE(1);
	Delay_us(15);
	NRF24L01_SendTxBuf(Buf);						
	W_CE(0);
	NRF24L01_Write_Reg(nRF_WRITE_REG + CONFIG, 0x0F);
	W_CE(1);	
}

uint8_t NRF24L01_Get_Value_Flag()
{
	return R_IRQ();
}

NPF24L01.h

#ifndef __nRF24L01_API_H
#define __nRF24L01_API_H

#include "stm32f10x.h"                  // Device header

uint8_t SPI_SwapByte(uint8_t byte);
uint8_t NRF24L01_Write_Reg(uint8_t reg,uint8_t value);
uint8_t NRF24L01_Read_Reg(uint8_t reg);
uint8_t NRF24L01_Read_Buf(uint8_t reg,uint8_t *pBuf, uint8_t len);
uint8_t NRF24L01_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t len);
uint8_t NRF24L01_GetRxBuf(uint8_t *rxbuf);
uint8_t NRF24L01_SendTxBuf(uint8_t *txbuf);
uint8_t NRF24L01_Check(void);
void NRF24L01_RT_Init(void);
void NRF24L01_Init(void);
void NRF24L01_SendBuf(uint8_t *Buf);
void NRF24L01_Pin_Init(void);
//uint8_t NRF24L01_Get_Value_Flag();

#endif

 NPF24L01_lr

#ifndef __nRF24L01_H
#define __nRF24L01_H

/**********  NRF24L01ӽޅ֨ӥ  ***********/
#define IRQ_Port	GPIOB
#define CE_Port		GPIOB
#define CSN_Port	GPIOB
#define SCK_Port	GPIOB
#define MOSI_Port	GPIOB
#define MISO_Port	GPIOB

#define IRQ_Pin		GPIO_Pin_11
#define CE_Pin		GPIO_Pin_12
#define CSN_Pin		GPIO_Pin_10
#define SCK_Pin		GPIO_Pin_13
#define MOSI_Pin	GPIO_Pin_15
#define MISO_Pin	GPIO_Pin_14

/**********  NRF24L01݄զǷәطļ®  ***********/
#define nRF_READ_REG        0x00 
#define nRF_WRITE_REG       0x20 
#define RD_RX_PLOAD     0x61  
#define WR_TX_PLOAD     0xA0  
#define FLUSH_TX        0xE1  
#define FLUSH_RX        0xE2  
#define REUSE_TX_PL     0xE3  
#define NOP             0xFF  
/**********  NRF24L01݄զǷַ֘   *************/
#define CONFIG          0x00                           
#define EN_AA           0x01  
#define EN_RXADDR       0x02  
#define SETUP_AW        0x03  
#define SETUP_RETR      0x04  
#define RF_CH           0x05  
#define RF_SETUP        0x06  
#define STATUS          0x07  
#define OBSERVE_TX      0x08  
#define CD              0x09  
#define RX_ADDR_P0      0x0A  
#define RX_ADDR_P1      0x0B  
#define RX_ADDR_P2      0x0C  
#define RX_ADDR_P3      0x0D  
#define RX_ADDR_P4      0x0E  
#define RX_ADDR_P5      0x0F  
#define TX_ADDR         0x10  
#define RX_PW_P0        0x11   
#define RX_PW_P1        0x12   
#define RX_PW_P2        0x13   
#define RX_PW_P3        0x14   
#define RX_PW_P4        0x15  
#define RX_PW_P5        0x16  
#define FIFO_STATUS     0x17  

/******   STATUS݄զǷbitλ֨ӥ      *******/
#define MAX_TX  	0x10  	  //կսخճע̍Վ˽א׏
#define TX_OK   	0x20  	  //TXע̍Ϊԉא׏
#define RX_OK   	0x40  	  //ޓ˕ս˽ߝא׏

#endif

key.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "Timer.h"
//#include "can.h"
#include "OLED.h"
//#include "SendMessage.h"
//#include "MyFlash.h"
//#include "Queue.h"

u8 KeyNum0,KeyNum1,KeyNum2;
u32 KeyRaiseFlag,KeyReduceFlag;
u8 MotorFirstFlag,IDSetFlag;
u32 IDNum;

void Key_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,ENABLE);	
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitTypeDefStruct;
	GPIO_InitTypeDefStruct.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitTypeDefStruct.GPIO_Pin=GPIO_Pin_7;
	GPIO_InitTypeDefStruct.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOB,&GPIO_InitTypeDefStruct);
	GPIO_InitTypeDefStruct.GPIO_Pin=GPIO_Pin_6;
	GPIO_Init(GPIOA,&GPIO_InitTypeDefStruct);
	
	GPIO_SetBits(GPIOB,GPIO_Pin_7);
	GPIO_SetBits(GPIOB,GPIO_Pin_6);
}
//按键1事件
void Key1PressShort(void)
{
  OLED_ShowNum(4, 1, 1, 4);
}

void Key1PressLong(void)
{
	OLED_ShowNum(4, 6, 1, 4);
}

void Key1Released(void)
{
	
}

//按键2事件	
void Key2PressShort(void)
{      
	 
}       
void Key2PressLong(void)
{
	

}

void Key2Released(void)
{
	
}

void (*OnKeyPressShort[])(void)={Key1PressShort,Key2PressShort};
void (*OnKeyPressLong[])(void)={Key1PressLong,Key2PressLong};
void (*OnKeyReleased[])(void)={Key1Released,Key2Released};

int KeyPin[]={GPIO_Pin_6,GPIO_Pin_7};
GPIO_TypeDef* KeyGPIO[]={GPIOB,GPIOB};

u8 PressedKey[]={0,0};
u32 KeyLastPressTime[]={0,0};
u32 KeyLastReleasedTime[]={0,0};
u8 KeyPressEvent[]={0,0};


void HandleKey(void)
{
	for(u8 i=0;i<2;i++)
	{
		if(PressedKey[i]==1)
		{
			if(CurrentTimes-KeyLastPressTime[i]>50)//如果按下按键超过50ms
			{
				if((GPIO_ReadInputDataBit(KeyGPIO[i],KeyPin[i])==1))
				{
					if(KeyPressEvent[i]==0)
					{
						if(OnKeyReleased[i])
						{
							OnKeyReleased[i]();
						}
						//触发松手事件
					}
					PressedKey[i]=0;//按键触发数组归零重新开始下一轮扫描
					KeyLastReleasedTime[i]=CurrentTimes;
				}
				else
				{
					if(CurrentTimes-KeyLastPressTime[i]>200)//控制长按时间
					{
						if(KeyPressEvent[i]==0)
						{
							KeyPressEvent[i]=1;
							if(OnKeyPressLong[i])
							{
								OnKeyPressLong[i]();
							}
							//触发长按事件
						}
					}
				}
			}
		}
		else//按键第一次按下
		{
			if((GPIO_ReadInputDataBit(KeyGPIO[i],KeyPin[i])==0)&&(CurrentTimes-KeyLastReleasedTime[i]>200))
			{
				PressedKey[i]=1;//按键已经按下
				KeyLastPressTime[i]=CurrentTimes;//记录按下的时间
				KeyPressEvent[i]=0;//清零长按事件的标志
				if(OnKeyPressShort[i])
				{
					OnKeyPressShort[i]();
				}
				//触发按下的事件
			}
		}
	}
}

key.h

#ifndef _Key_H_
#define _Key_H_


#define KEY2 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_7)	
#define KEY3 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_6)


extern u8 KeyNum0,KeyNum1,KeyNum2;
extern u32 KeyRaiseFlag,KeyReduceFlag;
extern u8 MotorFirstFlag,IDSetFlag;


void Key_Init(void);
void HandleKey(void);

#endif

电路板

06523c8daddf376ad28581dba18db07a.png

0438c54a21952e17fe8981e373574dfa.png

6252f23b5478e06d5ed6c9544da1cdf8.png

e21d9401fe2a9aaaa7b5e3834cd88138.jpeg

 

Kwf..
关注
STM32实现简单的智能手柄
2401_85258012的博客
09-17 581
智能手柄是一种可以通过无线连接与设备通信的控制器，它可以用于游戏机、电脑和其他智能设备。本文将详细介绍如何使用STM32微控制器实现一个简单的智能手柄。以上是一个简单的智能手柄的实现示例，仅供参考。实际的手柄功能和通信协议可能有所不同，需要根据具体的需求进行相应的开发。希望本文对您有所帮助！至此，我们已经实现了一个简单的智能手柄。通过STM32微控制器，我们可以读取手柄按钮和摇杆的状态，并将其发送给无线模块进行通信。接下来，我们将逐步实现智能手柄的功能。
【stm32】摇杆模块利用stm32获取摇杆值
m0_74086611的博客
03-07 6618
接线方式：GND、VCC（+5V）是供电端VRx，VRy （X、Y轴）为模拟输入信号，连接到模拟IO口A0~A7。VRx，VRy 的值：从 0 ~ 1023 分别代表 左~右，上~下。中间值为512。SW （Z轴）是数字输入信号，连接到数字端口，并启用上拉电阻。SW 的值：1代表未按下，0代表按下。接线+5v接stm32的+5v引脚GND接stm32的GNDVRX接A0VRY接A1sw不接。
【STM32外设系列】双轴按键PS2摇杆
qq_45217381的博客
11-08 5480
本文详细介绍了双轴按键PS2摇杆的使用方法，最后给出了详细的程序设计和程序工程文件。
基于STM32的PS2摇杆遥控
02-15
采用STM32F103单片机检测PS2摇杆的输出信息，方便后期的操控。IIC接口的OLED
5D摇杆驱动（STM32）
huazhen1234的专栏
07-05 2246
一、前期准备 单片机：STM32F103ZET6 开发环境：MDK5.14 库函数：标准库V3.5 5D摇杆模块：淘宝有售 二、实验效果 实现上下左右、左上、右上、左下、右下（有些手抖，按不到位）按下检测。 三、驱动原理 低有效，与普通按键驱动无异 需要完整工程或者有问题的请加QQ：1002521871，验证：呵呵。 四、驱动代码 key.h #ifndef __KEY_H__ #define...
STM32 PS2游戏摇杆 测试
weixin_62787296的博客
05-25 1495
对PS2游戏摇杆进行测试
基于stm32f403zet6游戏摇杆手柄
最新发布
weixin_66194218的博客
10-30 310
1. Cortex-M内核的STM32F407zet6为主控，使用DMA内存搬运, 双通道ADC外设，实现 ADC实时对两个摇杆的数据快速采集。5. 多个外部中断来实现按键的控制，并加了震动模块和蜂鸣器响应模拟攻击响应。6. 采用定时器实现看门狗功能，对蓝牙和摇杆的检测，实现休眠模式和未连接状态。2. 使用ADC采集数据通过USART串口，使用蓝牙模块实时进行数据通信。3. 使用HC-05蓝牙进行主从配置，可以支持板子与板子之间的无线通信。
SBUS转PPM stm32c8t6 航模遥控器
11-24
STM32C8T6是一款基于ARM Cortex-M0内核的微控制器，广泛应用于无人机和航模遥控器领域。在航模遥控系统中，数据传输协议的选择至关重要，SBUS和PPM是两种常见的多通道遥控信号编码方式。本文将详细探讨如何在STM32C...
基于STM32C8T6的mpu6050，遥控器程序
02-25
标题中的“基于STM32C8T6的mpu6050，遥控器程序”指的是一项利用STM32C8T6微控制器与MPU6050六轴传感器设计的遥控器项目。STM32C8T6是意法半导体（STMicroelectronics）生产的一款基于ARM Cortex-M0内核的微控制器，...
STM32C8T6使用HAL库，驱动多路18B20，GY906，2812LED，舵机
07-18
STM32C8T6是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M0+内核的微控制器，广泛应用于嵌入式系统设计。HAL库（Hardware Abstraction Layer，硬件抽象层）是ST提供的高级软件框架，旨在简化STM32的...
STM32-ARM-实验-9-摇杆输入&I2C
07-13
按下Key键时，读取STM32内部温度传感器的温度值，随机存入5组温度值到FLASH中。按下Temper键时，读取LM75A温度传感器的温度值，随机存入5组温度值到FLASH中。按下Wakeup键时，将FLASH中存入的总共10组数据读取出来，并在液晶屏幕坐标系上标出温度点，显示相应数据。
stm32f103c8t6实现用摇杆模块joystick和串口模块实现控制方向的代码例程，可在特定位置添加想要的代码
03-04
对代码使用上的问题可私聊
stm32f407和摇杆制作的控制手柄代码
03-30
正点原子探索者stm32f407和摇杆模块制作的控制手柄代码,可以直接拿来用,可以作为学习使用
基于STM32C8T6的航模舵机检测器（含PCB）
01-17
基于STM32C8T6的航模舵机检测器（含PCB图和程序源代码） 比较麻烦 此舵机检测器利用 比较麻烦 此舵机检测器利用 比较麻烦 此舵机检测器利用 比较麻烦 此舵机检测器利用 比较麻烦 此舵机检测器利用 STM32F103C8T6STM...
STM32C8T6 AS3933接收源码.zip
03-03
总结来说，"STM32C8T6 AS3933接收源码.zip"这个压缩包文件提供了一个PKE系统中智能传感器实现的关键部分，即通过STM32C8T6微控制器和AS3933无线感应芯片的配合，实现无钥匙进入系统的信号检测和处理。源码的分析和...
stm32cubeMX学习十四、游戏摇杆模块的使用(基于野火STM32F103ZET6开发板)
Bruce.yang的嵌入式之旅
09-09 5553
本程序编写基于秉火霸道STM32F103ZET6运行环境。 今天来玩一个PS2游戏摇杆模块，也被称为Joystick，下面来了解下工作原理以及如何来应用。
STM32F429连接USB飞行摇杆 (一) 连接摇杆
黑脚印 DarkSpoor
01-09 3007
本文介绍如何使用stm32连接usb接口的飞行摇杆。
摇杆按键+SG90 实现舵机云台（STM32F103C8T6）
weixin_47903856的博客
06-12 3060
代码很简单，主要使用ADC双通道读取两个电位器的值（实际上就是电压），通过获取到的值的范围来确定上下左右，从而来改变两个舵机的角度。
请帮我详细注释下列代码：public class PlateRecognize { public int plateRecognize(Mat src, Vector<String> licenseVec) { //���Ʒ��鼯�� Vector<Mat> plateVec = new Vector<Mat>(); int resultPD = plateDetect.plateDetect(src, plateVec); if (resultPD == 0) { int num = (int) plateVec.size(); for (int j = 0; j < num; j++) { Mat plate = plateVec.get(j); //��ȡ������ɫ String plateType = charsRecognise.getPlateType(plate); //��ȡ���ƺ� String plateIdentify = charsRecognise.charsRecognise(plate); String license = plateType + ":" + plateIdentify; licenseVec.add(license); } } return resultPD; }
04-22
这段代码是一个Java类，名为PlateRecognize。它定义了一个public方法plateRecognize，该方法接受一个名为src的Mat对象和一个名为licenseVec的Vector<String>对象作为输入参数，并返回一个int型的值。在方法内部，首先创建一个名为plateVec的Vector<Mat>对象，用于存储车牌图像。然后调用plateDetect.plateDetect方法对输入图像进行车牌检测，返回的结果赋值给resultPD。如果车牌检测成功（resultPD为0），则遍历得到的所有车牌图像，对每个车牌依次进行字符识别。具体来说，对于每个车牌图像，首先调用charsRecognise.getPlateType方法获取车牌类型（如蓝牌、黄牌等），然后调用charsRecognise.charsRecognise方法对车牌图像进行字符识别，得到车牌号码。最后，将车牌类型和车牌号码拼接成一个字符串，并将该字符串添加到licenseVec中。最后返回resultPD。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值