STM32的SPI和IIC相关知识点概述

最新推荐文章于 2022-10-04 22:25:51 发布
最新推荐文章于 2022-10-04 22:25:51 发布
阅读量681 收藏 1
点赞数
文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64746121/article/details/125011378
版权

文章目录

前言

本文将对stm32的SPI和IIC进行相关概念的概述，并提供他们的配置方法。

提示：以下是本篇文章正文内容，下面案例可供参考

一、SPI概述

SPI的方框图如下：

在这里插入图片描述
通常SPI通过4个引脚与外部器件相连：

  • MISO：主设备输入 / 从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。
  • MOSI：主设备输出 / 从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。
  • SCK：串口时钟，作为主设备的输出，从设备的输入
  • NSS:从设备选择。是一个可选的引脚，用来选择主/从设备。
    从设备的NSS引脚可以由主设备的一个标准I/O引脚来驱动。一旦被使能(SSOE位)，NSS引脚也可以作为输出引脚，并在SPI处于主模式时拉低；此时，所有的SPIl设备，如果它们的NSS引脚连接到主设备的NSS引脚，则会检测到低电平，如果它们被设置为NSS硬件模式，就会自动进入从设备状态。当配置为主设备、NSS配置为输入引脚(MSTR=1，SSOE=0)时，如果NSS被拉低，则这个SPI设备进入主模式失败状态:即MSTR位被自动清除，此设备进入从模式

SPI配置方法

  1. GPIO端口配置：
void GPIO_Config()
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	GPIO_AFIODeInit();

	//SPI-Clock:PA5 SPI-MISO:PA6 SPI-MOSI:PA7
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
}
  1. SPI外设配置：
void SPI_Config()
{
	SPI_InitTypeDef SPI_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
	
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
	SPI_InitStructure.SPI_CRCPolynomial = 7;
	
	SPI_Init(SPI1, &SPI_InitStructure);

//	SPI_I2S_ITConfig(SPI1, SPI_I2S_IT_RXNE, ENABLE);
//	SPI_I2S_ClearFlag(SPI1, SPI_I2S_IT_RXNE | SPI_I2S_IT_TXE);
}

在某处使能SPI：

SPI_Cmd(SPI1, ENABLE);

二、IIC配置方法

起始信号

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

1. 主函数：

int main(void)
{	
	delay_init();	    	       //延时函数初始化	  
	NVIC_Configuration(); 	   //设置NVIC中断分组2:2位抢占优先级，2位响应优先级 	
	OLED_Init();			         //初始化OLED  
	OLED_Clear(0);             //清屏（全黑）
	while(1) 
	{	
		TEST_MainPage();         //主界面显示测试
	}
}

2. 上下或左右滑动显示字符：

  • 水平左右滑动
OLED_WR_Byte(0x2E,OLED_CMD);        //关闭滚动
OLED_WR_Byte(0x26,OLED_CMD);        //水平向左或者右滚动 26/27
OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
OLED_WR_Byte(0x00,OLED_CMD);        //起始页 0
OLED_WR_Byte(0x07,OLED_CMD);        //滚动时间间隔
OLED_WR_Byte(0x07,OLED_CMD);        //终止页 7
OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
OLED_WR_Byte(0xFF,OLED_CMD);        //虚拟字节
OLED_WR_Byte(0x2F,OLED_CMD);        //开启滚动
  • 垂直或水平滚动：
OLED_WR_Byte(0x2e,OLED_CMD);        //关闭滚动
OLED_WR_Byte(0x29,OLED_CMD);        //水平垂直和水平滚动左右 29/2a
OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
OLED_WR_Byte(0x00,OLED_CMD);        //起始页 0
OLED_WR_Byte(0x07,OLED_CMD);        //滚动时间间隔
OLED_WR_Byte(0x07,OLED_CMD);        //终止页 1
OLED_WR_Byte(0x01,OLED_CMD);        //垂直滚动偏移量
OLED_WR_Byte(0x2F,OLED_CMD);        //开启滚动

四、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);

}
#偏执I765
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SPI与IIC通讯详解
kj7541
04-02 643
SPI通讯协议 传送门：https://www.cnblogs.com/deng-tao/p/6004280.html 个人觉得这个是网上比较详细的SPI通讯协议详解了； IIC通讯协议 IIC协议 总线信号 ： SDA ：串行数据线 SCL ：串行时钟 总线空闲状态 ： SDA ：高电平 SCL ：高电平 起始位：SCL为高电平期间 SDA出现下降沿 终止位：SCL为高电平期间 SDA...
MOS管电路设计的经典应用(1)-IIC双向level shift
weixin_43772512的博客
03-07 1万+
MOS管，作为硬件设计最重要的元器件之一，在很多应用场景下都会用到它。 在电路设计中，电平转换电路是不可缺少的部分。在供电方面，除了系统供电以外，其他很多情况都是需要通过电平转换电路，来得到我们所需的电压。同时电平转换这方面的电路也是五花八门，其中就有用到MOS管的案例。那么今天，小编就为大家讲解MOS管在电平转换电路中的应用。 双向level shift 此电路属于IIC电平转换电路。主要采用的是NMOS管。分别串接在时钟和数据信号线上。为了方便，我就介绍一下SCL这一根线上的电平转换。 作为时钟线，
IIC协议与电气规范
logan
02-03 7908
一.简介 I2C 总线在物理连接上非常简单，分别由SDA(串行数据线)和SCL(串行时钟线)及上拉电阻组成。I2C通信的基本原理是通过对SCL和SDA线高低电平时序的控制，来产生I2C总线协议所需要的信号进行数据传递。在总线空闲状态时，时钟线和数据线一般被上拉电阻拉高，保持着高电平。I2C通信方式为半双工，只有一根SDA线，同一时间只可以单向通信。I2C (Inter – Integrated Communication, often called as I Squared C or I Two C)..
【STM32】STM32端口复用和重映射（AFIO辅助功能时钟）
Yngz_Miao的博客
04-06 2万+
STM32F1xx官方资料： 《STM32中文参考手册V10》-第8章通用和复用功能IO(GPIO和AFIO)   端口复用功能 端口复用的定义 STM32有许多的内置外设（如串口、ADC、DCA等等），这些外设的外部引脚都是和GPIO复用的。也就是说，一个GPIO如果可以复用为内置外设的功能引脚，那么当这个GPIO作为内置外设使用的时候，就叫复用。详细的可以参考《STM32F103ZE...
STM32常用通信——USART，IIC，SPI，CAN
何解然_K|user
06-07 4943
STM32常用通信CAN通信CAN根据两根线上电位差来判断总线电平，总线电平分为显性电平和隐形电平，两者必居其一，发送方通过控制总线电平发送信息给接收方。显性电平对应逻辑0，两根线压差2.5V左右，隐形电平对应逻辑1，压差为0。总线上可以挂很多单元，显性电平具有优先权，一个单元显性电平，则总线为显性。CAN总线起止断有120R的电阻，用于做阻抗匹配，减少回波反射。CAN的位时序：<同步段SS...
STM32通过I2C在线升级(En)1
08-04
下面是相关的知识点： 1. 在线升级（In-Application Programming，IAP）概念：在线升级是指在Flash-memory-based系统中更新固件的能力，一旦系统安装在最终产品中。这是大多数Flash-memory-based系统的关键要求。 ...
STM32F407ZGT6ZET6高配板1
08-03
知识点1：STM32微控制器 STM32微控制器是STMicroelectronics公司出品的32位微控制器，基于ARM Cortex-M架构，具有高性能、低功耗和高集成度的特点。STM32系列微控制器广泛应用于工业自动化、消费电子、 автом...
SPI接口结构图1
08-03
SPI接口结构图1知识点总结 SPI（ Serial Peripheral...SPI接口结构图1知识点总结了SPI通信协议、OLED显示屏技术、STM32微控制器和SSD1306驱动IC等相关知识点，为电子工程师和嵌入式系统开发者提供了有价值的参考信息。
STM32F103RCT6原理图.pdf
11-28
"STM32F103RCT6原理图.pdf"知识点总览 微控制器 * STM32F103RCT6： STM32F103RCT6是STMicroelectronics公司生产的一种32位ARM Cortex-M3微控制器，具有高性能、低功耗和小尺寸等特点。 电路元件 *icapacitor：...
《嵌入式技术》期末考试题及答案A(基于STM32).pdf
12-08
本资源主要讨论嵌入式技术的相关知识点，包括ARM架构、STM32单片机、GPIO、TIMER、USART、OS等。 一、ARM架构 ARM架构是英国Acorn Computers公司设计的RISC架构微处理器，后来独立成为了ARM Holdings公司。ARM架构...
FPGA之IIC知识
08-10
FPGA之IIC这几天实现FPGA对AT24C02进行读写。采用的是IIC总线，所以要写IIC控制代码。写代码花了一下午，可是调试花了三天。真是相当蛋疼，用了各种方式进行调试。AT24C02采用的是IIC总线，256KB字节的存储容量。分为32夜，每页有8字节。
几个串口协议学习整理
weixin_33787529的博客
02-29 2218
一、UART UART是一个大家族，其包括了RS232、RS499、RS423、RS422和RS485等接口标准规范和总线标准规范。它们的主要区别在于其各自的电平范围不相同。 嵌入式设备中常常使用到的是TTL、TTL转RS232的这种方式。常用的就三根引线：发送线TX、接收线RX、电平参考地线GND。 1.1 电路示意图 1.2 通信协议 将传输数据的每个字符一位接一...
stm32之协议篇（IIC、SPI）
qq_54402650的博客
10-04 1400
UART,SPI,IIC协议总结！
stm32的I2C主从模式
滴水藏海
04-18 2万+
1，stm32的I2C总线既可以作为主模式也可以作为从模式 作为主模式和作为从模式在CUBE中的配置是一样的，只是i2c设备的地址不一样 Timing是时序，是在配置的时候生成的，不需要修改 当总线的频率设置为100KHZ的时候，rise time 和fall time 要设置为100ns ownAddress就是指的i2c总线的设备地址，该地址可以选择7b
STM32F103：什么时候需要复用IO（AFIO）?
u013082827的博客
08-24 4万+
文章来源： 刚接触STM32F103，在尝试编写“按键中断”和“PWM呼吸灯”程序的时候，发现例程都用到了管脚复用AFIO： //打开管脚复用AFIO RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); 写到“232USART串口通信”程序时，当我非常自信的写下上面这句代码后，发现例程里面却没有这句话，很让人摸不着头脑……查了很多资料，加上
STM32 CubeMX（三）—— SPI及IIC
qq_60091003的博客
05-23 4315
SPI及IIC通信方式串行通信通信接口通信总线通信协议SPI信号线配置方法STM32CubeMX配置SPIIIC 通信方式 通信双方之间的工作方式或信号传输方式。 终端与其他设备通过数据传输进行通信，根据数据的传输方式，有串行通信和并行通信。 串行通信 又称为点对点通信。 对于点对点之间的通信，根据数据的同步方式，又分为异步传送和同步传送两种方式。 根据数据的传输方向与时间关系，又可分为单工通信、半双工通信及全双工通信三种方式。 通信接口 接口指的是输入输出的硬件接口，实现通信的接口就是通信接口
UART, SPI, IIC的详解及三者的区别和联系
热门推荐
小凡的专栏
05-17 7万+
1、UART, SPI, IIC的详解 UART、SPI、IIC是经常用到的几个数据传输标准，下面分别总结一下： UART（Universal Asynchronous Receive Transmitter）：也就是我们经常所说的串口，基本都用于调试。 主机和从机至少要接三根线，RX、TX和GND。TX用于发送数据，RX用于接受数据（收发不是一根线，所以是全双工方式）。注意A和B通
STM32的SPI
qq_38113006的博客
01-09 1317
一、SPI功能描述 SPI的框图如下： SPI通过4个引脚与外部器件相连： MISO：主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。 MOSI：主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。 SCK：串口时钟，作为主设备的输出，从设备的输入 NSS：从设备选择。这是一个用来选择从设备的(可选的)引脚。这个引脚用来作为“片选引脚”，让主设备...
6761 i2c设备添加gpio控制设备上电
shark1621的博客
08-12 424
起初使用如下方式 &i2c1 { alsps@44 { ldo_hrs_pin = <&pio 177 0>; .... }; }; 在驱动中按如下的写法 LDO_HRS_PIN = of_get_named_gpio(client->dev.of_node,"ldo_hrs_pin", 0); gpio_request(LDO_HRS_PIN, "LDO_HRS...
stm32f429iic讲解
最新发布
07-29
STM32F429IIC是一款由STMicroelectronics公司推出的ARM Cortex-M4内核的32位微控制器。它是STM32F4系列微控制器的一员，具有丰富的外设和高性能特点。 该微控制器具有以下主要特点： 1. 内核：STM32F429IIC采用ARM Cortex-M4内核，拥有高性能和低功耗的特点。它支持单周期乘法和硬件除法指令，能够实现高效的数据处理能力。 2. 外设：STM32F429IIC具有丰富的外设资源，包括多个通用定时器、串行通信接口（USART、SPI、I2C等）、模拟外设（ADC、DAC等）、以太网接口、USB接口、SD卡接口等，可以满足各种应用需求。 3. 存储器：该微控制器内置了大容量的闪存和SRAM。闪存用于存储程序代码和数据，SRAM用于存储运行时数据。此外，它还支持外部存储器接口，如SDRAM、NOR Flash等。 4. 显示控制器：STM32F429IIC集成了先进的显示控制器，可以直接驱动液晶显示屏。它支持多种显示接口，如RGB接口、MIPI DSI接口等。 5. 低功耗：该微控制器具有多种低功耗模式，可根据应用需求灵活选择。它支持睡眠模式、停止模式和待机模式等，以最大程度地降低功耗。 总之，STM32F429IIC是一款功能强大的32位微控制器，适用于各种应用领域，如工业自动化、消费电子、医疗设备等。它提供了丰富的外设和高性能特点，可满足复杂应用的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值