代码收藏家技术教程 2025-02-17

STMicroelectronics 系列：STM32G0 系列_（19）.STM32G0系列的应用示例

STM32G0系列的应用示例

在上一节中，我们讨论了STM32G0系列的基本特性及其在不同场景中的应用潜力。本节将通过具体的应用示例，进一步展示STM32G0系列的使用方法和实际效果。我们将涵盖以下几个方面：

基本LED闪烁
按钮输入检测
UART通信
ADC数据采集
I2C通信
SPI通信
定时器应用
PWM输出
RTC时钟应用
外部中断

1. 基本LED闪烁

原理

LED闪烁是最基本的单片机应用之一，用于验证硬件连接和基本的GPIO操作。STM32G0系列的GPIO端口可以轻松地控制LED的亮灭，通过定时器或其他方法实现LED的闪烁。

内容

硬件准备

STM32G0开发板

LED

限流电阻

硬件连接

将LED的阳极通过限流电阻连接到STM32G0开发板的一个GPIO引脚（例如PA5），LED的阴极连接到地。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// 定义LED控制的GPIO引脚

#define LED_PIN GPIO_PIN_5

#define LED_PORT GPIOA



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_TIM2_Init(void);



// 主函数

int main(void)

{

    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化定时器

    MX_TIM2_Init();



    // 启动定时器

    HAL_TIM_Base_Start_IT(&htim2);



    // 进入无限循环

    while (1)

    {

        // 主循环可以执行其他任务

    }

}



// 定时器中断处理函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

    // 检查中断来自定时器2

    if (htim->Instance == TIM2)

    {

        // 切换LED状态

        HAL_GPIO_TogglePin(LED_PORT, LED_PIN);

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA5为输出模式

    GPIO_InitStruct.Pin = LED_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);

}



// 初始化定时器

static void MX_TIM2_Init(void)

{

    TIM_HandleTypeDef htim2;



    // 配置定时器2

    htim2.Instance = TIM2;

    htim2.Init.Prescaler = 8000 - 1; // 8MHz / 8000 = 1kHz

    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

    htim2.Init.Period = 1000 - 1; // 1秒

    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

    htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

    if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

    {

        // 初始化错误处理

        Error_Handler();

    }



    // 配置定时器中断

    if (HAL_TIM_Base_Start_IT(&htim2) != HAL_OK)

    {

        // 启动定时器中断失败处理

        Error_Handler();

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的GPIO和定时器来实现LED的闪烁。主要步骤如下：

初始化GPIO：将PA5配置为推挽输出模式。
初始化定时器：配置定时器2，使其每1秒产生一次中断。
定时器中断处理：在定时器中断处理函数中切换LED的状态。

2. 按钮输入检测

原理

按钮输入检测是另一种常见的单片机应用，用于实现用户交互。STM32G0系列的GPIO端口可以配置为输入模式，通过读取GPIO引脚的状态来检测按钮的按压。

内容

硬件准备

STM32G0开发板

按钮

限流电阻

硬件连接

将按钮的一端连接到STM32G0开发板的一个GPIO引脚（例如PA0），另一端连接到地。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// 定义按钮控制的GPIO引脚

#define BUTTON_PIN GPIO_PIN_0

#define BUTTON_PORT GPIOA



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);



// 主函数

int main(void)

{

    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 进入无限循环

    while (1)

    {

        // 检测按钮状态

        if (HAL_GPIO_ReadPin(BUTTON_PORT, BUTTON_PIN) == GPIO_PIN_RESET)

        {

            // 按钮被按下

            HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); // 切换LED状态

            HAL_Delay(200); // 延时200ms，防止按钮抖动

        }

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA0为输入模式

    GPIO_InitStruct.Pin = BUTTON_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    HAL_GPIO_Init(BUTTON_PORT, &GPIO_InitStruct);



    // 配置PA5为输出模式

    GPIO_InitStruct.Pin = GPIO_PIN_5;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的GPIO端口检测按钮的按压。主要步骤如下：

初始化GPIO：将PA0配置为输入模式，PA5配置为输出模式。
主循环：在主循环中读取PA0引脚的状态，如果按钮被按下，则切换PA5引脚的LED状态，并延时200ms以防止按钮抖动。

3. UART通信

原理

UART（通用异步收发传输器）用于实现单片机之间的串行通信。STM32G0系列集成了多个UART接口，可以通过配置这些接口实现不同波特率的通信。

内容

硬件准备

STM32G0开发板

串口调试助手

串口线

硬件连接

将STM32G0开发板的UART引脚（例如USART1的TX和RX）连接到串口调试助手。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// UART配置

#define UART1_TX_PIN GPIO_PIN_9

#define UART1_RX_PIN GPIO_PIN_10

#define UART1_PORT GPIOA

#define UART1_BAUDRATE 9600



UART_HandleTypeDef huart1;



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_USART1_UART_Init(void);



// 主函数

int main(void)

{

    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化UART

    MX_USART1_UART_Init();



    // 发送初始消息

    HAL_UART_Transmit(&huart1, (uint8_t*)"UART Communication Example\r\n", 27, HAL_MAX_DELAY);



    // 进入无限循环

    while (1)

    {

        // 发送消息

        HAL_UART_Transmit(&huart1, (uint8_t*)"Hello, World!\r\n", 14, HAL_MAX_DELAY);

        HAL_Delay(1000); // 延时1秒

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA9为UART1_TX

    GPIO_InitStruct.Pin = UART1_TX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);



    // 配置PA10为UART1_RX

    GPIO_InitStruct.Pin = UART1_RX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);

}



// 初始化UART

static void MX_USART1_UART_Init(void)

{

    huart1.Instance = USART1;

    huart1.Init.BaudRate = UART1_BAUDRATE;

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

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的USART1实现UART通信。主要步骤如下：

初始化GPIO：将PA9和PA10配置为USART1的TX和RX引脚。
初始化UART：配置USART1的波特率为9600，并设置其他通信参数。
主循环：在主循环中周期性地发送字符串“Hello, World!”，并通过串口调试助手进行验证。

4. ADC数据采集

原理

ADC（模数转换器）用于将模拟信号转换为数字信号。STM32G0系列集成了高性能的ADC，可以通过配置这些接口实现精确的数据采集。ADC在许多应用中非常有用，例如读取传感器数据、测量电压等。

内容

硬件准备

STM32G0开发板

电位器

电阻分压器（可选）

硬件连接

将电位器的中间引脚连接到STM32G0开发板的一个ADC引脚（例如PA0）。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// ADC配置

#define ADC1_CHANNEL 0

#define ADC1_PIN GPIO_PIN_0

#define ADC1_PORT GPIOA



// UART配置

#define UART1_TX_PIN GPIO_PIN_9

#define UART1_RX_PIN GPIO_PIN_10

#define UART1_PORT GPIOA

#define UART1_BAUDRATE 9600



ADC_HandleTypeDef hadc1;

UART_HandleTypeDef huart1;



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_ADC1_Init(void);

static void MX_USART1_UART_Init(void);



// 主函数

int main(void)

{

    uint32_t adc_value = 0;



    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化ADC

    MX_ADC1_Init();



    // 初始化UART

    MX_USART1_UART_Init();



    // 发送初始消息

    HAL_UART_Transmit(&huart1, (uint8_t*)"ADC Data Acquisition Example\r\n", 31, HAL_MAX_DELAY);



    // 进入无限循环

    while (1)

    {

        // 启动ADC转换

        HAL_ADC_Start(&hadc1);



        // 等待ADC转换完成

        if (HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY) == HAL_OK)

        {

            // 获取ADC转换结果

            adc_value = HAL_ADC_GetValue(&hadc1);



            // 通过UART发送ADC值

            char buffer[32];

            sprintf(buffer, "ADC Value: %lu\r\n", adc_value);

            HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);

        }



        // 延时1秒

        HAL_Delay(1000);

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA0为模拟输入

    GPIO_InitStruct.Pin = ADC1_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    HAL_GPIO_Init(ADC1_PORT, &GPIO_InitStruct);



    // 配置PA9为UART1_TX

    GPIO_InitStruct.Pin = UART1_TX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);



    // 配置PA10为UART1_RX

    GPIO_InitStruct.Pin = UART1_RX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);

}



// 初始化ADC

static void MX_ADC1_Init(void)

{

    ADC_ChannelConfTypeDef sConfig = {0};



    // 使能ADC1时钟

    __HAL_RCC_ADC1_CLK_ENABLE();



    // 初始化ADC1

    hadc1.Instance = ADC1;

    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;

    hadc1.Init.ContinuousConvMode = DISABLE;

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

    }



    // 配置ADC通道

    sConfig.Channel = ADC1_CHANNEL;

    sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;

    sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;

    if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)

    {

        // 通道配置错误处理

        Error_Handler();

    }

}



// 初始化UART

static void MX_USART1_UART_Init(void)

{

    huart1.Instance = USART1;

    huart1.Init.BaudRate = UART1_BAUDRATE;

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

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的ADC和UART实现数据采集并发送。主要步骤如下：

初始化GPIO：将PA0配置为模拟输入模式，PA9和PA10配置为USART1的TX和RX引脚。
初始化ADC：配置ADC1，使其在软件触发模式下进行单通道转换。
初始化UART：配置USART1，使其以9600波特率进行通信。
主循环：在主循环中启动ADC转换，等待转换完成，获取ADC值并通过UART发送，每1秒发送一次。

5. I2C通信

原理

I2C（Inter-Integrated Circuit）是一种串行通信协议，用于在单片机和外部设备之间进行简单的双向数据传输。STM32G0系列支持多个I2C接口，可以通过配置这些接口实现与各种I2C设备的通信。

内容

硬件准备

STM32G0开发板

I2C设备（例如温度传感器）

上拉电阻

硬件连接

将I2C设备的SDA和SCL引脚分别连接到STM32G0开发板的I2C引脚（例如PB7和PB6）。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// I2C配置

#define I2C1_SCL_PIN GPIO_PIN_6

#define I2C1_SDA_PIN GPIO_PIN_7

#define I2C1_PORT GPIOB

#define I2C1_SPEED 100000 // 100kHz



I2C_HandleTypeDef hi2c1;



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_I2C1_Init(void);



// 主函数

int main(void)

{

    uint8_t data[1] = {0};

    uint8_t device_address = 0x48; // 假设设备地址为0x48



    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化I2C

    MX_I2C1_Init();



    // 进入无限循环

    while (1)

    {

        // 读取I2C设备数据

        if (HAL_I2C_Master_Receive(&hi2c1, device_address << 1, data, 1, HAL_MAX_DELAY) == HAL_OK)

        {

            // 通过UART发送I2C数据

            char buffer[32];

            sprintf(buffer, "I2C Data: 0x%02X\r\n", data[0]);

            HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);

        }



        // 延时1秒

        HAL_Delay(1000);

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOB时钟

    __HAL_RCC_GPIOB_CLK_ENABLE();



    // 配置PB6为I2C1_SCL

    GPIO_InitStruct.Pin = I2C1_SCL_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;

    GPIO_InitStruct.Pull = GPIO_PULLUP;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF6_I2C1;

    HAL_GPIO_Init(I2C1_PORT, &GPIO_InitStruct);



    // 配置PB7为I2C1_SDA

    GPIO_InitStruct.Pin = I2C1_SDA_PIN;

    GPIO_InitStruct.Alternate = GPIO_AF6_I2C1;

    HAL_GPIO_Init(I2C1_PORT, &GPIO_InitStruct);



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA9为UART1_TX

    GPIO_InitStruct.Pin = UART1_TX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);



    // 配置PA10为UART1_RX

    GPIO_InitStruct.Pin = UART1_RX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);

}



// 初始化I2C

static void MX_I2C1_Init(void)

{

    hi2c1.Instance = I2C1;

    hi2c1.Init.Timing = 0x20909CEC; // 100kHz

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

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的I2C接口读取外部设备的数据并通过UART发送。主要步骤如下：

初始化GPIO：将PB6和PB7配置为I2C1的SCL和SDA引脚，PA9和PA10配置为USART1的TX和RX引脚。
初始化I2C：配置I2C1，使其以100kHz的波特率进行通信。
初始化UART：配置USART1，使其以9600波特率进行通信。
主循环：在主循环中读取I2C设备的数据，如果读取成功，则通过UART发送数据，每1秒读取一次。

6. SPI通信

原理

SPI（Serial Peripheral Interface）是一种同步串行通信协议，用于在单片机和外部设备之间进行高速数据传输。STM32G0系列支持多个SPI接口，可以通过配置这些接口实现与各种SPI设备的通信，如DAC、ADC、传感器等。

内容

硬件准备

STM32G0开发板

SPI设备（例如DAC）

限流电阻

硬件连接

将SPI设备的MOSI、MISO、SCLK和CS引脚分别连接到STM32G0开发板的SPI引脚（例如PA7、PA6、PA5和PA4）。

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// SPI配置

#define SPI1_SCK_PIN GPIO_PIN_5

#define SPI1_MISO_PIN GPIO_PIN_6

#define SPI1_MOSI_PIN GPIO_PIN_7

#define SPI1_CS_PIN GPIO_PIN_4

#define SPI1_PORT GPIOA



// UART配置

#define UART1_TX_PIN GPIO_PIN_9

#define UART1_RX_PIN GPIO_PIN_10

#define UART1_PORT GPIOA

#define UART1_BAUDRATE 9600



SPI_HandleTypeDef hspi1;

UART_HandleTypeDef huart1;



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_SPI1_Init(void);

static void MX_USART1_UART_Init(void);



// 主函数

int main(void)

{

    uint8_t data = 0x55; // 假设要发送的数据

    uint8_t received_data = 0;



    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化SPI

    MX_SPI1_Init();



    // 初始化UART

    MX_USART1_UART_Init();



    // 发送初始消息

    HAL_UART_Transmit(&huart1, (uint8_t*)"SPI Communication Example\r\n", 27, HAL_MAX_DELAY);



    // 进入无限循环

    while (1)

    {

        // 使能CS引脚

        HAL_GPIO_WritePin(SPI1_PORT, SPI1_CS_PIN, GPIO_PIN_RESET);



        // 发送数据

        HAL_SPI_Transmit(&hspi1, &data, 1, HAL_MAX_DELAY);



        // 接收数据

        HAL_SPI_Receive(&hspi1, &received_data, 1, HAL_MAX_DELAY);



        // 禁用CS引脚

        HAL_GPIO_WritePin(SPI1_PORT, SPI1_CS_PIN, GPIO_PIN_SET);



        // 通过UART发送接收到的数据

        char buffer[32];

        sprintf(buffer, "SPI Received Data: 0x%02X\r\n", received_data);

        HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);



        // 延时1秒

        HAL_Delay(1000);

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA4为SPI1_CS

    GPIO_InitStruct.Pin = SPI1_CS_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



    // 配置PA5为SPI1_SCK

    GPIO_InitStruct.Pin = SPI1_SCK_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



    // 配置PA6为SPI1_MISO

    GPIO_InitStruct.Pin = SPI1_MISO_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



    // 配置PA7为SPI1_MOSI

    GPIO_InitStruct.Pin = SPI1_MOSI_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);



    // 配置PA9为UART1_TX

    GPIO_InitStruct.Pin = UART1_TX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);



    // 配置PA10为UART1_RX

    GPIO_InitStruct.Pin = UART1_RX_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);

}



// 初始化SPI

static void MX_SPI1_Init(void)

{

    hspi1.Instance = SPI1;

    hspi1.Init.Mode = SPI_MODE_MASTER;

    hspi1.Init.Direction = SPI_DIRECTION_2LINES;

    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;

    hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;

    hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;

    hspi1.Init.NSS = SPI_NSS_SOFT;

    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;

    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;

    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;

    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;

    hspi1.Init.CRCPolynomial = 7;

    hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;

    hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;

    if (HAL_SPI_Init(&hspi1) != HAL_OK)

    {

        // 初始化错误处理

        Error_Handler();

    }

}



// 初始化UART

static void MX_USART1_UART_Init(void)

{

    huart1.Instance = USART1;

    huart1.Init.BaudRate = UART1_BAUDRATE;

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

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的SPI接口与外部设备进行通信，并通过UART发送接收到的数据。主要步骤如下：

初始化GPIO：将PA4配置为SPI1的CS引脚，PA5配置为SPI1的SCK引脚，PA6配置为SPI1的MISO引脚，PA7配置为SPI1的MOSI引脚。同时，将PA9和PA10配置为USART1的TX和RX引脚。
初始化SPI：配置SPI1为主模式，设置通信参数，如数据大小、时钟极性、时钟相位等。
初始化UART：配置USART1，使其以9600波特率进行通信。
主循环：在主循环中，使能CS引脚，发送数据，接收数据，禁用CS引脚，然后通过UART发送接收到的数据，每1秒进行一次通信。

7. 定时器应用

原理

定时器是单片机中常用的外设，用于生成定时中断或脉冲信号。STM32G0系列集成了多个定时器，可以通过配置这些定时器实现各种定时功能，如周期性任务、延时控制等。

内容

硬件准备

STM32G0开发板

软件开发

使用STM32CubeIDE进行开发，首先创建一个新的STM32项目，并选择对应的STM32G0系列芯片。

代码示例


// 包含必要的头文件

#include "stm32g0xx_hal.h"



// 定义LED控制的GPIO引脚

#define LED_PIN GPIO_PIN_5

#define LED_PORT GPIOA



// 定义定时器

TIM_HandleTypeDef htim2;



// 初始化函数

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_TIM2_Init(void);



// 主函数

int main(void)

{

    // 初始化HAL库

    HAL_Init();



    // 配置系统时钟

    SystemClock_Config();



    // 初始化GPIO

    MX_GPIO_Init();



    // 初始化定时器

    MX_TIM2_Init();



    // 启动定时器

    HAL_TIM_Base_Start_IT(&htim2);



    // 进入无限循环

    while (1)

    {

        // 主循环可以执行其他任务

    }

}



// 定时器中断处理函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

    // 检查中断来自定时器2

    if (htim->Instance == TIM2)

    {

        // 切换LED状态

        HAL_GPIO_TogglePin(LED_PORT, LED_PIN);

    }

}



// 初始化GPIO

static void MX_GPIO_Init(void)

{

    GPIO_InitTypeDef GPIO_InitStruct = {0};



    // 使能GPIOA时钟

    __HAL_RCC_GPIOA_CLK_ENABLE();



    // 配置PA5为输出模式

    GPIO_InitStruct.Pin = LED_PIN;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);

}



// 初始化定时器

static void MX_TIM2_Init(void)

{

    TIM_HandleTypeDef htim2;



    // 配置定时器2

    htim2.Instance = TIM2;

    htim2.Init.Prescaler = 8000 - 1; // 8MHz / 8000 = 1kHz

    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

    htim2.Init.Period = 1000 - 1; // 1秒

    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

    htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

    if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

    {

        // 初始化错误处理

        Error_Handler();

    }



    // 配置定时器中断

    if (HAL_TIM_Base_Start_IT(&htim2) != HAL_OK)

    {

        // 启动定时器中断失败处理

        Error_Handler();

    }

}



// 系统时钟配置

void SystemClock_Config(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};



    // 配置HSE时钟

    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 = 1;

    RCC_OscInitStruct.PLL.PLLN = 8;

    RCC_OscInitStruct.PLL.PLLP = 2;

    RCC_OscInitStruct.PLL.PLLQ = 7;

    if (HAL_RCC_OscInit(&RCC_OscInitStruct) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }



    // 配置系统时钟

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)

    {

        // 时钟配置错误处理

        Error_Handler();

    }

}



// 错误处理函数

void Error_Handler(void)

{

    // 无限循环，等待中断

    while (1)

    {

    }

}

描述

上述代码示例展示了如何使用STM32G0的定时器实现周期性任务。主要步骤如下：

初始化GPIO：将PA5配置为输出模式。
初始化定时器：配置定时器2，使其每1秒产生一次中断。
定时器中断处理：在定时器中断处理函数中切换PA5引脚的LED状态。
主循环：主循环中可以执行其他任务，定时器中断会周期性地切换LED状态。

作者：kkchenkx

物联沃分享整理
物联沃-IOTWORD物联网 » STMicroelectronics 系列：STM32G0 系列_（19）.STM32G0系列的应用示例

代码收藏家普通

分享到：

STM32G0系列的应用示例

1. 基本LED闪烁

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

2. 按钮输入检测

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

3. UART通信

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

4. ADC数据采集

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

5. I2C通信

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

6. SPI通信

原理

内容

硬件准备

硬件连接

软件开发

代码示例

描述

7. 定时器应用

原理

内容

硬件准备

软件开发

代码示例

描述

代码收藏家 普通

相关推荐

发表回复 取消回复

代码收藏家普通

发表回复取消回复