Bug fixes + Fix for LoRa Timer ticks drifting (#24) #278

* esp32/modussl: Releasing GIL when handshake is performed.

* esp32/machspi: enabling 2nd SPI peref. On GPY boards

* esp32/modwlan: Remove defaulting of wifi max_tx_pwr  to 20 in init

* esp32/modlte: Allow PDN list update when carrier is defined + updated sqns upgrade scripts to v1.2.4

* esp32/lte: add support for modem responses greater than UART buff size

* esp32/modlte: Restrict scanning of and 5,8 for old Fipy/Gpy v1.0

* [PYFW-325] Use Hardware timers for Lora lib ticks  #comment Initial Fix implementation

* [PYFW-325] Use Hardware timers for Lora lib ticks  #comment Hardware timer working, moved callback functions execution out of ISR context

* [PYFW-325] Hardware timer for Lora ticks fully implemented #close #comment Fix tested

Author: Islam Wahdan

esp32/frozen/LTE/sqnsupgrade.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-VERSION = "1.2.3"
+VERSION = "1.2.4"
 
 # Copyright (c) 2019, Pycom Limited.
 #
@@ -345,8 +345,10 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f
         resume = True if mirror or recover or atneg_only or info_only else resume
         verbose = True if debug else verbose
         load_fff = False if bootrom and switch_ffh else load_fff
+        target_baudrate = baudrate
         baudrate = self.__modem_speed if self.__speed_detected else baudrate
         if debug: print('mirror? {}  recover? {}  resume? {}  direct? {}  atneg_only? {} bootrom? {} load_fff? {}'.format(mirror, recover, resume, direct, atneg_only, bootrom, load_fff))
+        if debug: print('baudrate: {} target_baudrate: {}'.format(baudrate, target_baudrate))
         abort = True
         external = False
         self.__serial = None
@@ -512,8 +514,11 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f
             self.__serial.read()
         elif recover and (not direct):
             if atneg:
-                result = self.at_negotiation(baudrate, port, max_try, mirror, atneg_only, debug)
+                result = self.at_negotiation(baudrate, port, max_try, mirror, atneg_only, debug, target_baudrate)
                 if result:
+                    baudrate = target_baudrate
+                    self.__modem_speed = target_baudrate
+                    self.__speed_detected = True
                     if atneg_only:
                         return True
                     if mirror:
@@ -712,7 +717,11 @@ def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT
         MAX_TRY = max_try
         count = 0
         if msg is not None:
-            print(msg)
+            if debug:
+                print(msg + 'with baudrate {}'.format(baudrate))
+            else:
+                print(msg)
+
         self.__serial.read()
         self.__serial.write(b"AT\r\n")
         response = self.read_rsp(size=25)
@@ -729,10 +738,13 @@ def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT
             self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=100)
         return count < MAX_TRY
 
-    def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug):
+    def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug, target_baudrate):
         MAX_TRY = max_try
         count = 0
-        print('Attempting AT auto-negotiation...')
+        if debug:
+            print('Attempting AT auto-negotiation... with baudrate {} and target_baudrate {}'.format(baudrate, target_baudrate))
+        else:
+            print('Attempting AT auto-negotiation...')
         self.__serial.write(b"AT\r\n")
         response = self.read_rsp(size=20)
         if debug: print('{}'.format(response))
@@ -746,19 +758,21 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug):
             if debug: print('{}'.format(response))
         if b'OK' in response:
             self.__serial.read()
-            cmd = "AT+IPR=%d\n"%baudrate
-            if debug: print('Setting baudrate to {}'.format(baudrate))
+            cmd = "AT+IPR=%d\n"%target_baudrate
+            if debug: print('Setting baudrate to {}'.format(target_baudrate))
             self.__serial.write(cmd.encode())
             response = self.read_rsp(size=6)
             if debug: print('{}'.format(response))
             if b'OK' in response:
+                self.__modem_speed = target_baudrate
+                self.__speed_detected =  True
                 if atneg_only:
                     return True
                 if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
-                    self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=100)
+                    self.__serial = UART(1, baudrate=target_baudrate, pins=self.__pins, timeout_chars=100)
                 else:
                     self.__serial = None
-                    self.__serial = serial.Serial(port, baudrate, bytesize=serial.EIGHTBITS, timeout=0.1)
+                    self.__serial = serial.Serial(port, target_baudrate, bytesize=serial.EIGHTBITS, timeout=0.1)
                     self.__serial.reset_input_buffer()
                     self.__serial.reset_output_buffer()
                     self.__serial.flush()
@@ -774,7 +788,7 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug):
                     print('ERROR in AT+SMOD returned {}'.format(response))
                     return False
             else:
-                print('ERROR in AT+IPR={} returned {}'.format(baudrate, response))
+                print('ERROR in AT+IPR={} returned {}'.format(target_baudrate, response))
                 return False
         else:
             print('ERROR sending AT command... no response? {}'.format(response))
@@ -839,8 +853,15 @@ def upgrade_uart(self, ffh_mode=False, mfile=None, retry=False, resume=False, co
         print('Preparing modem for upgrade...')
         if not retry and ffh_mode:
             success = False
-            success = self.__run(bootrom=True, resume=resume, switch_ffh=True, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose)
-            time.sleep(1)
+            if self.__check_br(verbose=verbose, debug=debug):
+                success = self.__run(bootrom=True, resume=resume, switch_ffh=True, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose)
+                time.sleep(1)
+            else:
+                print('FFH mode is not necessary... ignoring!')
+                print('Do not specify updater.elf when updating!')
+                mfile = None
+                ffh_mode = False
+                success = True
         if success:
             if mfile is not None:
                 success = False

esp32/hal/esp32_mphal.c

@@ -37,29 +37,35 @@
 #include "modwlan.h"
 #include "modbt.h"
 
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/semphr.h"
-#include "freertos/queue.h"
-#include "freertos/timers.h"
-#include "freertos/xtensa_api.h"
-
+#include "driver/timer.h"
 
+typedef void (*HAL_tick_user_cb_t)(void);
 #if defined (LOPY) || defined(LOPY4) || defined(FIPY)
-static void (*HAL_tick_user_cb)(void);
+DRAM_ATTR static HAL_tick_user_cb_t HAL_tick_user_cb;
+
+#define TIMER1_ALARM_TIME_MS        1U
+#define TIMER1_DIVIDER              16U
+#define TIMER1_ALARM_COUNT          ((uint64_t)TIMER_BASE_CLK * (uint64_t)TIMER1_ALARM_TIME_MS) / ((uint64_t)TIMER1_DIVIDER * (uint64_t)1000)
+
 #endif
 
-#define TIMER_TICKS             160000        // 1 ms @160MHz
 
 #if defined (LOPY) || defined(LOPY4) || defined(FIPY)
-IRAM_ATTR static void HAL_TimerCallback (TimerHandle_t xTimer) {
-    if (HAL_tick_user_cb) {
+IRAM_ATTR static void HAL_TimerCallback (void* arg) {
+
+    if (HAL_tick_user_cb != NULL) {
+
         HAL_tick_user_cb();
     }
+
+    TIMERG0.int_clr_timers.t1 = 1;
+    TIMERG0.hw_timer[1].update=1;
+    TIMERG0.hw_timer[1].config.alarm_en = 1;
+
 }
 
 void HAL_set_tick_cb (void *cb) {
-    HAL_tick_user_cb = cb;
+    HAL_tick_user_cb = (HAL_tick_user_cb_t)cb;
 }
 #endif
 
@@ -68,8 +74,30 @@ void mp_hal_init(bool soft_reset) {
     #if defined (LOPY) || defined(LOPY4) || defined(FIPY)
         // setup the HAL timer for LoRa
         HAL_tick_user_cb = NULL;
-        TimerHandle_t hal_timer = xTimerCreate("HAL_Timer", 1 / portTICK_PERIOD_MS, pdTRUE, (void *) 0, HAL_TimerCallback);
-        xTimerStart (hal_timer, 0);
+
+        timer_config_t config;
+
+        config.alarm_en = 1;
+        config.auto_reload = 1;
+        config.counter_dir = TIMER_COUNT_UP;
+        config.divider = TIMER1_DIVIDER;
+        config.intr_type = TIMER_INTR_LEVEL;
+        config.counter_en = TIMER_PAUSE;
+        /*Configure timer*/
+        timer_init(TIMER_GROUP_0, TIMER_1, &config);
+        /*Stop timer counter*/
+        timer_pause(TIMER_GROUP_0, TIMER_1);
+        /*Load counter value */
+        timer_set_counter_value(TIMER_GROUP_0, TIMER_1, 0x00000000ULL);
+        /*Set alarm value*/
+        timer_set_alarm_value(TIMER_GROUP_0, TIMER_1, (uint64_t)TIMER1_ALARM_COUNT);
+        /*Enable timer interrupt*/
+        timer_enable_intr(TIMER_GROUP_0, TIMER_1);
+        /* Register Interrupt */
+        timer_isr_register(TIMER_GROUP_0, TIMER_1, HAL_TimerCallback, NULL, ESP_INTR_FLAG_IRAM, NULL);
+        /* Start Timer */
+        timer_start(TIMER_GROUP_0, TIMER_1);
+
     #endif
     }
 }

esp32/lora/timer-board.c

@@ -45,7 +45,7 @@ Maintainer: Miguel Luis and Gregory Cristian
 /*!
  * Hardware Timer tick counter
  */
-volatile TimerTime_t TimerTickCounter = 1;
+DRAM_ATTR volatile TimerTime_t TimerTickCounter = 1;
 
 /*!
  * Saved value of the Tick counter at the start of the next event
@@ -55,13 +55,18 @@ static TimerTime_t TimerTickCounterContext = 0;
 /*!
  * Value trigging the IRQ
  */
-volatile TimerTime_t TimeoutCntValue = 0;
-
+DRAM_ATTR volatile TimerTime_t TimeoutCntValue = 0;
+extern TaskHandle_t xLoRaTimerTaskHndl;
 
 static IRAM_ATTR void TimerCallback (void) {
+    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+
     TimerTickCounter++;
     if (TimeoutCntValue > 0 && TimerTickCounter == TimeoutCntValue) {
         TimerIrqHandler();
+        // Notify the thread so it will wake up when the ISR is complete
+        vTaskNotifyGiveFromISR(xLoRaTimerTaskHndl, &xHigherPriorityTaskWoken);
+        portYIELD_FROM_ISR();
     }
 }
 

esp32/lte/lteppp.c

@@ -52,7 +52,7 @@ extern TaskHandle_t xLTETaskHndl;
 /******************************************************************************
  DECLARE PRIVATE DATA
  ******************************************************************************/
-static char lteppp_trx_buffer[LTE_UART_BUFFER_SIZE];
+static char lteppp_trx_buffer[LTE_UART_BUFFER_SIZE + 1];
 static char lteppp_queue_buffer[LTE_UART_BUFFER_SIZE];
 static uart_dev_t* lteppp_uart_reg;
 static QueueHandle_t xCmdQueue;
@@ -80,7 +80,7 @@ static ltepppconnstatus_t lteppp_connstatus = LTE_PPP_IDLE;
  DECLARE PRIVATE FUNCTIONS
  ******************************************************************************/
 static void TASK_LTE (void *pvParameters);
-static bool lteppp_send_at_cmd_exp(const char *cmd, uint32_t timeout, const char *expected_rsp);
+static bool lteppp_send_at_cmd_exp(const char *cmd, uint32_t timeout, const char *expected_rsp, void* data_rem);
 static bool lteppp_send_at_cmd(const char *cmd, uint32_t timeout);
 static bool lteppp_check_sim_present(void);
 static void lteppp_status_cb (ppp_pcb *pcb, int err_code, void *ctx);
@@ -154,7 +154,7 @@ void lteppp_init(void) {
     lteppp_lte_state = E_LTE_INIT;
 
     xCmdQueue = xQueueCreate(LTE_CMD_QUEUE_SIZE_MAX, sizeof(lte_task_cmd_data_t));
-    xRxQueue = xQueueCreate(LTE_RSP_QUEUE_SIZE_MAX, LTE_AT_RSP_SIZE_MAX);
+    xRxQueue = xQueueCreate(LTE_RSP_QUEUE_SIZE_MAX, LTE_AT_RSP_SIZE_MAX + 1);
 
     xLTESem = xSemaphoreCreateMutex();
 
@@ -221,7 +221,7 @@ void lteppp_send_at_command_delay (lte_task_cmd_data_t *cmd, lte_task_rsp_data_t
     xQueueReceive(xRxQueue, rsp, (TickType_t)portMAX_DELAY);
 }
 
-bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_mp) {
+bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_mp, void* data_rem) {
 
     uint32_t rx_len = 0;
 
@@ -240,10 +240,13 @@ bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_m
         }
     } while (timeout > 0 && 0 == rx_len);
 
-    memset(lteppp_trx_buffer, 0, sizeof(lteppp_trx_buffer));
+    memset(lteppp_trx_buffer, 0, LTE_UART_BUFFER_SIZE);
+    uint16_t len_count = 0;
     while (rx_len > 0) {
         // try to read up to the size of the buffer minus null terminator (minus 2 because we store the OK status in the last byte)
-        rx_len = uart_read_bytes(LTE_UART_ID, (uint8_t *)lteppp_trx_buffer, sizeof(lteppp_trx_buffer) - 2, LTE_TRX_WAIT_MS(sizeof(lteppp_trx_buffer)) / portTICK_RATE_MS);
+        rx_len = uart_read_bytes(LTE_UART_ID, (uint8_t *)lteppp_trx_buffer, LTE_UART_BUFFER_SIZE - 2, LTE_TRX_WAIT_MS(LTE_UART_BUFFER_SIZE) / portTICK_RATE_MS);
+        len_count += rx_len;
+
         if (rx_len > 0) {
             // NULL terminate the string
             lteppp_trx_buffer[rx_len] = '\0';
@@ -255,8 +258,18 @@ bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_m
                 }
             }
             uart_get_buffered_data_len(LTE_UART_ID, &rx_len);
+            if((len_count + rx_len) >= (LTE_UART_BUFFER_SIZE - 2))
+            {
+                if (data_rem != NULL) {
+                    *((bool *)data_rem) = true;
+                    return true;
+                }
+            }
         }
     }
+    if (data_rem != NULL) {
+        *((bool *)data_rem) = false;
+    }
     return false;
 }
 
@@ -318,6 +331,7 @@ static void TASK_LTE (void *pvParameters) {
     lte_task_cmd_data_t *lte_task_cmd = (lte_task_cmd_data_t *)lteppp_trx_buffer;
     lte_task_rsp_data_t *lte_task_rsp = (lte_task_rsp_data_t *)lteppp_trx_buffer;
 
+
     connect_lte_uart();
 
     while (!lteppp_enabled)
@@ -405,7 +419,7 @@ static void TASK_LTE (void *pvParameters) {
     for (;;) {
         vTaskDelay(LTE_TASK_PERIOD_MS);
         if (xQueueReceive(xCmdQueue, lteppp_trx_buffer, 0)) {
-            lteppp_send_at_cmd_exp(lte_task_cmd->data, lte_task_cmd->timeout, NULL);
+            lteppp_send_at_cmd_exp(lte_task_cmd->data, lte_task_cmd->timeout, NULL, &(lte_task_rsp->data_remaining));
             xQueueSend(xRxQueue, (void *)lte_task_rsp, (TickType_t)portMAX_DELAY);
         } else {
             lte_state_t state = lteppp_get_state();
@@ -428,8 +442,8 @@ static void TASK_LTE (void *pvParameters) {
                 uart_get_buffered_data_len(LTE_UART_ID, &rx_len);
                 if (rx_len > 0) {
                     // try to read up to the size of the buffer
-                    rx_len = uart_read_bytes(LTE_UART_ID, (uint8_t *)lteppp_trx_buffer, sizeof(lteppp_trx_buffer),
-                                             LTE_TRX_WAIT_MS(sizeof(lteppp_trx_buffer)) / portTICK_RATE_MS);
+                    rx_len = uart_read_bytes(LTE_UART_ID, (uint8_t *)lteppp_trx_buffer, LTE_UART_BUFFER_SIZE,
+                                             LTE_TRX_WAIT_MS(LTE_UART_BUFFER_SIZE) / portTICK_RATE_MS);
                     if (rx_len > 0) {
                         pppos_input_tcpip(lteppp_pcb, (uint8_t *)lteppp_trx_buffer, rx_len);
                     }
@@ -444,26 +458,33 @@ static void TASK_LTE (void *pvParameters) {
 }
 
 
-static bool lteppp_send_at_cmd_exp (const char *cmd, uint32_t timeout, const char *expected_rsp) {
-    uint32_t cmd_len = strlen(cmd);
-    // char tmp_buf[128];
-
-    // flush the rx buffer first
-    uart_flush(LTE_UART_ID);
-    // uart_read_bytes(LTE_UART_ID, (uint8_t *)tmp_buf, sizeof(tmp_buf), 5 / portTICK_RATE_MS);
-    // then send the command
-    uart_write_bytes(LTE_UART_ID, cmd, cmd_len);
-    if (strcmp(cmd, "+++")) {
-        uart_write_bytes(LTE_UART_ID, "\r\n", 2);
+static bool lteppp_send_at_cmd_exp (const char *cmd, uint32_t timeout, const char *expected_rsp, void* data_rem) {
+    if(strstr(cmd, "Pycom_Dummy") != NULL)
+    {
+        return lteppp_wait_at_rsp(expected_rsp, timeout, false, data_rem);
     }
-    uart_wait_tx_done(LTE_UART_ID, LTE_TRX_WAIT_MS(cmd_len) / portTICK_RATE_MS);
-    vTaskDelay(2 / portTICK_RATE_MS);
+    else
+    {
+        uint32_t cmd_len = strlen(cmd);
+        // char tmp_buf[128];
+
+        // flush the rx buffer first
+        uart_flush(LTE_UART_ID);
+        // uart_read_bytes(LTE_UART_ID, (uint8_t *)tmp_buf, sizeof(tmp_buf), 5 / portTICK_RATE_MS);
+        // then send the command
+        uart_write_bytes(LTE_UART_ID, cmd, cmd_len);
+        if (strcmp(cmd, "+++")) {
+            uart_write_bytes(LTE_UART_ID, "\r\n", 2);
+        }
+        uart_wait_tx_done(LTE_UART_ID, LTE_TRX_WAIT_MS(cmd_len) / portTICK_RATE_MS);
+        vTaskDelay(2 / portTICK_RATE_MS);
 
-    return lteppp_wait_at_rsp(expected_rsp, timeout, false);
+        return lteppp_wait_at_rsp(expected_rsp, timeout, false, data_rem);
+    }
 }
 
 static bool lteppp_send_at_cmd(const char *cmd, uint32_t timeout) {
-    return lteppp_send_at_cmd_exp (cmd, timeout, LTE_OK_RSP);
+    return lteppp_send_at_cmd_exp (cmd, timeout, LTE_OK_RSP, NULL);
 }
 
 static bool lteppp_check_sim_present(void) {

esp32/lte/lteppp.h

@@ -58,10 +58,12 @@ typedef struct {
     uint32_t timeout;
     char data[LTE_AT_CMD_SIZE_MAX - 4];
 } lte_task_cmd_data_t;
-
+#pragma pack(1)
 typedef struct {
     char data[LTE_UART_BUFFER_SIZE];
+    bool data_remaining;
 } lte_task_rsp_data_t;
+#pragma pack()
 
 /******************************************************************************
  DECLARE PUBLIC FUNCTIONS
@@ -91,7 +93,7 @@ extern void lteppp_send_at_command (lte_task_cmd_data_t *cmd, lte_task_rsp_data_
 
 extern void lteppp_send_at_command_delay (lte_task_cmd_data_t *cmd, lte_task_rsp_data_t *rsp, TickType_t delay);
 
-extern bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_mp);
+extern bool lteppp_wait_at_rsp (const char *expected_rsp, uint32_t timeout, bool from_mp, void* data_rem);
 
 extern bool lteppp_task_ready(void);