fix(system): fixed issues with unused variable warnings when compiling with NDEBUG

Author: ESP-Marius

components/bt/host/bluedroid/stack/btu/btu_hcif.c

@@ -1748,6 +1748,7 @@ static void btu_hcif_command_status_evt_on_task(BT_HDR *event)
     // check the HCI command integrity: opcode
     hci_cmd_metadata_t *metadata = HCI_GET_CMD_METAMSG(hack->command);
     assert(metadata->opcode == opcode);
+    (void)metadata;
 
     HCI_FREE_CMD_BUF(hack->command);
     osi_free(event);

components/console/esp_console_common.c

@@ -166,8 +166,7 @@ void esp_console_repl_task(void *args)
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
 
     if (repl_com->state_mux != NULL) {
-        BaseType_t ret_val = xSemaphoreTake(repl_com->state_mux, portMAX_DELAY);
-        assert(ret_val == pdTRUE);
+        xSemaphoreTake(repl_com->state_mux, portMAX_DELAY);
     }
 
     /* Change standard input and output of the task if the requested UART is

components/console/esp_console_repl_internal.c

@@ -121,8 +121,7 @@ esp_err_t esp_console_common_deinit(esp_console_repl_com_t *repl_com)
     // wait for the task to notify that
     // esp_console_repl_task returned
     assert(repl_com->state_mux != NULL);
-    BaseType_t ret_val = xSemaphoreTake(repl_com->state_mux, portMAX_DELAY);
-    assert(ret_val == pdTRUE);
+    xSemaphoreTake(repl_com->state_mux, portMAX_DELAY);
 
     // delete the semaphore for the repl state
     vSemaphoreDelete(repl_com->state_mux);

components/driver/test_apps/components/test_driver_utils/test_spi_utils.c

@@ -76,6 +76,7 @@ void spitest_slave_task(void* arg)
     while (1) {
         BaseType_t ret = xQueueReceive(queue, &txdata, portMAX_DELAY);
         assert(ret);
+        (void)ret;
 
         spi_slave_transaction_t t = {};
         t.length = txdata.len;

components/esp_adc/adc_cali_curve_fitting.c

@@ -163,6 +163,8 @@ static void get_first_step_reference_point(int version_num, adc_unit_t unit_id,
     uint32_t digi = 0;
     ret = esp_efuse_rtc_calib_get_cal_voltage(version_num, unit_id, (int)atten, &digi, &voltage);
     assert(ret == ESP_OK);
+    (void)ret;
+
     calib_info->ref_data.ver1.voltage = voltage;
     calib_info->ref_data.ver1.digi = digi;
 }

components/esp_adc/adc_continuous.c

@@ -79,6 +79,7 @@ static IRAM_ATTR bool adc_dma_intr(adc_continuous_ctx_t *adc_digi_ctx)
         else {
             esp_err_t msync_ret = esp_cache_msync((void *)finished_buffer, finished_size, ESP_CACHE_MSYNC_FLAG_DIR_M2C);
             assert(msync_ret == ESP_OK);
+            (void)msync_ret;
         }
 #endif
 
@@ -126,6 +127,7 @@ static IRAM_ATTR bool adc_dma_intr(adc_continuous_ctx_t *adc_digi_ctx)
 #if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE
     esp_err_t msync_ret = esp_cache_msync((void *)(adc_digi_ctx->hal.rx_desc), adc_digi_ctx->adc_desc_size, ESP_CACHE_MSYNC_FLAG_DIR_C2M | ESP_CACHE_MSYNC_FLAG_INVALIDATE);
     assert(msync_ret == ESP_OK);
+    (void)msync_ret;
 #endif
     return need_yield;
 }
@@ -337,6 +339,7 @@ esp_err_t adc_continuous_start(adc_continuous_handle_t handle)
 #if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE
     esp_err_t ret = esp_cache_msync(handle->hal.rx_desc, handle->adc_desc_size, ESP_CACHE_MSYNC_FLAG_DIR_C2M);
     assert(ret == ESP_OK);
+    (void)ret;
 #endif
 
     adc_dma_start(handle->adc_dma, handle->hal.rx_desc);

components/esp_adc/esp32s2/adc_cali_line_fitting.c

@@ -107,6 +107,7 @@ esp_err_t adc_cali_create_scheme_line_fitting(const adc_cali_line_fitting_config
     adc_calib_parsed_info_t efuse_parsed_data = {0};
     bool success = prepare_calib_data_for(config->unit_id, config->atten, &efuse_parsed_data);
     assert(success);
+    (void)success;
     success = calculate_characterization_coefficients(&efuse_parsed_data, chars);
     assert(success);
     ESP_LOGD(TAG, "adc%d (atten leven %d) calibration done: A:%" PRId32" B:%" PRId32, config->unit_id, config->atten, chars->coeff_a, chars->coeff_b);

components/esp_driver_cam/csi/src/esp_cam_ctlr_csi.c

@@ -369,6 +369,7 @@ IRAM_ATTR static bool csi_dma_trans_done_callback(dw_gdma_channel_handle_t chan,
     if ((ctlr->trans.buffer != ctlr->backup_buffer) || ctlr->bk_buffer_exposed) {
         esp_err_t ret = esp_cache_msync((void *)(ctlr->trans.buffer), ctlr->trans.received_size, ESP_CACHE_MSYNC_FLAG_DIR_M2C);
         assert(ret == ESP_OK);
+        (void)ret;
         assert(ctlr->cbs.on_trans_finished);
         if (ctlr->cbs.on_trans_finished) {
             ctlr->trans.received_size = ctlr->fb_size_in_bytes;

components/esp_driver_cam/dvp/src/esp_cam_ctlr_dvp_cam.c

@@ -233,6 +233,8 @@ static uint32_t IRAM_ATTR esp_cam_ctlr_dvp_get_recved_size(esp_cam_ctlr_dvp_cam_
     if (esp_ptr_external_ram(rx_buffer)) {
         esp_err_t ret = esp_cache_msync(rx_buffer, recv_buffer_size, ESP_CACHE_MSYNC_FLAG_DIR_M2C);
         assert(ret == ESP_OK);
+        (void)ret;
+
     }
 
     if (ctlr->pic_format_jpeg) {

components/esp_driver_cam/dvp/src/esp_cam_ctlr_dvp_gdma.c

@@ -170,6 +170,7 @@ esp_err_t IRAM_ATTR esp_cam_ctlr_dvp_dma_start(esp_cam_ctlr_dvp_dma_t *dma, uint
     if (esp_ptr_external_ram(dma->desc)) {
         esp_err_t ret = esp_cache_msync(dma->desc, dma->desc_size, ESP_CACHE_MSYNC_FLAG_DIR_C2M | ESP_CACHE_MSYNC_FLAG_INVALIDATE);
         assert(ret == ESP_OK);
+        (void)ret;
     }
 
     return gdma_start(dma->dma_chan, (intptr_t)dma->desc);