添加智能灯固件代码

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/CMakeLists.txt

@@ -0,0 +1,6 @@
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(i2s-adc-dac)

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/Makefile

@@ -0,0 +1,9 @@
+#
+# This is a project Makefile. It is assumed the directory this Makefile resides in is a
+# project subdirectory.
+#
+
+PROJECT_NAME := i2s-adc-dac
+
+include $(IDF_PATH)/make/project.mk
+

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/README.md

@@ -0,0 +1,94 @@
+| Supported Targets | ESP32 |
+| ----------------- | ----- |
+
+# I2S Built-in ADC/DAC Example
+
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+In this example, we configure I2S to work in I2S_ADC and I2S_DAC modes and then:
+* recording sound from ADC,
+* playing the recorded sound,
+* playing an audio file in flash via DAC.
+
+#### Note:
+The `tools` directory contains `generate_audio_file.py` script for generating audio files:
+
+    * The script provides an example of generating audio tables from `.wav` files.
+    * In this example, the `wav` file must be in 16k/16bit mono format.
+    * The script will bundle the `wav` files into a single table named `audio_example_file.h`.
+    * Since the ADC can only play 8-bit data, the script will scale each 16-bit value to a 8-bit value.
+    * The script will covert all signed values into unsigned values because only positive values will be output by the ADC.
+
+## How to Use Example
+
+### Hardware Required
+
+* A development board with ESP32 SoC (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
+* A USB cable for power supply and programming
+* A microphone (with amplifier) and one or two speaker(s) for testing.
+
+The following is the hardware connection:
+
+|hardware|module|GPIO|
+|:---:|:---:|:---:|
+|Microphone|ADC1_CH0|GPIO36|
+|speaker(R)|DAC1|GPIO25|
+|speaker(L)|DAC2|GPIO26|
+
+### Configure the Project
+
+```
+idf.py menuconfig
+```
+
+* Set the flash size to 4 MB under Serial Flasher Options.
+* Select "Custom partition table CSV" and rename "Custom partition CSV file" to "partitions_adc_dac_example.csv".
+
+(Note that you can use `sdkconfig.defaults`)
+
+### Build and Flash
+
+Build the project and flash it to the board, then run monitor tool to view serial output:
+
+```
+idf.py -p PORT flash monitor
+```
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+
+Reset your development board. The application it will first record the sound through the microphone. Then it will play the recorded sound, and finally a piece of audio stored in the flash. The following is the output log:
+
+```
+partiton addr: 0x00110000; size: 2097152; label: storage
+Erasing flash
+partiton addr: 0x00110000; size: 2097152; label: storage
+Erase size: 323584 Bytes
+I2S: PLL_D2: Req RATE: 16000, real rate: 1004.000, BITS: 16, CLKM: 83, BCK: 60, MCLK: 83.333, SCLK: 32128.000000, diva: 64, divb: 21
+Sound recording 5%
+Sound recording 10%
+...
+Sound recording 97%
+Sound recording 102% 
+playing: 0 %
+playing: 1 %
+playing: 2 %
+...
+playing: 96 %
+playing: 97 %
+playing: 98 %
+Playing file example:
+I2S: PLL_D2: Req RATE: 16000, real rate: 1004.000, BITS: 16, CLKM: 83, BCK: 60, MCLK: 83.333, SCLK: 32128.000000, diva: 64, divb: 21
+```
+
+## Troubleshooting
+
+* Program upload failure
+
+    * Hardware connection is not correct: run `idf.py -p PORT monitor`, and reboot your board to see if there are any output logs.
+    * The baud rate for downloading is too high: lower your baud rate in the `menuconfig` menu, and try again.
+
+For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.

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

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "app_main.c"
+                    INCLUDE_DIRS ".")

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/main/app_main.c

@@ -0,0 +1,293 @@
+#include <stdio.h>
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_spi_flash.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_partition.h"
+#include "driver/i2s.h"
+#include "driver/adc.h"
+#include "audio_example_file.h"
+#include "esp_adc_cal.h"
+
+#if CONFIG_IDF_TARGET_ESP32
+
+static const char* TAG = "ad/da";
+#define V_REF   1100
+#define ADC1_TEST_CHANNEL (ADC1_CHANNEL_7)
+
+#define PARTITION_NAME   "storage"
+
+/*---------------------------------------------------------------
+                            EXAMPLE CONFIG
+---------------------------------------------------------------*/
+//enable record sound and save in flash
+#define RECORD_IN_FLASH_EN        (1)
+//enable replay recorded sound in flash
+#define REPLAY_FROM_FLASH_EN      (1)
+
+//i2s number
+#define EXAMPLE_I2S_NUM           (0)
+//i2s sample rate
+#define EXAMPLE_I2S_SAMPLE_RATE   (16000)
+//i2s data bits
+#define EXAMPLE_I2S_SAMPLE_BITS   (16)
+//enable display buffer for debug
+#define EXAMPLE_I2S_BUF_DEBUG     (0)
+//I2S read buffer length
+#define EXAMPLE_I2S_READ_LEN      (16 * 1024)
+//I2S data format
+#define EXAMPLE_I2S_FORMAT        (I2S_CHANNEL_FMT_RIGHT_LEFT)
+//I2S channel number
+#define EXAMPLE_I2S_CHANNEL_NUM   ((EXAMPLE_I2S_FORMAT < I2S_CHANNEL_FMT_ONLY_RIGHT) ? (2) : (1))
+//I2S built-in ADC unit
+#define I2S_ADC_UNIT              ADC_UNIT_1
+//I2S built-in ADC channel
+#define I2S_ADC_CHANNEL           ADC1_CHANNEL_0
+
+//flash record size, for recording 5 seconds' data
+#define FLASH_RECORD_SIZE         (EXAMPLE_I2S_CHANNEL_NUM * EXAMPLE_I2S_SAMPLE_RATE * EXAMPLE_I2S_SAMPLE_BITS / 8 * 5)
+#define FLASH_ERASE_SIZE          (FLASH_RECORD_SIZE % FLASH_SECTOR_SIZE == 0) ? FLASH_RECORD_SIZE : FLASH_RECORD_SIZE + (FLASH_SECTOR_SIZE - FLASH_RECORD_SIZE % FLASH_SECTOR_SIZE)
+//sector size of flash
+#define FLASH_SECTOR_SIZE         (0x1000)
+//flash read / write address
+#define FLASH_ADDR                (0x200000)
+
+
+/**
+ * @brief I2S ADC/DAC mode init.
+ */
+void example_i2s_init(void)
+{
+     int i2s_num = EXAMPLE_I2S_NUM;
+     i2s_config_t i2s_config = {
+        .mode = I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_TX | I2S_MODE_DAC_BUILT_IN | I2S_MODE_ADC_BUILT_IN,
+        .sample_rate =  EXAMPLE_I2S_SAMPLE_RATE,
+        .bits_per_sample = EXAMPLE_I2S_SAMPLE_BITS,
+        .communication_format = I2S_COMM_FORMAT_STAND_MSB,
+        .channel_format = EXAMPLE_I2S_FORMAT,
+        .intr_alloc_flags = 0,
+        .dma_buf_count = 2,
+        .dma_buf_len = 1024,
+        .use_apll = 1,
+     };
+     //install and start i2s driver
+     i2s_driver_install(i2s_num, &i2s_config, 0, NULL);
+     //init DAC pad
+     i2s_set_dac_mode(I2S_DAC_CHANNEL_BOTH_EN);
+     //init ADC pad
+     i2s_set_adc_mode(I2S_ADC_UNIT, I2S_ADC_CHANNEL);
+}
+
+/*
+ * @brief erase flash for recording
+ */
+void example_erase_flash(void)
+{
+#if RECORD_IN_FLASH_EN
+    printf("Erasing flash \n");
+    const esp_partition_t *data_partition = NULL;
+    data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
+            ESP_PARTITION_SUBTYPE_DATA_FAT, PARTITION_NAME);
+    if (data_partition != NULL) {
+        printf("partiton addr: 0x%08x; size: %d; label: %s\n", data_partition->address, data_partition->size, data_partition->label);
+    }
+    printf("Erase size: %d Bytes\n", FLASH_ERASE_SIZE);
+    ESP_ERROR_CHECK(esp_partition_erase_range(data_partition, 0, FLASH_ERASE_SIZE));
+#else
+    printf("Skip flash erasing...\n");
+#endif
+}
+
+/**
+ * @brief debug buffer data
+ */
+void example_disp_buf(uint8_t* buf, int length)
+{
+#if EXAMPLE_I2S_BUF_DEBUG
+    printf("======\n");
+    for (int i = 0; i < length; i++) {
+        printf("%02x ", buf[i]);
+        if ((i + 1) % 8 == 0) {
+            printf("\n");
+        }
+    }
+    printf("======\n");
+#endif
+}
+
+/**
+ * @brief Reset i2s clock and mode
+ */
+void example_reset_play_mode(void)
+{
+    i2s_set_clk(EXAMPLE_I2S_NUM, EXAMPLE_I2S_SAMPLE_RATE, EXAMPLE_I2S_SAMPLE_BITS, EXAMPLE_I2S_CHANNEL_NUM);
+}
+
+/**
+ * @brief Set i2s clock for example audio file
+ */
+void example_set_file_play_mode(void)
+{
+    i2s_set_clk(EXAMPLE_I2S_NUM, 16000, EXAMPLE_I2S_SAMPLE_BITS, 1);
+}
+
+/**
+ * @brief Scale data to 16bit/32bit for I2S DMA output.
+ *        DAC can only output 8bit data value.
+ *        I2S DMA will still send 16 bit or 32bit data, the highest 8bit contains DAC data.
+ */
+int example_i2s_dac_data_scale(uint8_t* d_buff, uint8_t* s_buff, uint32_t len)
+{
+    uint32_t j = 0;
+#if (EXAMPLE_I2S_SAMPLE_BITS == 16)
+    for (int i = 0; i < len; i++) {
+        d_buff[j++] = 0;
+        d_buff[j++] = s_buff[i];
+    }
+    return (len * 2);
+#else
+    for (int i = 0; i < len; i++) {
+        d_buff[j++] = 0;
+        d_buff[j++] = 0;
+        d_buff[j++] = 0;
+        d_buff[j++] = s_buff[i];
+    }
+    return (len * 4);
+#endif
+}
+
+/**
+ * @brief Scale data to 8bit for data from ADC.
+ *        Data from ADC are 12bit width by default.
+ *        DAC can only output 8 bit data.
+ *        Scale each 12bit ADC data to 8bit DAC data.
+ */
+void example_i2s_adc_data_scale(uint8_t * d_buff, uint8_t* s_buff, uint32_t len)
+{
+    uint32_t j = 0;
+    uint32_t dac_value = 0;
+#if (EXAMPLE_I2S_SAMPLE_BITS == 16)
+    for (int i = 0; i < len; i += 2) {
+        dac_value = ((((uint16_t) (s_buff[i + 1] & 0xf) << 8) | ((s_buff[i + 0]))));
+        d_buff[j++] = 0;
+        d_buff[j++] = dac_value * 256 / 4096;
+    }
+#else
+    for (int i = 0; i < len; i += 4) {
+        dac_value = ((((uint16_t)(s_buff[i + 3] & 0xf) << 8) | ((s_buff[i + 2]))));
+        d_buff[j++] = 0;
+        d_buff[j++] = 0;
+        d_buff[j++] = 0;
+        d_buff[j++] = dac_value * 256 / 4096;
+    }
+#endif
+}
+
+/**
+ * @brief I2S ADC/DAC example
+ *        1. Erase flash
+ *        2. Record audio from ADC and save in flash
+ *        3. Read flash and replay the sound via DAC
+ *        4. Play an example audio file(file format: 8bit/8khz/single channel)
+ *        5. Loop back to step 3
+ */
+void example_i2s_adc_dac(void*arg)
+{
+    const esp_partition_t *data_partition = NULL;
+    data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
+            ESP_PARTITION_SUBTYPE_DATA_FAT, PARTITION_NAME);
+    if (data_partition != NULL) {
+        printf("partiton addr: 0x%08x; size: %d; label: %s\n", data_partition->address, data_partition->size, data_partition->label);
+    } else {
+        ESP_LOGE(TAG, "Partition error: can't find partition name: %s\n", PARTITION_NAME);
+        vTaskDelete(NULL);
+    }
+    //1. Erase flash
+    example_erase_flash();
+    int i2s_read_len = EXAMPLE_I2S_READ_LEN;
+    int flash_wr_size = 0;
+    size_t bytes_read, bytes_written;
+
+    //2. Record audio from ADC and save in flash
+#if RECORD_IN_FLASH_EN
+    char* i2s_read_buff = (char*) calloc(i2s_read_len, sizeof(char));
+    uint8_t* flash_write_buff = (uint8_t*) calloc(i2s_read_len, sizeof(char));
+    i2s_adc_enable(EXAMPLE_I2S_NUM);
+    while (flash_wr_size < FLASH_RECORD_SIZE) {
+        //read data from I2S bus, in this case, from ADC.
+        i2s_read(EXAMPLE_I2S_NUM, (void*) i2s_read_buff, i2s_read_len, &bytes_read, portMAX_DELAY);
+        example_disp_buf((uint8_t*) i2s_read_buff, 64);
+        //save original data from I2S(ADC) into flash.
+        esp_partition_write(data_partition, flash_wr_size, i2s_read_buff, i2s_read_len);
+        flash_wr_size += i2s_read_len;
+        ets_printf("Sound recording %u%%\n", flash_wr_size * 100 / FLASH_RECORD_SIZE);
+    }
+    i2s_adc_disable(EXAMPLE_I2S_NUM);
+    free(i2s_read_buff);
+    i2s_read_buff = NULL;
+    free(flash_write_buff);
+    flash_write_buff = NULL;
+#endif
+
+    uint8_t* flash_read_buff = (uint8_t*) calloc(i2s_read_len, sizeof(char));
+    uint8_t* i2s_write_buff = (uint8_t*) calloc(i2s_read_len, sizeof(char));
+    while (1) {
+
+        //3. Read flash and replay the sound via DAC
+#if REPLAY_FROM_FLASH_EN
+        for (int rd_offset = 0; rd_offset < flash_wr_size; rd_offset += FLASH_SECTOR_SIZE) {
+            //read I2S(ADC) original data from flash
+            esp_partition_read(data_partition, rd_offset, flash_read_buff, FLASH_SECTOR_SIZE);
+            //process data and scale to 8bit for I2S DAC.
+            example_i2s_adc_data_scale(i2s_write_buff, flash_read_buff, FLASH_SECTOR_SIZE);
+            //send data
+            i2s_write(EXAMPLE_I2S_NUM, i2s_write_buff, FLASH_SECTOR_SIZE, &bytes_written, portMAX_DELAY);
+            printf("playing: %d %%\n", rd_offset * 100 / flash_wr_size);
+        }
+#endif
+
+        //4. Play an example audio file(file format: 8bit/16khz/single channel)
+        printf("Playing file example: \n");
+        int offset = 0;
+        int tot_size = sizeof(audio_table);
+        example_set_file_play_mode();
+        while (offset < tot_size) {
+            int play_len = ((tot_size - offset) > (4 * 1024)) ? (4 * 1024) : (tot_size - offset);
+            int i2s_wr_len = example_i2s_dac_data_scale(i2s_write_buff, (uint8_t*)(audio_table + offset), play_len);
+            i2s_write(EXAMPLE_I2S_NUM, i2s_write_buff, i2s_wr_len, &bytes_written, portMAX_DELAY);
+            offset += play_len;
+            example_disp_buf((uint8_t*) i2s_write_buff, 32);
+        }
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+        example_reset_play_mode();
+    }
+    free(flash_read_buff);
+    free(i2s_write_buff);
+    vTaskDelete(NULL);
+}
+
+void adc_read_task(void* arg)
+{
+    adc1_config_width(ADC_WIDTH_12Bit);
+    adc1_config_channel_atten(ADC1_TEST_CHANNEL, ADC_ATTEN_11db);
+    esp_adc_cal_characteristics_t characteristics;
+    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, V_REF, &characteristics);
+    while(1) {
+        uint32_t voltage;
+        esp_adc_cal_get_voltage(ADC1_TEST_CHANNEL, &characteristics, &voltage);
+        ESP_LOGI(TAG, "%d mV", voltage);
+        vTaskDelay(200 / portTICK_RATE_MS);
+    }
+}
+
+esp_err_t app_main(void)
+{
+    example_i2s_init();
+    esp_log_level_set("I2S", ESP_LOG_INFO);
+    xTaskCreate(example_i2s_adc_dac, "example_i2s_adc_dac", 1024 * 2, NULL, 5, NULL);
+    xTaskCreate(adc_read_task, "ADC read task", 2048, NULL, 5, NULL);
+    return ESP_OK;
+}
+#endif

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

@@ -0,0 +1,5 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
+

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/partitions_adc_dac_example.csv

@@ -0,0 +1,6 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
+nvs,      data, nvs,     0x9000,  0x6000,
+phy_init, data, phy,     0xf000,  0x1000,
+factory,  app,  factory, 0x10000, 1M,
+storage,  data, fat,     , 2M, 

firmware/esp-idf/wumei-smart-firmware/examples/peripherals/i2s_adc_dac/tools/generate_audio_file.py

@@ -0,0 +1,43 @@
+from __future__ import print_function
+from builtins import range
+import os
+import wave
+import struct
+
+
+def get_wave_array_str(filename, target_bits):
+    wave_read = wave.open(filename, "r")
+    array_str = ""
+    nchannels, sampwidth, framerate, nframes, comptype, compname = wave_read.getparams()
+    sampwidth *= 8
+    for i in range(wave_read.getnframes()):
+        val, = struct.unpack("<H", wave_read.readframes(1))
+        scale_val = (1 << target_bits) - 1
+        cur_lim   = (1 << sampwidth) - 1
+        # scale current data to 8-bit data
+        val       = val * scale_val / cur_lim
+        val       = int(val + ((scale_val + 1) // 2)) & scale_val
+        array_str += "0x%x, " % (val)
+        if (i + 1) % 16 == 0:
+            array_str += "\n"
+    return array_str
+
+
+def gen_wave_table(wav_file_list, target_file_name, scale_bits=8):
+    with open(target_file_name, "w") as audio_table:
+        print('#include <stdio.h>', file=audio_table)
+        print('const unsigned char audio_table[] = {', file=audio_table)
+        for wav in wav_file_list:
+            print("processing: {}".format(wav))
+            print(get_wave_array_str(filename=wav, target_bits=scale_bits), file=audio_table)
+        print('};\n', file=audio_table)
+    print("Done...")
+
+
+if __name__ == '__main__':
+    print("Generating audio array...")
+    wav_list = []
+    for filename in os.listdir("./"):
+        if filename.endswith(".wav"):
+            wav_list.append(filename)
+    gen_wave_table(wav_file_list=wav_list, target_file_name="audio_example_file.h")