cc3200: Make peripheral objects static.

This prevents duplication of objects in the sleep list. Also helps
with reducing the code size by ~100 bytes.

cc3200/hal/prcm.h

@@ -159,7 +159,7 @@ unsigned char ulRstReg;
 #define PRCM_HIB_WAKEUP_CAUSE_GPIO        0x00000004
 
 //*****************************************************************************
-// Values that can be passed to PRCMSEnableInterrupt
+// Values that can be passed to PRCMIntEnable
 //*****************************************************************************
 #define PRCM_INT_SLOW_CLK_CTR     0x00004000
 

cc3200/mods/pybadc.c

@@ -64,14 +64,25 @@
 ///
 ///     The sample rate is fixed to 62.5KHz and the resolution to 12 bits.
 
-typedef struct _pyb_obj_adc_t {
+
+/******************************************************************************
+ DECLARE CONSTANTS
+ ******************************************************************************/
+#define PYB_ADC_NUM_CHANNELS                4
+
+/******************************************************************************
+ DEFINE TYPES
+ ******************************************************************************/
+typedef struct {
     mp_obj_base_t base;
     byte channel;
     byte num;
-} pyb_obj_adc_t;
+} pyb_adc_obj_t;
 
-
+/******************************************************************************
-STATIC void pybadc_init (pyb_obj_adc_t *self) {
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+STATIC void pybadc_init (pyb_adc_obj_t *self) {
      // enable the ADC channel
      MAP_ADCChannelEnable(ADC_BASE, self->channel);
     // enable and configure the timer
@@ -81,11 +92,16 @@ STATIC void pybadc_init (pyb_obj_adc_t *self) {
     MAP_ADCEnable(ADC_BASE);
 }
 
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC pyb_adc_obj_t pyb_adc_obj[PYB_ADC_NUM_CHANNELS];
+
 /******************************************************************************/
 /* Micro Python bindings : adc object                                         */
 
 STATIC void adc_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
-    pyb_obj_adc_t *self = self_in;
+    pyb_adc_obj_t *self = self_in;
     print(env, "<ADC, channel=%u>", self->num);
 }
 
@@ -123,7 +139,7 @@ STATIC mp_obj_t adc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw,
     }
 
     // disable the callback before re-configuring
-    pyb_obj_adc_t *self = m_new_obj_with_finaliser(pyb_obj_adc_t);
+    pyb_adc_obj_t *self = &pyb_adc_obj[channel];
     self->base.type = &pyb_adc_type;
     self->channel = channel;
     self->num = num;
@@ -144,7 +160,7 @@ STATIC mp_obj_t adc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw,
 /// Read the value on the analog pin and return it.  The returned value
 /// will be between 0 and 4095.
 STATIC mp_obj_t adc_read(mp_obj_t self_in) {
-    pyb_obj_adc_t *self = self_in;
+    pyb_adc_obj_t *self = self_in;
     uint32_t sample;
 
     // wait until a new value is available
@@ -159,7 +175,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_read_obj, adc_read);
 /// \method enable()
 /// Enable the adc channel
 STATIC mp_obj_t adc_enable(mp_obj_t self_in) {
-    pyb_obj_adc_t *self = self_in;
+    pyb_adc_obj_t *self = self_in;
 
     pybadc_init(self);
     return mp_const_none;
@@ -169,7 +185,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_enable_obj, adc_enable);
 /// \method disable()
 /// Disable the adc channel
 STATIC mp_obj_t adc_disable(mp_obj_t self_in) {
-    pyb_obj_adc_t *self = self_in;
+    pyb_adc_obj_t *self = self_in;
 
     MAP_ADCChannelDisable(ADC_BASE, self->channel);
     // unregister it with the sleep module

cc3200/mods/pybi2c.c

@@ -119,6 +119,11 @@ typedef struct _pyb_i2c_obj_t {
                                                     }                       \
                                                 }
 
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC pyb_i2c_obj_t        pyb_i2c_obj;
+
 /******************************************************************************
  DEFINE PRIVATE FUNCTIONS
  ******************************************************************************/
@@ -327,8 +332,8 @@ STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n
         nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
     }
 
-    // create and setup the object
+    // setup the object
-    pyb_i2c_obj_t *self = m_new_obj_with_finaliser(pyb_i2c_obj_t);
+    pyb_i2c_obj_t *self = &pyb_i2c_obj;
     self->base.type = &pyb_i2c_type;
     self->mode = PYBI2C_MODE_DISABLED;
 

cc3200/mods/pybuart.c

@@ -95,17 +95,13 @@
  ******************************************************************************/
 STATIC void uart_init (pyb_uart_obj_t *self);
 STATIC bool uart_rx_wait (pyb_uart_obj_t *self, uint32_t timeout);
-STATIC pyb_uart_obj_t* pyb_uart_add (pyb_uart_id_t uart_id);
-STATIC pyb_uart_obj_t* pyb_uart_find (pyb_uart_id_t uart_id);
 STATIC void UARTGenericIntHandler(uint32_t uart_id);
 STATIC void UART0IntHandler(void);
 STATIC void UART1IntHandler(void);
-STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in);
 
 /******************************************************************************
  DEFINE PRIVATE TYPES
  ******************************************************************************/
-
 struct _pyb_uart_obj_t {
     mp_obj_base_t base;
     pyb_uart_id_t uart_id;
@@ -122,21 +118,15 @@ struct _pyb_uart_obj_t {
     bool enabled;
 };
 
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC pyb_uart_obj_t pyb_uart_obj[PYB_NUM_UARTS];
+
 /******************************************************************************
  DEFINE PUBLIC FUNCTIONS
  ******************************************************************************/
 void uart_init0 (void) {
-    mp_obj_list_init(&MP_STATE_PORT(pyb_uart_list), 0);
-}
-
-// unregister all interrupt sources
-void uart_deinit(void) {
-    for (int i = PYB_UART_0; i < PYB_NUM_UARTS; i++) {
-        pyb_uart_obj_t *self;
-        if ((self = pyb_uart_find (i))) {
-            pyb_uart_deinit(self);
-        }
-    }
 }
 
 bool uart_rx_any(pyb_uart_obj_t *self) {
@@ -255,33 +245,11 @@ STATIC bool uart_rx_wait (pyb_uart_obj_t *self, uint32_t timeout) {
     }
 }
 
-STATIC pyb_uart_obj_t* pyb_uart_add (pyb_uart_id_t uart_id) {
-    // create a new uart object
-    pyb_uart_obj_t *self = m_new_obj(pyb_uart_obj_t);
-    self->base.type = &pyb_uart_type;
-    self->uart_id = uart_id;
-    self->read_buf = NULL;
-    self->enabled = false;
-    // add it to the list
-    mp_obj_list_append(&MP_STATE_PORT(pyb_uart_list), self);
-    return self;
-}
-
-STATIC pyb_uart_obj_t* pyb_uart_find (pyb_uart_id_t uart_id) {
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(pyb_uart_list).len; i++) {
-        pyb_uart_obj_t *self = (pyb_uart_obj_t *)MP_STATE_PORT(pyb_uart_list).items[i];
-        if (self->uart_id == uart_id) {
-            return self;
-        }
-    }
-    return NULL;
-}
-
 STATIC void UARTGenericIntHandler(uint32_t uart_id) {
     pyb_uart_obj_t *self;
     uint32_t status;
 
-    if ((self = pyb_uart_find(uart_id))) {
+    self = &pyb_uart_obj[uart_id];
     status = MAP_UARTIntStatus(self->reg, true);
     // receive interrupt
     if (status & (UART_INT_RX | UART_INT_RT)) {
@@ -303,7 +271,6 @@ STATIC void UARTGenericIntHandler(uint32_t uart_id) {
         }
     }
 }
-}
 
 STATIC void UART0IntHandler(void) {
     UARTGenericIntHandler(0);
@@ -469,13 +436,14 @@ STATIC mp_obj_t pyb_uart_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t
         nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
     }
 
-    // search for an object in the list
+    // get the correct uart instance
-    pyb_uart_obj_t *self;
+    pyb_uart_obj_t *self = &pyb_uart_obj[uart_id];
-    if (!(self = pyb_uart_find(uart_id))) {
+    self->base.type = &pyb_uart_type;
-        self = pyb_uart_add(uart_id);
+    self->uart_id = uart_id;
-    }
-
     if (n_args > 1 || n_kw > 0) {
+        // invalidate the buffer and clear the enabled flag
+        self->read_buf = NULL;
+        self->enabled = false;
         // start the peripheral
         mp_map_t kw_args;
         mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
@@ -492,7 +460,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
 
 /// \method deinit()
 /// Turn off the UART bus.
-STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
+mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
     pyb_uart_obj_t *self = self_in;
     uint uartPerh;
 

cc3200/mods/pybuart.h

@@ -29,7 +29,6 @@
 #define PYBUART_H_
 
 typedef enum {
-    PYB_UART_NONE   = -1,
     PYB_UART_0      =  0,
     PYB_UART_1      =  1,
     PYB_NUM_UARTS
@@ -39,7 +38,7 @@ typedef struct _pyb_uart_obj_t pyb_uart_obj_t;
 extern const mp_obj_type_t pyb_uart_type;
 
 void uart_init0(void);
-void uart_deinit (void);
+mp_obj_t pyb_uart_deinit(mp_obj_t self_in);
 bool uart_rx_any(pyb_uart_obj_t *uart_obj);
 int uart_rx_char(pyb_uart_obj_t *uart_obj);
 bool uart_tx_char(pyb_uart_obj_t *self, int c);

cc3200/mpconfigport.h

@@ -120,7 +120,6 @@ extern const struct _mp_obj_module_t mp_module_network;
     const char *readline_hist[8];                                         \
     mp_obj_t mp_const_user_interrupt;                                     \
     mp_obj_t pyb_config_main;                                             \
-    mp_obj_list_t pyb_uart_list;                                          \
     mp_obj_list_t mod_network_nic_list;                                   \
     mp_obj_list_t pybsleep_obj_list;                                      \
     mp_obj_list_t mpcallback_obj_list;                                    \

cc3200/mptask.c

@@ -250,7 +250,10 @@ soft_reset_exit:
     wlan_stop_servers();
     wlan_stop();
 
-    uart_deinit();
+    // de-initialize the stdio uart
+    if (pyb_stdio_uart) {
+        pyb_uart_deinit(pyb_stdio_uart);
+    }
 
     goto soft_reset;
 }