applied patch from fep low power

Author: hansbinderup

drivers/I2C.h

@@ -25,7 +25,6 @@
 #include "hal/i2c_api.h"
 #include "platform/SingletonPtr.h"
 #include "platform/PlatformMutex.h"
-#include "platform/NonCopyable.h"
 
 #if DEVICE_I2C_ASYNCH
 #include "platform/CThunk.h"
@@ -79,7 +78,7 @@ namespace mbed {
  * }
  * @endcode
  */
-class I2C : private NonCopyable<I2C> {
+class I2C {
 
 public:
     enum RxStatus {
@@ -108,6 +107,10 @@ class I2C : private NonCopyable<I2C> {
     I2C(const i2c_pinmap_t &static_pinmap);
     I2C(const i2c_pinmap_t &&) = delete; // prevent passing of temporary objects
 
+    /** Create an I2C Master interface from an existing object
+     */
+    I2C(const I2C&) = default;
+
     /** Set the frequency of the I2C interface
      *
      *  @param hz The bus frequency in hertz
@@ -176,6 +179,14 @@ class I2C : private NonCopyable<I2C> {
      */
     void stop(void);
 
+    /** Recover I2C bus, when stuck with SDA low
+     * 
+     *  @returns
+     *    '0' - Successfully recovered
+     *    'I2C_ERROR_BUS_BUSY' - In case of failure
+     */
+    int recover(void);
+
     /** Acquire exclusive access to this I2C bus
      */
     virtual void lock(void);

drivers/source/I2C.cpp

@@ -148,6 +148,15 @@ void I2C::stop(void)
     unlock();
 }
 
+int I2C::recover(void)
+{
+    lock();
+    int ret = recover(_sda, _scl);
+    i2c_init(&_i2c, _sda, _scl);
+    unlock();
+    return ret;
+}
+
 void I2C::lock()
 {
     _mutex->lock();

drivers/source/SerialBase.cpp

@@ -24,13 +24,13 @@
 namespace mbed {
 
 SerialBase::SerialBase(PinName tx, PinName rx, int baud) :
+    _init_func(&SerialBase::_init),
 #if DEVICE_SERIAL_ASYNCH
     _thunk_irq(this),
 #endif
     _baud(baud),
     _tx_pin(tx),
-    _rx_pin(rx),
-    _init_func(&SerialBase::_init)
+    _rx_pin(rx)
 {
     // No lock needed in the constructor
 
@@ -42,6 +42,7 @@ SerialBase::SerialBase(PinName tx, PinName rx, int baud) :
 }
 
 SerialBase::SerialBase(const serial_pinmap_t &static_pinmap, int baud) :
+    _init_func(&SerialBase::_init_direct),
 #if DEVICE_SERIAL_ASYNCH
     _thunk_irq(this), _tx_usage(DMA_USAGE_NEVER),
     _rx_usage(DMA_USAGE_NEVER), _tx_callback(NULL),
@@ -52,8 +53,7 @@ SerialBase::SerialBase(const serial_pinmap_t &static_pinmap, int baud) :
     _baud(baud),
     _tx_pin(static_pinmap.tx_pin),
     _rx_pin(static_pinmap.rx_pin),
-    _static_pinmap(&static_pinmap),
-    _init_func(&SerialBase::_init_direct)
+    _static_pinmap(&static_pinmap)
 {
     // No lock needed in the constructor
 
@@ -107,17 +107,9 @@ void SerialBase::attach(Callback<void()> func, IrqType type)
         // Disable interrupts when attaching interrupt handler
         core_util_critical_section_enter();
         if (func) {
-            // lock deep sleep only the first time
-            if (!_irq[type]) {
-                sleep_manager_lock_deep_sleep();
-            }
             _irq[type] = func;
             serial_irq_set(&_serial, (SerialIrq)type, 1);
         } else {
-            // unlock deep sleep only the first time
-            if (_irq[type]) {
-                sleep_manager_unlock_deep_sleep();
-            }
             _irq[type] = NULL;
             serial_irq_set(&_serial, (SerialIrq)type, 0);
         }

events/EventQueue.h

@@ -746,12 +746,17 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(f);
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (id == 0) {
+            queue_full(QUEUE_FULL_CALL, sizeof(F));
+        }
+        return id;
     }
 
 
@@ -821,13 +826,18 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL_IN, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(f);
         equeue_event_delay(e, ms);
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (id == 0) {
+            queue_full(QUEUE_FULL_CALL_IN, sizeof(F));
+        }
+        return id;
     }
 
     /** Calls an event on the queue after a specified delay
@@ -900,14 +910,19 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL_EVERY, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(f);
         equeue_event_delay(e, ms);
         equeue_event_period(e, ms);
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (id == 0) {
+            queue_full(QUEUE_FULL_CALL_EVERY, sizeof(F));
+        }
+        return id;
     }
 
     /** Calls an event on the queue periodically
@@ -1239,6 +1254,18 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
         ((F *)p)->~F();
     }
 
+    enum queue_full_call_type {
+        QUEUE_FULL_CALL,
+        QUEUE_FULL_CALL_IN,
+        QUEUE_FULL_CALL_EVERY,
+    };
+
+    /** Error callback. Called when task is rejected because queue is full */
+    virtual void queue_full(queue_full_call_type call_type, size_t function_size) const
+    {
+        // Can be overridden in subclass
+    }
+
     // Context structures
     template <typename F, typename... ContextArgTs>
     struct context;

platform/mbed_rtc_time.h

@@ -38,6 +38,8 @@ struct timeval {
     time_t tv_sec;
     int32_t tv_usec;
 };
+#else
+#include <sys/time.h>
 #endif
 
 /** Implementation of the C time.h functions

platform/source/mbed_error.c

@@ -73,7 +73,7 @@ static bool is_reboot_error_valid = false;
 //we dont have many uses cases to create a C wrapper for MbedCRC and the data
 //we calculate CRC on in this context is very less we will use a local
 //implementation here.
-static unsigned int compute_crc32(const void *data, int datalen)
+__attribute__ ((unused)) static unsigned int compute_crc32(const void *data, int datalen)
 {
     const unsigned int polynomial = 0x04C11DB7; /* divisor is 32bit */
     unsigned int crc = 0; /* CRC value is 32bit */
@@ -200,7 +200,13 @@ static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsign
 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
     //Capture filename/linenumber if provided
     //Index for tracking error_filename
-    strncpy(current_error_ctx.error_filename, filename, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN);
+    const char* copy_from = strrchr(filename, '/');
+    if (!copy_from) {
+        copy_from = filename;
+    } else {
+        ++copy_from; // Skip the '/'
+    }
+    strncpy(current_error_ctx.error_filename, copy_from, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN);
     current_error_ctx.error_line_number = line_number;
 #endif
 

platform/source/mbed_os_timer.cpp

@@ -38,7 +38,7 @@ namespace internal {
 OsTimer *os_timer;
 
 namespace {
-uint64_t os_timer_data[(sizeof(OsTimer) + 7) / 8];
+[[maybe_unused]] uint64_t os_timer_data[(sizeof(OsTimer) + 7) / 8];
 }
 
 OsTimer *init_os_timer()

platform/source/mbed_power_mgmt.c

@@ -28,6 +28,7 @@
 #include "platform/mbed_wait_api.h"
 
 #include <stdio.h>
+#include <string.h>
 
 #if DEVICE_SLEEP
 

platform/source/minimal-printf/mbed_printf_wrapper.c

@@ -17,6 +17,7 @@
 #ifdef MBED_MINIMAL_PRINTF
 
 #include "mbed_printf_implementation.h"
+#include "mbed_toolchain.h"
 
 #include <limits.h>
 
@@ -60,7 +61,7 @@
 #warning "This compiler is not yet supported."
 #endif
 
-int SUB_PRINTF(const char *format, ...)
+MBED_USED int SUB_PRINTF(const char *format, ...)
 {
     va_list arguments;
     va_start(arguments, format);
@@ -70,7 +71,7 @@ int SUB_PRINTF(const char *format, ...)
     return result;
 }
 
-int SUB_SPRINTF(char *buffer, const char *format, ...)
+MBED_USED int SUB_SPRINTF(char *buffer, const char *format, ...)
 {
     va_list arguments;
     va_start(arguments, format);
@@ -80,7 +81,7 @@ int SUB_SPRINTF(char *buffer, const char *format, ...)
     return result;
 }
 
-int SUB_SNPRINTF(char *buffer, size_t length, const char *format, ...)
+MBED_USED int SUB_SNPRINTF(char *buffer, size_t length, const char *format, ...)
 {
     va_list arguments;
     va_start(arguments, format);
@@ -90,22 +91,22 @@ int SUB_SNPRINTF(char *buffer, size_t length, const char *format, ...)
     return result;
 }
 
-int SUB_VPRINTF(const char *format, va_list arguments)
+MBED_USED int SUB_VPRINTF(const char *format, va_list arguments)
 {
     return mbed_minimal_formatted_string(NULL, LONG_MAX, format, arguments, stdout);
 }
 
-int SUB_VSPRINTF(char *buffer, const char *format, va_list arguments)
+MBED_USED int SUB_VSPRINTF(char *buffer, const char *format, va_list arguments)
 {
     return mbed_minimal_formatted_string(buffer, LONG_MAX, format, arguments, NULL);
 }
 
-int SUB_VSNPRINTF(char *buffer, size_t length, const char *format, va_list arguments)
+MBED_USED int SUB_VSNPRINTF(char *buffer, size_t length, const char *format, va_list arguments)
 {
     return mbed_minimal_formatted_string(buffer, length, format, arguments, NULL);
 }
 
-int SUB_FPRINTF(FILE *stream, const char *format, ...)
+MBED_USED int SUB_FPRINTF(FILE *stream, const char *format, ...)
 {
     va_list arguments;
     va_start(arguments, format);
@@ -115,7 +116,7 @@ int SUB_FPRINTF(FILE *stream, const char *format, ...)
     return result;
 }
 
-int SUB_VFPRINTF(FILE *stream, const char *format, va_list arguments)
+MBED_USED int SUB_VFPRINTF(FILE *stream, const char *format, va_list arguments)
 {
     return mbed_minimal_formatted_string(NULL, LONG_MAX, format, arguments, stream);
 }

targets/TARGET_STM/TARGET_STM32F4/analogin_device.c

@@ -213,6 +213,9 @@ uint16_t adc_read(analogin_t *obj)
         adcValue = (uint16_t)HAL_ADC_GetValue(&obj->handle);
     }
     LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE((&obj->handle)->Instance), LL_ADC_PATH_INTERNAL_NONE);
+
+    HAL_ADC_Stop(&obj->handle);
+
     return adcValue;
 }