mirror of
https://github.com/m5stack/M5Stack_MicroPython.git
synced 2026-05-20 10:14:44 -07:00
Updated _thread module, _thread.wait() function added
Updated utime module Added prebuilt firmware with all modules enabled (for psRAM boards) Updated esp-idf to the latest commit Updated Xtenssa toolchains to version 1.22.0-80-g6c4433a-5.2.0
This commit is contained in:
Boris Lovosevic
+1
-1
@@ -7,7 +7,7 @@
|
||||
*.map
|
||||
*.hex
|
||||
*.dis
|
||||
*.exe
|
||||
#*.exe
|
||||
|
||||
# Packages
|
||||
############
|
||||
|
||||
@@ -44,7 +44,7 @@
|
||||
|
||||
|
||||
#=======================
|
||||
TOOLS_VER=ver20180106.id
|
||||
TOOLS_VER=ver20180112.id
|
||||
#=======================
|
||||
|
||||
# -----------------------------
|
||||
|
||||
@@ -637,7 +637,7 @@ executeCommand() {
|
||||
make ${arg} 2>/dev/null
|
||||
|
||||
# -----------------------------------
|
||||
elif [ "${arg}" == "firmware" ]; then
|
||||
elif [ "${arg}" == "firmware" ] || [ "${arg}" == "firmwareall" ]; then
|
||||
echo "======================="
|
||||
echo "Saving the firmware ..."
|
||||
echo "======================="
|
||||
@@ -645,6 +645,9 @@ executeCommand() {
|
||||
if [ "${BUILD_TYPE}" != "" ]; then
|
||||
esp32dir="esp32_psram"
|
||||
fi
|
||||
if [ "${arg}" == "firmwareall" ]; then
|
||||
esp32dir="esp32_psram_all"
|
||||
fi
|
||||
local useota=$(grep -e CONFIG_MICROPY_USE_OTA=y sdkconfig)
|
||||
if [ "${useota}" == "CONFIG_MICROPY_USE_OTA=y" ]; then
|
||||
esp32dir="${esp32dir}_ota"
|
||||
|
||||
@@ -225,6 +225,23 @@ STATIC mp_obj_t mach_rtc_now (mp_obj_t self_in) {
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mach_rtc_now_obj, mach_rtc_now);
|
||||
|
||||
//---------------------------------
|
||||
void sntp_task (void *pvParameters)
|
||||
{
|
||||
struct timeval tv;
|
||||
int synced = 0;
|
||||
|
||||
while (!synced) {
|
||||
vTaskDelay(100 / portTICK_PERIOD_MS);
|
||||
gettimeofday(&tv, NULL);
|
||||
// check if date > 2017/01/01
|
||||
if (tv.tv_sec > 1483228800) synced = true;
|
||||
}
|
||||
mach_rtc_obj.synced = true;
|
||||
mp_hal_ticks_base = tv.tv_sec;
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
STATIC mp_obj_t mach_rtc_ntp_sync(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
@@ -266,26 +283,19 @@ STATIC mp_obj_t mach_rtc_ntp_sync(size_t n_args, const mp_obj_t *pos_args, mp_ma
|
||||
now.tv_sec = 0;
|
||||
now.tv_usec = 0;
|
||||
settimeofday(&now, NULL);
|
||||
mp_hal_ticks_base = 0;
|
||||
|
||||
sntp_init();
|
||||
|
||||
TaskHandle_t sntp_handle;
|
||||
xTaskCreate(&sntp_task, "SNTP", 512, NULL, CONFIG_MICROPY_TASK_PRIORITY+1, &sntp_handle);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mach_rtc_ntp_sync_obj, 1, mach_rtc_ntp_sync);
|
||||
|
||||
//------------------------------------------------------
|
||||
STATIC mp_obj_t mach_rtc_has_synced (mp_obj_t self_in) {
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
|
||||
// check if date > 2017/01/01
|
||||
if (tv.tv_sec > 1483228800) {
|
||||
mach_rtc_obj.synced = true;
|
||||
}
|
||||
else {
|
||||
mach_rtc_obj.synced = false;
|
||||
}
|
||||
|
||||
if (mach_rtc_obj.synced) {
|
||||
return mp_const_true;
|
||||
} else {
|
||||
|
||||
BIN
Binary file not shown.
@@ -10,10 +10,10 @@ import machine, display, time, math
|
||||
tft = display.TFT()
|
||||
|
||||
#ESP32-WROVER-KIT v3:
|
||||
#tft.init(tft.ST7789, rst_pin=18, backl_pin=5, miso=25, mosi=23, clk=19, cs=22, dc=21)
|
||||
tft.init(tft.ST7789, rst_pin=18, backl_pin=5, miso=25, mosi=23, clk=19, cs=22, dc=21)
|
||||
|
||||
#Adafruit:
|
||||
tft.init(tft.ILI9341, width=240, height=320, miso=19, mosi=18, clk=5, cs=15, dc=33, bgr=True, hastouch=tft.TOUCH_STMPE, tcs=32)
|
||||
#tft.init(tft.ILI9341, width=240, height=320, miso=19, mosi=18, clk=5, cs=15, dc=33, bgr=True, hastouch=tft.TOUCH_STMPE, tcs=32)
|
||||
|
||||
#Set correct configuration
|
||||
#tft.init(tft.ILI9341, width=240, height=320, miso=19,mosi=23,clk=18,cs=5,dc=26,tcs=27,hastouch=True, bgr=True)
|
||||
|
||||
@@ -199,7 +199,8 @@ STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR_ticks_cpu), MP_ROM_PTR(&mp_utime_ticks_cpu_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&time_ticks_diff_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_tickscpu_diff), MP_ROM_PTR(&mp_utime_tickscpu_diff_obj) },
|
||||
//{ MP_OBJ_NEW_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&time_ticks_diff_obj) },
|
||||
};
|
||||
STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
|
||||
|
||||
|
||||
@@ -36,6 +36,7 @@
|
||||
#define MICROPY_REPL_EMACS_KEYS (1)
|
||||
#define MICROPY_REPL_AUTO_INDENT (1)
|
||||
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
|
||||
//#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_LONGLONG)
|
||||
#define MICROPY_ENABLE_SOURCE_LINE (1)
|
||||
#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_NORMAL)
|
||||
#define MICROPY_WARNINGS (1)
|
||||
|
||||
@@ -50,6 +50,7 @@
|
||||
#endif
|
||||
|
||||
uint32_t mp_hal_wdg_rst_tmo = 0;
|
||||
long mp_hal_ticks_base = 0;
|
||||
|
||||
//---------------------
|
||||
void mp_hal_reset_wdt()
|
||||
@@ -236,54 +237,84 @@ void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len) {
|
||||
uint64_t mp_hal_ticks_ms(void) {
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
return tv.tv_sec * 1000 + (tv.tv_usec / 1000);
|
||||
long sec = tv.tv_sec - mp_hal_ticks_base;
|
||||
return ((uint64_t)sec * 1000) + ((uint64_t)tv.tv_usec / 1000);
|
||||
}
|
||||
|
||||
//------------------------------
|
||||
uint64_t mp_hal_ticks_us(void) {
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
return tv.tv_sec * 1000000 + tv.tv_usec;
|
||||
long sec = tv.tv_sec - mp_hal_ticks_base;
|
||||
return ((uint64_t)sec * 1000000) + (uint64_t)tv.tv_usec;
|
||||
}
|
||||
|
||||
//---------------------------------
|
||||
void mp_hal_delay_ms(uint32_t ms) {
|
||||
if (ms == 0) return;
|
||||
/*
|
||||
* Delay specified number of milli seconds
|
||||
* For the delay time up to 10 ms the function is blocking
|
||||
* For delay times greater than 10 ms, the function
|
||||
* does not block the execution of the other threads.
|
||||
* Waiting can be interrupted if the thread receives the notification
|
||||
*
|
||||
* Returns the actual delay time.
|
||||
*
|
||||
*/
|
||||
//------------------------------
|
||||
int mp_hal_delay_ms(uint32_t ms)
|
||||
{
|
||||
if (ms == 0) return 0;
|
||||
|
||||
uint32_t wait_ticks = ms / portTICK_PERIOD_MS; // number of ticks in delay time
|
||||
uint32_t dticks = ms % portTICK_PERIOD_MS; // remaining milli seconds
|
||||
|
||||
if (wait_ticks == 0) {
|
||||
if (dticks) ets_delay_us(dticks * 1000);
|
||||
return;
|
||||
if (ms <= 10) {
|
||||
// For delays up to 10 ms we use blocking delay
|
||||
ets_delay_us(ms * 1000);
|
||||
return ms;
|
||||
}
|
||||
|
||||
uint32_t w_ms = ms / (CONFIG_TASK_WDT_TIMEOUT_S*1000/2); // number of half wdt periods
|
||||
long tticks_base = mp_hal_ticks_base;
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
uint32_t tstart = ((uint32_t)tv.tv_sec * 1000) + ((uint32_t)tv.tv_usec / 1000);
|
||||
uint32_t tend = tstart;
|
||||
uint32_t nres = tstart;
|
||||
|
||||
#ifdef CONFIG_MICROPY_USE_TASK_WDT
|
||||
esp_task_wdt_reset();
|
||||
#endif
|
||||
while (w_ms) {
|
||||
vTaskDelay((CONFIG_TASK_WDT_TIMEOUT_S*1000/2) / portTICK_PERIOD_MS);
|
||||
#ifdef CONFIG_MICROPY_USE_TASK_WDT
|
||||
esp_task_wdt_reset();
|
||||
#endif
|
||||
w_ms--;
|
||||
}
|
||||
wait_ticks = (ms % (CONFIG_TASK_WDT_TIMEOUT_S*1000/2)) / portTICK_PERIOD_MS; // remaining ms
|
||||
dticks = (ms % (CONFIG_TASK_WDT_TIMEOUT_S*1000/2)) % portTICK_PERIOD_MS; // remaining milli seconds
|
||||
|
||||
if (wait_ticks > 0) {
|
||||
MP_THREAD_GIL_EXIT();
|
||||
vTaskDelay(wait_ticks);
|
||||
MP_THREAD_GIL_ENTER();
|
||||
MP_THREAD_GIL_EXIT();
|
||||
|
||||
int ncheck = 0;
|
||||
while (1) {
|
||||
if (tticks_base != mp_hal_ticks_base) break;
|
||||
gettimeofday(&tv, NULL);
|
||||
tend = ((uint32_t)tv.tv_sec * 1000) + ((uint32_t)tv.tv_usec / 1000);
|
||||
if ((tend-tstart) >= ms) break;
|
||||
|
||||
vTaskDelay(2);
|
||||
|
||||
#ifdef CONFIG_MICROPY_USE_TASK_WDT
|
||||
if ((tend-nres) > (CONFIG_TASK_WDT_TIMEOUT_S*500)) {
|
||||
esp_task_wdt_reset();
|
||||
nres = tend;
|
||||
}
|
||||
#endif
|
||||
// Break if notification received
|
||||
ncheck++;
|
||||
if (ncheck >= 50) {
|
||||
ncheck = 0;
|
||||
if (mp_thread_checknotify()) break;
|
||||
}
|
||||
}
|
||||
// do the remaining delay accurately
|
||||
if (dticks) ets_delay_us(dticks * 1000);
|
||||
|
||||
MP_THREAD_GIL_ENTER();
|
||||
return (tend - tstart);
|
||||
}
|
||||
|
||||
//---------------------------------
|
||||
void mp_hal_delay_us(uint32_t us) {
|
||||
if (us == 0) return;
|
||||
if (us > 10000) {
|
||||
// Delay greater then 10 ms, use ms delay function
|
||||
uint32_t dus = us % 10000; // remaining micro seconds
|
||||
mp_hal_delay_ms(us/1000);
|
||||
if (dus) ets_delay_us(dus);
|
||||
|
||||
@@ -35,6 +35,7 @@
|
||||
|
||||
extern ringbuf_t stdin_ringbuf;
|
||||
extern uint32_t mp_hal_wdg_rst_tmo;
|
||||
extern long mp_hal_ticks_base;
|
||||
|
||||
void mp_hal_set_wdt_tmo();
|
||||
void mp_hal_reset_wdt();
|
||||
@@ -53,7 +54,7 @@ void mp_hal_stdout_tx_strn(const char *str, uint32_t len);
|
||||
void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len);
|
||||
|
||||
uint64_t mp_hal_ticks_ms(void);
|
||||
void mp_hal_delay_ms(uint32_t ms);
|
||||
int mp_hal_delay_ms(uint32_t ms);
|
||||
void mp_hal_delay_us(uint32_t);
|
||||
void mp_hal_delay_us_fast(uint32_t);
|
||||
void mp_hal_set_interrupt_char(int c);
|
||||
|
||||
@@ -85,6 +85,7 @@ typedef struct _thread_t {
|
||||
QueueHandle_t threadQueue; // queue used for inter thread communication
|
||||
int allow_suspend;
|
||||
int suspended;
|
||||
int waiting;
|
||||
int deleted;
|
||||
uint32_t type;
|
||||
struct _thread_t *next;
|
||||
@@ -135,6 +136,7 @@ void mp_thread_preinit(void *stack, uint32_t stack_len) {
|
||||
thread->threadQueue = xQueueCreate( THREAD_QUEUE_MAX_ITEMS, sizeof(thread_msg_t) );
|
||||
thread->allow_suspend = 0;
|
||||
thread->suspended = 0;
|
||||
thread->waiting = 0;
|
||||
thread->deleted = 0;
|
||||
thread->type = THREAD_TYPE_MAIN;
|
||||
thread->next = NULL;
|
||||
@@ -264,6 +266,7 @@ TaskHandle_t mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack
|
||||
th->threadQueue = xQueueCreate( THREAD_QUEUE_MAX_ITEMS, sizeof(thread_msg_t) );
|
||||
th->allow_suspend = 0;
|
||||
th->suspended = 0;
|
||||
th->waiting = 0;
|
||||
th->deleted = 0;
|
||||
th->type = THREAD_TYPE_PYTHON;
|
||||
thread = th;
|
||||
@@ -296,6 +299,7 @@ STATIC void mp_clean_thread(thread_t *th)
|
||||
th->ready = 0;
|
||||
th->deleted = 1;
|
||||
}
|
||||
|
||||
//---------------------------
|
||||
void mp_thread_finish(void) {
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
@@ -323,6 +327,8 @@ void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
|
||||
xSemaphoreGive(mutex->handle);
|
||||
}
|
||||
|
||||
// Terminate all Python threads
|
||||
// used before entering sleep/reset
|
||||
//---------------------------
|
||||
void mp_thread_deinit(void) {
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
@@ -362,7 +368,7 @@ int mp_thread_suspend(TaskHandle_t id) {
|
||||
continue;
|
||||
}
|
||||
if (th->id == id) {
|
||||
if ((th->allow_suspend) && (th->suspended == 0)) {
|
||||
if ((th->allow_suspend) && (th->suspended == 0) && (th->waiting == 0)) {
|
||||
th->suspended = 1;
|
||||
vTaskSuspend(th->id);
|
||||
res = 1;
|
||||
@@ -384,7 +390,7 @@ int mp_thread_resume(TaskHandle_t id) {
|
||||
continue;
|
||||
}
|
||||
if (th->id == id) {
|
||||
if ((th->allow_suspend) && (th->suspended)) {
|
||||
if ((th->allow_suspend) && (th->suspended) && (th->waiting == 0)) {
|
||||
th->suspended = 0;
|
||||
vTaskResume(th->id);
|
||||
res = 1;
|
||||
@@ -396,43 +402,49 @@ int mp_thread_resume(TaskHandle_t id) {
|
||||
return res;
|
||||
}
|
||||
|
||||
//-----------------------------------
|
||||
int mp_thread_stop(TaskHandle_t id) {
|
||||
//--------------------------
|
||||
int mp_thread_setblocked() {
|
||||
int res = 0;
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
for (thread_t *th = thread; th != NULL; th = th->next) {
|
||||
// don't stop the current task
|
||||
if (th->id == xTaskGetCurrentTaskHandle()) {
|
||||
continue;
|
||||
}
|
||||
if (th->id == id) {
|
||||
mp_clean_thread(th);
|
||||
vTaskDelete(th->id);
|
||||
res = 1;
|
||||
th->waiting = 1;
|
||||
res = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mp_thread_mutex_unlock(&thread_mutex);
|
||||
// allow FreeRTOS to clean-up the threads
|
||||
vTaskDelay(2);
|
||||
return res;
|
||||
}
|
||||
|
||||
//-----------------------------
|
||||
int mp_thread_setnotblocked() {
|
||||
int res = 0;
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
for (thread_t *th = thread; th != NULL; th = th->next) {
|
||||
if (th->id == xTaskGetCurrentTaskHandle()) {
|
||||
th->waiting = 0;
|
||||
res = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mp_thread_mutex_unlock(&thread_mutex);
|
||||
return res;
|
||||
}
|
||||
|
||||
// Send notification to thread 'id'
|
||||
// or to all threads if id=0
|
||||
//-----------------------------------------------------
|
||||
int mp_thread_notify(TaskHandle_t id, uint32_t value) {
|
||||
int res = 0;
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
for (thread_t *th = thread; th != NULL; th = th->next) {
|
||||
// don't notify the sending task
|
||||
if (th->id == xTaskGetCurrentTaskHandle()) {
|
||||
continue;
|
||||
}
|
||||
if ((id == 0) || (th->id == id)) {
|
||||
xTaskNotify(th->id, value, eSetBits);
|
||||
res = 1;
|
||||
res = xTaskNotify(th->id, value, eSetValueWithoutOverwrite);
|
||||
if (id != 0) break;
|
||||
}
|
||||
}
|
||||
if (id == 0) res = 1;
|
||||
mp_thread_mutex_unlock(&thread_mutex);
|
||||
return res;
|
||||
}
|
||||
@@ -453,6 +465,20 @@ uint32_t mp_thread_getnotify() {
|
||||
return value;
|
||||
}
|
||||
|
||||
//--------------------------------
|
||||
uint32_t mp_thread_checknotify() {
|
||||
uint32_t value = 0;
|
||||
mp_thread_mutex_lock(&thread_mutex, 1);
|
||||
for (thread_t *th = thread; th != NULL; th = th->next) {
|
||||
if (th->id == xTaskGetCurrentTaskHandle()) {
|
||||
value = xTaskNotifyWait(0, 0, &value, 0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
mp_thread_mutex_unlock(&thread_mutex);
|
||||
return value;
|
||||
}
|
||||
|
||||
//------------------------------
|
||||
uint32_t mp_thread_getSelfID() {
|
||||
uint32_t id = 0;
|
||||
@@ -584,7 +610,11 @@ int mp_thread_status(TaskHandle_t id) {
|
||||
continue;
|
||||
}
|
||||
if (th->id == id) {
|
||||
if (!th->deleted) res = th->suspended;
|
||||
if (!th->deleted) {
|
||||
if (th->suspended) res = 1;
|
||||
else if (th->waiting) res = 2;
|
||||
else res = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -621,6 +651,7 @@ int mp_thread_list(thread_list_t *list) {
|
||||
thr->id = (uint32_t)th->id;
|
||||
sprintf(thr->name, "%s", th->name);
|
||||
thr->suspended = th->suspended;
|
||||
thr->waiting = th->waiting;
|
||||
thr->type = th->type;
|
||||
thr->stack_len = th->stack_len;
|
||||
thr->stack_max = th->stack_len - min_stack;
|
||||
|
||||
@@ -47,11 +47,17 @@
|
||||
#define THREAD_TYPE_SERVICE 3
|
||||
|
||||
// Reserved thread notification constants
|
||||
#define THREAD_NOTIFY_PAUSE 70001
|
||||
#define THREAD_NOTIFY_RESUME 70002
|
||||
#define THREAD_NOTIFY_EXIT 70003
|
||||
#define THREAD_NOTIFY_STATUS 70004
|
||||
#define THREAD_NOTIFY_RESET 70005
|
||||
#define THREAD_NOTIFY_PAUSE 0x01000000
|
||||
#define THREAD_NOTIFY_RESUME 0x02000000
|
||||
#define THREAD_NOTIFY_EXIT 0x04000000
|
||||
#define THREAD_NOTIFY_STATUS 0x08000000
|
||||
#define THREAD_NOTIFY_RESET 0x10000000
|
||||
#define THREAD_WAIT_TIMEOUT 0x20000000
|
||||
|
||||
#define THREAD_STATUS_RUNNING 0
|
||||
#define THREAD_STATUS_SUSPENDED 1
|
||||
#define THREAD_STATUS_WAITING 2
|
||||
#define THREAD_STATUS_TERMINATED -1
|
||||
|
||||
#ifdef CONFIG_MICROPY_USE_TELNET
|
||||
#define TELNET_STACK_SIZE (1580)
|
||||
@@ -101,6 +107,7 @@ typedef struct _thread_listitem_t {
|
||||
uint32_t id; // thread id
|
||||
char name[THREAD_NAME_MAX_SIZE]; // thread name
|
||||
uint8_t suspended;
|
||||
uint8_t waiting;
|
||||
uint8_t type;
|
||||
uint32_t stack_len;
|
||||
uint32_t stack_max;
|
||||
@@ -123,13 +130,16 @@ void mp_thread_deinit(void);
|
||||
void mp_thread_allowsuspend(int allow);
|
||||
int mp_thread_suspend(TaskHandle_t id);
|
||||
int mp_thread_resume(TaskHandle_t id);
|
||||
int mp_thread_stop(TaskHandle_t id);
|
||||
int mp_thread_notify(TaskHandle_t id, uint32_t value);
|
||||
uint32_t mp_thread_getnotify();
|
||||
uint32_t mp_thread_checknotify();
|
||||
int mp_thread_semdmsg(TaskHandle_t id, int type, uint32_t msg_int, uint8_t *buf, uint32_t buflen);
|
||||
int mp_thread_getmsg(uint32_t *msg_int, uint8_t **buf, uint32_t *buflen, uint32_t *sender);
|
||||
int mp_thread_status(TaskHandle_t id);
|
||||
|
||||
int mp_thread_setblocked();
|
||||
int mp_thread_setnotblocked();
|
||||
|
||||
uint32_t mp_thread_getSelfID();
|
||||
int mp_thread_getSelfname(char *name);
|
||||
int mp_thread_getname(TaskHandle_t id, char *name);
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
// MicroPython version info
|
||||
#define MICROPY_GIT_TAG "ESP32_LoBo_v3.1.1"
|
||||
#define MICROPY_GIT_HASH "ga1b59679"
|
||||
#define MICROPY_BUILD_DATE "2017-01-07"
|
||||
#define MICROPY_GIT_TAG "ESP32_LoBo_v3.1.2"
|
||||
#define MICROPY_GIT_HASH "g2ddee729"
|
||||
#define MICROPY_BUILD_DATE "2017-01-12"
|
||||
#define MICROPY_VERSION_MAJOR (3)
|
||||
#define MICROPY_VERSION_MINOR (1)
|
||||
#define MICROPY_VERSION_MICRO (1)
|
||||
#define MICROPY_VERSION_STRING "3.1.1"
|
||||
#define MICROPY_VERSION_MICRO (2)
|
||||
#define MICROPY_VERSION_STRING "3.1.2"
|
||||
|
||||
@@ -36,53 +36,62 @@
|
||||
#include "py/runtime.h"
|
||||
#include "extmod/utime_mphal.h"
|
||||
|
||||
//----------------------------------------------
|
||||
STATIC mp_obj_t time_sleep(mp_obj_t seconds_o) {
|
||||
#if MICROPY_PY_BUILTINS_FLOAT
|
||||
mp_hal_delay_ms((mp_uint_t)(1000 * mp_obj_get_float(seconds_o)));
|
||||
uint32_t t = mp_hal_delay_ms((mp_uint_t)(1000 * mp_obj_get_float(seconds_o)));
|
||||
#else
|
||||
mp_hal_delay_ms(1000 * mp_obj_get_int(seconds_o));
|
||||
uint32_t t = mp_hal_delay_ms(1000 * mp_obj_get_int(seconds_o));
|
||||
#endif
|
||||
return mp_const_none;
|
||||
return MP_OBJ_NEW_SMALL_INT(t);
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(mp_utime_sleep_obj, time_sleep);
|
||||
|
||||
//-------------------------------------------
|
||||
STATIC mp_obj_t time_sleep_ms(mp_obj_t arg) {
|
||||
mp_int_t ms = mp_obj_get_int(arg);
|
||||
if (ms > 0) {
|
||||
mp_hal_delay_ms(ms);
|
||||
}
|
||||
return mp_const_none;
|
||||
uint32_t t = mp_hal_delay_ms(ms);
|
||||
return MP_OBJ_NEW_SMALL_INT(t);
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(mp_utime_sleep_ms_obj, time_sleep_ms);
|
||||
|
||||
//-------------------------------------------
|
||||
STATIC mp_obj_t time_sleep_us(mp_obj_t arg) {
|
||||
mp_int_t us = mp_obj_get_int(arg);
|
||||
if (us > 0) {
|
||||
mp_hal_delay_us(us);
|
||||
}
|
||||
mp_hal_delay_us(us);
|
||||
return mp_const_none;
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(mp_utime_sleep_us_obj, time_sleep_us);
|
||||
|
||||
//-----------------------------------
|
||||
STATIC mp_obj_t time_ticks_ms(void) {
|
||||
//return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
|
||||
return mp_obj_new_int(mp_hal_ticks_ms());
|
||||
return mp_obj_new_int_from_ull(mp_hal_ticks_ms());
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_0(mp_utime_ticks_ms_obj, time_ticks_ms);
|
||||
|
||||
//-----------------------------------
|
||||
STATIC mp_obj_t time_ticks_us(void) {
|
||||
//return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_us() & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
|
||||
return mp_obj_new_int(mp_hal_ticks_us());
|
||||
return mp_obj_new_int_from_ull(mp_hal_ticks_us());
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_0(mp_utime_ticks_us_obj, time_ticks_us);
|
||||
|
||||
//------------------------------------
|
||||
STATIC mp_obj_t time_ticks_cpu(void) {
|
||||
return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_cpu() & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_0(mp_utime_ticks_cpu_obj, time_ticks_cpu);
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
STATIC mp_obj_t time_ticks_diff(mp_obj_t end_in, mp_obj_t start_in) {
|
||||
/*
|
||||
uint64_t start = mp_obj_get_int(start_in);
|
||||
uint64_t end = mp_obj_get_int(end_in);
|
||||
int64_t diff = end - start;
|
||||
return mp_obj_new_int_from_ll(diff);
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_ticks_diff_obj, time_ticks_diff);
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
STATIC mp_obj_t time_tickscpu_diff(mp_obj_t end_in, mp_obj_t start_in) {
|
||||
// we assume that the arguments come from ticks_xx so are small ints
|
||||
mp_uint_t start = MP_OBJ_SMALL_INT_VALUE(start_in);
|
||||
mp_uint_t end = MP_OBJ_SMALL_INT_VALUE(end_in);
|
||||
@@ -91,19 +100,16 @@ STATIC mp_obj_t time_ticks_diff(mp_obj_t end_in, mp_obj_t start_in) {
|
||||
mp_int_t diff = ((end - start + MICROPY_PY_UTIME_TICKS_PERIOD / 2) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1))
|
||||
- MICROPY_PY_UTIME_TICKS_PERIOD / 2;
|
||||
return MP_OBJ_NEW_SMALL_INT(diff);
|
||||
*/
|
||||
uint64_t start = mp_obj_get_int(start_in);
|
||||
uint64_t end = mp_obj_get_int(end_in);
|
||||
uint64_t diff = end - start;
|
||||
return mp_obj_new_int(diff);
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_ticks_diff_obj, time_ticks_diff);
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_tickscpu_diff_obj, time_tickscpu_diff);
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
STATIC mp_obj_t time_ticks_add(mp_obj_t ticks_in, mp_obj_t delta_in) {
|
||||
// we assume that first argument come from ticks_xx so is small int
|
||||
mp_uint_t ticks = MP_OBJ_SMALL_INT_VALUE(ticks_in);
|
||||
mp_uint_t delta = mp_obj_get_int(delta_in);
|
||||
return MP_OBJ_NEW_SMALL_INT((ticks + delta) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
|
||||
// we assume that first argument come from ticks_xx so is 64-bit int
|
||||
uint64_t tickin = mp_obj_get_int(ticks_in);
|
||||
uint64_t delta = mp_obj_get_int(delta_in);
|
||||
int64_t addtick = tickin + delta;
|
||||
return mp_obj_new_int_from_ll(addtick);
|
||||
}
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_ticks_add_obj, time_ticks_add);
|
||||
|
||||
|
||||
@@ -36,6 +36,7 @@ MP_DECLARE_CONST_FUN_OBJ_0(mp_utime_ticks_ms_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_0(mp_utime_ticks_us_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_0(mp_utime_ticks_cpu_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_2(mp_utime_ticks_diff_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_2(mp_utime_tickscpu_diff_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_2(mp_utime_ticks_add_obj);
|
||||
|
||||
#endif // MICROPY_INCLUDED_EXTMOD_UTIME_MPHAL_H
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -33,98 +33,10 @@
|
||||
#if MICROPY_PY_THREAD
|
||||
|
||||
#include "py/mpthread.h"
|
||||
#include "mphalport.h"
|
||||
|
||||
extern TaskHandle_t MainTaskHandle;
|
||||
|
||||
/****************************************************************/
|
||||
// Lock object
|
||||
|
||||
STATIC const mp_obj_type_t mp_type_thread_lock;
|
||||
|
||||
//------------------------------------
|
||||
typedef struct _mp_obj_thread_lock_t {
|
||||
mp_obj_base_t base;
|
||||
mp_thread_mutex_t mutex;
|
||||
volatile bool locked;
|
||||
} mp_obj_thread_lock_t;
|
||||
|
||||
//---------------------------------------------------------
|
||||
STATIC mp_obj_thread_lock_t *mp_obj_new_thread_lock(void) {
|
||||
mp_obj_thread_lock_t *self = m_new_obj(mp_obj_thread_lock_t);
|
||||
self->base.type = &mp_type_thread_lock;
|
||||
mp_thread_mutex_init(&self->mutex);
|
||||
self->locked = false;
|
||||
return self;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
STATIC mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *args) {
|
||||
mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(args[0]);
|
||||
bool wait = true;
|
||||
if (n_args > 1) {
|
||||
wait = mp_obj_get_int(args[1]);
|
||||
// TODO support timeout arg
|
||||
}
|
||||
MP_THREAD_GIL_EXIT();
|
||||
int ret = mp_thread_mutex_lock(&self->mutex, wait);
|
||||
MP_THREAD_GIL_ENTER();
|
||||
if (ret == 0) {
|
||||
return mp_const_false;
|
||||
} else if (ret == 1) {
|
||||
self->locked = true;
|
||||
return mp_const_true;
|
||||
} else {
|
||||
mp_raise_OSError(-ret);
|
||||
}
|
||||
return mp_const_false;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock_acquire_obj, 1, 3, thread_lock_acquire);
|
||||
|
||||
//-----------------------------------------------------
|
||||
STATIC mp_obj_t thread_lock_release(mp_obj_t self_in) {
|
||||
mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
if (!self->locked) {
|
||||
mp_raise_msg(&mp_type_RuntimeError, NULL);
|
||||
}
|
||||
self->locked = false;
|
||||
MP_THREAD_GIL_EXIT();
|
||||
mp_thread_mutex_unlock(&self->mutex);
|
||||
MP_THREAD_GIL_ENTER();
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_release_obj, thread_lock_release);
|
||||
|
||||
//----------------------------------------------------
|
||||
STATIC mp_obj_t thread_lock_locked(mp_obj_t self_in) {
|
||||
mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
return mp_obj_new_bool(self->locked);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_locked_obj, thread_lock_locked);
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
STATIC mp_obj_t thread_lock___exit__(size_t n_args, const mp_obj_t *args) {
|
||||
(void)n_args; // unused
|
||||
return thread_lock_release(args[0]);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock___exit___obj, 4, 4, thread_lock___exit__);
|
||||
|
||||
//----------------------------------------------------------------
|
||||
STATIC const mp_rom_map_elem_t thread_lock_locals_dict_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock_acquire_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&thread_lock___exit___obj) },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_table);
|
||||
|
||||
//------------------------------------------------
|
||||
STATIC const mp_obj_type_t mp_type_thread_lock = {
|
||||
{ &mp_type_type },
|
||||
.name = MP_QSTR_lock,
|
||||
.locals_dict = (mp_obj_dict_t*)&thread_lock_locals_dict,
|
||||
};
|
||||
|
||||
/****************************************************************/
|
||||
// _thread module
|
||||
@@ -365,7 +277,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_thread_resume_obj, mod_thread_resume);
|
||||
STATIC mp_obj_t mod_thread_stop(mp_obj_t in_id) {
|
||||
uintptr_t thr_id = mp_obj_get_int(in_id);
|
||||
|
||||
if (mp_thread_stop((void *)thr_id)) return mp_const_true;
|
||||
if (mp_thread_notify((void *)thr_id, THREAD_NOTIFY_EXIT)) return mp_const_true;
|
||||
return mp_const_false;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_thread_stop_obj, mod_thread_stop);
|
||||
@@ -505,13 +417,17 @@ STATIC mp_obj_t mod_thread_list(mp_uint_t n_args, const mp_obj_t *args) {
|
||||
for (n=0; n<num; n++) {
|
||||
thr = list.threads + (sizeof(threadlistitem_t) * n);
|
||||
char th_type[8] = {'\0'};
|
||||
char th_state[16] = {'\0'};
|
||||
if (thr->type == THREAD_TYPE_MAIN) sprintf(th_type, "MAIN");
|
||||
else if (thr->type == THREAD_TYPE_PYTHON) sprintf(th_type, "PYTHON");
|
||||
else if (thr->type == THREAD_TYPE_SERVICE) sprintf(th_type, "SERVICE");
|
||||
else sprintf(th_type, "Unknown");
|
||||
if (thr->suspended) sprintf(th_state, "suspended");
|
||||
else if (thr->waiting) sprintf(th_state, "waiting");
|
||||
else sprintf(th_state, "running");
|
||||
|
||||
mp_printf(&mp_plat_print, "ID=%u, Name: %s, State: %s, Stack=%d, MaxUsed=%d, Type: %s\n",
|
||||
thr->id, thr->name, (thr->suspended ? "suspended" : "running"), thr->stack_len,
|
||||
thr->id, thr->name, th_state, thr->stack_len,
|
||||
thr->stack_max, th_type);
|
||||
}
|
||||
free(list.threads);
|
||||
@@ -525,8 +441,9 @@ STATIC mp_obj_t mod_thread_list(mp_uint_t n_args, const mp_obj_t *args) {
|
||||
thr_info[0] = mp_obj_new_int(thr->id);
|
||||
thr_info[1] = mp_obj_new_int(thr->type);
|
||||
thr_info[2] = mp_obj_new_str(thr->name, strlen(thr->name), false);
|
||||
if (thr->suspended) thr_info[3] = mp_const_true;
|
||||
else thr_info[3] = mp_const_false;
|
||||
if (thr->suspended) thr_info[3] = mp_obj_new_int(1);
|
||||
else if (thr->waiting) thr_info[3] = mp_obj_new_int(2);
|
||||
else thr_info[3] = mp_obj_new_int(0);
|
||||
thr_info[4] = mp_obj_new_int(thr->stack_len);
|
||||
thr_info[5] = mp_obj_new_int(thr->stack_max);
|
||||
tuple[n] = mp_obj_new_tuple(6, thr_info);
|
||||
@@ -538,7 +455,7 @@ STATIC mp_obj_t mod_thread_list(mp_uint_t n_args, const mp_obj_t *args) {
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_list_obj, 0, 1, mod_thread_list);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------------
|
||||
STATIC mp_obj_t mod_thread_replAcceptMsg(mp_uint_t n_args, const mp_obj_t *args) {
|
||||
int res = 0;
|
||||
if (n_args == 0) {
|
||||
@@ -551,38 +468,64 @@ STATIC mp_obj_t mod_thread_replAcceptMsg(mp_uint_t n_args, const mp_obj_t *args)
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_replAcceptMsg_obj, 0, 1, mod_thread_replAcceptMsg);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
STATIC mp_obj_t mod_thread_waitnotify(mp_uint_t n_args, const mp_obj_t *args) {
|
||||
uint32_t tmo = portMAX_DELAY;
|
||||
if (n_args > 0) {
|
||||
tmo = mp_obj_get_int(args[0]);
|
||||
if (tmo < 1) tmo = 1;
|
||||
tmo /= portTICK_PERIOD_MS;
|
||||
}
|
||||
uint32_t not_val = 0;
|
||||
mp_obj_t ret = mp_const_none;
|
||||
|
||||
if (mp_thread_setblocked()) {
|
||||
MP_THREAD_GIL_EXIT();
|
||||
if (xTaskNotifyWait(0, 0xffffffffUL, ¬_val, tmo) == pdPASS) {
|
||||
ret = MP_OBJ_NEW_SMALL_INT(not_val);
|
||||
}
|
||||
mp_thread_setnotblocked();
|
||||
MP_THREAD_GIL_ENTER();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_waitnotify_obj, 0, 1, mod_thread_waitnotify);
|
||||
|
||||
|
||||
//=================================================================
|
||||
STATIC const mp_rom_map_elem_t mp_module_thread_globals_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__thread) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_stack_size), MP_ROM_PTR(&mod_thread_stack_size_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_start_new_thread), MP_ROM_PTR(&mod_thread_start_new_thread_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_allowsuspend), MP_ROM_PTR(&mod_thread_allowsuspend_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_suspend), MP_ROM_PTR(&mod_thread_suspend_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_resume), MP_ROM_PTR(&mod_thread_resume_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_kill), MP_ROM_PTR(&mod_thread_stop_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_notify), MP_ROM_PTR(&mod_thread_notify_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getReplID), MP_ROM_PTR(&mod_thread_getREPLId_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_replAcceptMsg), MP_ROM_PTR(&mod_thread_replAcceptMsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getnotification), MP_ROM_PTR(&mod_thread_getnotify_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_sendmsg), MP_ROM_PTR(&mod_thread_sendmsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getmsg), MP_ROM_PTR(&mod_thread_getmsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_list), MP_ROM_PTR(&mod_thread_list_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getThreadName), MP_ROM_PTR(&mod_thread_getname_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getSelfName), MP_ROM_PTR(&mod_thread_getSelfname_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&mod_thread_status_obj) },
|
||||
//{ MP_ROM_QSTR(MP_QSTR_LockType), MP_ROM_PTR(&mp_type_thread_lock) },
|
||||
//{ MP_ROM_QSTR(MP_QSTR_get_ident), MP_ROM_PTR(&mod_thread_get_ident_obj) },
|
||||
//{ MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mod_thread_exit_obj) },
|
||||
//{ MP_ROM_QSTR(MP_QSTR_allocate_lock), MP_ROM_PTR(&mod_thread_allocate_lock_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__thread) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_stack_size), MP_ROM_PTR(&mod_thread_stack_size_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_start_new_thread), MP_ROM_PTR(&mod_thread_start_new_thread_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_allowsuspend), MP_ROM_PTR(&mod_thread_allowsuspend_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_suspend), MP_ROM_PTR(&mod_thread_suspend_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_resume), MP_ROM_PTR(&mod_thread_resume_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&mod_thread_stop_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_notify), MP_ROM_PTR(&mod_thread_notify_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getReplID), MP_ROM_PTR(&mod_thread_getREPLId_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_replAcceptMsg), MP_ROM_PTR(&mod_thread_replAcceptMsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getnotification), MP_ROM_PTR(&mod_thread_getnotify_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_sendmsg), MP_ROM_PTR(&mod_thread_sendmsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getmsg), MP_ROM_PTR(&mod_thread_getmsg_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_list), MP_ROM_PTR(&mod_thread_list_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getThreadName), MP_ROM_PTR(&mod_thread_getname_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_getSelfName), MP_ROM_PTR(&mod_thread_getSelfname_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&mod_thread_status_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_wait), MP_ROM_PTR(&mod_thread_waitnotify_obj) },
|
||||
|
||||
// Constants
|
||||
{ MP_ROM_QSTR(MP_QSTR_PAUSE), MP_ROM_INT(THREAD_NOTIFY_PAUSE) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_SUSPEND), MP_ROM_INT(THREAD_NOTIFY_PAUSE) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_RESUME), MP_ROM_INT(THREAD_NOTIFY_RESUME) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_EXIT), MP_ROM_INT(THREAD_NOTIFY_EXIT) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_STOP), MP_ROM_INT(THREAD_NOTIFY_EXIT) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_STATUS), MP_ROM_INT(THREAD_NOTIFY_STATUS) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_PAUSE), MP_ROM_INT(THREAD_NOTIFY_PAUSE) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_SUSPEND), MP_ROM_INT(THREAD_NOTIFY_PAUSE) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_RESUME), MP_ROM_INT(THREAD_NOTIFY_RESUME) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_EXIT), MP_ROM_INT(THREAD_NOTIFY_EXIT) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_STOP), MP_ROM_INT(THREAD_NOTIFY_EXIT) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_STATUS), MP_ROM_INT(THREAD_NOTIFY_STATUS) },
|
||||
|
||||
{ MP_ROM_QSTR(MP_QSTR_RUNNING), MP_ROM_INT(THREAD_STATUS_RUNNING) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_SUSPENDED), MP_ROM_INT(THREAD_STATUS_RUNNING) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_WAITING), MP_ROM_INT(THREAD_STATUS_RUNNING) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_TERMINATED), MP_ROM_INT(THREAD_STATUS_RUNNING) },
|
||||
};
|
||||
STATIC MP_DEFINE_CONST_DICT(mp_module_thread_globals, mp_module_thread_globals_table);
|
||||
|
||||
|
||||
@@ -51,7 +51,7 @@ void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len);
|
||||
#endif
|
||||
|
||||
#ifndef mp_hal_delay_ms
|
||||
void mp_hal_delay_ms(mp_uint_t ms);
|
||||
int mp_hal_delay_ms(mp_uint_t ms);
|
||||
#endif
|
||||
|
||||
#ifndef mp_hal_delay_us
|
||||
|
||||
Binary file not shown.
@@ -12,6 +12,7 @@ Available firmwares:
|
||||
|**esp32_ota** | MicroPython, dual partition layout, OTA enabled, 4MB Flash |
|
||||
|**esp32_psram** | MicroPython, single partition layout, 4MB Flash & 4MB SPIRAM |
|
||||
|**esp32_psram_ota** | MicroPython, dual partition layout, OTA enabled, 4MB Flash & 4MB SPIRAM |
|
||||
|**esp32_psram_all** | MicroPython, single partition layout, 4MB Flash & 4MB SPIRAM, ALL modules included |
|
||||
|
||||
|
||||
All firmwares are configured with 1 MB SPIFFS file system.<br>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user