第07章硬件接口层

约 3267 字大约 11 分钟

2026-02-03

7.1 电机模块

① 电机驱动芯片 BDR6120S

② 原理图

③ 代码

Int_BDR6120S.h

#ifndef __INT_BDR6120S_H__
#define __INT_BDR6120S_H__

#include "driver/gpio.h"
#include "esp_task.h"

#define BDR6120S_INTA GPIO_NUM_4
#define BDR6120S_INTB GPIO_NUM_5

/**
 * @brief 初始化BDR6120S
 * 
 */
void Int_BDR6120S_Init(void);

/**
 * @brief 开锁
 * 
 */
void Int_BDR6120S_OpenLock(void);


#endif /* __INT_BDR6120S_H__ */

Int_BDR6120S.c

#include "Int_BDR6120S.h"

// 静态函数：电机前进
static void Int_BDR6120S_Forward(void)
{
    gpio_set_level(BDR6120S_INTA, 1);
    gpio_set_level(BDR6120S_INTB, 0);
}

// 静态函数：电机后退
static void Int_BDR6120S_Backward(void)
{
    gpio_set_level(BDR6120S_INTA, 0);
    gpio_set_level(BDR6120S_INTB, 1);
}

// 静态函数：电机刹车
static void Int_BDR6120S_Brake(void)
{
    gpio_set_level(BDR6120S_INTA, 1);
    gpio_set_level(BDR6120S_INTB, 1);
}


/**
 * @brief 初始化BDR6120S
 * 
 */
void Int_BDR6120S_Init(void)
{
    // 1. 设置 GPIO
    // 创建gpio配置结构体
    gpio_config_t io_conf = {};
    // 关闭中断
    io_conf.intr_type = GPIO_INTR_DISABLE;
    // 设置为输出模式
    io_conf.mode = GPIO_MODE_OUTPUT;
    // 选择引脚
    io_conf.pin_bit_mask = (1 << BDR6120S_INTA) | (1 << BDR6120S_INTB);
    // 关闭下拉
    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
    // 关闭上拉
    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
    // 配置GPIO
    gpio_config(&io_conf);

    // 2. 设置电机初始状态(两个引脚拉低)
    gpio_set_level(BDR6120S_INTA, 0);
    gpio_set_level(BDR6120S_INTB, 0);

}

/**
 * @brief 开锁
 * 
 */
void Int_BDR6120S_OpenLock(void)
{
    // 1. 电机正转，保持200ms
    Int_BDR6120S_Forward();
    vTaskDelay(200);

    // 2. 电机刹车
    Int_BDR6120S_Brake();

    // 3. 保持5 让用户拉开门
    vTaskDelay(5000);

    // 4. 电机反转，保持200ms
    Int_BDR6120S_Backward();
    vTaskDelay(200);

    // 5. 电机刹车
    Int_BDR6120S_Brake();

}

main.c 测试验证

#include <stdio.h>
#include "Com_Debug.h"
#include "Int_BDR6120S.h"

void app_main(void)
{
    MY_LOGI("Smart Lock Project: BDR6120S");

    // 1. 初始化BDR6120S
    Int_BDR6120S_Init();
     // 2. 开锁
    Int_BDR6120S_OpenLock();

    while (1)
    {
        vTaskDelay(1000);
    }
}

7.2 语音模块

① 语音芯片 WTN6170

商品链接

② 原理图

③ 代码

Int_WTN6170.h

#ifndef __INT_WTN6170_H__
#define __INT_WTN6170_H__

#include "esp_task.h"
#include "sys/unistd.h"
#include "driver/gpio.h"

// 宏定义引脚
#define WIN6170_DATA_PIN GPIO_NUM_9
// 宏定义拉高和拉低引脚
#define WIN6170_DATA_PIN_H gpio_set_level(WIN6170_DATA_PIN, 1)
#define WIN6170_DATA_PIN_L gpio_set_level(WIN6170_DATA_PIN, 0)

/**
 * @brief 初始化WTN6170语音模块
 * 
 */
void Int_WTN6170_Init(void);

/**
 * @brief 发送命令
 * 
 * @param cmd 命令字节
 */
void Int_WTN6170_SendCmd(uint8_t cmd);


#endif /* __INT_WTN6170_H__ */

Int_WTN6170.c

#include "Int_WTN6170.h"

/**
 * @brief 初始化WTN6170语音模块
 * 
 */
void Int_WTN6170_Init(void)
{
    // 1. 设置GPIO -------------------------------
    // 初始化配置结构体
    gpio_config_t io_conf = {};
    // 禁用中断
    io_conf.intr_type = GPIO_INTR_DISABLE;
    // 设置为输出模式
    io_conf.mode = GPIO_MODE_OUTPUT;
    // 设置引脚位掩码（注意：ESP32-C3使用64位掩码）
    io_conf.pin_bit_mask = (1 << WIN6170_DATA_PIN);
    // 禁用下拉电阻
    io_conf.pull_down_en = 0;
    // 禁用上拉电阻
    io_conf.pull_up_en = 0;
    // 使用给定配置配置GPIO
    gpio_config(&io_conf);

    // 2. 拉高数据引脚，处于空闲状态
    WIN6170_DATA_PIN_H;

    // 3. 上电初始化需要时间，延时200ms
    vTaskDelay(200);

}

/**
 * @brief 发送命令
 * 
 * @param cmd 命令字节
 */
void Int_WTN6170_SendCmd(uint8_t cmd)
{
    // 拉低数据引脚，并延时4~20ms，这里延时10ms
    WIN6170_DATA_PIN_L;
    vTaskDelay(10);

    // 逐bit发送命令，先发低位
    for (uint8_t i = 0; i < 8; i++)
    {
        // 判断当前最低位，如果是1，拉高数据引脚
        if (cmd & 0x01)
        {
            // 高电平，持续600us
            WIN6170_DATA_PIN_H;
            usleep(600);
            // 低电平，持续200us
            WIN6170_DATA_PIN_L;
            usleep(200);
        }
        // 当前最低位，如果是0，拉低数据引脚
        else
        {
            // 高电平，持续200us
            WIN6170_DATA_PIN_H;
            usleep(200);
            // 低电平，持续600us
            WIN6170_DATA_PIN_L;
            usleep(600);
        }

        // 右移1为，将已经发出的位移走
        cmd >>= 1;
    }

    // 拉高数据引脚，并延时5ms
    WIN6170_DATA_PIN_H;
    vTaskDelay(5);
}

main.c 测试验证

#include <stdio.h>
#include "Com_Debug.h"
#include "Int_WTN6170.h"

void app_main(void)
{
    MY_LOGI("Smart Lock Project: WTN6170 Test");

    // 1. 初始化语音芯片
    Int_WTN6170_Init();

    // 2. 发送连码指令
   	Int_WTN6170_SendCmd(0xF3);
    Int_WTN6170_SendCmd(99);
    Int_WTN6170_SendCmd(0xF3);
    Int_WTN6170_SendCmd(100);

    // // 2. 发送连码指令
    // sayWithoutInt();
    // sayDoorOpen();
    // sayWithoutInt();
    // sayDoorClose();
    // sayWithoutInt();
    // sayNum(5);

    while (1)
    {
        vTaskDelay(1000);
    }    
}

7.3 按键模块

① 触摸芯片 SC12B

商品链接

② 原理图

③ 旧版 I2C Example

4.x版本的Example地址

④ 代码

Int_SC12B.h

#ifndef __INT_SC12B_H__
#define __INT_SC12B_H__

#include "esp_task.h"
#include "driver/gpio.h"
#include "driver/i2c.h"

// 宏定义 定义引脚
#define SC12B_INT_PIN GPIO_NUM_0
#define SC12B_I2C_SCL_PIN GPIO_NUM_1
#define SC12B_I2C_SDA_PIN GPIO_NUM_2

// 宏定义 SC12B I2C 地址
#define SC12B_I2C_ADDR 0x42

// 定义枚举类型，表示1~12个按键
typedef enum
{
    Touch_Key_0,
    Touch_Key_1,
    Touch_Key_2,
    Touch_Key_3,
    Touch_Key_4,
    Touch_Key_5,
    Touch_Key_6,
    Touch_Key_7,
    Touch_Key_8,
    Touch_Key_9,
    Touch_Key_SHARP,
    Touch_Key_M,
    Touch_Key_NONE,
} Touch_Key_Typedef;


/**
 * @brief 初始化SC12B
 * 
 */
void Int_SC12B_Init(void);

/**
 * @brief 读取被按下的按键
 * 
 * @return Touch_Key_Typedef 被按下的按键值 
 */
Touch_Key_Typedef Int_SC12B_ReadKey(void);

#endif /* __INT_SC12B_H__ */

Int_SC12B.c

#include "Int_SC12B.h"

// 定义I2C主控制器端口号，使用预定义的I2C_MASTER_NUM（通常为I2C_NUM_0或I2C_NUM_1）
int i2c_master_port = I2C_NUM_0;

// 静态函数：读寄存器
static uint8_t Int_SC12B_ReadReg(uint8_t reg_addr)
{
    uint8_t rx_data = 0;
    i2c_master_write_read_device(i2c_master_port, SC12B_I2C_ADDR, &reg_addr, 1, &rx_data, 1, 1000);
    return rx_data;
}

// 静态函数：写寄存器
static void Int_SC12B_WriteReg(uint8_t reg_addr, uint8_t data)
{
    uint8_t write_buf[2] = {reg_addr, data};
    i2c_master_write_to_device(i2c_master_port, SC12B_I2C_ADDR, write_buf, 2, 1000);
}

// 静态函数：作为中断服务函数
static void Int_SC12B_ISR_Handler(void *arg)
{
  is_key_pressed = 1;
}


/**
 * @brief 初始化SC12B
 *
 */
void Int_SC12B_Init(void)
{
    // 1 I2C 初始化设置 -----------------------------------
    // 1.1 定义I2C主控制器端口号(已定义全局变量)
    // 1.2 配置I2C主控制器参数的结构体
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,             // 设置为I2C主模式
        .sda_io_num = SC12B_I2C_SDA_PIN,     // SDA数据线使用的GPIO引脚号
        .scl_io_num = SC12B_I2C_SCL_PIN,     // SCL时钟线使用的GPIO引脚号
        .sda_pullup_en = GPIO_PULLUP_ENABLE, // 使能SDA上拉电阻，确保空闲时为高电平
        .scl_pullup_en = GPIO_PULLUP_ENABLE, // 使能SCL上拉电阻，确保空闲时为高电平
        .master.clk_speed = 400000,          // I2C总线时钟频率（通常为100kHz或400kHz）
    };
    // 1.3 使用配置参数初始化I2C控制器
    i2c_param_config(i2c_master_port, &conf);
    // 1.4 安装I2C驱动：
    // 参数1: I2C端口号
    // 参数2: 工作模式（主模式）
    // 参数3: 接收缓冲区大小（禁用RX缓冲区）
    // 参数4: 发送缓冲区大小（禁用TX缓冲区）
    // 参数5: 中断分配标志（0表示使用默认中断分配）
    i2c_driver_install(i2c_master_port, conf.mode, 0, 0, 0);

    // 2. 延时 300ms -----------------------
    vTaskDelay(300);

    // 3. 设置按键灵敏度 ------------------------------
    Int_SC12B_WriteReg(0x00, 0x15);
    Int_SC12B_WriteReg(0x01, 0x15);
}

/**
 * @brief 读取被按下的按键
 *
 * @return Touch_Key_Typedef 被按下的按键值
 */
Touch_Key_Typedef Int_SC12B_ReadKey(void)
{
    // 1. 读按键状态寄存器
    uint8_t key_status1 = Int_SC12B_ReadReg(0x08);
    uint8_t key_status2 = Int_SC12B_ReadReg(0x09);
    uint16_t key_status = (key_status1 << 8) | key_status2;

    // 2. 判断按键状态
    Touch_Key_Typedef touch_key = Touch_Key_NONE;
    switch (key_status)
    {
    case 0x8000:
        touch_key = Touch_Key_0;
        break;
    case 0x4000:
        touch_key = Touch_Key_1;
        break;
    case 0x2000:
        touch_key = Touch_Key_2;
        break;
    case 0x1000:
        touch_key = Touch_Key_3;
        break;
    case 0x0800:
        touch_key = Touch_Key_7;
        break;
    case 0x0400:
        touch_key = Touch_Key_5;
        break;
    case 0x0200:
        touch_key = Touch_Key_6;
        break;
    case 0x0100:
        touch_key = Touch_Key_4;
        break;
    case 0x0080:
        touch_key = Touch_Key_M;
        break;
    case 0x0040:
        touch_key = Touch_Key_8;
        break;
    case 0x0020:
        touch_key = Touch_Key_9;
        break;
    case 0x0010:
        touch_key = Touch_Key_SHARP;
        break;
    default:
        break;
    }

    // 返回
    return touch_key;
}

mian.c 测试代码

#include <stdio.h>
#include "Com_Debug.h"
#include "Int_SC12B.h"

void app_main(void)
{
    MY_LOGI("Smart Lock Project: SC12B");

     // 1. 初始化SC12B
    Int_SC12B_Init();

    while (1)
    {
        // 读取按键
        Touch_Key touchKey = Int_SC12B_ReadKey();
        if (touchKey != KEY_NO)
        {
            printf("touchKey = %d\r\n", touchKey);
        }
        vTaskDelay(10);
    }
}

⑤ 代码进阶（添加中断）

Int_SC12B.h

添加如下代码：

/* 代码省略 ... */

/**
 * @brief 返回被按下的按键，要求被轮询调用
 * 
 * @return Touch_Key_Typedef 被按下的按键值
 */
Touch_Key_Typedef Int_SC12B_TouchKey(void);

Int_SC12B.c

添加如下代码：

// 静态函数：作为中断服务函数
static void Int_SC12B_ISR_Handler(void *arg)
{
  	is_key_pressed = 1;
}

/**
 * @brief 初始化SC12B
 *
 */
void Int_SC12B_Init(void)
{
	/* 代码省略 ... */
    
    // 4. 设置中断 -------------------------------------
    // 4.1 定义配置结构体
    gpio_config_t io_conf;
    // 4.2 设置配置项
    io_conf.intr_type = GPIO_INTR_POSEDGE;       // 配置GPIO引脚中断 - 上升沿触发
    io_conf.pin_bit_mask = (1 << SC12B_INT_PIN); // 设置引脚位掩码，选择要配置的GPIO引脚
    io_conf.mode = GPIO_MODE_INPUT;  // 设置GPIO工作模式为输入模式（因为我们要检测外部信号）
    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;  // 浮空，不使能内部上拉电阻
    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;  // 浮空，不使能内部下拉电阻
    // 4.3 应用GPIO配置
    gpio_config(&io_conf);
    // // 4.4 设置中断,使用上升沿
    // gpio_set_intr_type(SC12B_INT_PIN, GPIO_INTR_POSEDGE);
    // 4.4 开启中断
    gpio_install_isr_service(0);
    // 4.5 添加中断服务函数
    gpio_isr_handler_add(SC12B_INT_PIN, Int_SC12B_ISR_Handler, NULL);

}


/**
 * @brief 返回被按下的按键，要求被轮询调用
 * 
 * @return Touch_Key_Typedef 被按下的按键值
 */
Touch_Key_Typedef Int_SC12B_TouchKey(void)
{
    // 判断标志位，是否有按键被按下
    if (is_key_pressed)
    {
        // 清除标志位
        is_key_pressed = 0;

        // 获取被按下的按键值
        Touch_Key_Typedef touch_key = Int_SC12B_ReadKey();

        // 返回按键值
        return touch_key;
    }

    return Touch_Key_NONE;
}

mian.c 测试代码

#include <stdio.h>
#include "Com_Debug.h"
#include "Int_SC12B.h"
#include "Int_WTN6170.h"

void app_main(void)
{
    MY_LOGI("Smart Lock Project: SC12B Touch Key Test");

    // 1. 初始化SC12B
    Int_SC12B_Init();
    // 2. 初始化WTN6170
    Int_WTN6170_Init();

    while (1)
    {
        // 读取按键状态
        Touch_Key_Typedef touch_key = Int_SC12B_TouchKey();
        if (touch_key != Touch_Key_NONE)
        {
            printf("Touch Key: %d \r\n", touch_key);
            sayWithoutInt();
            if (touch_key < 10)
            {
                sayNum(touch_key);
            }
        }

        // 阻塞延时
        vTaskDelay(10);
    }
}

7.4 全色灯模块

WS2812B-2020 商品链接

① The RMT Peripheral

RMT（Remote Control）模块是 ESP32 上的一个专用硬件外设，用于发送和接收可配置的脉冲信号，特别适合处理需要精确时序控制的数字协议。

高精度定时：基于 80 MHz 或更高频率的时钟源，可生成 纳秒级精度 的脉冲。
自动波形生成：通过配置“数据项”（rmt_item32_t），由硬件自动输出复杂波形，无需 CPU 实时干预。
DMA 支持：可与内存直接交互，实现长序列数据的自动发送。
多通道支持：ESP32 有 8 个 RMT 通道（Channel 0~7），可同时控制多个设备。

② 灯带的通信协议特点

像 WS2812 / NeoPixel 这类灯带使用的是单线异步串行协议，其通信依赖于极其精确的高低电平时间来表示 0 和 1：

位值	高电平时间	低电平时间	总周期
`0`	~0.4 μs	~0.85 μs	~1.25 μs
`1`	~0.8 μs	~0.45 μs	~1.25 μs

RMT 模块通过硬件级定时和预定义波形单元来完美匹配这种协议

③ 原理图

④ 使用 ESP32 组件库

下载地址

https://components.espressif.com/

搜索

选择组件

安装命令

安装

下载

⑤ 代码

Int_WS2812.h

#ifndef __INT_WS2812_H__
#define __INT_WS2812_H__

#include "driver/gpio.h"
#include "led_strip.h"

// 宏定义：设置引脚
#define WS2812_PIN GPIO_NUM_6
// 宏定义：LED 数量
#define LED_STRIP_LED_COUNT 12
// 宏定义：RMT 时钟频率（通常 10MHz）
#define LED_STRIP_RMT_RES_HZ  (10 * 1000 * 1000)

// extern 声明全局变量
extern uint8_t black[3];
extern uint8_t white[3];
extern uint8_t red[3];
extern uint8_t green[3];
extern uint8_t blue[3];
extern uint8_t cyan[3];   /* 青色 */
extern uint8_t purple[3]; /* 紫色 */

/**
 * @brief 初始化WS2812 LED strip
 * 
 */
void Int_WS2812_Init(void);

/**
 * @brief 打开指定LED
 * 
 * @param led_index LED 索引，0~11
 * @param r 红色分量（0-255）
 * @param g 绿色分量（0-255）
 * @param b 蓝色分量（0-255）
 */
void Int_WS2812_On(uint8_t led_index, uint8_t r, uint8_t g, uint8_t b);

/**
 * @brief 关闭所有LED
 * 
 */
void Int_WS2812_Off(void);


#endif /* __INT_WS2812_H__ */

Int_WS2812.c

#include "Int_WS2812.h"

// 定义 LED strip 句柄
led_strip_handle_t led_strip;

/* 定义几种常见颜色 RGB */
uint8_t black[3] = {0, 0, 0};
uint8_t white[3] = {255, 255, 255};
uint8_t red[3] = {255, 0, 0};
uint8_t green[3] = {0, 255, 0};
uint8_t blue[3] = {0, 0, 255};
uint8_t cyan[3] = {0, 255, 255};   /* 青色 */
uint8_t purple[3] = {255, 0, 255}; /* 紫色 */

/**
 * @brief 初始化WS2812 LED strip
 *
 */
void Int_WS2812_Init(void)
{
    // 1. 配置 GPIO
    led_strip_config_t strip_config = {
        .strip_gpio_num = WS2812_PIN,                                // GPIO 引脚号
        .max_leds = LED_STRIP_LED_COUNT,                             // LED 数量
        .led_model = LED_MODEL_WS2812,                               // LED 型号
        .color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_RGB, // 颜色顺序
        .flags = {
            .invert_out = false, // 是否反转输出信号
        }};

    // 2. 配置 RMT
    led_strip_rmt_config_t rmt_config = {
        .clk_src = RMT_CLK_SRC_DEFAULT,                    // 时钟源
        .resolution_hz = LED_STRIP_RMT_RES_HZ,             // RMT 时钟频率（通常 10MHz）
        .mem_block_symbols = 0,                             // RMT 内存块大小
        .flags = {
            .with_dma = 0, // 是否使用 DMA
        }};

    // 3. 创建 LED strip 设备
    led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip);

}

/**
 * @brief 打开指定LED
 * 
 * @param led_index LED 索引，0~11
 * @param r 红色分量（0-255）
 * @param g 绿色分量（0-255）
 * @param b 蓝色分量（0-255）
 */
void Int_WS2812_On(uint8_t led_index, uint8_t r, uint8_t g, uint8_t b)
{
    // 设置颜色
    led_strip_set_pixel(led_strip, led_index, r, g, b);
    // 刷新 LED strip
    led_strip_refresh(led_strip);
}

/**
 * @brief 关闭所有LED
 * 
 */
void Int_WS2812_Off(void)
{
    // 关闭所有 LED
    led_strip_clear(led_strip);
    // 刷新 LED strip
    led_strip_refresh(led_strip);

}

main.c 测试代码

#include <stdio.h>
#include "Com_Debug.h"
#include "Int_BDR6120S.h"
#include "Int/Int_WTN6170.h"
#include "Int_SC12B.h"
#include "Int_WS2812.h"

void app_main(void)
{
    

    // Ws2812初始化
    Int_WS2812_Init();

    Int_WS2812_LedOn(5, red);
    vTaskDelay(2000);
    Int_WS2812_LedOn(7, blue);
    vTaskDelay(2000);
    Int_WS2812_LedOn(0, white);
    vTaskDelay(2000);

    while (1)
    {
    }
}

第07章 硬件接口层

第07章硬件接口层