C Primer Plus (fourth)

最新推荐文章于 2024-10-03 00:32:59 发布

-----S-----

最新推荐文章于 2024-10-03 00:32:59 发布

阅读量114

点赞数 1

分类专栏： SPI IIC 文章标签： c语言单片机开发语言 stm32

本文链接：https://blog.csdn.net/qq_64746124/article/details/125078455

版权

SPI 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

IIC

1 篇文章 0 订阅

订阅专栏

本文详细介绍了STM32的SPI和IIC接口的配置方法，包括SPI的定义、连接方式、通讯过程和配置步骤，以及IIC的定义、信号类型和配置过程。此外，还展示了如何使用SPI驱动OLED屏幕和IIC驱动MPU6050传感器。SPI配置涉及SPI2的初始化、数据传输，而IIC配置则涵盖起始和终止信号的生成。最后，提供了OLED显示和MPU6050交互的函数实现。

摘要由CSDN通过智能技术生成

STM32的SPI及IIC

一、SPI配置方法

SPI定义

SPI（Serial Peripheral Interface）就是串行外围设备接口。
SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚。SPI 是一个环形总线结构，由 ss(cs)、sck、sdi、sdo 构成，时序主要是在 sck 的控制下，两个双向移位寄存器进行数据交换。
上升沿发送、下降沿接收、高位先发送。
上升沿到来的时候，sdo 上的电平将被发送到从设备的寄存器中。
下降沿到来的时候，sdi 上的电平将被接收到主设备的寄存器中。

连接方式

请添加图片描述
SS( Slave Select)：从设备选择信号线，常称为片选信号线。
SCK (Serial Clock)：时钟信号线，用于通讯数据同步。
MOSI (Master Output， Slave Input)：主设备输出/从设备输入引脚。
MISO(Master Input,，Slave Output)：主设备输入/从设备输出引脚。

通讯过程

在这里插入图片描述

配置方法

配置相关引脚的复用功能，使能 SPI2 时钟
初始化 SPI2,设置 SPI2 工作模式
使能 SPI2
SPI 传输数据
查看 SPI 传输状态

二、IIC配置方法

IIC定义

IIC（Inter-Integrated Circuit）其实是IICBus简称，所以中文应该叫集成电路总线，它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。I²C的正确读法为“I平方C”（“I-squared-C”），而“I二C”（“I-two-C”）则是另一种错误但被广泛使用的读法。自2006年10月1日起，使用I²C协议已经不需要支付专利费，但制造商仍然需要付费以获取I²C从属设备地址。

I2C 总线在传送数据过程中共有三种类型信号，它们分别是：开始信号、结束信号和应答信号。
开始信号：SCL 为高电平时，SDA由高电平向低电平跳变，开始传送数据。
结束信号：SCL 为高电平时，SDA 由低电平向高电平跳变，结束传送数据。
应答信号：接收数据的 IC在接收到 8bit 数据后，向发送数据的 IC 发出特定的低电平脉冲，表示已收到数据。

CPU 向受控单元发出一个信号后，等待受控单元发出一个应答信号，CPU接收到应答信号后，根据实际情况作出是否继续传递信号的判断。若未收到应答信号，由判断为受控单元出现故障。

配置方法

起始信号

void IIC_Start(void)
{
	SDA_OUT();
	SDA_H;   							//串行数据线高电平（空闲信号）
	CLK_H;   							//串行时钟线高电平（空闲信号）
	Delay_us(5);
	SDA_L;   							//串行数据线拉出下降沿
	Delay_us(5);
	CLK_L;   							//串行时钟线拉出下降沿
}

终止信号

void IIC_Stop(void)
{
	SDA_OUT();					//输出模式
	CLK_L;							//串行时钟线低电平
	SDA_L;							//串行数据线低电平
	CLK_H;							//串行时钟线高电平
	Delay_us(5);
	SDA_H;							//串行数据线高电平  上升沿
	Delay_us(5);
}

三、SPI驱动OLED屏幕

oled.h

#ifndef __OLED_H__
#define	__OLED_H__
#include "stm32f10x.h"
#include "stdlib.h"
#include "oledfont.h"  	 
#include "delay.h"
#include "bmp.h"
#include "gpio.h"

#define 	OLED			0
#define		SIZE			16
#define		XLevelL			0x00
#define		XLevelH			0x10
#define		Max_Column		128
#define		Max_Row			64
#define		Brightness		0xff
#define		X_WIDTH			128
#define		Y_WIDTH			64

//IO Definitions
#define		RST			PBout(10)	//RES
#define		DC			PBout(11)	//DC

#define		SPI2_NSS_PIN		GPIO_Pin_12		//CS
#define		SPI2_SCLK_PIN		GPIO_Pin_13		//D0
#define		SPI2_MISO_PIN		GPIO_Pin_14
#define		SPI2_MOSI_PIN		GPIO_Pin_15		//D1

#define		SPI2_NSS			PBout(12)

typedef enum
{
	OLED_CMD,
	OLED_DATA
}OLED_WR_MODE;

typedef enum 
{
	Display_ON,
	Display_OFF,
	Display_Clear,
	Display_Test
}DIS_MODE;

//OLED控制用函数
extern void OLED_WR_Byte(uint8_t dat,OLED_WR_MODE cmd);	    
extern void OLED_Display_Status(DIS_MODE mode);   							   		    
extern void OLEDConfiguration(void);
extern void OLED_DrawPoint(uint8_t x, uint8_t y, uint8_t t);
extern void OLED_Fill(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t dot);
extern void OLED_ShowChar(uint8_t x, uint8_t y, uint8_t chr);
extern void OLED_ShowNum(uint8_t x, uint8_t y, u32 num, uint8_t len, uint8_t size);
extern void OLED_ShowString(uint8_t x,uint8_t y, uint8_t *p);	 
extern void OLED_Set_Pos(uint8_t x, uint8_t y);
extern void OLED_ShowCHinese(uint8_t x, uint8_t y, uint8_t no);
extern void OLED_DrawBMP(uint8_t x0, uint8_t y0,uint8_t x1, uint8_t y1, uint8_t BMP[]);
#endif

oled.c

#include "oled.h"

//OLED的显存
//存放格式如下.
//[0]0 1 2 3 ... 127	
//[1]0 1 2 3 ... 127	
//[2]0 1 2 3 ... 127	
//[3]0 1 2 3 ... 127	
//[4]0 1 2 3 ... 127	
//[5]0 1 2 3 ... 127	
//[6]0 1 2 3 ... 127	
//[7]0 1 2 3 ... 127 			   

uint8_t SPI2_SendByte(uint8_t byte)
{
	while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);  	// 等待发送区空
	SPI_I2S_SendData(SPI2, byte);									   	// 发送一个字节  
	while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET); 	// 等待接收完一个字节
	return SPI_I2S_ReceiveData(SPI2);								   	// 返回收到的数据 
}


//向SSD1106写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(uint8_t dat,OLED_WR_MODE cmd)
{	
	//uint8_t i;
	switch(cmd)
	{
		case OLED_CMD:
			DC = 0;
			break;
		case OLED_DATA:
			DC = 1;
			break;
	}   			  	  
	SPI2_NSS = 0;
//	for(i = 0; i < 8; i ++)
//	{			  
//		OLED_SCLK_Clr();
//		if(dat & 0x80)
//		   OLED_SDIN_Set();
//		else 
//		   OLED_SDIN_Clr();
//		OLED_SCLK_Set();
//		dat<<=1;   
//	}	
	SPI2_SendByte(dat);
	SPI2_NSS = 1;
	DC = 1;   	  
} 
//#endif

void OLED_Set_Pos(uint8_t x, uint8_t y) 
{ 
	OLED_WR_Byte(0xB0 + y, OLED_CMD);
	OLED_WR_Byte(((x & 0xF0) >> 4) | 0x10, OLED_CMD);
	OLED_WR_Byte((x & 0x0F) | 0x01, OLED_CMD); 
}   

void OLED_Display_Status(DIS_MODE mode)
{
	uint8_t i,n;		
	switch(mode)
	{
		case Display_ON://开启OLED显示 
			OLED_WR_Byte(0X8D, OLED_CMD);  //SET DCDC命令
			OLED_WR_Byte(0X14, OLED_CMD);  //DCDC ON
			OLED_WR_Byte(0XAF, OLED_CMD);  //DISPLAY ON
			break;
		case Display_OFF://关闭OLED显示  
			OLED_WR_Byte(0X8D, OLED_CMD);  //SET DCDC命令
			OLED_WR_Byte(0X10, OLED_CMD);  //DCDC OFF
			OLED_WR_Byte(0XAE, OLED_CMD);  //DISPLAY OFF
			break;
		case Display_Clear://清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!	
			for(i = 0; i < 8; i ++)  
			{  
				OLED_WR_Byte(0xB0 + i, OLED_CMD);    //设置页地址（0~7）
				OLED_WR_Byte(0x00, OLED_CMD);      //设置显示位置—列低地址
				OLED_WR_Byte(0x10, OLED_CMD);      //设置显示位置—列高地址   
				for(n = 0; n < Max_Column; n ++)
				{
					OLED_WR_Byte(0, OLED_DATA); 
				}
			} //更新显示
			break;
		case Display_Test:
			for(i = 0; i < 8; i ++)  
			{  
				OLED_WR_Byte(0xb0 + i, OLED_CMD);    //设置页地址（0~7）
				OLED_WR_Byte(0x00, OLED_CMD);      //设置显示位置—列低地址
				OLED_WR_Byte(0x10, OLED_CMD);      //设置显示位置—列高地址   
				for(n = 0; n < Max_Column; n ++)
				{
					OLED_WR_Byte(1, OLED_DATA);
					DelayMs(5);
				}
			} //更新显示
			break;
	}
	
}
   
//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//mode:0,反白显示;1,正常显示				 
//size:选择字体 16/12 
void OLED_ShowChar(uint8_t x, uint8_t y, uint8_t chr)
{      	
	uint8_t c = 0, i = 0;	
	c = chr - ' ';//得到偏移后的值			
	if(x > Max_Column - 1)
	{
		x = 0;
		y += 2;
	}
	if(SIZE == 16)
	{
		OLED_Set_Pos(x, y);	
		for(i = 0; i < 8; i ++)
		{
			OLED_WR_Byte(F8X16[c * 16 + i], OLED_DATA);
		}
		OLED_Set_Pos(x, y + 1);
		for(i = 0; i < 8; i ++)
		{
			OLED_WR_Byte(F8X16[c * 16 + i + 8], OLED_DATA);
		}
	}
	else 
	{	
		OLED_Set_Pos(x, y + 1);
		for(i = 0; i < 6; i ++)
		{
			OLED_WR_Byte(F6x8[c][i],OLED_DATA);
		}
	}
}

void OLED_ShowChar1(uint8_t x, uint8_t y, uint8_t chr)
{      	
	uint8_t c = 0, i = 0;	
		c = chr - ' ';//得到偏移后的值			
		if(x > Max_Column - 1)
		{
			x = 0;
			y += 2;
		}
		if(SIZE == 16)
		{
			OLED_Set_Pos(x, y);	
			for(i = 0; i < 6; i ++)
			{
				OLED_WR_Byte(F6x8[c][i], OLED_DATA);
			}
			OLED_Set_Pos(x, y + 1);
			for(i = 0; i < 6; i ++)
			{
				OLED_WR_Byte(F6x8[c][i + 6], OLED_DATA);
			}
		}
		else 
		{	
			OLED_Set_Pos(x, y + 1);
			for(i = 0; i < 6; i ++)
			{
				OLED_WR_Byte(F6x8[c][i],OLED_DATA);
			}
		}
}
//m^n函数
u32 oled_pow(uint8_t m,uint8_t n)
{
	u32 result = 1;	 
	while(n --)
	{
		result *= m;
	}    
	return result;
}	

//显示2个数字
//x,y :起点坐标	 
//len :数字的位数
//size:字体大小
//mode:模式	0,填充模式;1,叠加模式
//num:数值(0~4294967295);	 		  
void OLED_ShowNum(uint8_t x, uint8_t y, u32 num, uint8_t len, uint8_t size)
{         	
	uint8_t t,temp;
	uint8_t enshow = 0;						   
	for(t = 0; t < len; t ++)
	{
		temp = (num / oled_pow(10, len - t - 1)) % 10;
		if(enshow == 0 && t < (len - 1))
		{
			if(temp == 0)
			{
				OLED_ShowChar(x + (size / 2) * t, y, ' ');
				continue;
			}else enshow = 1; 
		}
	 	OLED_ShowChar(x + (size / 2) * t, y, temp + '0'); 
	}
} 

//显示一个字符号串
void OLED_ShowString(uint8_t x, uint8_t y, uint8_t *chr)
{
	uint8_t j = 0;
	while (chr[j] != '\0')
	{		
		OLED_ShowChar(x, y, chr[j]);
		x += 8;
		if(x > 120)
		{
			x = 0; 
			y += 2;
		}
		j++;
	}
}


//显示汉字
void OLED_ShowCHinese(uint8_t x, uint8_t y, uint8_t no)
{      			    
	uint8_t t, adder = 0;
	OLED_Set_Pos(x, y);	
    for(t = 0; t < 16; t ++)
	{
		OLED_WR_Byte(Hzk[2 * no][t], OLED_DATA);
		adder += 1;
	}	
	OLED_Set_Pos(x, y + 1);	
    for(t = 0; t < 16; t ++)
	{	
		OLED_WR_Byte(Hzk[2 * no + 1][t], OLED_DATA);
		adder += 1;
    }					
}

/***********功能描述：显示显示BMP图片128×64起始点坐标(x,y),x的范围0～127，y为页的范围0～7*****************/
void OLED_DrawBMP(uint8_t x0, uint8_t y0,uint8_t x1, uint8_t y1, uint8_t BMP[])
{ 	
	uint8_t j = 0;
	uint8_t x, y;
  
	if(y1 % 8 == 0)
	{
		y = y1 / 8;
	}		      
	else 
	{
		y = y1 / 8 + 1;
	}
	
	for(y = y0; y < y1; y ++)
	{
		OLED_Set_Pos(x0, y);
		for(x = x0; x < x1; x ++)
		{      
			OLED_WR_Byte(BMP[j ++], OLED_DATA);	    	
		}
	}
} 

//初始化SSD1306					    
void OLEDConfiguration(void)
{ 	 	 
	SPI_InitTypeDef  	MySPI;
	GPIO_InitTypeDef 	MyGPIO;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB |RCC_APB2Periph_AFIO , ENABLE);

	// GPIO配置，设置为PB输出
	MyGPIO.GPIO_Pin = SPI2_NSS_PIN; 		
	MyGPIO.GPIO_Speed = GPIO_Speed_50MHz;		
	MyGPIO.GPIO_Mode = GPIO_Mode_Out_PP;		
	GPIO_Init(GPIOB, &MyGPIO);					
	SPI2_NSS = 1;								
	
	MyGPIO.GPIO_Pin = SPI2_SCLK_PIN | SPI2_MISO_PIN | SPI2_MOSI_PIN;		
	MyGPIO.GPIO_Speed = GPIO_Speed_50MHz;		
	MyGPIO.GPIO_Mode = GPIO_Mode_AF_PP;			
	GPIO_Init(GPIOB, &MyGPIO);							

	// SPI配置
	MySPI.SPI_Direction = SPI_Direction_2Lines_FullDuplex;		
	MySPI.SPI_Mode = SPI_Mode_Master;							
	MySPI.SPI_DataSize = SPI_DataSize_8b;					
	MySPI.SPI_CPOL = SPI_CPOL_Low;							
	MySPI.SPI_CPHA = SPI_CPHA_1Edge;						
	MySPI.SPI_NSS = SPI_NSS_Soft;								
	MySPI.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;		
	MySPI.SPI_FirstBit = SPI_FirstBit_MSB;				
	MySPI.SPI_CRCPolynomial = 7;						

	SPI_Init(SPI2, &MySPI);										
	SPI_Cmd(SPI2, ENABLE);									
	

 
	MyGPIO.GPIO_Pin 	= GPIO_Pin_10 | GPIO_Pin_11;	
 	MyGPIO.GPIO_Mode 	= GPIO_Mode_Out_PP; 		 
	MyGPIO.GPIO_Speed	= GPIO_Speed_50MHz;
 	GPIO_Init(GPIOB, &MyGPIO);	  /
	DC = 1;


	RST = 1;
	DelayMs(100);
	RST = 0;
	DelayMs(100);
	RST = 1; 
					  
	OLED_WR_Byte(0xAE, OLED_CMD);//--turn off oled panel
	OLED_WR_Byte(0x00, OLED_CMD);//---set low column address
	OLED_WR_Byte(0x10, OLED_CMD);//---set high column address
	OLED_WR_Byte(0x40, OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
	OLED_WR_Byte(0x81, OLED_CMD);//--set contrast control register
	OLED_WR_Byte(0xCF, OLED_CMD); // Set SEG Output Current Brightness
	OLED_WR_Byte(0xA1, OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
	OLED_WR_Byte(0xC8, OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
	OLED_WR_Byte(0xA6, OLED_CMD);//--set normal display
	OLED_WR_Byte(0xA8, OLED_CMD);//--set multiplex ratio(1 to 64)
	OLED_WR_Byte(0x3f, OLED_CMD);//--1/64 duty
	OLED_WR_Byte(0xD3, OLED_CMD);//-set display offset	Shift Mapping RAM Counter (0x00~0x3F)
	OLED_WR_Byte(0x00, OLED_CMD);//-not offset
	OLED_WR_Byte(0xd5, OLED_CMD);//--set display clock divide ratio/oscillator frequency
	OLED_WR_Byte(0x80, OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
	OLED_WR_Byte(0xD9, OLED_CMD);//--set pre-charge period
	OLED_WR_Byte(0xF1, OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
	OLED_WR_Byte(0xDA, OLED_CMD);//--set com pins hardware configuration
	OLED_WR_Byte(0x12, OLED_CMD);
	OLED_WR_Byte(0xDB, OLED_CMD);//--set vcomh
	OLED_WR_Byte(0x40, OLED_CMD);//Set VCOM Deselect Level
	OLED_WR_Byte(0x20, OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
	OLED_WR_Byte(0x02, OLED_CMD);//
	OLED_WR_Byte(0x8D, OLED_CMD);//--set Charge Pump enable/disable
	OLED_WR_Byte(0x14, OLED_CMD);//--set(0x10) disable
	OLED_WR_Byte(0xA4, OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
	OLED_WR_Byte(0xA6, OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
	OLED_WR_Byte(0xAF, OLED_CMD);//--turn on oled panel
	
	OLED_WR_Byte(0xAF, OLED_CMD); /*display ON*/ 
	OLED_Display_Status(Display_Clear);
	OLED_Set_Pos(0, 0); 	
}

四、IIC驱动mpu6050

#include "main.h"


ADC_HandleTypeDef hadc1;

I2C_HandleTypeDef hi2c1;

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim4;

UART_HandleTypeDef huart1;


void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM4_Init(void);
static void MX_ADC1_Init(void);
static void MX_I2C1_Init(void);

int main(void)
{
	int Pwma = 0;
	int Pwmb = 0;
	int EncoderA,EncoderB;
	int Vol = 0;
	int temp;

  HAL_Init();

  SystemClock_Config();


  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  MX_TIM2_Init();
  MX_TIM4_Init();
  MX_ADC1_Init();
  MX_I2C1_Init();
  Moter_Start();
  Encoder_start();
  OLED_Init();
  Adc_Init();
  MPU6050_initialize();
  DMP_Init();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
	  Read_DMP();
	  temp = Read_Temperature();
	  printf("temp: %d\r\n",temp);
	  printf("Pitch: %f\r\n",Pitch);
	  printf("Roll: %f\r\n",Roll);
	  HAL_Delay(50);
  }
  /* USER CODE END 3 */
}


void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses 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();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}


static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Common config 
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}


static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 100000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_Init 2 */

}

static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 7199;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);

}


static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_Encoder_InitTypeDef sConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 0;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 65535;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
  sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC1Filter = 10;
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC2Filter = 10;
  if (HAL_TIM_Encoder_Init(&htim2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}


static void MX_TIM4_Init(void)
{

  /* USER CODE BEGIN TIM4_Init 0 */

  /* USER CODE END TIM4_Init 0 */

  TIM_Encoder_InitTypeDef sConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM4_Init 1 */

  /* USER CODE END TIM4_Init 1 */
  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 0;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 65535;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
  sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC1Filter = 10;
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC2Filter = 10;
  if (HAL_TIM_Encoder_Init(&htim4, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM4_Init 2 */

  /* USER CODE END TIM4_Init 2 */

}


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 = 128000;
  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 */

}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, MoterB_2_Pin|MoterB_1_Pin|MoterA_1_Pin|MoterA_2_Pin 
                          |OLED_RST_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(OLED_DC_GPIO_Port, OLED_DC_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, OLED_D0_SDA_Pin|OLED_D0_SCL_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin : KEY_Pin */
  GPIO_InitStruct.Pin = KEY_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(KEY_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : MoterB_2_Pin MoterB_1_Pin MoterA_1_Pin MoterA_2_Pin */
  GPIO_InitStruct.Pin = MoterB_2_Pin|MoterB_1_Pin|MoterA_1_Pin|MoterA_2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : OLED_DC_Pin */
  GPIO_InitStruct.Pin = OLED_DC_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(OLED_DC_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : OLED_RST_Pin */
  GPIO_InitStruct.Pin = OLED_RST_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(OLED_RST_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : OLED_D0_SDA_Pin OLED_D0_SCL_Pin */
  GPIO_InitStruct.Pin = OLED_D0_SDA_Pin|OLED_D0_SCL_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}