void app_main(void) { audio_pipeline_handle_t pipeline; audio_element_handle_t i2s_stream_writer, i2s_stream_reader; esp_log_level_set("*", ESP_LOG_INFO); esp_log_level_set(TAG, ESP_LOG_DEBUG); ESP_LOGI(TAG, "[ 1 ] Start codec chip"); audio_hal_codec_config_t audio_hal_codec_cfg = AUDIO_HAL_ES8388_DEFAULT(); audio_hal_codec_cfg.adc_input = AUDIO_HAL_ADC_INPUT_LINE2; audio_hal_codec_cfg.i2s_iface.samples = AUDIO_HAL_44K_SAMPLES; audio_hal_handle_t hal = audio_hal_init(&audio_hal_codec_cfg, 0); audio_hal_ctrl_codec(hal, AUDIO_HAL_CODEC_MODE_BOTH, AUDIO_HAL_CTRL_START); ESP_LOGI(TAG, "[ 2 ] Create audio pipeline for playback"); audio_pipeline_cfg_t pipeline_cfg = DEFAULT_AUDIO_PIPELINE_CONFIG(); pipeline = audio_pipeline_init(&pipeline_cfg); ESP_LOGI(TAG, "[3.1] Create i2s stream to write data to codec chip"); i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT(); i2s_cfg.type = AUDIO_STREAM_WRITER; i2s_stream_writer = i2s_stream_init(&i2s_cfg); ESP_LOGI(TAG, "[3.2] Create i2s stream to read data from codec chip"); i2s_stream_cfg_t i2s_cfg_read = I2S_STREAM_CFG_DEFAULT(); i2s_cfg_read.type = AUDIO_STREAM_READER; i2s_stream_reader = i2s_stream_init(&i2s_cfg_read); ESP_LOGI(TAG, "[3.3] Register all elements to audio pipeline"); audio_pipeline_register(pipeline, i2s_stream_reader, "i2s_read"); audio_pipeline_register(pipeline, i2s_stream_writer, "i2s_write"); ESP_LOGI(TAG, "[3.4] Link it together [codec_chip]-->i2s_stream_reader-->i2s_stream_writer-->[codec_chip]"); audio_pipeline_link(pipeline, (const char *[]) {"i2s_read", "i2s_write"}, 2);
void app_main(void) { audio_pipeline_handle_t pipeline; audio_element_handle_t i2s_stream_writer, mp3_decoder; esp_log_level_set("*", ESP_LOG_WARN); esp_log_level_set(TAG, ESP_LOG_INFO); ESP_LOGI(TAG, "[ 1 ] Start audio codec chip"); audio_hal_codec_config_t audio_hal_codec_cfg = AUDIO_HAL_ES8388_DEFAULT(); audio_hal_handle_t hal = audio_hal_init(&audio_hal_codec_cfg, 0); audio_hal_ctrl_codec(hal, AUDIO_HAL_CODEC_MODE_DECODE, AUDIO_HAL_CTRL_START); ESP_LOGI(TAG, "[ 2 ] Create audio pipeline, add all elements to pipeline, and subscribe pipeline event"); audio_pipeline_cfg_t pipeline_cfg = DEFAULT_AUDIO_PIPELINE_CONFIG(); pipeline = audio_pipeline_init(&pipeline_cfg); mem_assert(pipeline); ESP_LOGI(TAG, "[2.1] Create mp3 decoder to decode mp3 file and set custom read callback"); mp3_decoder_cfg_t mp3_cfg = DEFAULT_MP3_DECODER_CONFIG(); mp3_decoder = mp3_decoder_init(&mp3_cfg); audio_element_set_read_cb(mp3_decoder, mp3_music_read_cb, NULL); ESP_LOGI(TAG, "[2.2] Create i2s stream to write data to codec chip"); i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT(); i2s_cfg.type = AUDIO_STREAM_WRITER; i2s_stream_writer = i2s_stream_init(&i2s_cfg); ESP_LOGI(TAG, "[2.3] Register all elements to audio pipeline"); audio_pipeline_register(pipeline, mp3_decoder, "mp3"); audio_pipeline_register(pipeline, i2s_stream_writer, "i2s"); ESP_LOGI(TAG, "[2.4] Link it together [mp3_music_read_cb]-->mp3_decoder-->i2s_stream-->[codec_chip]"); audio_pipeline_link(pipeline, (const char *[]) {"mp3", "i2s"}, 2);
void init() { const uart_config_t uart_config = { .baud_rate = 115200, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE }; uart_param_config(UART_NUM_1, &uart_config); uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); // We won't use a buffer for sending data. uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 0, 0, NULL, 0); } int sendData(const char* logName, const char* data) { const int len = strlen(data); const int txBytes = uart_write_bytes(UART_NUM_1, data, len); ESP_LOGI(logName, "Wrote %d bytes", txBytes); return txBytes; } static void tx_task() { static const char *TX_TASK_TAG = "TX_TASK"; esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO); while (1) { sendData(TX_TASK_TAG, "Hello world"); vTaskDelay(2000 / portTICK_PERIOD_MS); } } static void rx_task() { static const char *RX_TASK_TAG = "RX_TASK"; esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO); uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1); while (1) { const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1000 / portTICK_RATE_MS); if (rxBytes > 0) { data[rxBytes] = 0; ESP_LOGI(RX_TASK_TAG, "Read %d bytes: '%s'", rxBytes, data); ESP_LOG_BUFFER_HEXDUMP(RX_TASK_TAG, data, rxBytes, ESP_LOG_INFO); } } free(data); } void app_main() { init(); xTaskCreate(rx_task, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL); xTaskCreate(tx_task, "uart_tx_task", 1024*2, NULL, configMAX_PRIORITIES-1, NULL); }
/** * The ESP-IDF provides a logging/debug mechanism where logging statements can be inserted * into the code. At run time, the logging levels can be adjusted dynamically through * a call to esp_log_level_set. This allows us to selectively switch on or off * distinct log levels. Imagine a situation where you have no logging (normal status) * and something isn't working as desired. Now what you can do is switch on all logging * or a subset of logging through this JavaScript API. */ void jswrap_ESP32_setLogLevel(JsVar *jsTagToSet, JsVar *jsLogLevel) { char tagToSetStr[20]; esp_log_level_t level; ESP_LOGD(tag, ">> jswrap_ESP32_setLogLevel"); // TODO: Add guards for invalid parameters. jsvGetString(jsTagToSet, tagToSetStr, sizeof(tagToSetStr)); // Examine the level string and see what kind of level it is. if (jsvIsStringEqual(jsLogLevel, "verbose")) { level = ESP_LOG_VERBOSE; } else if (jsvIsStringEqual(jsLogLevel, "debug")) { level = ESP_LOG_DEBUG; } else if (jsvIsStringEqual(jsLogLevel, "info")) { level = ESP_LOG_INFO; } else if (jsvIsStringEqual(jsLogLevel, "warn")) { level = ESP_LOG_WARN; } else if (jsvIsStringEqual(jsLogLevel, "error")) { level = ESP_LOG_ERROR; } else if (jsvIsStringEqual(jsLogLevel, "none")) { level = ESP_LOG_NONE; } else { ESP_LOGW(tag, "<< jswrap_ESP32_setLogLevel - Unknown log level"); return; } esp_log_level_set(tagToSetStr, level); // Call the ESP-IDF to set the log level for the given tag. ESP_LOGD(tag, "<< jswrap_ESP32_setLogLevel"); return; } // End of jswrap_ESP32_setLogLevel
static void mqtt_app_start(void) { const esp_mqtt_client_config_t mqtt_cfg = { .uri = "mqtts://test.mosquitto.org:8884", .event_handle = mqtt_event_handler, .client_cert_pem = (const char *)client_cert_pem_start, .client_key_pem = (const char *)client_key_pem_start, }; ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size()); esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg); esp_mqtt_client_start(client); } void app_main() { ESP_LOGI(TAG, "[APP] Startup.."); ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size()); ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version()); esp_log_level_set("*", ESP_LOG_INFO); esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT_TCP", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT_SSL", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE); esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE); nvs_flash_init(); wifi_init(); mqtt_app_start(); }
static void uart_evt_task(void *pvParameters) { int uart_num = UART_NUM_0; uart_config_t uart_config = { .baud_rate = 115200, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, .rx_flow_ctrl_thresh = 122, }; //Set UART parameters uart_param_config(uart_num, &uart_config); //Set UART log level esp_log_level_set(TAG, ESP_LOG_INFO); //Install UART driver, and get the queue. uart_driver_install(uart_num, BUF_SIZE * 2, BUF_SIZE * 2, 10, &uart0_queue, 0); //Set UART pins,(-1: default pin, no change.) //For UART0, we can just use the default pins. //uart_set_pin(uart_num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); //Set uart pattern detect function. uart_enable_pattern_det_intr(uart_num, '+', 3, 10000, 10, 10); //Create a task to handler UART event from ISR xTaskCreate(uart_task, "uart_task", UART_TASK_STACK_SIZE, NULL, UART_TASK_PRIO, NULL); //process data uint8_t* data = (uint8_t*) malloc(BUF_SIZE); do { int len = uart_read_bytes(uart_num, data, BUF_SIZE, 100 / portTICK_RATE_MS); if(len > 0) { //ESP_LOGI(TAG, "uart read : %d", len); //uart_write_bytes(uart_num, (const char*)data, len); uart_input_handler((const char*)data, len); } } while(1); } void uart_init(void) { memset(&rcvMsg, 0, sizeof(rcvMsg)); rcvMsg.RcvBuffSize = RECV_BUF_SIZE; rcvMsg.pRcvMsgBuff = NULL; rcvMsg.pRcvMsgBuff = (uint8_t *) malloc(RECV_BUF_SIZE); if (rcvMsg.pRcvMsgBuff == NULL) { ESP_LOGE(TAG, "receive buffer alloc failed"); return; } rcvMsg.pReadPos = rcvMsg.pRcvMsgBuff; rcvMsg.pWritePos = rcvMsg.pRcvMsgBuff; xTaskCreate(uart_evt_task, "uart_evt_task", UART_EVT_TASK_STACK_SIZE, NULL, UART_EVT_TASK_PRIO, NULL); }
void initialise_wifi(void) { esp_log_level_set("wifi", ESP_LOG_WARN); static bool initialized = false; if (initialized) { return; } tcpip_adapter_init(); wifi_event_group = xEventGroupCreate(); ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) ); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK( esp_wifi_init(&cfg) ); ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) ); ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_NULL) ); ESP_ERROR_CHECK( esp_wifi_start() ); initialized = true; }
void app_main() { ESP_LOGI(TAG, "[APP] Startup.."); ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size()); ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version()); esp_log_level_set("*", ESP_LOG_INFO); esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT_TCP", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT_SSL", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT_WS", ESP_LOG_VERBOSE); esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE); esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE); nvs_flash_init(); wifi_init(); mqtt_app_start(); }