【家用智能仪表盘】esp32 s2 LED、按键驱动

pomin

【家用智能仪表盘】esp32 s2 LED、按键驱动 [复制链接]

# esp32 s2 LED、按键驱动

> ESP32-S2-Kaluga-1 开发板的 LED、按键驱动。

## ✨ led 驱动

- 硬件采用 GPIO45 来控制一个 WS2812 灯珠

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_637869" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=637869&handlekey=savephoto_637869">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

参照官方给出的控制WS2812的例程，完成板载WS2812颜色的控制，这部分程序是使用的led_strip的库，采用ESP32的RMT（红外线）驱动修改38kHz的频率到适合的频率来达到WS2812的百ns时序要求，总的流程就是：

1. RMT 配置创建
2. RMT 驱动安装
3. LED_STRIP 配置创建
4. LED_STRIP 驱动安装

后面采用HSV颜色模型和RGB色彩转换，将HSV中的H（色调）不断变化，来实现渐变色的颜色特效。

```c
/**
 * @author: Pomin
 * @date: 2022-08-27 22:33:39
 * @github: https://github.com/POMIN-163
 * @lastedit: 2022-08-28 22:35:55
 * @description: led
 **/
#include "app_init.h"
#include "driver/rmt.h"
#include "led_strip.h"

led_strip_t* strip;

#define TAG "led"

/**
 * <a href="https://bbs.eeworld.com.cn/home.php?mod=space&uid=159083" target="_blank">@brief</a> 初始化 WS2812 的管脚
 *
 * @param gpio_num
 * @param led_number
 * @param rmt_channel
 * <a href="https://bbs.eeworld.com.cn/home.php?mod=space&uid=784970" target="_blank">@return</a> esp_err_t
**/
esp_err_t rmt_init(uint8_t gpio_num, int led_number, uint8_t rmt_channel) {
  ESP_LOGI(TAG, "Initializing WS2812");
  rmt_config_t config = RMT_DEFAULT_CONFIG_TX(gpio_num, rmt_channel);

config.clk_div = 2;

ESP_ERROR_CHECK(rmt_config(&config));
  ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));

led_strip_config_t strip_config =
  LED_STRIP_DEFAULT_CONFIG(led_number, (led_strip_dev_t)config.channel);
  strip = led_strip_new_rmt_ws2812(&strip_config);

if (!strip) {
  ESP_LOGE(TAG, "install WS2812 driver failed");
  return ESP_FAIL;
  }

ESP_ERROR_CHECK(strip->clear(strip, 100));

return ESP_OK;
}

/* hsv 色彩空间 */
typedef struct chsv {
  uint16_t h;
  uint16_t s;
  uint16_t v;
} chsv;

/* rgb 色彩 */
typedef struct crgb {
  uint8_t r;
  uint8_t g;
  uint8_t b;
} crgb;

/**
 * @brief hsv 转 rgb
 *
 * @param rgb
 * @param hsv
 **/
void HSVtoRGB(crgb* rgb, chsv* hsv) {
  // R,G,B from 0-255, H from 0-360, S,V from 0-100

uint16_t rgb_max = (uint16_t)(hsv->v * 2.55f);
  uint16_t rgb_min = (uint16_t)(rgb_max * (100 - hsv->s) / 100.0f);

int i = hsv->h / 60;
  int difs = hsv->h % 60;// factorial part of h

// rgb adjustment amount by hue
  uint16_t rgb_Adj = (rgb_max - rgb_min) * difs / 60.0f;

switch (i) {
  case 0:
    rgb->r = (uint8_t)rgb_max;
    rgb->g = (uint8_t)(rgb_min + rgb_Adj);
    rgb->b = (uint8_t)rgb_min;
    break;
  case 1:
    rgb->r = (uint8_t)(rgb_max - rgb_Adj);
    rgb->g = (uint8_t)rgb_max;
    rgb->b = (uint8_t)rgb_min;
    break;
  case 2:
    rgb->r = (uint8_t)rgb_min;
    rgb->g = (uint8_t)rgb_max;
    rgb->b = (uint8_t)(rgb_min + rgb_Adj);
    break;
  case 3:
    rgb->r = (uint8_t)rgb_min;
    rgb->g = (uint8_t)(rgb_max - rgb_Adj);
    rgb->b = (uint8_t)rgb_max;
    break;
  case 4:
    rgb->r = (uint8_t)(rgb_min + rgb_Adj);
    rgb->g = (uint8_t)rgb_min;
    rgb->b = (uint8_t)rgb_max;
    break;
  default:// case 5:
    rgb->r = (uint8_t)rgb_max;
    rgb->g = (uint8_t)rgb_min;
    rgb->b = (uint8_t)(rgb_max - rgb_Adj);
    break;
  }
}

/**
 * @brief 流光溢彩特效
 *
 **/
crgb* rgb_brilliant(void) {
  static crgb rgb = {0};
  static int step = 1;
  static chsv hsv = {
  .h = 0,  // 0 ~ 360
  .s = 100,// 0 ~ 100
  .v = 20 // 0 ~ 100
  };
  hsv.h += step;
  if (hsv.h == 358) {
  step = -1;
  } else if (hsv.h == 0) {
  step = 1;
  }
  HSVtoRGB(&rgb, &hsv);
  return &rgb;
}

void led_task(void* arg) {
  crgb * rgb;

while (1) {
  vTaskDelay(1);
  rgb = rgb_brilliant();
  strip->set_pixel(strip, 0, rgb->r, rgb->g, rgb->b);
  strip->refresh(strip, 0);
  }
  vTaskDelete(NULL);
}

/**
 * @brief led 初始化
 *
**/
void led_init(void) {
  ESP_ERROR_CHECK(
  rmt_init(CONFIG_RMT_TX_GPIO, CONFIG_STRIP_LED_NUMBER, RMT_CHANNEL_0));
  BaseType_t res = xTaskCreatePinnedToCore(&led_task, "led_task", 1 * 1024,
               NULL, 5, NULL, 0);
  if (res == pdPASS) {
  ESP_LOGI(TAG, "successed init.");
  } else {
  ESP_LOGE(TAG, "failed init.");
  }
}

```

### WS2812驱动库解读

这个led_strip的库写的风格和Linux内核驱动还是有些像的，值得一读。

对于ws2812_t结构体包含led_strip_t结构体、RMT的通道、利用柔性数组实现的显存数组。这个结构体被写在了.c文件中当做了私有类。

```c
typedef struct {
  led_strip_t parent;
  rmt_channel_t rmt_channel;
  uint32_t strip_len;
  uint8_t buffer[0];
} ws2812_t;
```

在使用这个库时都是对led_strip_t指针进行的操作，而led_strip_t结构体中是一些驱动显示的方法。显存部分和led_strip_t结构体就类似于C++中的私有成员和公共成员。

```c
struct led_strip_s {
  esp_err_t (*set_pixel)(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue);
  esp_err_t (*refresh)(led_strip_t *strip, uint32_t timeout_ms);
  esp_err_t (*clear)(led_strip_t *strip, uint32_t timeout_ms);
  esp_err_t (*del)(led_strip_t *strip);
};
```

`led_strip_new_rmt_ws2812` 这个函数就是实现了WS2812对象的创建，但是返回的是“父类”led_strip_t的指针，来实现上层应用开发时只需配置、调用即可，对于库内驱动代码需要的成员不可直接访问的效果，妙不可言！！

```c
led_strip_t *led_strip_new_rmt_ws2812(const led_strip_config_t *config)
{
  led_strip_t *ret = NULL;
  STRIP_CHECK(config, "configuration can't be null", err, NULL);

// 24 bits per led
  uint32_t ws2812_size = sizeof(ws2812_t) + config->max_leds * 3;
  ws2812_t *ws2812 = calloc(1, ws2812_size);
  STRIP_CHECK(ws2812, "request memory for ws2812 failed", err, NULL);

uint32_t counter_clk_hz = 0;
  STRIP_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev, &counter_clk_hz) == ESP_OK,
      "get rmt counter clock failed", err, NULL);
  // ns -> ticks
  float ratio = (float)counter_clk_hz / 1e9;
  ws2812_t0h_ticks = (uint32_t)(ratio * WS2812_T0H_NS);
  ws2812_t0l_ticks = (uint32_t)(ratio * WS2812_T0L_NS);
  ws2812_t1h_ticks = (uint32_t)(ratio * WS2812_T1H_NS);
  ws2812_t1l_ticks = (uint32_t)(ratio * WS2812_T1L_NS);

// set ws2812 to rmt adapter
  rmt_translator_init((rmt_channel_t)config->dev, ws2812_rmt_adapter);

ws2812->rmt_channel = (rmt_channel_t)config->dev;
  ws2812->strip_len = config->max_leds;

ws2812->parent.set_pixel = ws2812_set_pixel;
  ws2812->parent.refresh = ws2812_refresh;
  ws2812->parent.clear = ws2812_clear;
  ws2812->parent.del = ws2812_del;

return &ws2812->parent;
err:
  return ret;
}
```

## ⭕ 按键驱动

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_637866" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=637866&handlekey=savephoto_637866">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

按键采用的是电阻分压、单路ADC测电压的方案来连接六个按键，对于例程内的代码实现的是按键控制WS2812显示不同的颜色大致为：

1. 采样
2. 均值滤波
3. 电压门限判断
4. 获取按下按键编号

原例程的扫描频率是200ms、采样次数64次，这不能满足lvgl驱动需要的流畅效果，就根据例程改了改，同时也注册到lvgl的按键驱动。

```c
/**
 * @author: Pomin
 * @date: 2022-08-27 22:33:46
 * @github: https://github.com/POMIN-163
 * @lastedit: 2022-08-31 21:41:16
 * @description: ADC 按键驱动
**/
#include "app_init.h"
#include "gui_guider.h"
#include "lvgl_helpers.h"

#define NO_OF_SAMPLES 8
#define SAMPLE_TIME 20

static const adc_channel_t channel = ADC_CHANNEL_5;
static const adc_bits_width_t width = ADC_WIDTH_BIT_13;
static const adc_atten_t atten = ADC_ATTEN_DB_11;
static const adc_unit_t unit = ADC_UNIT_1;

static uint8_t key_status;

/* 门限 */
#define DEVIATION 0.1

#define TAG "btns"

/**
 * @brief ADC 转换
 *
 * @param adc_reading
 * @return double
**/
double adc_voltage_conversion(uint32_t adc_reading) {
  double voltage = 0;

voltage = (2.60 * adc_reading) / 8191;

return voltage;
}

void button_task(void *arg) {
  while (1) {
  uint32_t adc_reading = 0;
  double voltage = 0;

for (int i = 0; i < NO_OF_SAMPLES; i++) {
    if (unit == ADC_UNIT_1) {
      adc_reading += adc1_get_raw((adc1_channel_t)channel);
    } else {
      int raw;
      adc2_get_raw((adc2_channel_t)channel, width, &raw);
      adc_reading += raw;
    }
  }

adc_reading /= NO_OF_SAMPLES;
  voltage = adc_voltage_conversion(adc_reading);

key_status = 0;
  if (voltage > 2.6) {
    continue;
  } else if (voltage > 2.41 - DEVIATION && voltage <= 2.41 + DEVIATION) {
    key_status = 1;

} else if (voltage > 1.98 - DEVIATION && voltage <= 1.98 + DEVIATION) {
    key_status = 2;

} else if (voltage > 1.65 - DEVIATION && voltage <= 1.65 + DEVIATION) {
    key_status = 3;

} else if (voltage > 1.11 - DEVIATION && voltage <= 1.11 + DEVIATION) {
    key_status = 4;

} else if (voltage > 0.82 - DEVIATION && voltage <= 0.82 + DEVIATION) {
    key_status = 5;

} else if (voltage > 0.38 - DEVIATION && voltage <= 0.38 + DEVIATION) {
    key_status = 6;
  }

vTaskDelay(pdMS_TO_TICKS(SAMPLE_TIME));
  }
  vTaskDelete(NULL);
}

/**
 * @brief 初始化 ADC
 *
**/
void adc_init(void) {
  if (unit == ADC_UNIT_1) {
  adc1_config_width(width);
  adc1_config_channel_atten(channel, atten);
  } else {
  adc2_config_channel_atten((adc2_channel_t)channel, atten);
  }
}

/**
 * @brief 按键初始化
 *
**/
void btns_init(void) {
  adc_init();
  BaseType_t res = xTaskCreatePinnedToCore(&button_task, "button_task", 4 * 1024, NULL, 5, NULL, 0);
  if (res == pdPASS) {
  ESP_LOGI(TAG, "successed init.");
  } else {
  ESP_LOGE(TAG, "failed init.");
  }
}

/* * *lvgl 驱动支持* * */
static void button_read(lv_indev_drv_t *indev_drv, lv_indev_data_t *data);
static int8_t button_get_pressed_id(void);
lv_indev_t *indev_button;

void lv_port_indev_init(void) {
  static lv_indev_drv_t indev_drv;

lv_indev_drv_init(&indev_drv);
  indev_drv.type = LV_INDEV_TYPE_BUTTON;
  indev_drv.read_cb = button_read;
  indev_button = lv_indev_drv_register(&indev_drv);

static const lv_point_t btn_points[6] = {
  { 300, 20}, /* Button 0 */
  { 300, 60}, /* Button 1 */
  { 300, 100 }, /* Button 2 */
  { 300, 140 }, /* Button 3 */
  { 300, 180 }, /* Button 4 */
  { 300, 220 }, /* Button 5 */
  };
  lv_indev_set_button_points(indev_button, btn_points);
}

static void button_read(lv_indev_drv_t *indev_drv, lv_indev_data_t *data) {
  static uint8_t last_btn = 0;
  int8_t btn_act = button_get_pressed_id();

if (btn_act >= 0) {
  data->state = LV_INDEV_STATE_PR;
  last_btn = btn_act;
  } else {
  data->state = LV_INDEV_STATE_REL;
  }
  data->btn_id = last_btn;
}

static int8_t button_get_pressed_id(void) {
  for (uint8_t i = 0; i < 6; i++) {
  if (key_status - 1 == i) {
    return i;
  }
  }
  return -1;
}
```

## 💎 驱动效果

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_637868" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=637868&handlekey=savephoto_637868">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_637867" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=637867&handlekey=savephoto_637867">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

Jacktang

有关esp32 s2 LED、按键驱动测评讲的很细

wangerxian

这个WS2812库是官方提供的吗？

pomin

wangerxian 发表于 2022-9-1 14:30 这个WS2812库是官方提供的吗？

是的，官方有开源例程

链接已隐藏，如需查看请登录或者注册

【家用智能仪表盘】esp32 s2 LED、按键驱动 [复制链接]

最新回复