Merge remote-tracking branch 'upstream/master'

Author: tkuyucu-nordicsemi

libraries/USBDevice/USBSerial/USBCDC.cpp

@@ -29,9 +29,9 @@ static uint8_t cdc_line_coding[7]= {0x80, 0x25, 0x00, 0x00, 0x00, 0x00, 0x08};
 
 #define MAX_CDC_REPORT_SIZE MAX_PACKET_SIZE_EPBULK
 
-USBCDC::USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) {
+USBCDC::USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking): USBDevice(vendor_id, product_id, product_release) {
     terminal_connected = false;
-    USBDevice::connect();
+    USBDevice::connect(connect_blocking);
 }
 
 bool USBCDC::USBCallback_request(void) {

libraries/USBDevice/USBSerial/USBCDC.h

@@ -35,8 +35,9 @@ class USBCDC: public USBDevice {
     * @param vendor_id Your vendor_id
     * @param product_id Your product_id
     * @param product_release Your preoduct_release
+    * @param connect_blocking define if the connection must be blocked if USB not plugged in
     */
-    USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release);
+    USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking);
 
 protected:
 

libraries/USBDevice/USBSerial/USBSerial.h

@@ -53,9 +53,10 @@ class USBSerial: public USBCDC, public Stream {
     * @param vendor_id Your vendor_id (default: 0x1f00)
     * @param product_id Your product_id (default: 0x2012)
     * @param product_release Your preoduct_release (default: 0x0001)
+    * @param connect_blocking define if the connection must be blocked if USB not plugged in
     *
     */
-    USBSerial(uint16_t vendor_id = 0x1f00, uint16_t product_id = 0x2012, uint16_t product_release = 0x0001): USBCDC(vendor_id, product_id, product_release), buf(128){
+    USBSerial(uint16_t vendor_id = 0x1f00, uint16_t product_id = 0x2012, uint16_t product_release = 0x0001, bool connect_blocking = true): USBCDC(vendor_id, product_id, product_release, connect_blocking), buf(128){
         settingsChangedCallback = 0;
     };
 

libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/TARGET_KL25Z/PinNames.h

@@ -196,10 +196,10 @@ typedef enum {
     LED_BLUE = PTD1,
 
     // mbed original LED naming
-    LED1 = LED_BLUE,
+    LED1 = LED_RED,
     LED2 = LED_GREEN,
-    LED3 = LED_RED,
-    LED4 = LED_RED,
+    LED3 = LED_BLUE,
+    LED4 = LED_BLUE,
 
     // USB Pins
     USBTX = PTA2,
@@ -229,6 +229,9 @@ typedef enum {
     A3 = PTB3,
     A4 = PTC2,
     A5 = PTC1,
+    
+    I2C_SCL = D15,
+    I2C_SDA = D14,
 
     // Not connected
     NC = (int)0xFFFFFFFF

libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/PinNames.h

@@ -93,7 +93,6 @@ typedef enum {
   PB_8  = 0x18,
   PB_9  = 0x19,
   PB_10 = 0x1A,
-  PB_11 = 0x1B,
   PB_12 = 0x1C,
   PB_13 = 0x1D,
   PB_14 = 0x1E,

libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/sleep.c

@@ -35,26 +35,12 @@ static TIM_HandleTypeDef TimMasterHandle;
 
 void sleep(void)
 {
-    // Disable us_ticker update interrupt
-    TimMasterHandle.Instance = TIM1;
-    __HAL_TIM_DISABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
-  
     // Request to enter SLEEP mode
     HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
-  
-    // Re-enable us_ticker update interrupt
-    __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
 }
 
 void deepsleep(void)
 {
-    // Disable us_ticker update interrupt
-    TimMasterHandle.Instance = TIM1;
-    __HAL_TIM_DISABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
-    
     // Request to enter STOP mode with regulator in low power mode
     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
-
-    // Re-enable us_ticker update interrupt
-    __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
 }

libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c

@@ -30,138 +30,53 @@
 #include "PeripheralNames.h"
 #include "stm32f4xx_hal.h"
 
-// Timer selection:
-#define TIM_MST            TIM1
-#define TIM_MST_UP_IRQ     TIM1_UP_TIM10_IRQn
-#define TIM_MST_OC_IRQ     TIM1_CC_IRQn
-#define TIM_MST_RCC        __TIM1_CLK_ENABLE()
+// 32-bit timer selection
+#define TIM_MST            TIM5
+#define TIM_MST_IRQ        TIM5_IRQn
+#define TIM_MST_RCC        __TIM5_CLK_ENABLE()
 
 static TIM_HandleTypeDef TimMasterHandle;
-    
-static int      us_ticker_inited = 0;
-static volatile uint32_t SlaveCounter = 0;
-static volatile uint32_t oc_int_part = 0;
-static volatile uint16_t oc_rem_part = 0;
-
-void set_compare(uint16_t count) {
-    // Set new output compare value
-    __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, count);
-    // Enable IT
-    __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1);
-}
-
-// Used to increment the slave counter
-static void tim_update_irq_handler(void) {
-    if (__HAL_TIM_GET_ITSTATUS(&TimMasterHandle, TIM_IT_UPDATE) == SET) {
-        __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_UPDATE);
-        __HAL_TIM_SetCounter(&TimMasterHandle, 0); // Reset counter !!!
-        SlaveCounter++;
-    }
-}
-
-// Used by interrupt system
-static void tim_oc_irq_handler(void) {
-    uint16_t cval = TIM_MST->CNT;
-  
-    // Clear interrupt flag
-    if (__HAL_TIM_GET_ITSTATUS(&TimMasterHandle, TIM_IT_CC1) == SET) {
-        __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1);
-    }
-
-    if (oc_rem_part > 0) {
-        set_compare(oc_rem_part); // Finish the remaining time left
-        oc_rem_part = 0;
-    }
-    else {
-        if (oc_int_part > 0) {
-            set_compare(0xFFFF);
-            oc_rem_part = cval; // To finish the counter loop the next time
-            oc_int_part--;
-        }
-        else {
-            us_ticker_irq_handler();
-        }
-    }
-}
+static int us_ticker_inited = 0;
 
 void us_ticker_init(void) {
     if (us_ticker_inited) return;
     us_ticker_inited = 1;
 
-    // Enable Timer clock
+    // Enable timer clock
     TIM_MST_RCC;
 
     // Configure time base
     TimMasterHandle.Instance = TIM_MST;
-    TimMasterHandle.Init.Period            = 0xFFFF;
+    TimMasterHandle.Init.Period            = 0xFFFFFFFF;
     TimMasterHandle.Init.Prescaler         = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick
     TimMasterHandle.Init.ClockDivision     = 0;
     TimMasterHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
     TimMasterHandle.Init.RepetitionCounter = 0;
     HAL_TIM_OC_Init(&TimMasterHandle);
-   
-    // Configure interrupts
-    __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
-    
-    // Update interrupt used for 32-bit counter
-    NVIC_SetVector(TIM_MST_UP_IRQ, (uint32_t)tim_update_irq_handler);
-    NVIC_EnableIRQ(TIM_MST_UP_IRQ);
 
-    // Output compare interrupt used for timeout feature
-    NVIC_SetVector(TIM_MST_OC_IRQ, (uint32_t)tim_oc_irq_handler);
-    NVIC_EnableIRQ(TIM_MST_OC_IRQ);
+    NVIC_SetVector(TIM_MST_IRQ, (uint32_t)us_ticker_irq_handler);
+    NVIC_EnableIRQ(TIM_MST_IRQ);
 
     // Enable timer
     HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1);
 }
 
 uint32_t us_ticker_read() {
-    uint32_t counter, counter2;
     if (!us_ticker_inited) us_ticker_init();
-    // A situation might appear when Master overflows right after Slave is read and before the
-    // new (overflowed) value of Master is read. Which would make the code below consider the
-    // previous (incorrect) value of Slave and the new value of Master, which would return a
-    // value in the past. Avoid this by computing consecutive values of the timer until they
-    // are properly ordered.
-    counter = (uint32_t)(SlaveCounter << 16);
-    counter += TIM_MST->CNT;
-    while (1) {
-        counter2 = (uint32_t)(SlaveCounter << 16);
-        counter2 += TIM_MST->CNT;
-        if (counter2 > counter) {
-            break;
-        }
-        counter = counter2;
-    }
-    return counter2;
+    return TIM_MST->CNT;
 }
 
 void us_ticker_set_interrupt(unsigned int timestamp) {
-    int delta = (int)(timestamp - us_ticker_read());
-    uint16_t cval = TIM_MST->CNT;
-
-    if (delta <= 0) { // This event was in the past
-        us_ticker_irq_handler();
-    }
-    else {
-        oc_int_part = (uint32_t)(delta >> 16);
-        oc_rem_part = (uint16_t)(delta & 0xFFFF);
-        if (oc_rem_part <= (0xFFFF - cval)) {
-            set_compare(cval + oc_rem_part);
-            oc_rem_part = 0;
-        } else {
-            set_compare(0xFFFF);
-            oc_rem_part = oc_rem_part - (0xFFFF - cval);
-        }
-    }
+    // Set new output compare value
+    __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp);
+    // Enable IT
+    __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1);
 }
 
 void us_ticker_disable_interrupt(void) {
     __HAL_TIM_DISABLE_IT(&TimMasterHandle, TIM_IT_CC1);
 }
 
 void us_ticker_clear_interrupt(void) {
-    if (__HAL_TIM_GET_ITSTATUS(&TimMasterHandle, TIM_IT_CC1) == SET) {
-        __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1);
-    }
+    __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1);
 }

libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/sleep.c

@@ -102,17 +102,11 @@ static void SetSysClock_HSI(void)
 // MCU SLEEP mode
 void sleep(void)
 {
-    // Disable us_ticker update interrupt
-    TIM_ITConfig(TIM9, TIM_IT_Update, DISABLE);
-
     // Enable PWR clock
     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);    
 
     // Request to enter SLEEP mode with regulator ON
     PWR_EnterSleepMode(PWR_Regulator_ON, PWR_SLEEPEntry_WFI);
-
-    // Re-enable us_ticker update interrupt
-    TIM_ITConfig(TIM9, TIM_IT_Update, ENABLE);
 }
 
 // MCU STOP mode (Regulator in LP mode, LSI, HSI and HSE OFF)