/** * @brief Handle when a pattern has been detected by UART * * @param esp_dte ESP32 Modem DTE object */ static void esp_handle_uart_pattern(esp_modem_dte_t *esp_dte) { int pos = uart_pattern_pop_pos(esp_dte->uart_port); int read_len = 0; if (pos != -1) { if (pos < ESP_MODEM_LINE_BUFFER_SIZE - 1) { /* read one line(include '\n') */ read_len = pos + 1; } else { ESP_LOGW(MODEM_TAG, "ESP Modem Line buffer too small"); read_len = ESP_MODEM_LINE_BUFFER_SIZE - 1; } read_len = uart_read_bytes(esp_dte->uart_port, esp_dte->buffer, read_len, pdMS_TO_TICKS(100)); if (read_len) { /* make sure the line is a standard string */ esp_dte->buffer[read_len] = '\0'; /* Send new line to handle */ esp_dte_handle_line(esp_dte); } else { ESP_LOGE(MODEM_TAG, "uart read bytes failed"); } } else { ESP_LOGW(MODEM_TAG, "Pattern Queue Size too small"); uart_flush(esp_dte->uart_port); } }
void disconnectCallbackHandler(AWS_IoT_Client *pClient, void *data) { ESP_LOGW(TAG, "MQTT Disconnect"); IoT_Error_t rc = FAILURE; if(NULL == pClient) { return; } if(aws_iot_is_autoreconnect_enabled(pClient)) { ESP_LOGI(TAG, "Auto Reconnect is enabled, Reconnecting attempt will start now"); } else { ESP_LOGW(TAG, "Auto Reconnect not enabled. Starting manual reconnect..."); // rc = aws_iot_mqtt_attempt_reconnect(pClient); if(NETWORK_RECONNECTED == rc) { ESP_LOGW(TAG, "Manual Reconnect Successful"); } else { ESP_LOGW(TAG, "Manual Reconnect Failed - %d", rc); } } }
/* Deallocates a mailbox. If there are messages still present in the mailbox when the mailbox is deallocated, it is an indication of a programming error in lwIP and the developer should be notified. */ void sys_mbox_free(sys_mbox_t *mbox) { uint32_t mbox_message_num = 0; if ( (NULL == mbox) || (NULL == *mbox) ) { return; } mbox_message_num = uxQueueMessagesWaiting((*mbox)->os_mbox); LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("mbox free: mbox=%p os_mbox=%p owner=%p msg_num=%d\n", *mbox, (*mbox)->os_mbox, (*mbox)->owner, mbox_message_num)); #if ESP_THREAD_SAFE if ((*mbox)->owner) { if (0 == mbox_message_num) { /* * If mbox->owner is not NULL, it indicates the mbox is recvmbox or acceptmbox, * we need to post a NULL message to mbox in case some application tasks are blocked * on this mbox */ if (sys_mbox_trypost(mbox, NULL) != ERR_OK) { /* Should never be here because post a message to empty mbox should always be successful */ ESP_LOGW(TAG, "WARNING: failed to post NULL msg to mbox\n"); } else { LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("mbox free: post null successfully\n")); } } (*mbox)->owner = NULL; } else { if (mbox_message_num > 1) { ESP_LOGW(TAG, "WARNING: mbox has %d message, potential memory leaking\n", mbox_message_num); } if (mbox_message_num > 0) { LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("mbox free: reset mbox queue\n")); xQueueReset((*mbox)->os_mbox); } /* For recvmbox or acceptmbox, free them in netconn_free() when all sockets' API are returned */ vQueueDelete((*mbox)->os_mbox); free(*mbox); *mbox = NULL; } #else vQueueDelete((*mbox)->os_mbox); free(*mbox); *mbox = NULL; #endif }
/** * @brief Start an instance of the task. * * @param [in] taskData Data to be passed into the task. * @return N/A. */ void Task::start(void* taskData) { if (m_handle != nullptr) { ESP_LOGW(LOG_TAG, "Task::start - There might be a task already running!"); } m_taskData = taskData; ::xTaskCreatePinnedToCore(&runTask, m_taskName.c_str(), m_stackSize, this, m_priority, &m_handle, m_coreId); } // start
static esp_err_t encrypt_bootloader() { esp_err_t err; uint32_t image_length; /* Check for plaintext bootloader (verification will fail if it's already encrypted) */ if (esp_image_verify_bootloader(&image_length) == ESP_OK) { ESP_LOGD(TAG, "bootloader is plaintext. Encrypting..."); err = esp_flash_encrypt_region(ESP_BOOTLOADER_OFFSET, image_length); if (err != ESP_OK) { ESP_LOGE(TAG, "Failed to encrypt bootloader in place: 0x%x", err); return err; } if (esp_secure_boot_enabled()) { /* If secure boot is enabled and bootloader was plaintext, also need to encrypt secure boot IV+digest. */ ESP_LOGD(TAG, "Encrypting secure bootloader IV & digest..."); err = esp_flash_encrypt_region(FLASH_OFFS_SECURE_BOOT_IV_DIGEST, FLASH_SECTOR_SIZE); if (err != ESP_OK) { ESP_LOGE(TAG, "Failed to encrypt bootloader IV & digest in place: 0x%x", err); return err; } } } else { ESP_LOGW(TAG, "no valid bootloader was found"); } return ESP_OK; }
static int httpd_sock_err(const char *ctx, int sockfd) { int errval; int sock_err; size_t sock_err_len = sizeof(sock_err); if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &sock_err, &sock_err_len) < 0) { ESP_LOGE(TAG, LOG_FMT("error calling getsockopt : %d"), errno); return HTTPD_SOCK_ERR_FAIL; } ESP_LOGW(TAG, LOG_FMT("error in %s : %d"), ctx, sock_err); switch(sock_err) { case EAGAIN: case EINTR: errval = HTTPD_SOCK_ERR_TIMEOUT; break; case EINVAL: case EBADF: case EFAULT: case ENOTSOCK: errval = HTTPD_SOCK_ERR_INVALID; break; default: errval = HTTPD_SOCK_ERR_FAIL; } return errval; }
/** * 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
int httpd_req_recv(httpd_req_t *r, char *buf, size_t buf_len) { if (r == NULL || buf == NULL) { return HTTPD_SOCK_ERR_INVALID; } if (!httpd_valid_req(r)) { ESP_LOGW(TAG, LOG_FMT("invalid request")); return HTTPD_SOCK_ERR_INVALID; } struct httpd_req_aux *ra = r->aux; ESP_LOGD(TAG, LOG_FMT("remaining length = %d"), ra->remaining_len); if (buf_len > ra->remaining_len) { buf_len = ra->remaining_len; } if (buf_len == 0) { return buf_len; } int ret = httpd_recv(r, buf, buf_len); if (ret < 0) { ESP_LOGD(TAG, LOG_FMT("error in httpd_recv")); return ret; } ra->remaining_len -= ret; ESP_LOGD(TAG, LOG_FMT("received length = %d"), ret); return ret; }
/** * @brief Notify phase callback which is called on each PPP internal state change * * @param pcb PPP control block * @param phase Phase ID * @param ctx Context of callback */ static void on_ppp_notify_phase(ppp_pcb *pcb, u8_t phase, void *ctx) { switch (phase) { case PPP_PHASE_DEAD: ESP_LOGD(MODEM_TAG, "Phase Dead"); break; case PPP_PHASE_INITIALIZE: ESP_LOGD(MODEM_TAG, "Phase Start"); break; case PPP_PHASE_ESTABLISH: ESP_LOGD(MODEM_TAG, "Phase Establish"); break; case PPP_PHASE_AUTHENTICATE: ESP_LOGD(MODEM_TAG, "Phase Authenticate"); break; case PPP_PHASE_NETWORK: ESP_LOGD(MODEM_TAG, "Phase Network"); break; case PPP_PHASE_RUNNING: ESP_LOGD(MODEM_TAG, "Phase Running"); break; case PPP_PHASE_TERMINATE: ESP_LOGD(MODEM_TAG, "Phase Terminate"); break; case PPP_PHASE_DISCONNECT: ESP_LOGD(MODEM_TAG, "Phase Disconnect"); break; default: ESP_LOGW(MODEM_TAG, "Phase Unknown: %d", phase); break; } }
static esp_err_t slave_slchost_reg_write(sdmmc_card_t* card, uint32_t addr, uint32_t val) { if ((addr & DR_REG_SLCHOST_MASK) != DR_REG_SLCHOST_BASE) { ESP_LOGW(TAG, "%s: invalid addr 0x%08x\n", __func__, addr); return ESP_ERR_INVALID_ARG; } return sdmmc_io_write_bytes(card, 1, addr & (~DR_REG_SLCHOST_MASK), &val, sizeof(val)); }
static esp_err_t httpd_accept_conn(struct httpd_data *hd, int listen_fd) { /* If no space is available for new session, close the least recently used one */ if (hd->config.lru_purge_enable == true) { if (!httpd_is_sess_available(hd)) { /* Queue asynchronous closure of the least recently used session */ return httpd_sess_close_lru(hd); /* Returning from this allowes the main server thread to process * the queued asynchronous control message for closing LRU session. * Since connection request hasn't been addressed yet using accept() * therefore httpd_accept_conn() will be called again, but this time * with space available for one session */ } } struct sockaddr_in addr_from; socklen_t addr_from_len = sizeof(addr_from); int new_fd = accept(listen_fd, (struct sockaddr *)&addr_from, &addr_from_len); if (new_fd < 0) { ESP_LOGW(TAG, LOG_FMT("error in accept (%d)"), errno); return ESP_FAIL; } ESP_LOGD(TAG, LOG_FMT("newfd = %d"), new_fd); struct timeval tv; /* Set recv timeout of this fd as per config */ tv.tv_sec = hd->config.recv_wait_timeout; tv.tv_usec = 0; setsockopt(new_fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)); /* Set send timeout of this fd as per config */ tv.tv_sec = hd->config.send_wait_timeout; tv.tv_usec = 0; setsockopt(new_fd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&tv, sizeof(tv)); if (ESP_OK != httpd_sess_new(hd, new_fd)) { ESP_LOGW(TAG, LOG_FMT("session creation failed")); close(new_fd); return ESP_FAIL; } ESP_LOGD(TAG, LOG_FMT("complete")); return ESP_OK; }
void MQTTCloseSession(MQTTClient *c) { ESP_LOGW(TAG, "mqtt close session"); c->ping_outstanding = 0; c->isconnected = 0; if (c->cleansession) { MQTTCleanSession(c); } }
/** * @brief UART Event Task Entry * * @param param task parameter */ static void uart_event_task_entry(void *param) { esp_modem_dte_t *esp_dte = (esp_modem_dte_t *)param; uart_event_t event; while (1) { if (xQueueReceive(esp_dte->event_queue, &event, pdMS_TO_TICKS(100))) { switch (event.type) { case UART_DATA: esp_handle_uart_data(esp_dte); break; case UART_FIFO_OVF: ESP_LOGW(MODEM_TAG, "HW FIFO Overflow"); uart_flush_input(esp_dte->uart_port); xQueueReset(esp_dte->event_queue); break; case UART_BUFFER_FULL: ESP_LOGW(MODEM_TAG, "Ring Buffer Full"); uart_flush_input(esp_dte->uart_port); xQueueReset(esp_dte->event_queue); break; case UART_BREAK: ESP_LOGW(MODEM_TAG, "Rx Break"); break; case UART_PARITY_ERR: ESP_LOGE(MODEM_TAG, "Parity Error"); break; case UART_FRAME_ERR: ESP_LOGE(MODEM_TAG, "Frame Error"); break; case UART_PATTERN_DET: esp_handle_uart_pattern(esp_dte); break; default: ESP_LOGW(MODEM_TAG, "unknown uart event type: %d", event.type); break; } } /* Drive the event loop */ esp_event_loop_run(esp_dte->event_loop_hdl, pdMS_TO_TICKS(50)); } vTaskDelete(NULL); }
esp_err_t sdmmc_init_mmc_read_ext_csd(sdmmc_card_t* card) { int card_type; esp_err_t err = ESP_OK; uint8_t* ext_csd = heap_caps_malloc(EXT_CSD_MMC_SIZE, MALLOC_CAP_DMA); if (!ext_csd) { ESP_LOGE(TAG, "%s: could not allocate ext_csd", __func__); return ESP_ERR_NO_MEM; } uint32_t sectors = 0; ESP_LOGD(TAG, "MMC version: %d", card->csd.mmc_ver); if (card->csd.mmc_ver < MMC_CSD_MMCVER_4_0) { err = ESP_ERR_NOT_SUPPORTED; goto out; } /* read EXT_CSD */ err = sdmmc_mmc_send_ext_csd_data(card, ext_csd, EXT_CSD_MMC_SIZE); if (err != ESP_OK) { ESP_LOGE(TAG, "%s: send_ext_csd_data error 0x%x", __func__, err); goto out; } card_type = ext_csd[EXT_CSD_CARD_TYPE]; card->is_ddr = 0; if (card_type & EXT_CSD_CARD_TYPE_F_52M_1_8V) { card->max_freq_khz = SDMMC_FREQ_52M; if ((card->host.flags & SDMMC_HOST_FLAG_DDR) && card->host.max_freq_khz >= SDMMC_FREQ_26M && card->host.get_bus_width(card->host.slot) == 4) { ESP_LOGD(TAG, "card and host support DDR mode"); card->is_ddr = 1; } } else if (card_type & EXT_CSD_CARD_TYPE_F_52M) { card->max_freq_khz = SDMMC_FREQ_52M; } else if (card_type & EXT_CSD_CARD_TYPE_F_26M) { card->max_freq_khz = SDMMC_FREQ_26M; } else { ESP_LOGW(TAG, "%s: unknown CARD_TYPE 0x%x", __func__, card_type); } /* For MMC cards, use speed value from EXT_CSD */ card->csd.tr_speed = card->max_freq_khz * 1000; ESP_LOGD(TAG, "MMC card type %d, max_freq_khz=%d, is_ddr=%d", card_type, card->max_freq_khz, card->is_ddr); card->max_freq_khz = MIN(card->max_freq_khz, card->host.max_freq_khz); if (card->host.flags & SDMMC_HOST_FLAG_8BIT) { card->ext_csd.power_class = ext_csd[(card->max_freq_khz > SDMMC_FREQ_26M) ? EXT_CSD_PWR_CL_52_360 : EXT_CSD_PWR_CL_26_360] >> 4; card->log_bus_width = 3; } else if (card->host.flags & SDMMC_HOST_FLAG_4BIT) {
int check_working_socket() { int ret; #if EXAMPLE_ESP_TCP_MODE_SERVER ESP_LOGD(TAG, "check server_socket"); ret = get_socket_error_code(server_socket); if(ret != 0) { ESP_LOGW(TAG, "server socket error %d %s", ret, strerror(ret)); } if(ret == ECONNRESET) return ret; #endif ESP_LOGD(TAG, "check connect_socket"); ret = get_socket_error_code(connect_socket); if(ret != 0) { ESP_LOGW(TAG, "connect socket error %d %s", ret, strerror(ret)); } if(ret != 0) return ret; return 0; }
int httpd_req_to_sockfd(httpd_req_t *r) { if (r == NULL) { return -1; } if (!httpd_valid_req(r)) { ESP_LOGW(TAG, LOG_FMT("invalid request")); return -1; } struct httpd_req_aux *ra = r->aux; return ra->sd->fd; }
void bootloader_utility_load_boot_image(const bootloader_state_t *bs, int start_index) { int index = start_index; esp_partition_pos_t part; esp_image_metadata_t image_data; if(start_index == TEST_APP_INDEX) { if (try_load_partition(&bs->test, &image_data)) { load_image(&image_data); } else { ESP_LOGE(TAG, "No bootable test partition in the partition table"); bootloader_reset(); } } /* work backwards from start_index, down to the factory app */ for(index = start_index; index >= FACTORY_INDEX; index--) { part = index_to_partition(bs, index); if (part.size == 0) { continue; } ESP_LOGD(TAG, TRY_LOG_FORMAT, index, part.offset, part.size); if (try_load_partition(&part, &image_data)) { load_image(&image_data); } log_invalid_app_partition(index); } /* failing that work forwards from start_index, try valid OTA slots */ for(index = start_index + 1; index < bs->app_count; index++) { part = index_to_partition(bs, index); if (part.size == 0) { continue; } ESP_LOGD(TAG, TRY_LOG_FORMAT, index, part.offset, part.size); if (try_load_partition(&part, &image_data)) { load_image(&image_data); } log_invalid_app_partition(index); } if (try_load_partition(&bs->test, &image_data)) { ESP_LOGW(TAG, "Falling back to test app as only bootable partition"); load_image(&image_data); } ESP_LOGE(TAG, "No bootable app partitions in the partition table"); bzero(&image_data, sizeof(esp_image_metadata_t)); bootloader_reset(); }
static int ssl_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms) { int poll, ret; transport_ssl_t *ssl = esp_transport_get_context_data(t); if ((poll = esp_transport_poll_write(t, timeout_ms)) <= 0) { ESP_LOGW(TAG, "Poll timeout or error, errno=%s, fd=%d, timeout_ms=%d", strerror(errno), ssl->tls->sockfd, timeout_ms); return poll; } ret = esp_tls_conn_write(ssl->tls, (const unsigned char *) buffer, len); if (ret <= 0) { ESP_LOGE(TAG, "esp_tls_conn_write error, errno=%s", strerror(errno)); } return ret; }
/* Deallocates a mailbox. If there are messages still present in the mailbox when the mailbox is deallocated, it is an indication of a programming error in lwIP and the developer should be notified. */ void sys_mbox_free(sys_mbox_t *mbox) { #define MAX_POLL_CNT 100 #define PER_POLL_DELAY 20 uint16_t count = 0; bool post_null = true; LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: set alive false\n")); (*mbox)->alive = false; while ( count++ < MAX_POLL_CNT ){ //ESP32_WORKAROUND LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:try lock=%d\n", count)); if (!sys_mutex_trylock( &(*mbox)->lock )){ LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:get lock ok %d\n", count)); sys_mutex_unlock( &(*mbox)->lock ); break; } if (post_null){ LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null to mbox\n")); if (sys_mbox_trypost( mbox, NULL) != ERR_OK){ ESP_STATS_DROP_INC(esp.free_mbox_post_fail); LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null mbox fail\n")); } else { post_null = false; LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null mbox ok\n")); } } if (count == (MAX_POLL_CNT-1)){ ESP_LOGW(TAG, "WARNING: mbox %p had a consumer who never unblocked. Leaking!\n", (*mbox)->os_mbox); } sys_delay_ms(PER_POLL_DELAY); } LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:free mbox\n")); if (uxQueueMessagesWaiting((*mbox)->os_mbox)) { xQueueReset((*mbox)->os_mbox); /* Line for breakpoint. Should never break here! */ __asm__ volatile ("nop"); }
static esp_err_t slave_slc_reg_read(sdmmc_card_t* card, uint32_t addr, uint32_t* val) { if ((addr & DR_REG_SLC_MASK) != DR_REG_SLC_BASE) { ESP_LOGW(TAG, "%s: invalid addr 0x%08x\n", __func__, addr); return ESP_ERR_INVALID_ARG; } uint32_t word = (addr - DR_REG_SLC_BASE) / 4; if (word > INT8_MAX) { return ESP_ERR_INVALID_ARG; } uint32_t window_command = word | (SLC_WIN_CMD_READ << SLC_WIN_CMD_S); esp_err_t err = slave_slchost_reg_write(card, SLCHOST_WIN_CMD, window_command); if (err != ESP_OK) { return err; } return slave_slchost_reg_read(card, SLCHOST_STATE_W0, val); }
/** * @brief Create a %BLE Service. * * With a %BLE server, we can host one or more services. Invoking this function causes the creation of a definition * of a new service. Every service must have a unique UUID. * @param [in] uuid The UUID of the new service. * @param [in] numHandles The maximum number of handles associated with this service. * @param [in] inst_id With multiple services with the same UUID we need to provide inst_id value different for each service. * @return A reference to the new service object. */ BLEService* BLEServer::createService(BLEUUID uuid, uint32_t numHandles, uint8_t inst_id) { ESP_LOGD(LOG_TAG, ">> createService - %s", uuid.toString().c_str()); m_semaphoreCreateEvt.take("createService"); // Check that a service with the supplied UUID does not already exist. if (m_serviceMap.getByUUID(uuid) != nullptr) { ESP_LOGW(LOG_TAG, "<< Attempt to create a new service with uuid %s but a service with that UUID already exists.", uuid.toString().c_str()); } BLEService* pService = new BLEService(uuid, numHandles); pService->m_instId = inst_id; m_serviceMap.setByUUID(uuid, pService); // Save a reference to this service being on this server. pService->executeCreate(this); // Perform the API calls to actually create the service. m_semaphoreCreateEvt.wait("createService"); ESP_LOGD(LOG_TAG, "<< createService"); return pService; } // createService
void esp_phy_load_cal_and_init(void) { esp_phy_calibration_data_t* cal_data = (esp_phy_calibration_data_t*) calloc(sizeof(esp_phy_calibration_data_t), 1); if (cal_data == NULL) { ESP_LOGE(TAG, "failed to allocate memory for RF calibration data"); abort(); } const esp_phy_init_data_t* init_data = esp_phy_get_init_data(); if (init_data == NULL) { ESP_LOGE(TAG, "failed to obtain PHY init data"); abort(); } #ifdef CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE esp_phy_calibration_mode_t calibration_mode = PHY_RF_CAL_PARTIAL; if (rtc_get_reset_reason(0) == DEEPSLEEP_RESET) { calibration_mode = PHY_RF_CAL_NONE; } esp_err_t err = esp_phy_load_cal_data_from_nvs(cal_data); if (err != ESP_OK) { ESP_LOGW(TAG, "failed to load RF calibration data (0x%x), falling back to full calibration", err); calibration_mode = PHY_RF_CAL_FULL; } esp_phy_rf_init(init_data, calibration_mode, cal_data); if (calibration_mode != PHY_RF_CAL_NONE && err != ESP_OK) { err = esp_phy_store_cal_data_to_nvs(cal_data); } else { err = ESP_OK; } #else esp_phy_rf_init(init_data, PHY_RF_CAL_FULL, cal_data); #endif esp_phy_release_init_data(init_data); free(cal_data); // PHY maintains a copy of calibration data, so we can free this }
static void spp_task_task_handler(void *arg) { spp_task_msg_t msg; for (;;) { if (pdTRUE == xQueueReceive(spp_task_task_queue, &msg, (portTickType)portMAX_DELAY)) { ESP_LOGD(SPP_TASK_TAG, "%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event); switch (msg.sig) { case SPP_TASK_SIG_WORK_DISPATCH: spp_task_work_dispatched(&msg); break; default: ESP_LOGW(SPP_TASK_TAG, "%s, unhandled sig: %d", __func__, msg.sig); break; } if (msg.param) { free(msg.param); } } } }
/** * @brief Configure ES8388 ADC and DAC volume. Basicly you can consider this as ADC and DAC gain * * @param mode: set ADC or DAC or all * @param volume: -96 ~ 0 for example Es8388SetAdcDacVolume(ES_MODULE_ADC, 30, 6); means set ADC volume -30.5db * @param dot: whether include 0.5. for example Es8388SetAdcDacVolume(ES_MODULE_ADC, 30, 4); means set ADC volume -30db * * @return * - (-1) Parameter error * - (0) Success */ static int es8388_set_adc_dac_volume(int mode, int volume, int dot) { int res = 0; if ( volume < -96 || volume > 0 ) { ESP_LOGW(ES_TAG, "Warning: volume < -96! or > 0!\n"); if (volume < -96) volume = -96; else volume = 0; } dot = (dot >= 5 ? 1 : 0); volume = (-volume << 1) + dot; if (mode == ES_MODULE_ADC || mode == ES_MODULE_ADC_DAC) { res |= es_write_reg(ES8388_ADDR, ES8388_ADCCONTROL8, volume); res |= es_write_reg(ES8388_ADDR, ES8388_ADCCONTROL9, volume); //ADC Right Volume=0db } if (mode == ES_MODULE_DAC || mode == ES_MODULE_ADC_DAC) { res |= es_write_reg(ES8388_ADDR, ES8388_DACCONTROL5, volume); res |= es_write_reg(ES8388_ADDR, ES8388_DACCONTROL4, volume); } return res; }
/** * @brief GPS Event Handler * * @param event_handler_arg handler specific arguments * @param event_base event base, here is fixed to ESP_NMEA_EVENT * @param event_id event id * @param event_data event specific arguments */ static void gps_event_handler(void *event_handler_arg, esp_event_base_t event_base, int32_t event_id, void *event_data) { gps_t *gps = NULL; switch (event_id) { case GPS_UPDATE: gps = (gps_t *)event_data; /* print information parsed from GPS statements */ ESP_LOGI(TAG, "%d/%d/%d %d:%d:%d => \r\n" "\t\t\t\t\t\tlatitude = %.05f°N\r\n" "\t\t\t\t\t\tlongtitude = %.05f°E\r\n" "\t\t\t\t\t\taltitude = %.02fm\r\n" "\t\t\t\t\t\tspeed = %fm/s", gps->date.year + YEAR_BASE, gps->date.month, gps->date.day, gps->tim.hour + TIME_ZONE, gps->tim.minute, gps->tim.second, gps->latitude, gps->longitude, gps->altitude, gps->speed); break; case GPS_UNKNOWN: /* print unknown statements */ ESP_LOGW(TAG, "Unknown statement:%s", (char *)event_data); break; default: break; } }
esp_err_t esp_vfs_fat_spiflash_mount(const char* base_path, const char* partition_label, const esp_vfs_fat_mount_config_t* mount_config, wl_handle_t* wl_handle) { esp_err_t result = ESP_OK; const size_t workbuf_size = 4096; void *workbuf = NULL; esp_partition_subtype_t subtype = partition_label ? ESP_PARTITION_SUBTYPE_ANY : ESP_PARTITION_SUBTYPE_DATA_FAT; const esp_partition_t *data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, subtype, partition_label); if (data_partition == NULL) { ESP_LOGE(TAG, "Failed to find FATFS partition (type='data', subtype='fat', partition_label='%s'). Check the partition table.", partition_label); return ESP_ERR_NOT_FOUND; } result = wl_mount(data_partition, wl_handle); if (result != ESP_OK) { ESP_LOGE(TAG, "failed to mount wear levelling layer. result = %i", result); return result; } // connect driver to FATFS BYTE pdrv = 0xFF; if (ff_diskio_get_drive(&pdrv) != ESP_OK) { ESP_LOGD(TAG, "the maximum count of volumes is already mounted"); return ESP_ERR_NO_MEM; } ESP_LOGD(TAG, "using pdrv=%i", pdrv); char drv[3] = {(char)('0' + pdrv), ':', 0}; result = ff_diskio_register_wl_partition(pdrv, *wl_handle); if (result != ESP_OK) { ESP_LOGE(TAG, "ff_diskio_register_wl_partition failed pdrv=%i, error - 0x(%x)", pdrv, result); goto fail; } FATFS *fs; result = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs); if (result == ESP_ERR_INVALID_STATE) { // it's okay, already registered with VFS } else if (result != ESP_OK) { ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", result); goto fail; } // Try to mount partition FRESULT fresult = f_mount(fs, drv, 1); if (fresult != FR_OK) { ESP_LOGW(TAG, "f_mount failed (%d)", fresult); if (!(fresult == FR_NO_FILESYSTEM && mount_config->format_if_mount_failed)) { result = ESP_FAIL; goto fail; } workbuf = malloc(workbuf_size); ESP_LOGI(TAG, "Formatting FATFS partition"); fresult = f_mkfs(drv, FM_ANY | FM_SFD, workbuf_size, workbuf, workbuf_size); if (fresult != FR_OK) { result = ESP_FAIL; ESP_LOGE(TAG, "f_mkfs failed (%d)", fresult); goto fail; } free(workbuf); workbuf = NULL; ESP_LOGI(TAG, "Mounting again"); fresult = f_mount(fs, drv, 0); if (fresult != FR_OK) { result = ESP_FAIL; ESP_LOGE(TAG, "f_mount failed after formatting (%d)", fresult); goto fail; } } return ESP_OK; fail: free(workbuf); esp_vfs_fat_unregister_path(base_path); ff_diskio_unregister(pdrv); return result; }
static void udp_conn(void *pvParameters) { ESP_LOGI(TAG, "task udp_conn start... \n\r"); //等待是否已经成功连接到路由器的标志位 xEventGroupWaitBits(udp_event_group, WIFI_CONNECTED_BIT, false, true, portMAX_DELAY); ESP_LOGI(TAG, "esp32 is ready !!! create udp client or connect servece after 5s... \n\r"); vTaskDelay(5000 / portTICK_RATE_MS); //创建客户端并且检查是否创建成功 #if Server_Station_Option ESP_LOGI(TAG, "Now Let us create udp server ... \n\r"); if (create_udp_server() == ESP_FAIL) { ESP_LOGI(TAG, " server create socket error , stop !!! \n\r"); vTaskDelete(NULL); } else { ESP_LOGI(TAG, "server create socket Succeed !!! \n\r"); } #else ESP_LOGI(TAG, "Now Let us create udp client ... \n\r"); if (create_udp_client() == ESP_FAIL) { ESP_LOGI(TAG, "client create socket error , stop !!! \n\r"); vTaskDelete(NULL); } else { ESP_LOGI(TAG, "client create socket Succeed !!! \n\r"); } #endif //创建一个发送和接收数据的任务 TaskHandle_t tx_rx_task; xTaskCreate(&send_recv_data, "send_recv_data", 4096, NULL, 4, &tx_rx_task); //等待 UDP连接成功标志位 xEventGroupWaitBits(udp_event_group, UDP_CONNCETED_SUCCESS, false, true, portMAX_DELAY); int bps; char sendBuff[1024] = "hello xuhong,I am from Esp32 ..."; while (1) { total_data = 0; vTaskDelay(3000 / portTICK_RATE_MS); //时隔三秒发送一次数据 #if !Server_Station_Option send_Buff_with_UDP(sendBuff, 1024); #endif bps = total_data / 3; if (total_data <= 0) { int err_ret = check_connected_socket(); if (err_ret == -1) { ESP_LOGW(TAG, "udp send & recv stop !!! will close socket ... \n\r"); close_socket(); break; } } ESP_LOGI(TAG, "udp recv %d byte per sec! total pack: %d \n\r", bps, success_pack); } vTaskDelete(tx_rx_task); vTaskDelete(NULL); }
static void https_get_task(void *pvParameters) { char buf[512]; int ret, flags, len; mbedtls_entropy_context entropy; mbedtls_ctr_drbg_context ctr_drbg; mbedtls_ssl_context ssl; mbedtls_x509_crt cacert; mbedtls_ssl_config conf; mbedtls_net_context server_fd; mbedtls_ssl_init(&ssl); mbedtls_x509_crt_init(&cacert); mbedtls_ctr_drbg_init(&ctr_drbg); ESP_LOGI(TAG, "Seeding the random number generator"); mbedtls_ssl_config_init(&conf); mbedtls_entropy_init(&entropy); if((ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0)) != 0) { ESP_LOGE(TAG, "mbedtls_ctr_drbg_seed returned %d", ret); abort(); } ESP_LOGI(TAG, "Loading the CA root certificate..."); ret = mbedtls_x509_crt_parse(&cacert, server_root_cert_pem_start, server_root_cert_pem_end-server_root_cert_pem_start); if(ret < 0) { ESP_LOGE(TAG, "mbedtls_x509_crt_parse returned -0x%x\n\n", -ret); abort(); } ESP_LOGI(TAG, "Setting hostname for TLS session..."); /* Hostname set here should match CN in server certificate */ if((ret = mbedtls_ssl_set_hostname(&ssl, WEB_SERVER)) != 0) { ESP_LOGE(TAG, "mbedtls_ssl_set_hostname returned -0x%x", -ret); abort(); } ESP_LOGI(TAG, "Setting up the SSL/TLS structure..."); if((ret = mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) { ESP_LOGE(TAG, "mbedtls_ssl_config_defaults returned %d", ret); goto exit; } /* MBEDTLS_SSL_VERIFY_OPTIONAL is bad for security, in this example it will print a warning if CA verification fails but it will continue to connect. You should consider using MBEDTLS_SSL_VERIFY_REQUIRED in your own code. */ mbedtls_ssl_conf_authmode(&conf, MBEDTLS_SSL_VERIFY_OPTIONAL); mbedtls_ssl_conf_ca_chain(&conf, &cacert, NULL); mbedtls_ssl_conf_rng(&conf, mbedtls_ctr_drbg_random, &ctr_drbg); #ifdef CONFIG_MBEDTLS_DEBUG mbedtls_esp_enable_debug_log(&conf, 4); #endif if ((ret = mbedtls_ssl_setup(&ssl, &conf)) != 0) { ESP_LOGE(TAG, "mbedtls_ssl_setup returned -0x%x\n\n", -ret); goto exit; } while(1) { /* Wait for the callback to set the CONNECTED_BIT in the event group. */ xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY); ESP_LOGI(TAG, "Connected to AP"); mbedtls_net_init(&server_fd); ESP_LOGI(TAG, "Connecting to %s:%s...", WEB_SERVER, WEB_PORT); if ((ret = mbedtls_net_connect(&server_fd, WEB_SERVER, WEB_PORT, MBEDTLS_NET_PROTO_TCP)) != 0) { ESP_LOGE(TAG, "mbedtls_net_connect returned -%x", -ret); goto exit; } ESP_LOGI(TAG, "Connected."); mbedtls_ssl_set_bio(&ssl, &server_fd, mbedtls_net_send, mbedtls_net_recv, NULL); ESP_LOGI(TAG, "Performing the SSL/TLS handshake..."); while ((ret = mbedtls_ssl_handshake(&ssl)) != 0) { if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) { ESP_LOGE(TAG, "mbedtls_ssl_handshake returned -0x%x", -ret); goto exit; } } ESP_LOGI(TAG, "Verifying peer X.509 certificate..."); if ((flags = mbedtls_ssl_get_verify_result(&ssl)) != 0) { /* In real life, we probably want to close connection if ret != 0 */ ESP_LOGW(TAG, "Failed to verify peer certificate!"); bzero(buf, sizeof(buf)); mbedtls_x509_crt_verify_info(buf, sizeof(buf), " ! ", flags); ESP_LOGW(TAG, "verification info: %s", buf); } else { ESP_LOGI(TAG, "Certificate verified."); } ESP_LOGI(TAG, "Cipher suite is %s", mbedtls_ssl_get_ciphersuite(&ssl)); ESP_LOGI(TAG, "Writing HTTP request..."); size_t written_bytes = 0; do { ret = mbedtls_ssl_write(&ssl, (const unsigned char *)REQUEST + written_bytes, strlen(REQUEST) - written_bytes); if (ret >= 0) { ESP_LOGI(TAG, "%d bytes written", ret); written_bytes += ret; } else if (ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_WANT_READ) { ESP_LOGE(TAG, "mbedtls_ssl_write returned -0x%x", -ret); goto exit; } } while(written_bytes < strlen(REQUEST)); ESP_LOGI(TAG, "Reading HTTP response..."); do { len = sizeof(buf) - 1; bzero(buf, sizeof(buf)); ret = mbedtls_ssl_read(&ssl, (unsigned char *)buf, len); if(ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE) continue; if(ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { ret = 0; break; } if(ret < 0) { ESP_LOGE(TAG, "mbedtls_ssl_read returned -0x%x", -ret); break; } if(ret == 0) { ESP_LOGI(TAG, "connection closed"); break; } len = ret; ESP_LOGD(TAG, "%d bytes read", len); /* Print response directly to stdout as it is read */ for(int i = 0; i < len; i++) { putchar(buf[i]); } } while(1); mbedtls_ssl_close_notify(&ssl); exit: mbedtls_ssl_session_reset(&ssl); mbedtls_net_free(&server_fd); if(ret != 0) { mbedtls_strerror(ret, buf, 100); ESP_LOGE(TAG, "Last error was: -0x%x - %s", -ret, buf); } putchar('\n'); // JSON output doesn't have a newline at end static int request_count; ESP_LOGI(TAG, "Completed %d requests", ++request_count); for(int countdown = 10; countdown >= 0; countdown--) { ESP_LOGI(TAG, "%d...", countdown); vTaskDelay(1000 / portTICK_PERIOD_MS); } ESP_LOGI(TAG, "Starting again!"); } }
esp_err_t esp_read_mac(uint8_t* mac, esp_mac_type_t type) { uint8_t efuse_mac[6]; if (mac == NULL) { ESP_LOGE(TAG, "mac address param is NULL"); return ESP_ERR_INVALID_ARG; } if (type < ESP_MAC_WIFI_STA || type > ESP_MAC_ETH) { ESP_LOGE(TAG, "mac type is incorrect"); return ESP_ERR_INVALID_ARG; } _Static_assert(UNIVERSAL_MAC_ADDR_NUM == FOUR_UNIVERSAL_MAC_ADDR \ || UNIVERSAL_MAC_ADDR_NUM == TWO_UNIVERSAL_MAC_ADDR, \ "incorrect NUM_MAC_ADDRESS_FROM_EFUSE value"); if (esp_base_mac_addr_get(efuse_mac) != ESP_OK) { esp_efuse_mac_get_default(efuse_mac); } switch (type) { case ESP_MAC_WIFI_STA: memcpy(mac, efuse_mac, 6); break; case ESP_MAC_WIFI_SOFTAP: if (UNIVERSAL_MAC_ADDR_NUM == FOUR_UNIVERSAL_MAC_ADDR) { memcpy(mac, efuse_mac, 6); mac[5] += 1; } else if (UNIVERSAL_MAC_ADDR_NUM == TWO_UNIVERSAL_MAC_ADDR) { esp_derive_local_mac(mac, efuse_mac); } break; case ESP_MAC_BT: memcpy(mac, efuse_mac, 6); if (UNIVERSAL_MAC_ADDR_NUM == FOUR_UNIVERSAL_MAC_ADDR) { mac[5] += 2; } else if (UNIVERSAL_MAC_ADDR_NUM == TWO_UNIVERSAL_MAC_ADDR) { mac[5] += 1; } break; case ESP_MAC_ETH: if (UNIVERSAL_MAC_ADDR_NUM == FOUR_UNIVERSAL_MAC_ADDR) { memcpy(mac, efuse_mac, 6); mac[5] += 3; } else if (UNIVERSAL_MAC_ADDR_NUM == TWO_UNIVERSAL_MAC_ADDR) { efuse_mac[5] += 1; esp_derive_local_mac(mac, efuse_mac); } break; default: ESP_LOGW(TAG, "incorrect mac type"); break; } return ESP_OK; }
static esp_err_t esp_spiffs_init(const esp_vfs_spiffs_conf_t* conf) { int index; //find if such partition is already mounted if (esp_spiffs_by_label(conf->partition_label, &index) == ESP_OK) { return ESP_ERR_INVALID_STATE; } if (esp_spiffs_get_empty(&index) != ESP_OK) { ESP_LOGE(TAG, "max mounted partitions reached"); return ESP_ERR_INVALID_STATE; } esp_partition_subtype_t subtype = conf->partition_label ? ESP_PARTITION_SUBTYPE_ANY : ESP_PARTITION_SUBTYPE_DATA_SPIFFS; const esp_partition_t* partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, subtype, conf->partition_label); if (!partition) { ESP_LOGE(TAG, "spiffs partition could not be found"); return ESP_ERR_NOT_FOUND; } if (partition->encrypted) { ESP_LOGE(TAG, "spiffs can not run on encrypted partition"); return ESP_ERR_INVALID_STATE; } esp_spiffs_t * efs = malloc(sizeof(esp_spiffs_t)); if (efs == NULL) { ESP_LOGE(TAG, "esp_spiffs could not be malloced"); return ESP_ERR_NO_MEM; } memset(efs, 0, sizeof(esp_spiffs_t)); efs->cfg.hal_erase_f = spiffs_api_erase; efs->cfg.hal_read_f = spiffs_api_read; efs->cfg.hal_write_f = spiffs_api_write; efs->cfg.log_block_size = g_rom_flashchip.sector_size; efs->cfg.log_page_size = g_rom_flashchip.page_size; efs->cfg.phys_addr = 0; efs->cfg.phys_erase_block = g_rom_flashchip.sector_size; efs->cfg.phys_size = partition->size; efs->by_label = conf->partition_label != NULL; efs->lock = xSemaphoreCreateMutex(); if (efs->lock == NULL) { ESP_LOGE(TAG, "mutex lock could not be created"); esp_spiffs_free(&efs); return ESP_ERR_NO_MEM; } efs->fds_sz = conf->max_files * sizeof(spiffs_fd); efs->fds = malloc(efs->fds_sz); if (efs->fds == NULL) { ESP_LOGE(TAG, "fd buffer could not be malloced"); esp_spiffs_free(&efs); return ESP_ERR_NO_MEM; } memset(efs->fds, 0, efs->fds_sz); #if SPIFFS_CACHE efs->cache_sz = sizeof(spiffs_cache) + conf->max_files * (sizeof(spiffs_cache_page) + efs->cfg.log_page_size); efs->cache = malloc(efs->cache_sz); if (efs->cache == NULL) { ESP_LOGE(TAG, "cache buffer could not be malloced"); esp_spiffs_free(&efs); return ESP_ERR_NO_MEM; } memset(efs->cache, 0, efs->cache_sz); #endif const uint32_t work_sz = efs->cfg.log_page_size * 2; efs->work = malloc(work_sz); if (efs->work == NULL) { ESP_LOGE(TAG, "work buffer could not be malloced"); esp_spiffs_free(&efs); return ESP_ERR_NO_MEM; } memset(efs->work, 0, work_sz); efs->fs = malloc(sizeof(spiffs)); if (efs->fs == NULL) { ESP_LOGE(TAG, "spiffs could not be malloced"); esp_spiffs_free(&efs); return ESP_ERR_NO_MEM; } memset(efs->fs, 0, sizeof(spiffs)); efs->fs->user_data = (void *)efs; efs->partition = partition; s32_t res = SPIFFS_mount(efs->fs, &efs->cfg, efs->work, efs->fds, efs->fds_sz, efs->cache, efs->cache_sz, spiffs_api_check); if (conf->format_if_mount_failed && res != SPIFFS_OK) { ESP_LOGW(TAG, "mount failed, %i. formatting...", SPIFFS_errno(efs->fs)); SPIFFS_clearerr(efs->fs); res = SPIFFS_format(efs->fs); if (res != SPIFFS_OK) { ESP_LOGE(TAG, "format failed, %i", SPIFFS_errno(efs->fs)); SPIFFS_clearerr(efs->fs); esp_spiffs_free(&efs); return ESP_FAIL; } res = SPIFFS_mount(efs->fs, &efs->cfg, efs->work, efs->fds, efs->fds_sz, efs->cache, efs->cache_sz, spiffs_api_check); } if (res != SPIFFS_OK) { ESP_LOGE(TAG, "mount failed, %i", SPIFFS_errno(efs->fs)); SPIFFS_clearerr(efs->fs); esp_spiffs_free(&efs); return ESP_FAIL; } _efs[index] = efs; return ESP_OK; }