Embedded_Projects
/
ESP32S2_Cal
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fixed bugs in weekday, implemented LTC2941 driver.

This commit is contained in:
imi415 2022-02-08 21:45:58 +08:00
parent 66c4b9b064
commit 1af5bf82f2
Signed by: imi415
GPG Key ID: 17F01E106F9F5E0A
11 changed files with 185 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
main/CMakeLists.txt
View File

@ -8,6 +8,7 @@ idf_component_register(SRCS
"impl/impl_dht.c"
"impl/impl_epd.c"
"impl/impl_lvgl.c"
"impl/impl_sdfs.c"
"interface/if_standby.c"
"interface/if_wifi.c"
"lib/epd-spi/src/epd_common.c"
@ -165,6 +166,7 @@ idf_component_register(SRCS
"lib/lvgl/src/widgets/lv_switch.c"
"lib/lvgl/src/widgets/lv_table.c"
"lib/lvgl/src/widgets/lv_textarea.c"
"service/service_battery.c"
"service/service_clock.c"
"service/service_dht.c"
"service/service_wifi.c"

2
main/impl/impl_epd.c
View File

@ -8,7 +8,7 @@
#define EPD_GPIO_RES GPIO_NUM_10
#define EPD_GPIO_DC GPIO_NUM_12
#define EPD_SPI_HOST SPI2_HOST
#define EPD_SPI_HOST SPI3_HOST
#define EPD_SPI_SPEED (16 * 1000 * 1000) /* 16MHz */
#define EPD_SPI_MAX_XFER_SIZE (1024)

18
main/impl/impl_sdfs.c Normal file
View File

@ -0,0 +1,18 @@
#include "impl_sdfs.h"
#include "lvgl.h"
lv_fs_res_t impl_sdfs_open(lv_fs_drv_t *drv, void *file_p, const char *path, lv_fs_mode_t mode) {
//
return LV_FS_RES_OK;
}
lv_fs_res_t impl_sdfs_close(lv_fs_drv_t *drv, void *file_p) {
//
return LV_FS_RES_OK;
}
esp_err_t impl_sdfs_init(void) {
//
return ESP_OK;
}

6
main/impl/impl_sdfs.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef IMPL_SDFS_H
#define IMPL_SDFS_H
#include "esp_system.h"
#endif

42
main/lib/ltc2941/ltc2941.c
View File

@ -0,0 +1,42 @@
#include "ltc2941.h"
#define LTC2941_REG_STATUS 0x00
#define LTC2941_REG_CONTROL 0x01
#define LTC2941_REG_CHARGE_MSB 0x02
#define LTC2941_REG_CHARGE_LSB 0x03
ltc2941_ret_t ltc2941_init(ltc2941_t *bat) {
uint8_t control_reg =
((bat->config.alert_mode & 0x03U) << 0x01U) |
((bat->config.prescaler & 0x07U) << 0x03U) |
((bat->config.alert_level & 0x03U) << 0x06U);
bat->cb.write_register_cb(bat->user_data, LTC2941_REG_CONTROL, control_reg);
return LTC2941_OK;
}
ltc2941_ret_t ltc2941_read_status(ltc2941_t *bat, uint8_t *status) {
return bat->cb.read_register_cb(bat->user_data, LTC2941_REG_STATUS, status);
}
ltc2941_ret_t ltc2941_read_charge(ltc2941_t *bat, uint16_t *charge) {
uint8_t reg = 0x00;
bat->cb.read_register_cb(bat->user_data, LTC2941_REG_CHARGE_MSB, &reg);
*charge = reg << 0x08U;
bat->cb.read_register_cb(bat->user_data, LTC2941_REG_CHARGE_LSB, &reg);
*charge |= reg;
return LTC2941_OK;
}
ltc2941_ret_t ltc2941_write_charge(ltc2941_t *bat, uint16_t charge) {
uint8_t reg = (charge >> 0x08U); // MSB
bat->cb.write_register_cb(bat->user_data, LTC2941_REG_CHARGE_MSB, reg);
reg = (charge & 0xFFU); // LSB
bat->cb.write_register_cb(bat->user_data, LTC2941_REG_CHARGE_LSB, reg);
return LTC2941_OK;
}

64
main/lib/ltc2941/ltc2941.h
View File

@ -0,0 +1,64 @@
#ifndef __LTC2941_BATTERY_H
#define __LTC2941_BATTERY_H
#include <stdint.h>
typedef enum {
LTC2941_OK,
LTC2941_ERROR
} ltc2941_ret_t;
typedef enum {
LTC2941_ALERT_3_0V = 0x03,
LTC2941_ALERT_2_9V = 0x02,
LTC2941_ALERT_2_8V = 0x01,
LTC2941_ALERT_OFF = 0x00
} ltc2941_battery_alert_t;
typedef enum {
LTC2941_PRE_1 = 0x00,
LTC2941_PRE_2 = 0x01,
LTC2941_PRE_4 = 0x02,
LTC2941_PRE_8 = 0x03,
LTC2941_PRE_16 = 0x04,
LTC2941_PRE_32 = 0x05,
LTC2941_PRE_64 = 0x06,
LTC2941_PRE_128 = 0x07
} ltc2941_prescale_t;
typedef enum {
LTC2941_ALERT_DISABLED = 0x00,
LTC2941_ALERT_CC = 0x01,
LTC2941_ALERT_AL = 0x02
} ltc2941_alert_mode_t;
typedef struct {
ltc2941_ret_t (*write_register_cb)(void * handle, uint8_t reg, uint8_t value);
ltc2941_ret_t (*read_register_cb)(void *handle, uint8_t reg, uint8_t *value);
} ltc2941_cb_t;
typedef struct {
ltc2941_prescale_t prescaler;
ltc2941_alert_mode_t alert_mode;
ltc2941_battery_alert_t alert_level;
} ltc2941_config_t;
typedef struct {
ltc2941_cb_t cb;
ltc2941_config_t config;
void *user_data;
} ltc2941_t;
#define LTC2941_STATUS_CHIPID (1 << 7U)
#define LTC2941_STATUS_OVERFLOW (1 << 5U)
#define LTC2941_STATUS_ALRT_HIGH (1 << 3U)
#define LTC2941_STATUS_ALRT_LOW (1 << 2U)
#define LTC2941_STATUS_ALRT_VBAT (1 << 1U)
#define LTC2941_STATUS_ALRT_UVLO 1U
ltc2941_ret_t ltc2941_init(ltc2941_t *bat);
ltc2941_ret_t ltc2941_read_status(ltc2941_t *bat, uint8_t *status);
ltc2941_ret_t ltc2941_read_charge(ltc2941_t *bat, uint16_t *charge);
ltc2941_ret_t ltc2941_write_charge(ltc2941_t *bat, uint16_t charge);
#endif

0
main/service/service_battery.c Normal file
View File

0
main/service/service_battery.h Normal file
View File

2
main/service/service_clock.c
View File

@ -10,7 +10,7 @@
static TaskHandle_t s_clock_task_handle;
static const char *s_wday_array[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI"};
static const char *s_wday_array[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
void clock_task(void *pvParameters) {
struct tm timeinfo;

60
main/service/service_wifi.c
View File

@ -24,14 +24,36 @@ static QueueHandle_t s_service_wifi_event_queue;
static uint8_t s_retry_count = 0;
typedef enum {
SERVICE_WIFI_EVENT_CONNECTING,
SERVICE_WIFI_EVENT_DISCONNECTED,
SERVICE_WIFI_EVENT_CONNECTED,
SERVICE_WIFI_EVENT_START_DPP,
SERVICE_WIFI_EV_STATE_CHANGE,
} service_wifi_event_t;
typedef enum {
SERVICE_WIFI_STATE_DISABLED,
SERVICE_WIFI_STATE_DPP,
SERVICE_WIFI_STATE_CONNECTING,
SERVICE_WIFI_STATE_CONNECTED,
SERVICE_WIFI_STATE_IP_READY,
} service_wifi_state_t;
typedef struct {
service_wifi_event_t ev;
void *payload;
} service_wifi_request_t;
static esp_err_t service_wifi_update_state(service_wifi_state_t new_state) {
service_wifi_request_t req = {
.ev = SERVICE_WIFI_EV_STATE_CHANGE,
.payload = (void *)new_state,
};
if(xQueueSend(s_service_wifi_event_queue, &req, 0) != pdPASS) {
return ESP_FAIL;
}
return ESP_OK;
}
static void service_wifi_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data) {
service_wifi_event_t service_ev;
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
esp_wifi_connect();
} else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
@ -41,8 +63,7 @@ static void service_wifi_event_handler(void *arg, esp_event_base_t event_base, i
}
} else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
s_retry_count = 0;
service_ev = SERVICE_WIFI_EVENT_CONNECTED;
xQueueSend(s_service_wifi_event_queue, &service_ev, 0);
service_wifi_update_state(SERVICE_WIFI_STATE_IP_READY);
}
}
@ -89,15 +110,18 @@ void service_wifi_task(void *pvParameters) {
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
ESP_ERROR_CHECK(esp_wifi_start());
service_wifi_event_t queue_event;
service_wifi_request_t request;
for (;;) {
if (xQueueReceive(s_service_wifi_event_queue, &queue_event, portMAX_DELAY) == pdPASS) {
switch (queue_event) {
case SERVICE_WIFI_EVENT_CONNECTED:
if_standby_component_update(IF_STANDBY_COMPONENT_WIFI, "\U000F0928");
break;
default:
break;
if (xQueueReceive(s_service_wifi_event_queue, &request, portMAX_DELAY) == pdPASS) {
if (request.ev == SERVICE_WIFI_EV_STATE_CHANGE) {
service_wifi_state_t state = (service_wifi_state_t)request.payload;
switch (state) {
case SERVICE_WIFI_STATE_IP_READY:
if_standby_component_update(IF_STANDBY_COMPONENT_WIFI, "\U000F0928");
break;
default:
break;
}
}
}
}
@ -114,7 +138,7 @@ esp_err_t service_wifi_init(void) {
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, service_wifi_event_handler, NULL));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, service_wifi_event_handler, NULL));
s_service_wifi_event_queue = xQueueCreate(2, sizeof(service_wifi_event_t));
s_service_wifi_event_queue = xQueueCreate(2, sizeof(service_wifi_request_t));
if (s_service_wifi_event_queue == NULL) {
return ESP_FAIL;
}
@ -126,3 +150,7 @@ esp_err_t service_wifi_init(void) {
return ESP_OK;
}
esp_err_t service_wifi_notify() {
return ESP_OK;
}

7
main/service/service_wifi.h
View File

@ -3,6 +3,13 @@
#include "esp_system.h"
typedef enum {
SERVICE_WIFI_NOTIFY_STANDBY_REFRESH,
SERVICE_WIFI_NOTIFY_SETTINGS_REFRESH,
} service_wifi_notify_t;
esp_err_t service_wifi_init(void);
esp_err_t service_wifi_notify();
#endif