cc3200: Add power management framework. Add mpcallback class.

Supports suspend and hibernate modes. Waking is possible throug GPIO
and WLAN.
The mpcallback class is generic and can be reused by other classes.

cc3200/FreeRTOS/FreeRTOSConfig.h

@@ -83,7 +83,7 @@
 #define configUSE_TICK_HOOK				        1
 #define configCPU_CLOCK_HZ				        ( ( unsigned long ) 80000000 )
 #define configTICK_RATE_HZ				        ( ( TickType_t ) 1000 )
-#define configMINIMAL_STACK_SIZE		        ( ( unsigned short ) 64 )
+#define configMINIMAL_STACK_SIZE		        ( ( unsigned short ) 72 )
 #define configTOTAL_HEAP_SIZE			        ( ( size_t ) ( 16384 ) )
 #define configMAX_TASK_NAME_LEN			        ( 8 )
 #define configUSE_TRACE_FACILITY		        0

cc3200/application.mk

@@ -76,6 +76,7 @@ APP_MISC_SRC_C = $(addprefix misc/,\
 	FreeRTOSHooks.c \
 	pin_named_pins.c \
 	help.c \
+	mpcallback.c \
 	mperror.c \
 	mpexception.c \
 	pin_defs_cc3200.c \
@@ -89,8 +90,8 @@ APP_MODS_SRC_C = $(addprefix mods/,\
 	modutime.c \
 	modwlan.c \
 	pybadc.c \
-	pybi2c.c \
 	pybpin.c \
+	pybi2c.c \
 	pybrtc.c \
 	pybsd.c \
 	pybsleep.c \
@@ -128,6 +129,7 @@ APP_UTIL_SRC_C = $(addprefix util/,\
 	
 APP_UTIL_SRC_S = $(addprefix util/,\
 	gchelper.s \
+	sleeprestore.s \
 	)
 	
 APP_MAIN_SRC_C = \

cc3200/boards/LAUNCHXL/mpconfigboard.h

@@ -46,3 +46,5 @@
 #define MICROPY_SYS_LED_PORT_PIN                    GPIO_PIN_1
 #define MICROPY_SAFE_BOOT_PORT_PIN                    GPIO_PIN_6
 
+#define MICROPY_PORT_SFLASH_BLOCK_COUNT             32
+

cc3200/boards/cc3200_prefix.c

@@ -43,7 +43,7 @@
 { \
     { &pin_type }, \
     .name     = MP_QSTR_ ## p_pin_name, \
-    .callback = NULL, \
+    .callback = mp_const_none, \
     .port     = PORT_A ## p_port, \
     .type     = PIN_TYPE_STD, \
     .bit      = (p_bit), \

cc3200/boards/make-pins.py

@@ -40,12 +40,11 @@ class Pin(object):
         self.board_pin = True
         
     def print(self):
-        print('const pin_obj_t pin_{:6s} = PIN({:6s}, {:1d}, {:3d}, {:2d});'.format(
+        print('pin_obj_t pin_{:6s} = PIN({:6s}, {:1d}, {:3d}, {:2d});'.format(
                self.name, self.name, self.port, self.gpio_bit, self.pin_num))
 
     def print_header(self, hdr_file):
-        hdr_file.write('extern const pin_obj_t pin_{:s};\n'.
-                       format(self.name))
+        hdr_file.write('extern pin_obj_t pin_{:s};\n'.format(self.name))
 
 
 class Pins(object):

cc3200/bootmgr/main.c

@@ -57,7 +57,7 @@
 //*****************************************************************************
 // Local Constants
 //*****************************************************************************
-#define SL_STOP_TIMEOUT                     250
+#define SL_STOP_TIMEOUT                     35
 #define BOOTMGR_HASH_ALGO                   SHAMD5_ALGO_MD5
 #define BOOTMGR_HASH_SIZE                   32
 #define BOOTMGR_BUFF_SIZE                   512
@@ -65,8 +65,8 @@
 #define BOOTMGR_WAIT_SAFE_MODE_MS           1600
 #define BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS    200
 
-#define BOOTMGR_SAFE_MODE_ENTER_MS          700
-#define BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS   70
+#define BOOTMGR_SAFE_MODE_ENTER_MS          800
+#define BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS   80
 
 //*****************************************************************************
 // Exported functions declarations
@@ -307,7 +307,7 @@ int main (void) {
     bootmgr_board_init();
 
     // start simplelink since we need it to access the sflash
-    sl_Start(NULL, NULL, NULL);
+    sl_Start(0, 0, 0);
 
     // if a boot info file is found, load it, else, create a new one with the default boot info
     if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_READ, NULL, &fhandle)) {

cc3200/fatfs/src/drivers/sflash_diskio.h

@@ -2,7 +2,7 @@
 #define SFLASH_DISKIO_H_
 
 #define SFLASH_BLOCK_SIZE           2048
-#define SFLASH_BLOCK_COUNT          32          // makes for 64KB of space
+#define SFLASH_BLOCK_COUNT          MICROPY_PORT_SFLASH_BLOCK_COUNT
 #define SFLASH_SECTOR_SIZE          512
 #define SFLASH_SECTOR_COUNT         ((SFLASH_BLOCK_SIZE * SFLASH_BLOCK_COUNT) / SFLASH_SECTOR_SIZE)
 #define SFLASH_SECTORS_PER_BLOCK    (SFLASH_BLOCK_SIZE / SFLASH_SECTOR_SIZE)

cc3200/hal/startup_gcc.c

@@ -65,7 +65,7 @@ void ResetISR(void);
 #ifdef DEBUG
 static void NmiSR(void) __attribute__( ( naked ) );
 static void FaultISR( void ) __attribute__( ( naked ) );
-void HardFault_HandlerC(unsigned long *hardfault_args);
+void HardFault_HandlerC(uint32_t *pulFaultStackAddress);
 static void BusFaultHandler(void) __attribute__( ( naked ) );
 #endif
 static void IntDefaultHandler(void) __attribute__( ( naked ) );

cc3200/misc/mpcallback.c

+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include MICROPY_HAL_H
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "inc/hw_types.h"
+#include "interrupt.h"
+#include "pybsleep.h"
+#include "mpcallback.h"
+#include "mpexception.h"
+#include "mperror.h"
+
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC mpcallback_obj_t *mpcallback_find (mp_obj_t parent);
+
+/******************************************************************************
+ DEFINE PUBLIC DATA
+ ******************************************************************************/
+const mp_arg_t mpcallback_init_args[] = {
+    { MP_QSTR_intmode,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_handler,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    { MP_QSTR_priority,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+    { MP_QSTR_value,        MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_wake,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PYB_PWR_MODE_ACTIVE_IDLE } },
+};
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+void mpcallback_init0 (void) {
+    // initialize the callback objects list
+    mp_obj_list_init(&MP_STATE_PORT(mpcallback_obj_list), 0);
+}
+
+mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods) {
+    mpcallback_obj_t *self = m_new_obj(mpcallback_obj_t);
+    self->base.type = &pyb_callback_type;
+    self->handler = handler;
+    self->parent = parent;
+    self->methods = (mp_cb_methods_t *)methods;
+    // remove any old callback if present
+    mpcallback_remove(self->parent);
+    mp_obj_list_append(&MP_STATE_PORT(mpcallback_obj_list), self);
+    return self;
+}
+
+void mpcallback_remove (const mp_obj_t parent) {
+    mpcallback_obj_t *callback_obj;
+    if ((callback_obj = mpcallback_find(parent))) {
+        mp_obj_list_remove(&MP_STATE_PORT(mpcallback_obj_list), callback_obj);
+    }
+}
+
+uint mpcallback_translate_priority (uint priority) {
+    if (priority < 1 || priority > 7) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+
+   switch (priority) {
+   case 1:
+       return INT_PRIORITY_LVL_7;
+   case 2:
+       return INT_PRIORITY_LVL_6;
+   case 3:
+       return INT_PRIORITY_LVL_5;
+   case 4:
+       return INT_PRIORITY_LVL_4;
+   case 5:
+       return INT_PRIORITY_LVL_3;
+   case 6:
+       return INT_PRIORITY_LVL_2;
+   case 7:
+       return INT_PRIORITY_LVL_1;
+   default:
+       return INT_PRIORITY_LVL_7;
+   }
+}
+
+void mpcallback_handler (mp_obj_t self_in) {
+    mpcallback_obj_t *self = self_in;
+    if (self->handler != mp_const_none) {
+        // disable interrupts to avoid nesting
+        uint primsk = disable_irq();
+        // when executing code within a handler we must lock the GC to prevent
+        // any memory allocations.  We must also catch any exceptions.
+        gc_lock();
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_call_function_1(self->handler, self->parent);
+            nlr_pop();
+        }
+        else {
+            // uncaught exception; disable the callback so that it doesn't run again
+            self->methods->disable (self->parent);
+            self->handler = mp_const_none;
+            // printing an exception here will cause a stack overflow that will end up in
+            // a hard fault, so is better to signal the uncaught (probably non-recoverable)
+            // exception by blinking the system led instead.
+            mperror_signal_error();
+        }
+        gc_unlock();
+        enable_irq(primsk);
+    }
+}
+
+/******************************************************************************
+ DEFINE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC mpcallback_obj_t *mpcallback_find (mp_obj_t parent) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mpcallback_obj_list).len; i++) {
+        // search for the object and then remove it
+        mpcallback_obj_t *callback_obj = ((mpcallback_obj_t *)(MP_STATE_PORT(mpcallback_obj_list).items[i]));
+        if (callback_obj->parent == parent) {
+            return callback_obj;
+        }
+    }
+    return NULL;
+}
+
+/******************************************************************************/
+// Micro Python bindings
+
+/// \method init()
+/// Initializes the interrupt callback. With no parameters passed, everything will default
+/// to the values assigned to mpcallback_init_args[].
+STATIC mp_obj_t callback_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mpcallback_obj_t *self = pos_args[0];
+    // this is a bit of a hack, but it let us reuse the callback_create method from our parent
+    ((mp_obj_t *)pos_args)[0] = self->parent;
+    self->methods->init (n_args, pos_args, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(callback_init_obj, 1, callback_init);
+
+/// \method enable()
+/// Enables the interrupt callback
+STATIC mp_obj_t callback_enable (mp_obj_t self_in) {
+    mpcallback_obj_t *self = self_in;
+    self->methods->enable(self->parent);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(callback_enable_obj, callback_enable);
+
+/// \method disable()
+/// Disables the interrupt callback
+STATIC mp_obj_t callback_disable (mp_obj_t self_in) {
+    mpcallback_obj_t *self = self_in;
+    self->methods->disable(self->parent);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(callback_disable_obj, callback_disable);
+
+/// \method \call()
+/// Triggers the interrupt callback
+STATIC mp_obj_t callback_call(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    mpcallback_handler (self_in);
+    return mp_const_none;
+}
+
+STATIC const mp_map_elem_t callback_locals_dict_table[] = {
+    // instance methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&callback_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),              (mp_obj_t)&callback_enable_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),             (mp_obj_t)&callback_disable_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(callback_locals_dict, callback_locals_dict_table);
+
+const mp_obj_type_t pyb_callback_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_callback,
+    .call = callback_call,
+    .locals_dict = (mp_obj_t)&callback_locals_dict,
+};
+

cc3200/misc/mpcallback.h

+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MPCALLBACK_H_
+#define MPCALLBACK_H_
+
+/******************************************************************************
+ DEFINE CONSTANTS
+ ******************************************************************************/
+#define mpcallback_INIT_NUM_ARGS                  5
+
+/******************************************************************************
+ DEFINE TYPES
+ ******************************************************************************/
+typedef void (*mp_cb_method_t) (mp_obj_t self);
+typedef mp_obj_t (*mp_cb_init_t) (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+typedef struct {
+    mp_cb_init_t init;
+    mp_cb_method_t enable;
+    mp_cb_method_t disable;
+} mp_cb_methods_t;
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t parent;
+    mp_obj_t handler;
+    mp_cb_methods_t *methods;
+} mpcallback_obj_t;
+
+/******************************************************************************
+ DECLARE EXPORTED DATA
+ ******************************************************************************/
+extern const mp_arg_t mpcallback_init_args[];
+extern const mp_obj_type_t pyb_callback_type;
+
+/******************************************************************************
+ DECLARE PUBLIC FUNCTIONS
+ ******************************************************************************/
+void mpcallback_init0 (void);
+mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods);
+void mpcallback_remove (const mp_obj_t parent);
+void mpcallback_handler (mp_obj_t self_in);
+uint mpcallback_translate_priority (uint priority);
+mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods);
+
+#endif /* MPCALLBACK_H_ */

cc3200/misc/mperror.c

@@ -51,8 +51,8 @@
 /******************************************************************************
  DEFINE CONSTANTS
  ******************************************************************************/
-#define MPERROR_TOOGLE_MS                           (200)
-#define MPERROR_SIGNAL_ERROR_MS                     (2000)
+#define MPERROR_TOOGLE_MS                           (40)
+#define MPERROR_SIGNAL_ERROR_MS                     (1000)
 #define MPERROR_HEARTBEAT_ON_MS                     (80)
 #define MPERROR_HEARTBEAT_OFF_MS                    (2920)
 
@@ -113,7 +113,7 @@ void mperror_deinit_sfe_pin (void) {
 
 void mperror_signal_error (void) {
     uint32_t count = 0;
-    while ((MPERROR_TOOGLE_MS * count++) > MPERROR_SIGNAL_ERROR_MS) {
+    while ((MPERROR_TOOGLE_MS * count++) < MPERROR_SIGNAL_ERROR_MS) {
         // toogle the led
         MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
         UtilsDelay(UTILS_DELAY_US_TO_COUNT(MPERROR_TOOGLE_MS * 1000));

cc3200/misc/pin_defs_cc3200.c

@@ -26,6 +26,7 @@
  */
 
 #include "py/mpconfig.h"
+#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "inc/hw_types.h"
 #include "inc/hw_gpio.h"
@@ -35,32 +36,20 @@
 #include "gpio.h"
 #include "pin.h"
 #include "pybpin.h"
-#include MICROPY_HAL_H
+
 
 
 // Returns the pin mode. This value returned by this macro should be one of:
 // GPIO_DIR_MODE_IN or GPIO_DIR_MODE_OUT
-uint32_t pin_get_mode(const pin_obj_t *self) {
-    return MAP_GPIODirModeGet(self->port, self->bit);
+uint32_t pin_get_mode (const pin_obj_t *self) {
+    return self->mode;
 }
 
-uint32_t pin_get_type(const pin_obj_t *self) {
-
-    uint32_t strenght;
-    uint32_t type;
-
-    MAP_PinConfigGet(self->pin_num, &strenght, &type);
-
-    return type;
+uint32_t pin_get_type (const pin_obj_t *self) {
+    return self->type;
 }
 
 uint32_t pin_get_strenght (const pin_obj_t *self) {
-
-    uint32_t strenght;
-    uint32_t type;
-
-    MAP_PinConfigGet(self->pin_num, &strenght, &type);
-
-    return strenght;
+    return self->strength;
 }
 

cc3200/misc/pin_named_pins.c

@@ -49,7 +49,7 @@ const mp_obj_type_t pin_cpu_pins_obj_type = {
     .locals_dict = (mp_obj_t)&pin_cpu_pins_locals_dict,
 };
 
-const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
+pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
     mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
     mp_map_elem_t *named_elem = mp_map_lookup(named_map, name, MP_MAP_LOOKUP);
     if (named_elem != NULL && named_elem->value != NULL) {
@@ -58,7 +58,7 @@ const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t na
     return NULL;
 }
 
-const pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num) {
+pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num) {
     mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
     for (uint i = 0; i < named_map->used; i++) {
         if (((pin_obj_t *)named_map->table[i].value)->pin_num == pin_num) {
@@ -68,7 +68,7 @@ const pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num) {
     return NULL;
 }
 
-const pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit) {
+pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit) {
     mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
     for (uint i = 0; i < named_map->used; i++) {
         if ((((pin_obj_t *)named_map->table[i].value)->port == port) &&

cc3200/mods/modpyb.c

@@ -30,6 +30,7 @@
 #include <stdint.h>
 
 #include "py/mpstate.h"
+#include "py/runtime.h"
 #include MICROPY_HAL_H
 #include "irq.h"
 #include "inc/hw_types.h"
@@ -45,6 +46,7 @@
 #include "pybsystick.h"
 #include "simplelink.h"
 #include "modwlan.h"
+#include "moduos.h"
 #include "telnet.h"
 #include "ff.h"
 #include "diskio.h"
@@ -53,11 +55,13 @@
 #include "portable.h"
 #include "task.h"
 #include "mpexception.h"
+#include "mpcallback.h"
 #include "random.h"
 #include "pybadc.h"
 #include "pybi2c.h"
 #include "pybsd.h"
 #include "pybwdt.h"
+#include "pybsleep.h"
 #include "utils.h"
 #include "gccollect.h"
 #include "mperror.h"
@@ -69,6 +73,7 @@ extern OsiTaskHandle    svTaskHandle;
 extern OsiTaskHandle    xSimpleLinkSpawnTaskHndl;
 #endif
 
+
 /// \module pyb - functions related to the pyboard
 ///
 /// The `pyb` module contains specific functions related to the pyboard.
@@ -117,15 +122,6 @@ STATIC mp_obj_t pyb_info(uint n_args, const mp_obj_t *args) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_info_obj, 0, 1, pyb_info);
 #endif
 
-/// \function unique_id()
-/// Returns a string of 6 bytes (48 bits), which is the unique MAC address of the SoC
-STATIC mp_obj_t pyb_mac(void) {
-    uint8_t mac[6];
-    wlan_get_mac (mac);
-    return mp_obj_new_bytes(mac, 6);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_mac_obj, pyb_mac);
-
 /// \function freq()
 /// Returns the CPU frequency: (F_CPU).
 STATIC mp_obj_t pyb_freq(void) {
@@ -133,14 +129,6 @@ STATIC mp_obj_t pyb_freq(void) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_freq_obj, pyb_freq);
 
-/// \function sync()
-/// Sync all file systems.
-STATIC mp_obj_t pyb_sync(void) {
-    sflash_disk_flush();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_sync_obj, pyb_sync);
-
 /// \function millis()
 /// Returns the number of milliseconds since the board was last reset.
 ///
@@ -225,18 +213,6 @@ STATIC mp_obj_t pyb_udelay(mp_obj_t usec_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_udelay_obj, pyb_udelay);
 
-STATIC mp_obj_t pyb_stop(void) {
-    return mp_const_none;
-}
-
-MP_DEFINE_CONST_FUN_OBJ_0(pyb_stop_obj, pyb_stop);
-
-STATIC mp_obj_t pyb_standby(void) {
-    return mp_const_none;
-}
-
-MP_DEFINE_CONST_FUN_OBJ_0(pyb_standby_obj, pyb_standby);
-
 /// \function repl_uart(uart)
 /// Get or set the UART object that the REPL is repeated on.
 STATIC mp_obj_t pyb_repl_uart(uint n_args, const mp_obj_t *args) {
@@ -275,31 +251,26 @@ MP_DECLARE_CONST_FUN_OBJ(pyb_main_obj); // defined in main.c
 STATIC const mp_map_elem_t pyb_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_pyb) },
 
-    { MP_OBJ_NEW_QSTR(MP_QSTR_hard_reset),          (mp_obj_t)&pyb_hard_reset_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_reset),               (mp_obj_t)&pyb_hard_reset_obj },
 #ifdef DEBUG
     { MP_OBJ_NEW_QSTR(MP_QSTR_info),                (mp_obj_t)&pyb_info_obj },
 #endif
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mac),                 (mp_obj_t)&pyb_mac_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_freq),                (mp_obj_t)&pyb_freq_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_repl_info),           (mp_obj_t)&pyb_set_repl_info_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_repl_uart),           (mp_obj_t)&pyb_repl_uart_obj },
 
-    { MP_OBJ_NEW_QSTR(MP_QSTR_wfi),                 (mp_obj_t)&pyb_wfi_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_disable_irq),         (mp_obj_t)&pyb_disable_irq_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_enable_irq),          (mp_obj_t)&pyb_enable_irq_obj },
 
-    { MP_OBJ_NEW_QSTR(MP_QSTR_stop),                (mp_obj_t)&pyb_stop_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_standby),             (mp_obj_t)&pyb_standby_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_main),                (mp_obj_t)&pyb_main_obj },
 
-    { MP_OBJ_NEW_QSTR(MP_QSTR_repl_uart),           (mp_obj_t)&pyb_repl_uart_obj },
-
     { MP_OBJ_NEW_QSTR(MP_QSTR_millis),              (mp_obj_t)&pyb_millis_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_millis),      (mp_obj_t)&pyb_elapsed_millis_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_micros),              (mp_obj_t)&pyb_micros_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_micros),      (mp_obj_t)&pyb_elapsed_micros_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_delay),               (mp_obj_t)&pyb_delay_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_udelay),              (mp_obj_t)&pyb_udelay_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_sync),                (mp_obj_t)&pyb_sync_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sync),                (mp_obj_t)&os_sync_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_mkdisk),              (mp_obj_t)&pyb_mkdisk_obj },
 
 #if MICROPY_HW_ENABLE_RNG
@@ -315,6 +286,7 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_I2C),                 (mp_obj_t)&pyb_i2c_type },
     { MP_OBJ_NEW_QSTR(MP_QSTR_UART),                (mp_obj_t)&pyb_uart_type },
     { MP_OBJ_NEW_QSTR(MP_QSTR_WDT),                 (mp_obj_t)&pyb_wdt_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_Sleep),               (mp_obj_t)&pyb_sleep_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_HeartBeat),           (mp_obj_t)&pyb_heartbeat_obj },
 
 #if MICROPY_HW_HAS_SDCARD

cc3200/mods/moduos.c

@@ -282,11 +282,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_stat_obj, os_stat);
 
 /// \function sync()
 /// Sync all filesystems.
-STATIC mp_obj_t os_sync(void) {