JY62陀螺仪的联调用STM32CubeMX

最新推荐文章于 2024-01-27 10:07:48 发布
最新推荐文章于 2024-01-27 10:07:48 发布
阅读量2.7k 收藏 39
点赞数 7
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41376117/article/details/128602546
版权

想用陀螺仪实时显示欧拉角

这是陀螺仪的官网
JY62产品规格书
通讯协议
JY62 WT61协议
一、JY62模块连串口看看
维特智能产品资料提供的程序不给力，不能直接用在STM32CubeMx的工程里，所以需要自己编。
在这里插入图片描述
先用TTL转USB的模块跟电脑连上，在串口助手里看看收发内容，此模块是一直发送的，有个休眠模式（就是发和接到休眠命令时刻一样的加速度和角度），再次解除休眠又实时变化了。
引脚这么接：
VCC->3V3;RX->TXD;TX->RXD;GND->GND;
模块默认是115200波特率，所以串口助手也115200，接了一段数据大概是这样
在这里插入图片描述
可以看到和通讯协议上写的差不多，0x55开头，0x51加速度，0x52角速度，0x53角度
TYPE 备注
0x51 加速度
0x52 角速度
0x53 角度
也可以输入命令，
0xFF 0xAA 0x52 Z轴归零
0xFF 0xAA 0x60 休眠与解休眠

二、用STM32CubeMX生成

打算两个串口，透传的方式，来解析模块数据。USART1与电脑通讯，USART2与模块通讯，STM32中USART1与USART2互为收发目标。
2.1、选用STM32F103ZET6芯片
在这里插入图片描述
2.2、Sytem Core里SYS里头把No debug改成 Serial Wire，这样之后可以Debug来看数据。
在这里插入图片描述
2.3、Connectivity下，打开USART1和2，Mode选 Asynchronous ,波特率115200
在这里插入图片描述
在DMA Settings里，要添加两个DMA，Add之后会有固定通道分配
在这里插入图片描述
USART2也是这样配置
在这里插入图片描述
2.4、NVIC要勾选 global interrupt，中断里写程序
在这里插入图片描述

2.5、Clock Config,不知道为啥64M可以72说不匹配。。。。。
在这里插入图片描述
2.6、写工程名和 选工程开发工具
在这里插入图片描述
2.7、之后点击GENERATE CODE

三、在KeilV5改写
3.1、先把USART1的printf复写了，在stm32f1xx_it.c里

#include <stdlib.h>
#include <stdio.h>
int fputc(int ch, FILE *f)		
{  		
	/* 堵塞判断串口是否发送完成 */	
  while((USART1->SR & 0X40) == RESET);		
		
	/* 串口发送完成，将该字符发送 */	
	USART1->DR = (uint8_t)ch;  	
		
  return ch;		
}

还有在选项里勾选Use MicroLIB
在这里插入图片描述
3.2、对于USART1中断里，接到就发

void USART1_IRQHandler(void)
{
   /* USER CODE BEGIN USART2_IRQn 0 */
	if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)
	{
		//清除空闲标志位
		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		HAL_UART_DMAStop(&huart1);
		uint8_t len = buffersize2-__HAL_DMA_GET_COUNTER(huart1.hdmarx);
		
		HAL_UART_Receive_DMA(&huart1,buffer,buffersize2);
		HAL_UART_Transmit_DMA(&huart2,buffer,len);
	}
	
  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART2_IRQn 1 */

  /* USER CODE END USART2_IRQn 1 */
}

对于USART2按照通讯协议解析一下

void USART2_IRQHandler(void)
{
   /* USER CODE BEGIN USART2_IRQn 0 */
	if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE)!= RESET)
	{
		//清除空闲标志位
		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		HAL_UART_DMAStop(&huart2);
		uint8_t len = buffersize2-__HAL_DMA_GET_COUNTER(huart2.hdmarx);

		HAL_UART_Receive_DMA(&huart2,buffer2,buffersize2);
		if(buffer2[0]-0x55==0)
		{
			if(buffer2[1]-0x51==0)// 加速度
			{
				// x
				AxL=buffer2[2];
				AxH=buffer2[3];
				myff=(AxH<<8)|AxL;
				acc[0]=myff/32768*16*9.8;
				// y
				AyL=buffer2[4];
				AyH=buffer2[5];
				myff=((AyH<<8)|AyL);
				acc[1]=myff/32768*16*9.8;
				// z
				AzL=buffer2[6];
				AzH=buffer2[7];
				myff=((AzH<<8)|AzL);
				acc[2]=myff/32768*16*9.8;
				//printf("Acc:%.3f %.3f %.3f\r\n",acc[0],acc[1],acc[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
			else if(buffer2[1]-0x52==0)// 角速度
			{
				// x
				WxL=buffer2[2];
				WxH=buffer2[3];
				myff=(WxH<<8)|WxL;
				anglSpeed[0]= myff/32768*2000;
				// y
				WyL=buffer2[4];
				WyH=buffer2[5];
				myff=((WyH<<8)|WyL);
				anglSpeed[1]=myff/32768*2000;
				// z
				WzL=buffer2[6];
				WzH=buffer2[7];
				myff=((WzH<<8)|WzL);
				anglSpeed[2]=myff/32768*2000;
				//printf("Angle:%.3f %.3f %.3f\r\n",angl[0],angl[1],angl[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
			else if(buffer2[1]-0x53==0)// 角度
			{
				// x
				WxL=buffer2[2];
				WxH=buffer2[3];
				myff=(WxH<<8)|WxL;
				angl[0]= myff/32768*180;
				// y
				WyL=buffer2[4];
				WyH=buffer2[5];
				myff=((WyH<<8)|WyL);
				angl[1]=myff/32768*180;
				// z
				WzL=buffer2[6];
				WzH=buffer2[7];
				myff=((WzH<<8)|WzL);
				angl[2]=myff/32768*180;
				//printf("Angle:%.3f %.3f %.3f\r\n",angl[0],angl[1],angl[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
		}
		
	}
  /* USER CODE END USART2_IRQn 0 */
	
  /* USER CODE BEGIN USART2_IRQn 1 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE END USART2_IRQn 1 */
}

这里acc，anglSpeed，angl都是公有变量，main.c里头有他们的外部引用
3.3、整体文件程序main.c和stm32f1xx_it.c
main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

const uint8_t buffersize=11;
uint8_t buffer[buffersize];
uint8_t buffer2[buffersize];

extern float angl[3];
extern float acc[3];
extern float anglSpeed[3];
#include <stdlib.h>
#include <stdio.h>
#include "string.h"
// Z轴角度归零
char myYAWCMD[3] = {0XFF,0XAA,0X52};
// 加计校准
char myACCCMD[3] = {0XFF,0XAA,0X67};
// 休眠与解休眠
char mySLEEPCMD[3] = {0XFF,0XAA,0X60};
// 串口模式
char myUARTMODECMD[3] = {0XFF,0XAA,0X61};
// I2C模式
char myIICMODECMD[3] = {0XFF,0XAA,0X62};
// 波特率115200
char myBAUD_115200[3] = {0XFF,0XAA,0X63};
// 波特率9600
char myBAUD_9600[3] = {0XFF,0XAA,0X64};
// 水平安装
char mySHUIPINGSET[3] = {0XFF,0XAA,0X65};
// 垂直安装
char myCHUIZHISET[3] = {0XFF,0XAA,0X66};


typedef unsigned char u8;
void SYN_FrameInfo2(u8 Music, u8 *HZdata);
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

	//printf("正在进行加速度校准\r\n");
	//sendcmd(ACCCMD);
	
  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
	//HAL_UART_Receive_DMA(&huart2,buffer,buffersize);
	__HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
//	
//	HAL_UART_Receive_DMA(&huart1,buffer,buffersize);
	__HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
	
	HAL_UART_Transmit_DMA(&huart2,(uint8_t*)myYAWCMD,3);
	HAL_UART_Transmit_DMA(&huart2,(uint8_t*)mySHUIPINGSET,3);
	HAL_UART_Transmit_DMA(&huart2,(uint8_t*)myCHUIZHISET,3);
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
		printf("Acc:%.3f %.3f %.3f\r\n",acc[0],acc[1],acc[2]);
		printf("AgSpd:%.3f %.3f %.3f\r\n",anglSpeed[0],anglSpeed[1],anglSpeed[2]);
		printf("Angle:%.3f %.3f %.3f\r\n",angl[0],angl[1],angl[2]);
		
		HAL_Delay(400);
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel4_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
  /* DMA1_Channel5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
  /* DMA1_Channel7_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

stm32f1xx_it.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    stm32f1xx_it.c
  * @brief   Interrupt Service Routines.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f1xx_it.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */

/* USER CODE END TD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
const uint8_t buffersize2=11;
extern uint8_t buffer[buffersize2];
extern uint8_t buffer2[buffersize2];

#include <stdlib.h>
#include <stdio.h>
int fputc(int ch, FILE *f)		
{  		
	/* 堵塞判断串口是否发送完成 */	
  while((USART1->SR & 0X40) == RESET);		
		
	/* 串口发送完成，将该字符发送 */	
	USART1->DR = (uint8_t)ch;  	
		
  return ch;		
}		


/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;
extern DMA_HandleTypeDef hdma_usart2_rx;
extern DMA_HandleTypeDef hdma_usart2_tx;
extern UART_HandleTypeDef huart1;
extern UART_HandleTypeDef huart2;
/* USER CODE BEGIN EV */


/* USER CODE END EV */

/******************************************************************************/
/*           Cortex-M3 Processor Interruption and Exception Handlers          */
/******************************************************************************/
/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
  while (1)
  {
  }
  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Prefetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

/******************************************************************************/
/* STM32F1xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32f1xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles DMA1 channel4 global interrupt.
  */
void DMA1_Channel4_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel4_IRQn 0 */

  /* USER CODE END DMA1_Channel4_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart1_tx);
  /* USER CODE BEGIN DMA1_Channel4_IRQn 1 */

  /* USER CODE END DMA1_Channel4_IRQn 1 */
}

/**
  * @brief This function handles DMA1 channel5 global interrupt.
  */
void DMA1_Channel5_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel5_IRQn 0 */

  /* USER CODE END DMA1_Channel5_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart1_rx);
  /* USER CODE BEGIN DMA1_Channel5_IRQn 1 */
  /* USER CODE END DMA1_Channel5_IRQn 1 */
}

/**
  * @brief This function handles DMA1 channel6 global interrupt.
  */
void DMA1_Channel6_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel6_IRQn 0 */

  /* USER CODE END DMA1_Channel6_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart2_rx);
  /* USER CODE BEGIN DMA1_Channel6_IRQn 1 */
  /* USER CODE END DMA1_Channel6_IRQn 1 */
}

/**
  * @brief This function handles DMA1 channel7 global interrupt.
  */
void DMA1_Channel7_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel7_IRQn 0 */

  /* USER CODE END DMA1_Channel7_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart2_tx);
  /* USER CODE BEGIN DMA1_Channel7_IRQn 1 */

  /* USER CODE END DMA1_Channel7_IRQn 1 */
}



/* USER CODE BEGIN 1 */

typedef unsigned char u8;
//extern void SYN_FrameInfo2(u8 Music, u8 *HZdata);

static float myff = 0;
float angl[3];
float anglSpeed[3];
uint16_t WxH;
uint16_t WxL;
uint16_t WyH;
uint16_t WyL;
uint16_t WzH;
uint16_t WzL;
uint16_t WxHL;

float acc[3];
uint16_t AxH;
uint16_t AxL;
uint16_t AyH;
uint16_t AyL;
uint16_t AzH;
uint16_t AzL;
/* USER CODE END 1 */

/**
  * @brief This function handles USART2 global interrupt.
  */
void USART2_IRQHandler(void)
{
   /* USER CODE BEGIN USART2_IRQn 0 */
	if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE)!= RESET)
	{
		//清除空闲标志位
		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		HAL_UART_DMAStop(&huart2);
		uint8_t len = buffersize2-__HAL_DMA_GET_COUNTER(huart2.hdmarx);

		HAL_UART_Receive_DMA(&huart2,buffer2,buffersize2);
		if(buffer2[0]-0x55==0)
		{
			if(buffer2[1]-0x51==0)// 加速度
			{
				// x
				AxL=buffer2[2];
				AxH=buffer2[3];
				myff=(AxH<<8)|AxL;
				acc[0]=myff/32768*16*9.8;
				// y
				AyL=buffer2[4];
				AyH=buffer2[5];
				myff=((AyH<<8)|AyL);
				acc[1]=myff/32768*16*9.8;
				// z
				AzL=buffer2[6];
				AzH=buffer2[7];
				myff=((AzH<<8)|AzL);
				acc[2]=myff/32768*16*9.8;
				//printf("Acc:%.3f %.3f %.3f\r\n",acc[0],acc[1],acc[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
			else if(buffer2[1]-0x52==0)// 角速度
			{
				// x
				WxL=buffer2[2];
				WxH=buffer2[3];
				myff=(WxH<<8)|WxL;
				anglSpeed[0]= myff/32768*2000;
				// y
				WyL=buffer2[4];
				WyH=buffer2[5];
				myff=((WyH<<8)|WyL);
				anglSpeed[1]=myff/32768*2000;
				// z
				WzL=buffer2[6];
				WzH=buffer2[7];
				myff=((WzH<<8)|WzL);
				anglSpeed[2]=myff/32768*2000;
				//printf("Angle:%.3f %.3f %.3f\r\n",angl[0],angl[1],angl[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
			else if(buffer2[1]-0x53==0)// 角度
			{
				// x
				WxL=buffer2[2];
				WxH=buffer2[3];
				myff=(WxH<<8)|WxL;
				angl[0]= myff/32768*180;
				// y
				WyL=buffer2[4];
				WyH=buffer2[5];
				myff=((WyH<<8)|WyL);
				angl[1]=myff/32768*180;
				// z
				WzL=buffer2[6];
				WzH=buffer2[7];
				myff=((WzH<<8)|WzL);
				angl[2]=myff/32768*180;
				//printf("Angle:%.3f %.3f %.3f\r\n",angl[0],angl[1],angl[2]);
				//HAL_UART_Transmit_DMA(&huart1,buffer2,len);
			}
		}
		
	}
  /* USER CODE END USART2_IRQn 0 */
	
  /* USER CODE BEGIN USART2_IRQn 1 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE END USART2_IRQn 1 */
}
/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
   /* USER CODE BEGIN USART2_IRQn 0 */
	if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)
	{
		//清除空闲标志位
		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		HAL_UART_DMAStop(&huart1);
		uint8_t len = buffersize2-__HAL_DMA_GET_COUNTER(huart1.hdmarx);
		
		HAL_UART_Receive_DMA(&huart1,buffer,buffersize2);
		HAL_UART_Transmit_DMA(&huart2,buffer,len);
		//printf("Acc:%.3f %.3f %.3f\r\n",(float)stcAcc.a[0]/32768*16,(float)stcAcc.a[1]/32768*16,(float)stcAcc.a[2]/32768*16);
		
	}
	
  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART2_IRQn 1 */

  /* USER CODE END USART2_IRQn 1 */
}

四、JY62与STM32连线
在这里插入图片描述
串口收发与针脚似乎有个顺序，至少USART1和2是这样的，比如USART1，A9发T,A10收R，USART2是A2发T，A3收R。先发后收，这样就不用每次都查 “STM32F103ZE核心板–原理图”了。
五、效果
在这里插入图片描述
目前我还存在个问题，就是角速度的值要么没有，要么是一个值不改变。很纠结。。。。看起来模块很好用，我主要用欧拉角。

胸毛男
关注
  • 7
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
用STM32F103读取JY62角度传感器的陀螺仪、加速度的数据
Fred_1986的博客
08-25 5510
1 准备工作 硬件设备：JY62模块、六合一、USB-TTL、杜邦线、STM32F103C8T6单片机。给大家看下图片。 JY62 STM32F103C8T6 2）软件准备 ： KEIL 5 (5.17版本的） 链接：https://pan.baidu.com/s/1SEWmixu4jtUL2HH_3Hcn2g 提取码：zryo 3）示例代码：https://pan.baidu.com/s/1sXnlT
JY61陀螺仪（stm32，arduino，51通用）
04-14
jy61陀螺仪，上位机+程序+操作说明书+驱动
维特智能6轴姿态角度传感器上位机JY61/JY62/JY60
02-26
适用于维特智能姿态角度传感器模块6轴系列的电脑端软件
两轮平衡小车制作保姆式教程（2-1）——软件模块：JY62
weixin_62261692的博客
01-27 895
两轮平衡小车制作保姆式教程，板块2-1：软件模块陀螺仪JY62的使用。
stm32+jy901+hc06+角度准确输出+上位机3d演示+串口输出
04-18
该资源采用STM32+jy901九轴mpu9250模块通过串口输出角度，彻底解决Z轴漂移，就是yaw角度偏差。其中可以通过USB连线用电脑上位机查看3D姿态图还可以通过连接HC06蓝牙模块接收角度信息，上位机文件含有。
STM32F103陀螺仪程序
03-24
基于STM32 F103 和六轴陀螺仪加速度计的计步器，适合初学者。
基于STM32的陀螺仪数据采集程序
06-11
基于STM32的陀螺仪数据采集程序
STM32例程分享-04-MPU6050陀螺仪模块(IIC)
weixin_43351158的博客
05-01 2026
STM32例程分享-04-MPU6050陀螺仪模块(IIC)
stm32的陀螺仪资料
11-04
对于6050的STM32驱动！！！希望大家能进行些修改！！下载吧！
程序是STM32和陀螺仪的I2C通信程序
11-02
MCU是基于STM32系列的单片机，其中和陀螺仪的通讯方式采用I2C接口，在使用时需要按照自己的硬件修改配置
陀螺仪JY62底层代码
最新发布
01-27
JY62底层驱动程序，内容简洁，亲测能用。代码是基于STM32F103标准库的，可移植性强，直接把我的文件添加到你的工程中就能用。可以移植到其他型号的单片机中使用，例如：TI的TM4C123，只是底层函数不一样，操作方法是一样的，移植起来很简单。
STM32+陀螺仪+GPS代码
04-19
STM32+陀螺仪+GPS代码，是我们做项目的代码，有需要的可以参考一下
JY61陀螺仪STM32F1测试代码
11-03
JY61陀螺仪STM32测试代码 0.96寸OLED显示 使用串口通信
jy61模块+stm32+3D演示+串口输出
04-12
jy61模块+stm32，通过串口4输出角度数据，可以连接HC06蓝牙模块等读取角度数据，同时还可以连接上位机通过电脑观察角度和3D模型演示
STM32F1单片机MPU6050加速度计陀螺仪驱动代码
05-07
STM32单片机，使用keil4编写的MPU6050加速度计和陀螺仪驱动代码，经过测试，代码遵守燕骏编程规范v3.0（已上传CSDN）
JY901陀螺仪，STM32资料
08-07
【标题】"JY901陀螺仪与STM32结合应用详解" 【正文】 在现代电子设备中，陀螺仪作为一种传感器，被广泛应用于各种领域，如无人机、智能手机、游戏控制器等，用于检测设备的旋转和姿态变化。JY901是一款常见的数字...
stm32通过串口获取JY60陀螺仪姿态角
01-12
STM32是一款基于ARM Cortex-M内核的微控制器，广泛应用于嵌入式系统设计，而JY60则是一款常见的数字陀螺仪，用于测量物体的旋转角度和速度。本项目旨在利用STM32通过串行通信接口（UART）与JY60陀螺仪进行数据交互，...
STM32HAL库实现JY61P陀螺仪
2201_75475731的博客
10-01 1383
JY61P可以通过串口进行数据通信，这使得它可以与各种设备和控制器进行连接和交互。下面是关于JY61P串口使用的简要介绍：硬件连接：将JY61P的串口引脚（TX和RX）连接到要使用的设备的串口引脚（如STM32的TX和RX引脚）。同时，确保连接共地（GND）引脚以建立电气连接。通信协议：JY61P使用标准的串口通信协议，通常是UART或USART。要与JY61P进行通信，需要设置相同的波特率（数据传输速率）、数据位、停止位和奇偶校验位等参数。通常，JY61P的默认波特率是115200。
陀螺仪程序---可直接用
weixin_44922566的博客
12-23 1959
陀螺仪 STM32 UART 串口
JY61P与arduino
04-09
的连接操作步骤是什么？ 对于这个问题，我可以给您提供一些信息。JY61P是一款6轴惯性测量单元（IMU），通常用于测量物体的角度、加速度和角速度。如果您想将JY61P与Arduino连接起来，可以使用一个4针杜邦线，将JY61P的SCL引脚连接到Arduino的A5引脚，将JY61P的SDA引脚连接到Arduino的A4引脚。此外，您还需要将JY61P的VCC引脚连接到Arduino的5V引脚，将JY61P的GND引脚连接到Arduino的GND引脚。一旦您成功连接了JY61P和Arduino，您就可以使用Arduino编写代码，读取JY61P的测量数据并进行相关操作。希望这可以帮助您解决问题！
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胸毛男

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值