- sed -i.bak -e's/CONFIG_OPTIMIZATION_LEVEL_DEBUG\=y/CONFIG_OPTIMIZATION_LEVEL_RELEASE=y/' sdkconfig
- make defconfig
- make all V=1
+ # Check if there are any stray printf/ets_printf references in WiFi libs
+ - cd ../components/esp32/lib
+ - test $(xtensa-esp32-elf-nm *.a | grep -w printf | wc -l) -eq 0
+ - test $(xtensa-esp32-elf-nm *.a | grep -w ets_printf | wc -l) -eq 0
.build_gitlab: &build_template
._mutex_create = mutex_create_wrapper,
._mutex_lock = mutex_lock_wrapper,
._mutex_unlock = mutex_unlock_wrapper,
- ._read_efuse_mac = system_efuse_read_mac,
+ ._read_efuse_mac = esp_efuse_read_mac,
};
static void bt_controller_task(void *pvParam)
#include "rom/ets_sys.h"
#include "rom/uart.h"
#include "sdkconfig.h"
-
-typedef enum{
- XTAL_40M = 40,
- XTAL_26M = 26,
- XTAL_24M = 24,
- XTAL_AUTO = 0
-} xtal_freq_t;
-
-typedef enum{
- CPU_80M = 1,
- CPU_160M = 2,
- CPU_240M = 3,
-} cpu_freq_t;
-
-extern void phy_get_romfunc_addr();
-
-// TODO: these functions need to be moved from librtc to ESP-IDF
-extern void rtc_init_lite();
-extern void rtc_set_cpu_freq(xtal_freq_t xtal_freq, cpu_freq_t cpu_freq);
+#include "phy.h"
+#include "rtc.h"
/*
* This function is not exposed as an API at this point,
// wait uart tx finish, otherwise some uart output will be lost
uart_tx_wait_idle(0);
- rtc_init_lite();
+ rtc_init_lite(XTAL_AUTO);
cpu_freq_t freq = CPU_80M;
switch(freq_mhz) {
case 240:
// wait uart tx finish, otherwise some uart output will be lost
uart_tx_wait_idle(0);
- rtc_set_cpu_freq(XTAL_AUTO, freq);
+ rtc_set_cpu_freq(freq);
ets_update_cpu_frequency(freq_mhz);
}
#include "soc/dport_reg.h"
#include "esp_attr.h"
#include "esp_deepsleep.h"
+#include "rtc.h"
/* Updating RTC_MEMORY_CRC_REG register via set_rtc_memory_crc()
is not thread-safe. */
}
void __attribute__((weak, alias("esp_default_wake_deep_sleep"))) esp_wake_deep_sleep(void);
+
+void esp_deep_sleep(uint64_t time_in_us)
+{
+ rtc_set_cpu_freq(CPU_XTAL);
+ if (esp_get_deep_sleep_wake_stub() == NULL) {
+ esp_set_deep_sleep_wake_stub(esp_wake_deep_sleep);
+ }
+ uint32_t period = rtc_slowck_cali(CALI_RTC_MUX, 128);
+ uint32_t cycle_l, cycle_h;
+ rtc_usec2rtc(time_in_us >> 32, time_in_us, period, &cycle_h, &cycle_l);
+ rtc_slp_prep_lite(1, 0);
+ rtc_sleep(cycle_h, cycle_l, TIMER_EXPIRE_EN, 0);
+ while (1) {
+ ;
+ }
+}
+
+void system_deep_sleep(uint64_t) __attribute__((alias("esp_deep_sleep")));
*/
/**
- * @brief Set the chip to deep-sleep mode.
- *
- * The device will automatically wake up after the deep-sleep time set
- * by the users. Upon waking up, the device boots up from user_init.
- *
- * @attention The parameter time_in_us to be "uint64" is for further development.
- * Only the low 32 bits of parameter time_in_us are avalable now.
- *
- * @param uint64 time_in_us : deep-sleep time, only the low 32bits are avalable now. unit: microsecond
- *
- * @return null
- */
-void system_deep_sleep(uint64_t time_in_us);
+ * @brief Enter deep-sleep mode
+ *
+ * The device will automatically wake up after the deep-sleep time
+ * Upon waking up, the device calls deep sleep wake stub, and then proceeds
+ * to load application.
+ *
+ * This function does not return.
+ *
+ * @param time_in_us deep-sleep time, unit: microsecond
+ */
+void esp_deep_sleep(uint64_t time_in_us) __attribute__((noreturn));
+
+
+/**
+ * @brief Enter deep-sleep mode
+ *
+ * Function has been renamed to esp_deep_sleep.
+ * This name is deprecated and will be removed in a future version.
+ *
+ * @param time_in_us deep-sleep time, unit: microsecond
+ */
+void system_deep_sleep(uint64_t time_in_us) __attribute__((noreturn, deprecated));
/**
* @brief Default stub to run on wake from deep sleep.
*
* Allows for executing code immediately on wake from sleep, before
- * the software bootloader or esp-idf app has started up.
+ * the software bootloader or ESP-IDF app has started up.
*
* This function is weak-linked, so you can implement your own version
* to run code immediately when the chip wakes from
* Function has been renamed to esp_restart.
* This name will be removed in a future release.
*/
-void system_restart(void) __attribute((deprecated, noreturn));
+void system_restart(void) __attribute__ ((deprecated, noreturn));
/**
* @brief Get system time, unit: microsecond.
*/
uint32_t esp_get_free_heap_size(void);
-
/**
* @brief Get the size of available heap.
*
*
* @return ESP_OK on success
*/
-esp_err_t esp_efuse_read_mac(uint8_t mac[6]);
+esp_err_t esp_efuse_read_mac(uint8_t* mac);
/**
* @brief Read hardware MAC address.
*/
esp_err_t system_efuse_read_mac(uint8_t mac[6]) __attribute__ ((deprecated));
+/**
+ * Get SDK version
+ *
+ * This function is deprecated and will be removed in a future release.
+ *
+ * @return constant string "master"
+ */
+const char* system_get_sdk_version(void) __attribute__ ((deprecated));
+
+
#ifdef __cplusplus
}
#define ETS_MEM_BAR() asm volatile ( "" : : : "memory" )
+typedef enum {
+ OK = 0,
+ FAIL,
+ PENDING,
+ BUSY,
+ CANCEL,
+} STATUS;
+
/**
* @}
*/
#include "esp_types.h"
#include "esp_attr.h"
+#include "ets_sys.h"
#ifdef __cplusplus
extern "C" {
int received;
} UartDevice;
-typedef enum {
- OK = 0,
- FAIL,
- PENDING,
- BUSY,
- CANCEL,
-} STATUS;
-
/**
* @brief Init uart device struct value and reset uart0/uart1 rx.
* Please do not call this function in SDK.
* share the name with the existing functions from hal.h.
* Including this header file will define XTHAL_USE_CACHE_MACROS
* which directs hal.h not to use the functions.
- *
+ */
/*
* Single-cache-line operations in C-callable inline assembly.
-Subproject commit e2e5781dc27e638c5e63f85bc23590dd21af1619
+Subproject commit 5182dd9dab9ec37e69711de33bb0c200502c4c03
return ESP_ERR_INVALID_SIZE;
}
uint8_t sta_mac[6];
- system_efuse_read_mac(sta_mac);
+ esp_efuse_read_mac(sta_mac);
if (memcmp(sta_mac, cal_data_mac, sizeof(sta_mac)) != 0) {
ESP_LOGE(TAG, "%s: calibration data MAC check failed: expected " \
MACSTR ", found " MACSTR,
return err;
}
uint8_t sta_mac[6];
- system_efuse_read_mac(sta_mac);
+ esp_efuse_read_mac(sta_mac);
err = nvs_set_blob(handle, PHY_CAL_MAC_KEY, sta_mac, sizeof(sta_mac));
if (err != ESP_OK) {
return err;
--- /dev/null
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <stdint.h>
+#include <stddef.h>
+#include "soc/soc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum{
+ XTAL_40M = 40,
+ XTAL_26M = 26,
+ XTAL_24M = 24,
+ XTAL_AUTO = 0
+} xtal_freq_t;
+
+typedef enum{
+ CPU_XTAL = 0,
+ CPU_80M = 1,
+ CPU_160M = 2,
+ CPU_240M = 3,
+ CPU_2M = 4
+} cpu_freq_t;
+
+typedef enum {
+ CALI_RTC_MUX = 0,
+ CALI_8MD256 = 1,
+ CALI_32K_XTAL = 2
+} cali_clk_t;
+
+/**
+ * This function must be called to initialize RTC library
+ * @param xtal_freq Frequency of main crystal
+ */
+void rtc_init_lite(xtal_freq_t xtal_freq);
+
+/**
+ * Switch CPU frequency
+ * @param cpu_freq new CPU frequency
+ */
+void rtc_set_cpu_freq(cpu_freq_t cpu_freq);
+
+/**
+ * @brief Return RTC slow clock's period
+ * @param cali_clk clock to calibrate
+ * @param slow_clk_cycles number of slow clock cycles to average
+ * @param xtal_freq chip's main XTAL freq
+ * @return average slow clock period in microseconds, Q13.19 fixed point format
+ */
+uint32_t rtc_slowck_cali(cali_clk_t cali_clk, uint32_t slow_clk_cycles);
+
+/**
+ * @brief Convert from microseconds to slow clock cycles
+ * @param time_in_us_h Time in microseconds, higher 32 bit part
+ * @param time_in_us_l Time in microseconds, lower 32 bit part
+ * @param slow_clk_period Period of slow clock in microseconds, Q13.19 fixed point format (as returned by rtc_slowck_cali).
+ * @param[out] cylces_h output, higher 32 bit part of number of slow clock cycles
+ * @param[out] cycles_l output, lower 32 bit part of number of slow clock cycles
+ */
+void rtc_usec2rtc(uint32_t time_in_us_h, uint32_t time_in_us_l, uint32_t slow_clk_period, uint32_t *cylces_h, uint32_t *cycles_l);
+
+
+#define DEEP_SLEEP_PD_NORMAL BIT(0) /*!< Base deep sleep mode */
+#define DEEP_SLEEP_PD_RTC_PERIPH BIT(1) /*!< Power down RTC peripherals */
+#define DEEP_SLEEP_PD_RTC_SLOW_MEM BIT(2) /*!< Power down RTC SLOW memory */
+#define DEEP_SLEEP_PD_RTC_FAST_MEM BIT(3) /*!< Power down RTC FAST memory */
+
+/**
+ * @brief Prepare for entering sleep mode
+ * @param deep_slp DEEP_SLEEP_PD_ flags combined with OR (DEEP_SLEEP_PD_NORMAL must be included)
+ * @param cpu_lp_mode for deep sleep, should be 0
+ */
+void rtc_slp_prep_lite(uint32_t deep_slp, uint32_t cpu_lp_mode);
+
+
+#define RTC_EXT_EVENT0_TRIG BIT(0)
+#define RTC_EXT_EVENT1_TRIG BIT(1)
+#define RTC_GPIO_TRIG BIT(2)
+#define RTC_TIMER_EXPIRE BIT(3)
+#define RTC_SDIO_TRIG BIT(4)
+#define RTC_MAC_TRIG BIT(5)
+#define RTC_UART0_TRIG BIT(6)
+#define RTC_UART1_TRIG BIT(7)
+#define RTC_TOUCH_TRIG BIT(8)
+#define RTC_SAR_TRIG BIT(9)
+#define RTC_BT_TRIG BIT(10)
+
+
+#define RTC_EXT_EVENT0_TRIG_EN RTC_EXT_EVENT0_TRIG
+#define RTC_EXT_EVENT1_TRIG_EN RTC_EXT_EVENT1_TRIG
+#define RTC_GPIO_TRIG_EN RTC_GPIO_TRIG
+#define RTC_TIMER_EXPIRE_EN RTC_TIMER_EXPIRE
+#define RTC_SDIO_TRIG_EN RTC_SDIO_TRIG
+#define RTC_MAC_TRIG_EN RTC_MAC_TRIG
+#define RTC_UART0_TRIG_EN RTC_UART0_TRIG
+#define RTC_UART1_TRIG_EN RTC_UART1_TRIG
+#define RTC_TOUCH_TRIG_EN RTC_TOUCH_TRIG
+#define RTC_SAR_TRIG_EN RTC_SAR_TRIG
+#define RTC_BT_TRIG_EN RTC_BT_TRIG
+
+/**
+ * @brief Enter sleep mode for given number of cycles
+ * @param cycles_h higher 32 bit part of number of slow clock cycles
+ * @param cycles_l lower 32 bit part of number of slow clock cycles
+ * @param wakeup_opt wake up reason to enable (RTC_xxx_EN flags combined with OR)
+ * @param reject_opt reserved, should be 0
+ * @return TBD
+ */
+uint32_t rtc_sleep(uint32_t cycles_h, uint32_t cycles_l, uint32_t wakeup_opt, uint32_t reject_opt);
+
+
+#ifdef __cplusplus
+}
+#endif
+
static const char* TAG = "system_api";
-esp_err_t system_efuse_read_mac(uint8_t mac[6])
+void system_init()
+{
+}
+
+esp_err_t esp_efuse_read_mac(uint8_t* mac)
{
uint8_t efuse_crc;
uint8_t calc_crc;
return ESP_OK;
}
+esp_err_t system_efuse_read_mac(uint8_t mac[6]) __attribute__((alias("esp_efuse_read_mac")));
+
-void IRAM_ATTR system_restart(void)
+void IRAM_ATTR esp_restart(void)
{
esp_wifi_stop();
}
}
+void system_restart(void) __attribute__((alias("esp_restart")));
+
void system_restore(void)
{
esp_wifi_restore();
}
-#if 0
-void system_deep_sleep_instant(uint64_t time_in_us)
-{
- u32 period, cycle_h, cycle_l;
-
- {
- struct rst_info debug_data;
- memset(&debug_data, 0, sizeof(struct rst_info));
-
- WRITE_PERI_REG(RTC_STORE0, DEEP_SLEEP_AWAKE_FLAG);
- debug_data.flag = DEEP_SLEEP_AWAKE_FLAG;
-
- system_write_rtc_mem(0, &debug_data, sizeof(struct rst_info));
- }
-
- rtc_set_cpu_freq(XTAL_AUTO, CPU_XTAL);
- esp_set_deep_sleep_wake_stub(esp_wake_deep_sleep);
-
- period = rtc_slowck_cali(CALI_RTC_MUX, 128, XTAL_AUTO);
- rtc_usec2rtc(time_in_us >> 32, time_in_us, period, &cycle_h, &cycle_l);
-
- rtc_slp_prep_lite(1, 0);
- rtc_sleep(cycle_h, cycle_l, TIMER_EXPIRE_EN, 0);
-}
-
-static uint64_t deep_sleep_time;
-
-static void system_deep_sleep_step2(void)
-{
- system_deep_sleep_instant(deep_sleep_time);
-}
-
-void system_deep_sleep(uint64 time_in_us)
-{
- wifi_set_sleep_flag(1);
-
- deep_sleep_time = time_in_us;
-
- os_timer_disarm(&sta_con_timer);
- os_timer_setfn(&sta_con_timer, (os_timer_func_t *)system_deep_sleep_step2, NULL);
- os_timer_arm(&sta_con_timer, 100, 0);
-}
-
-#endif
-
-uint32_t system_get_free_heap_size(void)
+uint32_t esp_get_free_heap_size(void)
{
return xPortGetFreeHeapSize();
}
-
-struct rst_info *system_get_rst_info(void)
-{
- return NULL;
-}
+uint32_t system_get_free_heap_size(void) __attribute__((alias("esp_get_free_heap_size")));
const char* system_get_sdk_version(void)
{
}
printf("Restarting now.\n");
fflush(stdout);
- system_restart();
+ esp_restart();
}
void app_main()
const int deep_sleep_sec = 10;
ESP_LOGI(TAG, "Entering deep sleep for %d seconds", deep_sleep_sec);
- system_deep_sleep(1000000LL * deep_sleep_sec);
+ esp_deep_sleep(1000000LL * deep_sleep_sec);
}
static void obtain_time(void)
}
printf("Restarting now.\n");
fflush(stdout);
- system_restart();
+ esp_restart();
}
if (err != ESP_OK) printf("Error (%d) saving run time blob to NVS!\n", err);
printf("Restarting...\n");
fflush(stdout);
- system_restart();
+ esp_restart();
}
}
vTaskDelay(200 / portTICK_RATE_MS);
projects / esp-idf / commitdiff