STM32的SPI和IIC

最新推荐文章于 2024-04-13 07:31:03 发布
最新推荐文章于 2024-04-13 07:31:03 发布
阅读量321 收藏 2
点赞数
文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57907099/article/details/125054541
版权

实验室第四次作业

SPI配置方法

SPI的配置方法分下面三个步骤：

1.GPIO端口配置：
 

void GPIO_Config()
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, 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);
}



2.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);
}



3.在某处使能SPI：

SPI_Cmd(SPI1, ENABLE);

二、IIC配置方法
 

1.起始信号：

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


2.终止信号：

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



三、SPI驱动OLED

OLED简介

OLED（Organic Light Emitting Diode）：有机发光二极管 OLED显示屏：性能优异的新型显示屏，具有功耗低、相应速度快、宽视角、轻薄柔韧等特点 0.96寸OLED模块：小巧玲珑、占用接口少、简单易用，是电子设计中非常常见的显示屏模块 供电：3~5.5V，通信协议：I2C/SPI，分辨率：128*64

 

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

}

Bamboo蜻蜓
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SPI/I2S调试心得与经验总结
qq_39989653的博客
12-04 3884
一、调试中首先检查SPI使能总线是否正确； 检查时序（现有时钟，后片选拉低），接收时必须有发送才能有时钟 二、对照flash芯片手册查看SPI时序 三、检查状态位 1.查询标志位： 1）while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE)==RESET);//检查发送是否完成 2）while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE)==RES...
《嵌入式系统原理与应用》 |（十一）SPI知识梳理
12 26 25 的博客
01-01 2499
系列索引：《嵌入式系统原理与应用》 | 嵌入式系统 重点知识梳理 目录 SPI的物理层接口及互联 SPI的时钟极性及时钟相位 SPI的数据格式及传输速率 STM32中SPI的特性 SPI的工作模式、配置步骤及数据收发过程 SPI的状态标志和中断（两个重要的：TXE和RXNE） SPI的常用库函数（初始化设置、收发数据） SPI的物理层接口及互联 SPI（...
STM32H743VIT6使用STM32CubeMX通过I2S驱动WM8978（2）
最新发布
phmatthaus的专栏
04-13 1398
STM32H743VIT6使用STM32CubeMX通过I2S驱动WM8978（2）
STM32个人笔记-I2S
weixin_47077788的博客
03-27 4974
现实存在的声音是模拟量，这对声音保存和长距离传输造成很大的困难，一般的做法是把模拟量转成对应的数字量保存，在需要还原声音的地方再把数字量的转成模拟量输出。模拟量转换成数字量，3个过程：采样、量化和编码。蓝线的距离就是采样信号的周期，即对应一个采样频率（Fs）。Fs越高，采样信号越符合曲线，但采样数据量也会越大，一般使用44.1KHzFs即可得高保真的声音。蓝线长度就是源声音的量化值。量化位数表示每个采样点用多少位数代表数据范围，常用的有16bit、24bit和32bit等。
i2C设备地址怎么看？
刘师傅的博客
10-15 1万+
IIC设备地址一般为8（0~7）位。 其中第7位1为读，0为写。 剩下的0~6位参考IIC设备的datasheet和板卡原理图可知，如下图。 上图中意思是设备地址由两个引脚ADD1和ADD0决定。每个引脚有三种状态，0（低电平）、1（高电平）、NC（不接）。根据原理图中相应引脚的状态可知设备地址。 ...
STM32——SPI接口原理与配置
weixin_62584795的博客
08-28 5464
STM32——SPI接口原理与配置
STM32软件模拟IIC读RC522
01-04
总的来说，STM32软件模拟IIC读RC522是一个涉及硬件接口模拟、IIC协议理解和RC522模块通信的综合任务。这个过程中，对微控制器的GPIO操作、时序控制以及RFID技术的理解都至关重要。通过细致的编程和调试，可以实现STM...
stm32_temp.rar_stm32 spi iic_stm32 temp
09-23
标题中的“stm32_temp.rar_stm32 spi iic_stm32 temp”暗示了这个压缩包包含与STM32微控制器相关的温度管理、SPI和IIC通信协议的应用程序。 SPI（Serial Peripheral Interface）是一种同步串行接口，常用于连接微...
STM32同时显示两块OLED屏-SPI-IIC
05-04
在本文中，我们将深入探讨如何使用STM32F103VET6微控制器通过SPI和IIC接口同时驱动两块OLED显示屏。STM32系列是基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计，而OLED（有机发光二极管）显示器因其高...
OLED-STM32-SPI和IIC例程资料.zip
05-26
《OLED显示器与STM32微控制器：SPI和IIC通信详解》 在电子设备的开发和设计中，OLED（有机发光二极管）显示器因其高对比度、宽视角和快速响应时间而广泛应用于各种嵌入式系统。在本资料中，我们将深入探讨如何使用...
stm32 103rct6 iic和模拟spi读取BMP280温度和高度传感器 kell 5
03-05
包能用，不能用，喷我。里面注释清楚， IIC SCK PA2 SDA PA3 ...SPI SCL --> 时钟线 SDI --> 数据输入线;三线模式下为双向数据线 SDO --> 数据输出线; IIC 线模式下无用 CSB --> 片选引脚，拉低后启用
stm32h7-drivers_stm32h7_寄存器版本驱动_stm32h7i2c_stm32h7-drivers_I2S_源
09-30
stm32H7系列寄存器版本驱动，包含I2S，I2C等
STM32中SPI通讯
08-24
经过本人测试，程序可以正常运行，可以在STM32控制器上实现SPI的接收与发送。
stm32 GPIO模拟SPI接口实现双机通信
m0_63619481的博客
08-08 4503
一般主从方式工作，这种模式通常有一个主设备和一个或多个从设备，通常采用的是4根线，它们是MISO（主机输入从机输出）、MOSI（主机输出，针对主机来说）、SCLK（时钟，主机产生）、CS（片选，一般由主机发送或者直接使能，通常为低电平有效）MOSI：主设备数据输出，从设备数据输入，所以主设备MOSI信号为推挽输出模式，从设备的MOSI信号为浮空输入模式。CS：使能信号，由主设备控制从设备，，所以主设备CS信号为推挽输出模式，从设备的CS信号为浮空输入模式。2、主设备向从设备写以及读。...
SPI/I2S调试总结
飞光
12-12 8335
SPI芯片:W25Q16   I2S芯片：AK4386   主芯片：STM32F105   1.查询标志位：          1）while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE)==RESET);//检查发送是否完成          2）while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_R
STM32F1 HAL库开发——关掉和开启SPI中断
王纯配的博客
05-10 3637
从机要实现的功能是：SPI1接收到一帧数据（e.g 6bytes）进入回调函数中，关掉SPI1中断——>数据处理+uart发送——>开启SPI1中断，等待下一次数据接收。 库函数方法： SPI_I2S_ITConfig(SPI1,SPI_I2S_IT_RXNE,DISABLE); …数据处理… SPI_I2S_ITConfig(SPI1,SPI_I2S_IT_RXNE,ENABLE); HAL库方法 __HAL_SPI_DISABLE_IT(&hspi1, SPI_IT_RXNE); .
SPI通信(SPI1主机与SPI2从机)
热门推荐
我爱你Max
09-06 1万+
芯片型号stm32f103 主机采用spi1，从机spi2，中断接收测试 主机配置函数： #include "spi.h" void SPI1_Init(void) {         NVIC_InitTypeDef NVIC_InitStructure;     GPIO_InitTypeDef  GPIO_InitStructure;     SPI_InitTypeDe
初探STM32 SPI2中断接受多组数据的处理方式
chengbozhe的专栏
12-10 1万+
初探STM32 SPI2中断接受多组数据的处理方式 一、描述 两块STM32板子之间进行SPI通讯，都使用的是SPI2。主机连续发送多组数据（数据的格式为半字，即16位），从机采用SPI2中断方式接受主机发过来的多组数据。 针对从机中断接受方法我尝试了两种方案： 方案一：从机没接收主机发来的一组数据就进入中断一次，即主机发来几组数据从机就进入几次中断。 方案二：仅当主机发来第一组数据时，
STM32第二十二课（I2S，HAL，cubemx）
Huskar_Liu的博客
12-24 3099
本文使用cubemx生成尽可能多的代码。
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、付费专栏及课程。

余额充值