【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→I2C→M24C02

已于 2023-06-13 15:04:59 修改
阅读量962 收藏 9
点赞数 1
文章标签： stm32 蓝桥杯 单片机
于 2023-01-16 18:36:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66792436/article/details/128706108
版权

文章目录

前言

G4板载了一块M24C02(eeprom)和一块MCP4017(可编程电阻)，省赛中多考M24C02，本篇文章讲述如何用软件I2驱动M24C02。

I2C

1.原理图以及配置元素

在这里插入图片描述
分析:由图可知，PB6为I2C的SCL线，PB7为I2C的SDA线

2.CubeMx的配置步骤

在这里插入图片描述
大赛是提供了I2C的驱动的这里我们只需要把两个引脚设置输出模式就行了，不再需要其他步骤。

3.生成工程

在这里插入图片描述
在这里插入图片描述
将红框中的两个文件复制黏贴到工程文件夹中的bsp文件夹中并改名为i2c.c和i2c.h。
在这里插入图片描述
在bsp文件中新建i2cc.c和i2c.h文件
打开工程将两个文件添加到工程中去
在这里插入图片描述
至此工程就建立完毕了

4.测试代码

i2c.h:

#ifndef __I2C_H
#define __I2C_H

#include "main.h"

void I2CStart(void);
void I2CStop(void);
unsigned char I2CWaitAck(void);
void I2CSendAck(void);
void I2CSendNotAck(void);
void I2CSendByte(unsigned char cSendByte);
unsigned char I2CReceiveByte(void);
void I2CInit(void);

/*******下方为自己添加的函数声明**************/
unsigned char eeprom_read(unsigned char addr);
void eeprom_write(unsigned char addr, unsigned char dat);

#endif

i2c.c:

#include "i2c.h"

#define DELAY_TIME	20


/**
  * @brief SDA线输入模式配置
  * @param None
  * @retval None
  */
void SDA_Input_Mode()
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7;
    GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
    GPIO_InitStructure.Pull = GPIO_PULLUP;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/**
  * @brief SDA线输出模式配置
  * @param None
  * @retval None
  */
void SDA_Output_Mode()
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7;
    GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStructure.Pull = GPIO_NOPULL;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/**
  * @brief SDA线输出一个位
  * @param val 输出的数据
  * @retval None
  */
void SDA_Output( uint16_t val )
{
    if ( val )
    {
        GPIOB->BSRR |= GPIO_PIN_7;
    }
    else
    {
        GPIOB->BRR |= GPIO_PIN_7;
    }
}

/**
  * @brief SCL线输出一个位
  * @param val 输出的数据
  * @retval None
  */
void SCL_Output( uint16_t val )
{
    if ( val )
    {
        GPIOB->BSRR |= GPIO_PIN_6;
    }
    else
    {
        GPIOB->BRR |= GPIO_PIN_6;
    }
}

/**
  * @brief SDA输入一位
  * @param None
  * @retval GPIO读入一位
  */
uint8_t SDA_Input(void)
{
	if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == GPIO_PIN_SET){
		return 1;
	}else{
		return 0;
	}
}


/**
  * @brief I2C的短暂延时
  * @param None
  * @retval None
  */
static void delay1(unsigned int n)
{
    uint32_t i;
    for ( i = 0; i < n; ++i);
}

/**
  * @brief I2C起始信号
  * @param None
  * @retval None
  */
void I2CStart(void)
{
    SDA_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SDA_Output(0);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);
}

/**
  * @brief I2C结束信号
  * @param None
  * @retval None
  */
void I2CStop(void)
{
    SCL_Output(0);
    delay1(DELAY_TIME);
    SDA_Output(0);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SDA_Output(1);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C等待确认信号
  * @param None
  * @retval None
  */
unsigned char I2CWaitAck(void)
{
    unsigned short cErrTime = 5;
    SDA_Input_Mode();
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    while(SDA_Input())
    {
        cErrTime--;
        delay1(DELAY_TIME);
        if (0 == cErrTime)
        {
            SDA_Output_Mode();
            I2CStop();
            return ERROR;
        }
    }
    SDA_Output_Mode();
    SCL_Output(0);
    delay1(DELAY_TIME);
    return SUCCESS;
}

/**
  * @brief I2C发送确认信号
  * @param None
  * @retval None
  */
void I2CSendAck(void)
{
    SDA_Output(0);
    delay1(DELAY_TIME);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C发送非确认信号
  * @param None
  * @retval None
  */
void I2CSendNotAck(void)
{
    SDA_Output(1);
    delay1(DELAY_TIME);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C发送一个字节
  * @param cSendByte 需要发送的字节
  * @retval None
  */
void I2CSendByte(unsigned char cSendByte)
{
    unsigned char  i = 8;
    while (i--)
    {
        SCL_Output(0);
        delay1(DELAY_TIME);
        SDA_Output(cSendByte & 0x80);
        delay1(DELAY_TIME);
        cSendByte += cSendByte;
        delay1(DELAY_TIME);
        SCL_Output(1);
        delay1(DELAY_TIME);
    }
    SCL_Output(0);
    delay1(DELAY_TIME);
}

/**
  * @brief I2C接收一个字节
  * @param None
  * @retval 接收到的字节
  */
unsigned char I2CReceiveByte(void)
{
    unsigned char i = 8;
    unsigned char cR_Byte = 0;
    SDA_Input_Mode();
    while (i--)
    {
        cR_Byte += cR_Byte;
        SCL_Output(0);
        delay1(DELAY_TIME);
        delay1(DELAY_TIME);
        SCL_Output(1);
        delay1(DELAY_TIME);
        cR_Byte |=  SDA_Input();
    }
    SCL_Output(0);
    delay1(DELAY_TIME);
    SDA_Output_Mode();
    return cR_Byte;
}

//
void I2CInit(void)
{
		GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7 | GPIO_PIN_6;
    GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStructure.Pull = GPIO_PULLUP;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/**************以上是大赛提供的驱动**************************/


/***********以下是自己写的对24C02的读写操作******************/

unsigned char eeprom_read(unsigned char addr)
{
	unsigned char dat;
	
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(addr);
	I2CWaitAck();
	I2CStop();
	
	I2CStart();
	I2CSendByte(0xa1);
	I2CWaitAck();
	dat = I2CReceiveByte();
	I2CWaitAck();
	I2CStop();
	
	return dat;
}


void eeprom_write(unsigned char addr, unsigned char dat)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(addr);
	I2CWaitAck();
	I2CSendByte(dat);
	I2CWaitAck();
	I2CStop();
}

main.c:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "lcd.h"
#include "badc.h"
#include "stdio.h"
#include "i2c.h"
#include "interrupt.h"
/* 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 ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
extern struct keys key[4];
unsigned char adc1_L, adc1_H;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

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

/* 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 */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM3_Init();
  MX_TIM16_Init();
  MX_TIM17_Init();
  MX_ADC1_Init();
  MX_ADC2_Init();
  /* USER CODE BEGIN 2 */
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);
	HAL_TIM_Base_Start_IT(&htim3);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
		char text[30];
		unsigned int adc1, adc2;
		adc1 = getADC(&hadc1);
		sprintf(text, "    V1:%.2f", adc1 * 3.3 / 4096);
		LCD_DisplayStringLine(Line4, (unsigned char *)text);
		adc2 = getADC(&hadc2);
		sprintf(text, "    V2:%.2f", adc2 * 3.3 / 4096);
		LCD_DisplayStringLine(Line5, (unsigned char *)text);
		if(key[0].single_flag) //短按写入
		{
			adc1_L = adc1 & 0xff;
			adc1_H = adc1 >> 8;
			eeprom_write(1, adc1_L);
			HAL_Delay(10);
			eeprom_write(2, adc1_H);
			key[0].single_flag = 0;
		}
		if(key[0].long_flag) //长按读出
		{
			char text[30];
			unsigned int eep_temp = (eeprom_read(2) << 8) + eeprom_read(1);
			sprintf(text, "    ADC_eep=%.2f", eep_temp * 3.3 / 4096);
			LCD_DisplayStringLine(Line8, (unsigned char *)text);
			key[0].long_flag = 0;	
		}
  }
  /* USER CODE END 3 */
}

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

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
  RCC_OscInitStruct.PLL.PLLN = 20;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the peripherals clocks
  */
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12;
  PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* 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 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

5.演示效果

eeprom实验

总结

以上就是I2C的配置过程，测试代码以及测试效果
参考的学习视频:【2023蓝桥杯 嵌入式组适用】CT117E-M4 新款开发板 3小时省赛模块 速成总结
之前的模块配置方法及测试:
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→LED
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→LCD
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→KEY→单击
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→KEY→长按(持续响应)以及双击
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→TIM→PWM
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→ADC

火花页.
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
12006.eeprom之M24C02
写给自己的笔记
04-27 1052
eeprom之M24C02笔记1 简介2 24C02 芯片手册2.1 性能介绍2.2 信号管脚介绍2.3 存储器结构图2.4 设备操作IIC协议2.5 设备地址及读写命令控制2.6 写指令之按字节写-按页写2.7 读数据几种方式2.8 芯片命名含义2.9 裸机操作流程图3 测试方案4 应用程序开发 1 简介 串行E2PROM是基于I2C-BUS 的存储器件，遵循二线制协议，由于其具有接口方便，体积小，数据掉电不丢失等特点，在仪器仪表及工业自动化控制中得到大量的应用。随着世界上各公司对该器件的开发，市场上推
24c02读程序C语言详解,24C02读写操作程序(C语言)
weixin_39606799的博客
05-20 3810
24C02读写操作程序.c#define uchar unsigned char#define uint unsigned int＃i nclude ＃i nclude ＃i nclude sbit scl=P3^5; //24c02 SCLsbit sda=P3^4; //24c02 SDAsbit DOG=P1^7; //狗uchar x24c02_read(uchar address)...
【蓝桥杯嵌入式】MCP4017可编程电阻学习（iic通信）
qq_64777806的博客
03-06 539
由Total（Rab）可知这个可编程电阻总电阻为100k欧（当寄存器为0x7F时达到最大电阻）。由Step（Rs），可知相当于寄存器每增加一个数，电阻增加787.402欧。
stm32F4之使用I2C读写24C02
清寻
04-04 2557
一.24C02简单介绍 1.串行E2PROM是基于I2C-BUS 的存储器件， 2.可以支持100万次擦除，数据可以保存100年， 3.支持每次读写1字节 4.写周期最大5ms（即最好保证在5ms后进行读写，否则可以数据将会读取错误） 二.24C02的读写时序...
【蓝桥杯嵌入式学习G431】模块七：I2C-EEPROM
qq_36439118的博客
03-20 483
时序图：代码都是根据时序图来编写，具体原理略显复杂，本文章暂时只分享速通技巧，掌握模块化即可。原理可搜索其他人的教程。
基于STM32F103的24m02芯片驱动代码
03-19
基于STM32F103的24m02芯片驱动代码，使用软件iic协议，实现数据存储及读取
嵌入式系统/ARM技术中的I2C总线与串行EEPROM
11-14
在I2C总线上，数据是串行传输的，但数据的读／写是以8位为单位的，不可以只指定存储器内部某特定的比特位进行读或者替换操作，至少需要以8位为单位进行存取。 　　M24Cxx与主机的连接实例如图1所示，简单的传输格式实例如图2所示。在PC总线对应的EEPROM中，认为最多可以连接8个地址，每个地址至多为8位（256字节，2K位）的存储器，基于I2C总线的规范标准，利用起始字节的0位区分读或写操作，利用1～4位指定器件编号。这样，就可以指定接收数据的器件。然后接着的第2字节是存储器地址，第3字节以后为数据。    图1 I2C总线对应的存储器与主机的连接 　　因为可以连接地址为8位（256字
LM3S驱动库例程_I2C读写存储器24c02例程
12-18
基于ti驱动库lm3s芯片I2C读写e2prom存储芯片24c02的例程，经测试可以用，可配合LM3S的I2C说明文档阅读。
蓝桥杯STM32G431RBT6学习——M24C02
weixin_44098974的博客
02-01 1807
蓝桥杯STM32G431RBT6学习——M24C02
STM32G0开发笔记-Platformio+libopencm3-EEPROM M24C02使用
MakerInChina
01-11 539
使用Platformio平台的libopencm3开发框架来开发STM32G0，以下为EEPROM M24C02的使用方法。
ist的matlab代码-I2C_EEPROM:支持广泛的I2Ceeprom
05-26
是的matlab代码<title> I2C EEProm </ title> 一个相当通用的I2C EEProm库 版本0.3从01/06/2016 12:52:30 可以与Arduino IDE一起使用。 Lib基于Wire。 下载 ，可能是较新版本，可能是较新版本特征 大部分与Arduino EEPROM Lib兼容 支持许多I2C EEProm 相对简单的创建用户定义的EEProm 低内存消耗 支持的EEProm 随时可以添加更多的EEProms。 爱特梅尔 班级名称 尺寸 页面大小 地址模式 AT24C01 128 第八名 1个 AT24C02 256 第八名 1个 AT24C04 512 16 1个 AT24C08 1024 16 1个 AT24C16 2048 16 1个 AT24C32 4096 32 2个 AT24C64 8192 64 2个 AT24C128 16384 64 2个 AT24C256 32768 64 2个 AT24C512 65536 128 2个 意法半导体 班级名称 尺寸 页面大小 地址模式 M24C01 128 16 1个 ST24C01 12
嵌入式系统/ARM技术中的I2C总线的读操作的流程
11-14
M24Cxx的读操作模式及其各种模式的操作流程如图1、图2所示。 　　1.  当前地址读 　　EEPROM内部具有保持当前地址的寄存器。读取当前地址的数据时，不需要指定地址。只要单纯给出读指令就可读出数据。读取完毕后，内部所保持的当前地址将自动进位。 　　图1 I2C存储器的读操作（1） 　　图2 I2C存储器的读操作（2） 　　数据读操作后的ACK／NoACK信号由主机返回，但必须返回NoACK信号。 　　2.  随机读 　　随机读是由主机指定任意的地址读取的。利用写指令设定地址，如果赋予读指令则可以读出当前地址。所以，与字节写操作时相同，在第1字节的数据后面给出地址。在这
EEPROM24C02烧写程序
08-15
是通过52单片机来控制EEPROM24C02烧写的，这是源代码。
i2c_24c64.rar_24c64 verilog_24lc64 verilog_eeprom 模型_i2c verilog
07-14
基于verilog的i2c接口EEPROM 24lc64的测试程序，包括了eeprom的虚拟模型，实际在硬件上验证没问题，也可以通过modleism进行仿真
13_读写EEPROM24C02_单片机_
10-02
单片机入门资料，读写EEPROM24C02程序并编译通过。
24c02读写程序带说明
05-14
#include #include #define uchar unsigned char #define uint unsigned int //********************2402读写指令********************** #define c2402wdat 0xa0 #define c2402rdat 0xa1 //**************************end****************** //**************2402IO***dinyi****************** sbit sda=P1^0; sbit scl=P1^1; sbit P13=P1^3; //********************************************** void dins(uchar a) { uchar b; for(;a>0;a--) for(b=100;b>0;b--) ; } //**************************12MHz**************如为24MHz则所有延时需加陪********************** void start() //**********开始********************** { sda=1; scl=1; _nop_(); _nop_();
I2C总线对应的存储器
11-14
I2C总线是Philips公司所提倡的两线式的简单接口。它不但应用于EEPROM，而且还应用于LCD驱动器以及RAM、I／O端口等。I2C总线上不但能连接若干个从属控制器，还可以连接多主控器，因而可以在总线上连接多个主机，共享...
b站江科大stm32笔记（持续更新）
最新发布
Xkccsdn147的博客
04-13 2116
笔记
mcp2515 stm32驱动
07-29
MCP2515是一款CAN总线控制器芯片，而STM32是一款32位微控制器。所以“MCP2515 STM32驱动”指的是通过驱动程序将MCP2515与STM32微控制器连接起来，实现CAN总线通信功能。 MCP2515和STM32之间的连接可以通过SPI总线来实现。首先，需要配置STM32的GPIO引脚和SPI外设。然后，编写驱动程序，通过SPI接口与MCP2515进行通信和控制。 在驱动程序中，首先需要初始化MCP2515芯片，设置CAN通信的波特率、模式和滤波器等参数。然后，可以通过驱动程序的接口函数，实现CAN消息的发送和接收。 对于消息的发送，驱动程序将待发送的数据封装成CAN消息的格式，并通过SPI接口将数据发送给MCP2515。MCP2515将数据发送到CAN总线上。 对于消息的接收，驱动程序通过SPI接口从MCP2515读取接收到的CAN消息。驱动程序可以对接收到的CAN消息进行解析，获取其中的数据信息，并进行相应的处理。 通过MCP2515 STM32驱动，可以实现STM32与CAN总线的通信。这对于需要使用CAN总线进行数据传输的应用场景非常有用，比如汽车电子控制领域、工业控制系统等。 总结起来，MCP2515 STM32驱动是通过编写驱动程序，将MCP2515与STM32微控制器连接起来，实现CAN总线通信功能的过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值