添加智能灯固件代码

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS "i2ctools_example_main.c"
+                            "cmd_i2ctools.c"
+                    INCLUDE_DIRS ".")

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/Kconfig.projbuild

@@ -0,0 +1,10 @@
+menu "Example Configuration"
+
+    config EXAMPLE_STORE_HISTORY
+        bool "Store command history in flash"
+        default y
+        help
+            Linenoise line editing library provides functions to save and load
+            command history. If this option is enabled, initalizes a FAT filesystem
+            and uses it to store command history.
+endmenu

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/cmd_i2ctools.c

@@ -0,0 +1,409 @@
+/* cmd_i2ctools.c
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#include <stdio.h>
+#include "argtable3/argtable3.h"
+#include "driver/i2c.h"
+#include "esp_console.h"
+#include "esp_log.h"
+
+#define I2C_MASTER_TX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */
+#define I2C_MASTER_RX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */
+#define WRITE_BIT I2C_MASTER_WRITE  /*!< I2C master write */
+#define READ_BIT I2C_MASTER_READ    /*!< I2C master read */
+#define ACK_CHECK_EN 0x1            /*!< I2C master will check ack from slave*/
+#define ACK_CHECK_DIS 0x0           /*!< I2C master will not check ack from slave */
+#define ACK_VAL 0x0                 /*!< I2C ack value */
+#define NACK_VAL 0x1                /*!< I2C nack value */
+
+static const char *TAG = "cmd_i2ctools";
+
+static gpio_num_t i2c_gpio_sda = 18;
+static gpio_num_t i2c_gpio_scl = 19;
+static uint32_t i2c_frequency = 100000;
+static i2c_port_t i2c_port = I2C_NUM_0;
+
+static esp_err_t i2c_get_port(int port, i2c_port_t *i2c_port)
+{
+    if (port >= I2C_NUM_MAX) {
+        ESP_LOGE(TAG, "Wrong port number: %d", port);
+        return ESP_FAIL;
+    }
+    switch (port) {
+    case 0:
+        *i2c_port = I2C_NUM_0;
+        break;
+    case 1:
+        *i2c_port = I2C_NUM_1;
+        break;
+    default:
+        *i2c_port = I2C_NUM_0;
+        break;
+    }
+    return ESP_OK;
+}
+
+static esp_err_t i2c_master_driver_initialize(void)
+{
+    i2c_config_t conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = i2c_gpio_sda,
+        .sda_pullup_en = GPIO_PULLUP_ENABLE,
+        .scl_io_num = i2c_gpio_scl,
+        .scl_pullup_en = GPIO_PULLUP_ENABLE,
+        .master.clk_speed = i2c_frequency
+    };
+    return i2c_param_config(i2c_port, &conf);
+}
+
+static struct {
+    struct arg_int *port;
+    struct arg_int *freq;
+    struct arg_int *sda;
+    struct arg_int *scl;
+    struct arg_end *end;
+} i2cconfig_args;
+
+static int do_i2cconfig_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&i2cconfig_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, i2cconfig_args.end, argv[0]);
+        return 0;
+    }
+
+    /* Check "--port" option */
+    if (i2cconfig_args.port->count) {
+        if (i2c_get_port(i2cconfig_args.port->ival[0], &i2c_port) != ESP_OK) {
+            return 1;
+        }
+    }
+    /* Check "--freq" option */
+    if (i2cconfig_args.freq->count) {
+        i2c_frequency = i2cconfig_args.freq->ival[0];
+    }
+    /* Check "--sda" option */
+    i2c_gpio_sda = i2cconfig_args.sda->ival[0];
+    /* Check "--scl" option */
+    i2c_gpio_scl = i2cconfig_args.scl->ival[0];
+    return 0;
+}
+
+static void register_i2cconfig(void)
+{
+    i2cconfig_args.port = arg_int0(NULL, "port", "<0|1>", "Set the I2C bus port number");
+    i2cconfig_args.freq = arg_int0(NULL, "freq", "<Hz>", "Set the frequency(Hz) of I2C bus");
+    i2cconfig_args.sda = arg_int1(NULL, "sda", "<gpio>", "Set the gpio for I2C SDA");
+    i2cconfig_args.scl = arg_int1(NULL, "scl", "<gpio>", "Set the gpio for I2C SCL");
+    i2cconfig_args.end = arg_end(2);
+    const esp_console_cmd_t i2cconfig_cmd = {
+        .command = "i2cconfig",
+        .help = "Config I2C bus",
+        .hint = NULL,
+        .func = &do_i2cconfig_cmd,
+        .argtable = &i2cconfig_args
+    };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&i2cconfig_cmd));
+}
+
+static int do_i2cdetect_cmd(int argc, char **argv)
+{
+    i2c_driver_install(i2c_port, I2C_MODE_MASTER, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
+    i2c_master_driver_initialize();
+    uint8_t address;
+    printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+    for (int i = 0; i < 128; i += 16) {
+        printf("%02x: ", i);
+        for (int j = 0; j < 16; j++) {
+            fflush(stdout);
+            address = i + j;
+            i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+            i2c_master_start(cmd);
+            i2c_master_write_byte(cmd, (address << 1) | WRITE_BIT, ACK_CHECK_EN);
+            i2c_master_stop(cmd);
+            esp_err_t ret = i2c_master_cmd_begin(i2c_port, cmd, 50 / portTICK_RATE_MS);
+            i2c_cmd_link_delete(cmd);
+            if (ret == ESP_OK) {
+                printf("%02x ", address);
+            } else if (ret == ESP_ERR_TIMEOUT) {
+                printf("UU ");
+            } else {
+                printf("-- ");
+            }
+        }
+        printf("\r\n");
+    }
+
+    i2c_driver_delete(i2c_port);
+    return 0;
+}
+
+static void register_i2cdectect(void)
+{
+    const esp_console_cmd_t i2cdetect_cmd = {
+        .command = "i2cdetect",
+        .help = "Scan I2C bus for devices",
+        .hint = NULL,
+        .func = &do_i2cdetect_cmd,
+        .argtable = NULL
+    };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&i2cdetect_cmd));
+}
+
+static struct {
+    struct arg_int *chip_address;
+    struct arg_int *register_address;
+    struct arg_int *data_length;
+    struct arg_end *end;
+} i2cget_args;
+
+static int do_i2cget_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&i2cget_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, i2cget_args.end, argv[0]);
+        return 0;
+    }
+
+    /* Check chip address: "-c" option */
+    int chip_addr = i2cget_args.chip_address->ival[0];
+    /* Check register address: "-r" option */
+    int data_addr = -1;
+    if (i2cget_args.register_address->count) {
+        data_addr = i2cget_args.register_address->ival[0];
+    }
+    /* Check data length: "-l" option */
+    int len = 1;
+    if (i2cget_args.data_length->count) {
+        len = i2cget_args.data_length->ival[0];
+    }
+    uint8_t *data = malloc(len);
+
+    i2c_driver_install(i2c_port, I2C_MODE_MASTER, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
+    i2c_master_driver_initialize();
+    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+    i2c_master_start(cmd);
+    if (data_addr != -1) {
+        i2c_master_write_byte(cmd, chip_addr << 1 | WRITE_BIT, ACK_CHECK_EN);
+        i2c_master_write_byte(cmd, data_addr, ACK_CHECK_EN);
+        i2c_master_start(cmd);
+    }
+    i2c_master_write_byte(cmd, chip_addr << 1 | READ_BIT, ACK_CHECK_EN);
+    if (len > 1) {
+        i2c_master_read(cmd, data, len - 1, ACK_VAL);
+    }
+    i2c_master_read_byte(cmd, data + len - 1, NACK_VAL);
+    i2c_master_stop(cmd);
+    esp_err_t ret = i2c_master_cmd_begin(i2c_port, cmd, 1000 / portTICK_RATE_MS);
+    i2c_cmd_link_delete(cmd);
+    if (ret == ESP_OK) {
+        for (int i = 0; i < len; i++) {
+            printf("0x%02x ", data[i]);
+            if ((i + 1) % 16 == 0) {
+                printf("\r\n");
+            }
+        }
+        if (len % 16) {
+            printf("\r\n");
+        }
+    } else if (ret == ESP_ERR_TIMEOUT) {
+        ESP_LOGW(TAG, "Bus is busy");
+    } else {
+        ESP_LOGW(TAG, "Read failed");
+    }
+    free(data);
+    i2c_driver_delete(i2c_port);
+    return 0;
+}
+
+static void register_i2cget(void)
+{
+    i2cget_args.chip_address = arg_int1("c", "chip", "<chip_addr>", "Specify the address of the chip on that bus");
+    i2cget_args.register_address = arg_int0("r", "register", "<register_addr>", "Specify the address on that chip to read from");
+    i2cget_args.data_length = arg_int0("l", "length", "<length>", "Specify the length to read from that data address");
+    i2cget_args.end = arg_end(1);
+    const esp_console_cmd_t i2cget_cmd = {
+        .command = "i2cget",
+        .help = "Read registers visible through the I2C bus",
+        .hint = NULL,
+        .func = &do_i2cget_cmd,
+        .argtable = &i2cget_args
+    };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&i2cget_cmd));
+}
+
+static struct {
+    struct arg_int *chip_address;
+    struct arg_int *register_address;
+    struct arg_int *data;
+    struct arg_end *end;
+} i2cset_args;
+
+static int do_i2cset_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&i2cset_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, i2cset_args.end, argv[0]);
+        return 0;
+    }
+
+    /* Check chip address: "-c" option */
+    int chip_addr = i2cset_args.chip_address->ival[0];
+    /* Check register address: "-r" option */
+    int data_addr = 0;
+    if (i2cset_args.register_address->count) {
+        data_addr = i2cset_args.register_address->ival[0];
+    }
+    /* Check data: "-d" option */
+    int len = i2cset_args.data->count;
+
+    i2c_driver_install(i2c_port, I2C_MODE_MASTER, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
+    i2c_master_driver_initialize();
+    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+    i2c_master_start(cmd);
+    i2c_master_write_byte(cmd, chip_addr << 1 | WRITE_BIT, ACK_CHECK_EN);
+    if (i2cset_args.register_address->count) {
+        i2c_master_write_byte(cmd, data_addr, ACK_CHECK_EN);
+    }
+    for (int i = 0; i < len; i++) {
+        i2c_master_write_byte(cmd, i2cset_args.data->ival[i], ACK_CHECK_EN);
+    }
+    i2c_master_stop(cmd);
+    esp_err_t ret = i2c_master_cmd_begin(i2c_port, cmd, 1000 / portTICK_RATE_MS);
+    i2c_cmd_link_delete(cmd);
+    if (ret == ESP_OK) {
+        ESP_LOGI(TAG, "Write OK");
+    } else if (ret == ESP_ERR_TIMEOUT) {
+        ESP_LOGW(TAG, "Bus is busy");
+    } else {
+        ESP_LOGW(TAG, "Write Failed");
+    }
+    i2c_driver_delete(i2c_port);
+    return 0;
+}
+
+static void register_i2cset(void)
+{
+    i2cset_args.chip_address = arg_int1("c", "chip", "<chip_addr>", "Specify the address of the chip on that bus");
+    i2cset_args.register_address = arg_int0("r", "register", "<register_addr>", "Specify the address on that chip to read from");
+    i2cset_args.data = arg_intn(NULL, NULL, "<data>", 0, 256, "Specify the data to write to that data address");
+    i2cset_args.end = arg_end(2);
+    const esp_console_cmd_t i2cset_cmd = {
+        .command = "i2cset",
+        .help = "Set registers visible through the I2C bus",
+        .hint = NULL,
+        .func = &do_i2cset_cmd,
+        .argtable = &i2cset_args
+    };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&i2cset_cmd));
+}
+
+static struct {
+    struct arg_int *chip_address;
+    struct arg_int *size;
+    struct arg_end *end;
+} i2cdump_args;
+
+static int do_i2cdump_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&i2cdump_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, i2cdump_args.end, argv[0]);
+        return 0;
+    }
+
+    /* Check chip address: "-c" option */
+    int chip_addr = i2cdump_args.chip_address->ival[0];
+    /* Check read size: "-s" option */
+    int size = 1;
+    if (i2cdump_args.size->count) {
+        size = i2cdump_args.size->ival[0];
+    }
+    if (size != 1 && size != 2 && size != 4) {
+        ESP_LOGE(TAG, "Wrong read size. Only support 1,2,4");
+        return 1;
+    }
+    i2c_driver_install(i2c_port, I2C_MODE_MASTER, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
+    i2c_master_driver_initialize();
+    uint8_t data_addr;
+    uint8_t data[4];
+    int32_t block[16];
+    printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f"
+           "    0123456789abcdef\r\n");
+    for (int i = 0; i < 128; i += 16) {
+        printf("%02x: ", i);
+        for (int j = 0; j < 16; j += size) {
+            fflush(stdout);
+            data_addr = i + j;
+            i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+            i2c_master_start(cmd);
+            i2c_master_write_byte(cmd, chip_addr << 1 | WRITE_BIT, ACK_CHECK_EN);
+            i2c_master_write_byte(cmd, data_addr, ACK_CHECK_EN);
+            i2c_master_start(cmd);
+            i2c_master_write_byte(cmd, chip_addr << 1 | READ_BIT, ACK_CHECK_EN);
+            if (size > 1) {
+                i2c_master_read(cmd, data, size - 1, ACK_VAL);
+            }
+            i2c_master_read_byte(cmd, data + size - 1, NACK_VAL);
+            i2c_master_stop(cmd);
+            esp_err_t ret = i2c_master_cmd_begin(i2c_port, cmd, 50 / portTICK_RATE_MS);
+            i2c_cmd_link_delete(cmd);
+            if (ret == ESP_OK) {
+                for (int k = 0; k < size; k++) {
+                    printf("%02x ", data[k]);
+                    block[j + k] = data[k];
+                }
+            } else {
+                for (int k = 0; k < size; k++) {
+                    printf("XX ");
+                    block[j + k] = -1;
+                }
+            }
+        }
+        printf("   ");
+        for (int k = 0; k < 16; k++) {
+            if (block[k] < 0) {
+                printf("X");
+            }
+            if ((block[k] & 0xff) == 0x00 || (block[k] & 0xff) == 0xff) {
+                printf(".");
+            } else if ((block[k] & 0xff) < 32 || (block[k] & 0xff) >= 127) {
+                printf("?");
+            } else {
+                printf("%c", block[k] & 0xff);
+            }
+        }
+        printf("\r\n");
+    }
+    i2c_driver_delete(i2c_port);
+    return 0;
+}
+
+static void register_i2cdump(void)
+{
+    i2cdump_args.chip_address = arg_int1("c", "chip", "<chip_addr>", "Specify the address of the chip on that bus");
+    i2cdump_args.size = arg_int0("s", "size", "<size>", "Specify the size of each read");
+    i2cdump_args.end = arg_end(1);
+    const esp_console_cmd_t i2cdump_cmd = {
+        .command = "i2cdump",
+        .help = "Examine registers visible through the I2C bus",
+        .hint = NULL,
+        .func = &do_i2cdump_cmd,
+        .argtable = &i2cdump_args
+    };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&i2cdump_cmd));
+}
+
+void register_i2ctools(void)
+{
+    register_i2cconfig();
+    register_i2cdectect();
+    register_i2cget();
+    register_i2cset();
+    register_i2cdump();
+}

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/cmd_i2ctools.h

@@ -0,0 +1,20 @@
+/* cmd_i2ctools.h
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void register_i2ctools(void);
+
+#ifdef __cplusplus
+}
+#endif

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/component.mk

@@ -0,0 +1,3 @@
+#
+# Main Makefile. This is basically the same as a component makefile.
+#

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2c/i2c_tools/main/i2ctools_example_main.c

@@ -0,0 +1,71 @@
+/* i2c-tools example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "sdkconfig.h"
+#include "esp_log.h"
+#include "esp_console.h"
+#include "esp_vfs_fat.h"
+#include "cmd_system.h"
+#include "cmd_i2ctools.h"
+
+static const char *TAG = "i2c-tools";
+
+#if CONFIG_EXAMPLE_STORE_HISTORY
+
+#define MOUNT_PATH "/data"
+#define HISTORY_PATH MOUNT_PATH "/history.txt"
+
+static void initialize_filesystem(void)
+{
+    static wl_handle_t wl_handle;
+    const esp_vfs_fat_mount_config_t mount_config = {
+        .max_files = 4,
+        .format_if_mount_failed = true
+    };
+    esp_err_t err = esp_vfs_fat_spiflash_mount(MOUNT_PATH, "storage", &mount_config, &wl_handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to mount FATFS (%s)", esp_err_to_name(err));
+        return;
+    }
+}
+#endif // CONFIG_EXAMPLE_STORE_HISTORY
+
+void app_main(void)
+{
+    esp_console_repl_t *repl = NULL;
+    esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
+    esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
+#if CONFIG_EXAMPLE_STORE_HISTORY
+    initialize_filesystem();
+    repl_config.history_save_path = HISTORY_PATH;
+#endif
+    repl_config.prompt = "i2c-tools>";
+    // init console REPL environment
+    ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
+
+    register_i2ctools();
+    register_system();
+
+    printf("\n ==============================================================\n");
+    printf(" |             Steps to Use i2c-tools                         |\n");
+    printf(" |                                                            |\n");
+    printf(" |  1. Try 'help', check all supported commands               |\n");
+    printf(" |  2. Try 'i2cconfig' to configure your I2C bus              |\n");
+    printf(" |  3. Try 'i2cdetect' to scan devices on the bus             |\n");
+    printf(" |  4. Try 'i2cget' to get the content of specific register   |\n");
+    printf(" |  5. Try 'i2cset' to set the value of specific register     |\n");
+    printf(" |  6. Try 'i2cdump' to dump all the register (Experiment)    |\n");
+    printf(" |                                                            |\n");
+    printf(" ==============================================================\n\n");
+
+    // start console REPL
+    ESP_ERROR_CHECK(esp_console_start_repl(repl));
+}