STM32 HAL移植u8g2库（I2C）

已于 2022-06-12 10:50:29 修改
阅读量1.6k 收藏 14
点赞数 3
文章标签： stm32 单片机 arm
于 2022-06-12 10:45:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Scarlett29/article/details/125242250
版权

通过STM32CubeMX配置I2C。

复制相关文件到工程文件夹

保留对应的显示屏型号，如SSD1306，就保留u8x8_d_ssd1306_128x64_noname.c，其它u8x8_d_XXXX.c都删掉。

GPIO和延迟回调

该函数用于设置和复位 GPIO（如果是软件实现的接口），例如软件 I2C、SPI、8080 或 6800 接口。此外，此函数用于实现引脚时序的忙等待延迟。

HAL 发送的消息分为三类。

  1. “U8X8_MSG_DELAY_”形式的延迟消息。这些消息用于为 I2C、SPI 等的软件实现提供延迟。
    为了使软件（又名 bit-banged）接口工作，您需要实现 MCU 特定的忙等待循环以提供正确的延迟量.
    对于示例实现，我使用了 CyDelay* 形式的赛普拉斯 PSoC 特定延迟函数

  2. “U8X*_MSG_GPIO”形式的GPIO 消息。这些消息用于将 1 和 0 写入用于连接设备的 GPIO。即 SCL/SDA 或 Reset 或 CS 等。
    对于示例实现，我使用了 Cypress 引脚写入函数，这些函数都采用“pinname_Write()”的形式。

  3. GPIO 菜单引脚用于获取输入引脚的状态。这些消息只有内置菜单功能需要，如果不使用 U8G2/U8X8 菜单功能，可以忽略。

GPIO和延迟回调模板

uint8_t u8x8_gpio_and_delay_template(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
  switch(msg)
  {
    case U8X8_MSG_GPIO_AND_DELAY_INIT:	// called once during init phase of u8g2/u8x8
      break;							// can be used to setup pins
    case U8X8_MSG_DELAY_NANO:			// delay arg_int * 1 nano second
      break;    
    case U8X8_MSG_DELAY_100NANO:		// delay arg_int * 100 nano seconds
      break;
    case U8X8_MSG_DELAY_10MICRO:		// delay arg_int * 10 micro seconds
      break;
    case U8X8_MSG_DELAY_MILLI:			// delay arg_int * 1 milli second
      break;
    case U8X8_MSG_DELAY_I2C:				// arg_int is the I2C speed in 100KHz, e.g. 4 = 400 KHz
      break;							// arg_int=1: delay by 5us, arg_int = 4: delay by 1.25us
    case U8X8_MSG_GPIO_D0:				// D0 or SPI clock pin: Output level in arg_int
    //case U8X8_MSG_GPIO_SPI_CLOCK:
      break;
    case U8X8_MSG_GPIO_D1:				// D1 or SPI data pin: Output level in arg_int
    //case U8X8_MSG_GPIO_SPI_DATA:
      break;
    case U8X8_MSG_GPIO_D2:				// D2 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D3:				// D3 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D4:				// D4 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D5:				// D5 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D6:				// D6 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D7:				// D7 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_E:				// E/WR pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS:				// CS (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_DC:				// DC (data/cmd, A0, register select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_RESET:			// Reset pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS1:				// CS1 (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS2:				// CS2 (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_I2C_CLOCK:		// arg_int=0: Output low at I2C clock pin
      break;							// arg_int=1: Input dir with pullup high for I2C clock pin
    case U8X8_MSG_GPIO_I2C_DATA:			// arg_int=0: Output low at I2C data pin
      break;							// arg_int=1: Input dir with pullup high for I2C data pin
    case U8X8_MSG_GPIO_MENU_SELECT:
      u8x8_SetGPIOResult(u8x8, /* get menu select pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_NEXT:
      u8x8_SetGPIOResult(u8x8, /* get menu next pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_PREV:
      u8x8_SetGPIOResult(u8x8, /* get menu prev pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_HOME:
      u8x8_SetGPIOResult(u8x8, /* get menu home pin state */ 0);
      break;
    default:
      u8x8_SetGPIOResult(u8x8, 1);			// default return value
      break;
  }
  return 1;
}

 信号回调

为了连接到显示控制器的通信端口，您需要有一个面向字节的接口，即 SPI、I2C 等。该接口可以实现为 bit-banged 软件接口或使用 MCU 特定硬件。作为 u8x8_byte.c 中 U8X8 库的一部分，提供了几个软件 bit-banged 接口：

字节程序描述
u8x8_byte_4wire_sw_spi标准 8 位 SPI 通信，带“四针”（SCK、MOSI、DC、CS）
u8x8_byte_3wire_sw_spi9 位“三针”通信（SCK、MOSI、CS）
u8x8_byte_8bit_6800mode并行接口，6800格式
u8x8_byte_8bit_8080mode并行接口，8080格式
u8x8_byte_sw_i2c两线制，I2C 通信
u8x8_byte_ks0108KS0108控制器专用接口

上述函数使用了你定义的 uC 特定的 gpio 和 delay 函数。

硬件接口函数需要处理来自系统其余部分的消息。您需要实现的消息是：

信息描述
U8X8_MSG_BYTE_INIT在显示的初始化阶段发送一次。
U8X8_MSG_BYTE_SET_DC设置数据/命令引脚的电平。arg_int包含预期的输出水平。用于u8x8_gpio_SetDC(u8x8, arg_int)向 GPIO 过程发送消息。
U8X8_MSG_BYTE_START_TRANSFER在此处设置片选线。 u8x8->display_info->chip_enable_level包含预期水平。用于u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level)调用 GPIO 过程。
U8X8_MSG_BYTE_SEND发送一个或多个字节，位于arg_ptr，arg_int包含字节数。
U8X8_MSG_BYTE_END_TRANSFER取消选择设备。从这里使用 CS 级别：u8x8->display_info->chip_disable_level.

 硬件IPS通讯模板

下面的代码列出了一个典型的 SPI 实现。这些消息被转换为对 Arduino SPI 库的调用。

extern "C" uint8_t u8x8_byte_arduino_hw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr) {
  uint8_t *data;
  uint8_t internal_spi_mode; 
  switch(msg) {
    case U8X8_MSG_BYTE_SEND:
      data = (uint8_t *)arg_ptr;
      while( arg_int > 0 ) {
        SPI.transfer((uint8_t)*data);
        data++;
        arg_int--;
      }  
      break;
    case U8X8_MSG_BYTE_INIT:
      u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
      SPI.begin();
      break;
    case U8X8_MSG_BYTE_SET_DC:
      u8x8_gpio_SetDC(u8x8, arg_int);
      break;
    case U8X8_MSG_BYTE_START_TRANSFER:
      /* SPI mode has to be mapped to the mode of the current controller, at least Uno, Due, 101 have different SPI_MODEx values */
      internal_spi_mode =  0;
      switch(u8x8->display_info->spi_mode) {
        case 0: internal_spi_mode = SPI_MODE0; break;
        case 1: internal_spi_mode = SPI_MODE1; break;
        case 2: internal_spi_mode = SPI_MODE2; break;
        case 3: internal_spi_mode = SPI_MODE3; break;
      }
      SPI.beginTransaction(SPISettings(u8x8->display_info->sck_clock_hz, MSBFIRST, internal_spi_mode));
      u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);  
      u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
      break;
    case U8X8_MSG_BYTE_END_TRANSFER:      
      u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
      u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
      SPI.endTransaction();
      break;
    default:
      return 0;
  }  
  return 1;
}

硬件I2C通讯模板

uint8_t u8x8_byte_i2c(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
  static uint8_t buffer[32];		/* u8g2/u8x8 will never send more than 32 bytes between START_TRANSFER and END_TRANSFER */
  static uint8_t buf_idx;
  uint8_t *data;
 
  switch(msg)
  {
    case U8X8_MSG_BYTE_SEND:
      data = (uint8_t *)arg_ptr;      
      while( arg_int > 0 )
      {
	buffer[buf_idx++] = *data;
	data++;
	arg_int--;
      }      
      break;
    case U8X8_MSG_BYTE_INIT:
      /* add your custom code to init i2c subsystem */
      break;
    case U8X8_MSG_BYTE_SET_DC:
      /* ignored for i2c */
      break;
    case U8X8_MSG_BYTE_START_TRANSFER:
      buf_idx = 0;
      break;
    case U8X8_MSG_BYTE_END_TRANSFER:
      i2c_transfer(u8x8_GetI2CAddress(u8x8) >> 1, buf_idx, buffer);
      break;
    default:
      return 0;
  }
  return 1;
}

 开始移植

根据使用的显示屏型号，在u8g2_d_setup.c  保留 void u8g2_Setup_ssd1306_i2c_128x64_noname_f。

/* u8g2_d_setup.c */
/* generated code, codebuild, u8g2 project */

#include "u8g2.h"

/* ssd1306 f */
void u8g2_Setup_ssd1306_i2c_128x64_noname_f(u8g2_t *u8g2, const u8g2_cb_t *rotation, u8x8_msg_cb byte_cb, u8x8_msg_cb gpio_and_delay_cb)
{
  uint8_t tile_buf_height;
  uint8_t *buf;
  u8g2_SetupDisplay(u8g2, u8x8_d_ssd1306_128x64_noname, u8x8_cad_ssd13xx_fast_i2c, byte_cb, gpio_and_delay_cb);
  buf = u8g2_m_16_8_f(&tile_buf_height);
  u8g2_SetupBuffer(u8g2, buf, tile_buf_height, u8g2_ll_hvline_vertical_top_lsb, rotation);
}
/* end of generated code */

 void u8g2_Setup_ssd1306_i2c_128x64_noname_f 会使用在uint8_t *u8g2_m_16_8_f，在u8g2_d_memory.c 保留 uint8_t *u8g2_m_16_8_f。

/* u8g2_d_memory.c */
/* generated code, codebuild, u8g2 project */

#include "u8g2.h"

uint8_t *u8g2_m_16_8_f(uint8_t *page_cnt)
{
  #ifdef U8G2_USE_DYNAMIC_ALLOC
  *page_cnt = 8;
  return 0;
  #else
  static uint8_t buf[1024];
  *page_cnt = 8;
  return buf;
  #endif
}
/* end of generated code */

编写oled.h。

#ifndef __oled_H
#define __oled_H
#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "u8g2.h"
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */



/* USER CODE BEGIN Private defines */

/* USER CODE END Private defines */
#define u8         unsigned char  // ?unsigned char ????
#define MAX_LEN    128  //
#define OLED_ADDRESS  0x78 // oled模块从机地址
#define OLED_CMD   0x00  // 写命令
#define OLED_DATA  0x40  // 写数据
 
/* USER CODE BEGIN Prototypes */
 uint8_t u8x8_byte_hw_i2c(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);
 uint8_t u8x8_gpio_and_delay(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);
 void u8g2Init(u8g2_t *u8g2);
 #ifdef __cplusplus
}
#endif
#endif /*__ i2c_H */
/* USER CODE END Prototypes */

编写oled.c。

u8x8_gpio_and_delay 和 u8x8_byte_hw_i2c 两个回调函数，最终会添加到 void u8g2Init 初始化函数内。

#include "u8g2_oled.h"
#include "i2c.h"

uint8_t u8x8_byte_hw_i2c(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
    /* u8g2/u8x8 will never send more than 32 bytes between START_TRANSFER and END_TRANSFER */
    static uint8_t buffer[128];
    static uint8_t buf_idx;
    uint8_t *data;

    switch (msg)
    {
    case U8X8_MSG_BYTE_INIT:
    {
        /* add your custom code to init i2c subsystem */
        MX_I2C2_Init(); //I2C初始化
    }
    break;

    case U8X8_MSG_BYTE_START_TRANSFER:
    {
        buf_idx = 0;
    }
    break;

    case U8X8_MSG_BYTE_SEND:
    {
        data = (uint8_t *)arg_ptr;

        while (arg_int > 0)
        {
            buffer[buf_idx++] = *data;
            data++;
            arg_int--;
        }
    }
    break;

    case U8X8_MSG_BYTE_END_TRANSFER:
    {
        if (HAL_I2C_Master_Transmit(&hi2c2, OLED_ADDRESS, buffer, buf_idx, 1000) != HAL_OK)
            return 0;
    }
    break;

    case U8X8_MSG_BYTE_SET_DC:
        break;

    default:
        return 0;
    }

    return 1;
}

void delay_us(uint32_t time)
{
    uint32_t i = 8 * time;
    while (i--)
        ;
}

uint8_t u8x8_gpio_and_delay(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
    switch (msg)
    {
    case U8X8_MSG_DELAY_100NANO: // delay arg_int * 100 nano seconds
        __NOP();
        break;
    case U8X8_MSG_DELAY_10MICRO: // delay arg_int * 10 micro seconds
        for (uint16_t n = 0; n < 320; n++)
        {
            __NOP();
        }
        break;
    case U8X8_MSG_DELAY_MILLI: // delay arg_int * 1 milli second
        HAL_Delay(1);
        break;
    case U8X8_MSG_DELAY_I2C: // arg_int is the I2C speed in 100KHz, e.g. 4 = 400 KHz
        delay_us(5);
        break;                    // arg_int=1: delay by 5us, arg_int = 4: delay by 1.25us
    case U8X8_MSG_GPIO_I2C_CLOCK: // arg_int=0: Output low at I2C clock pin
        break;                    // arg_int=1: Input dir with pullup high for I2C clock pin
    case U8X8_MSG_GPIO_I2C_DATA:  // arg_int=0: Output low at I2C data pin
        break;                    // arg_int=1: Input dir with pullup high for I2C data pin
    case U8X8_MSG_GPIO_MENU_SELECT:
        u8x8_SetGPIOResult(u8x8, /* get menu select pin state */ 0);
        break;
    case U8X8_MSG_GPIO_MENU_NEXT:
        u8x8_SetGPIOResult(u8x8, /* get menu next pin state */ 0);
        break;
    case U8X8_MSG_GPIO_MENU_PREV:
        u8x8_SetGPIOResult(u8x8, /* get menu prev pin state */ 0);
        break;
    case U8X8_MSG_GPIO_MENU_HOME:
        u8x8_SetGPIOResult(u8x8, /* get menu home pin state */ 0);
        break;
    default:
        u8x8_SetGPIOResult(u8x8, 1); // default return value
        break;
    }
    return 1;
}
void u8g2Init(u8g2_t *u8g2)
{
	u8g2_Setup_ssd1306_i2c_128x64_noname_f(u8g2, U8G2_R0, u8x8_byte_hw_i2c, u8x8_gpio_and_delay); // 初始化 u8g2 结构体
	u8g2_InitDisplay(u8g2);                                                                       // 根据所选的芯片进行初始化工作，初始化完成后，显示器处于关闭状态
	u8g2_SetPowerSave(u8g2, 0);                                                                   // 打开显示器
	u8g2_ClearBuffer(u8g2);
}

在main函数添加测试代码。

  while (1)
  {
    u8g2_ClearBuffer(&u8g2);
    u8g2_DrawBox(&u8g2,0,0,20,20);
    u8g2_DrawBox(&u8g2,20,20,20,20);
    u8g2_DrawFrame(&u8g2,10,40,20,20);
    u8g2_SendBuffer(&u8g2);
      
    
    HAL_Delay(100);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

Scarlett29
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于STM32移植U8g2图形库——OLED显示（HAL库）_stm32 u8g2(1)
2401_83704159的博客
04-06 817
上述编写的移植函数代码属于HAL库下的代码，标准库的代码其实差不多，有个别地方需要注意修改。（当然，前提是需要熟悉U8g2的使用，这一点网上有很多用法博客写得都很详细，感兴趣的读者朋友可以去看看）**：这些函数代码就是对应的U8g2图形库的接口函数，通过这些函数去启用U8g2图形库。），为了减小整个工程的代码体积，在移植U8g2时，可以。，需要使用的时候就去打开工具箱，使用里面的已经写好的。这个文件，其它的屏幕驱动和分辨率的文件可以删掉。这个函数），其它的可以删掉或注释掉。这个函数，所以留下这个函数，
STM32之移植uCOSIII（HAL库）
weixin_57517458的博客
12-06 202
文章目录一.使用CubeMX建立STM32F103C8T6HAL库二.准备uCOSIII源码三.开始移植四.运行五.调试仿真总结参考 一.使用CubeMX建立STM32F103C8T6HAL库 配置sys 设置PC13为GPIO_Output用于点亮LED灯 设置串口USART1 设置工程 在main函数中的while循环里添加语句 while (1) { /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ HAL_GPIO
STM32HAL库OLED移植U8g2库
04-04
STM32HAL库开发移植U8g2库，编译软件为CLion,OLED为IIC通信
STM32移植U8g2图形库
最新发布
angers11的博客
05-04 949
一直想找一个可移值性强的显示驱动，偶然发现U8G2这个图像库，发现这个库能实现许多好玩有趣的动画，可以编一些界面，作为知识储备。U8g2 是一个用于嵌入式设备的简易图形库，可以在多种 OLED 和 LCD 屏幕上，支持包括 SSD1306 (新版型号为SSD1315)等多种类型的底层驱动，并可以很方便地移植到 Arduino 、树莓派、NodeMCU 和 ARM 上。
玩转u8g2 OLED库，一篇就够——基于SMT32、HAL
热门推荐
珍妮玛士多的博客
04-22 1万+
OLED图形库众多，如Adafruit_GFX 和 Adafruit_SSD1306库。但是，今天要使用的是 U8g2图形库。参考文章：深入学习Arduino u8g2 OLED库，一篇就够参考文章：GitHub–>u8g2reference。
基于STM32移植U8g2图形库——OLED显示（HAL库）
black_sneak的博客
08-13 1万+
基于STM32移植U8g2图形库的OLED显示教学（HAL库版本，文末有代码开源）
stm32移植u8g2显示库(spi驱动st7567)
physicsexpert的博客
12-25 4194
U8G2是一个开源的单色图形显示库，除了在arduino框架下使用外，U8G2还在GitHub上上传了所有的源码，方便我们移植到其他平台（）我手上的lcd屏幕为st7567驱动，目前该驱动的移植资料较少，所以发出来供大家参考。
stm32f103c8t6移植u8g2库，烧录程序接好线即可。
04-08
stm32f103c8t6移植u8g2库，使用cubemx+hal库，已经完成配置，驱动ssd1306的0.96寸oled。在cubemx里查看接线，烧录好程序就可以直接用。
STM32移植u8g2库（HAL库）（硬件SPI）（sh1106_128x64）
01-07
STM32移植u8g2库（HAL库）（硬件SPI）（sh1106_128x64）MCU型号为STM32F103RCT6，OLED屏为中景园电子1.3寸屏，驱动芯片为sh1106，分辨率为128x64，MDK版本为V5.34。
U8G2(SSD1306)移植例程 STM32F103C8T6(硬件IIC) CUBEMX
05-10
例程注释非常详细，配置项几乎每一个地方都写了注释 另例程部分有freertos的入口 此例程使用的硬件： 1. 模块为STM32F103C8T6 2. 屏幕为四排针的SSD1306(IIC)，分辨率为128*64 此例程使用的开发环境： 1. MDK KEIL5 2. CUBEMX 6.4.0 2.1 CUBEMX硬件包版本 STM32Cube FW_F1 V1.8.4 3. IDE VSCODE
STM32-HAL-U8G2-OLED.zip
11-02
STM32F407 通过SPI或I2C实现OLED，并移植U8G2方便图形化管理
STM32 HAL库 硬件I2C对MPU6050的使用
11-02
通过STM32 Cubermx 实现 硬件I2C对MPU6050的操作，包括DMP的移植，程序代码注释详细，有部分程序代码摘录于正点原子的函数， 基于STM32F407ZG 芯片开发
基于STM32的u8g2移植以及学习
m0_51274562的博客
11-28 5047
U8g2是嵌入式设备的单色图形库。主要应用于嵌入式设备，包括我们常见的单片机使用，最常用的是OLED屏或者LCD屏进行使用的一个库；我们常用的OLED屏其内部原理一个M x n 的像素点阵，想显示什么就得把具体位置的像素点亮起来。对于每一个像素点，有可能是1点亮，也有可能是0点亮；其坐标系如下所示。
STM32F103基于HAL库移植U8g2库驱动I2C SSD1306 Oled
perseverance51博客
04-08 1350
STM32F103基于HAL库移植U8g2库驱动I2C SSD1306 Oled
30秒学会U8G2库移植到STM32平台上
u014428915的博客
07-01 996
如果移植过程中出现u8x8_GetMenuEvent(u8x8_t *u8x8)未定义错误，则自己重新写一个空函数即可。2)u8g2_d_memory.c 屏蔽里面所有文件，只留对应文件（ssd1306只留这个函数），其余屏蔽。1)u8g2_setup.c 屏蔽里面所有文件，只留对应文件（ssd1306只留这个函数），其余屏蔽。1）如果你是使用的spi。需要重新是实现下这个函数：根据自己的实际使用的管脚来修改。然后根据自己的驱动添加u8x8_d_找到src文件夹，把里面的所有文件。
U8g2库的STM32硬件SPI（DMA）移植教程（HAL、OLED显示、四线SPI、DMA）
珍妮玛士多的博客
04-17 5569
本文教你把U8g2图形库移植到STM32上，基于STM32的硬件SPI、CubeMX
【STM32 CubeMX】移植u8g2(一次成功)
m0_62599305的博客
09-30 2238
在本文中，我们将介绍如何在STM32上成功地移植u8g2图形库，以便能够轻松地控制OLED或LCD显示屏。u8g2库提供了一个灵活、功能强大的框架，可以简化图形界面的开发过程。通过合理地配置STM32 CubeMX以及适当的硬件连接，我们可以使得u8g2与STM32微控制器完美结合。我们将逐步引导您完成整个移植过程，从STM32 CubeMX的项目创建，到u8g2库的集成和配置，最终实现一个简单的示例程序，以确保整个过程的顺利进行。让我们一起开始吧！
stm32 hal i2c库
06-20
### 回答1： STM32 HAL I2C库是一种用于STM32微控制器的库集合，用于实现I2C总线通信协议。该库集成了STM32微控制器所有的I2C控制器寄存器，提供了更为简单易用的API接口，方便开发人员进行I2C总线通信开发。 STM32 HAL I2C库的主要特点包括以下几点： 1. 支持多种I2C模式：包括标准模式（100Kbps）、快速模式（400Kbps）和高速模式（1Mbps）等。 2. 支持多个I2C从机设备：可以连接多个从机设备，并分别进行读写操作。 3. 提供了简单易懂的API接口：开发人员可以使用简单的函数调用实现I2C总线设备的初始化、读写操作等。 4. 提供了中断和DMA两种数据传输方式：可以根据实际应用场景选择适合的数据传输方式。 5. 支持主机和从机模式切换：可以在运行过程中切换主机和从机模式。 总之，STM32 HAL I2C库是一种非常实用的工具，可以帮助开发人员快速方便地进行STM32微控制器的I2C总线通信开发。无论是在工业自动化、智能家居、医疗设备等领域，都有着广泛的应用。 ### 回答2： STM32 HAL I2C库是为STM32微控制器设计的一个硬件抽象层库，可以方便地实现I2C总线的读写操作。I2C（Inter-Integrated Circuit）总线是一种串行通信总线，常用于连接微控制器、传感器、模拟转换器等设备。在使用I2C通信时，我们需要设置一些参数，如设备地址、传输模式、传输速率等。STM32 HAL I2C库封装了这些设置，在使用前，只需要初始化相关参数即可。 在STM32 HAL I2C库中，我们可以使用一些常用的函数，如I2C_Init()、I2C_Mem_Write()、I2C_Mem_Read()等。其中，I2C_Init()函数用于初始化I2C总线，设置传输模式、速率等参数；I2C_Mem_Write()和I2C_Mem_Read()函数用于在指定的设备地址下，读写指定的寄存器。 此外，STM32 HAL I2C库还提供了一些高级函数，如I2C_Master_Transmit()、I2C_Master_Receive()、I2C_Slave_Transmit()、I2C_Slave_Receive()等，可以方便地实现主从模式的通信。 总之，STM32 HAL I2C库提供了方便快捷的API接口，简化了I2C总线操作过程，使得开发者可以更加专注于应用程序的开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值