new platform added, migration to newest ESP-IDF WiP

+ some new formatting

Author: Random90

main/Tasks/core/blinker.task.c

@@ -1,29 +1,28 @@
-#include "freertos/FreeRTOS.h"
+#include "blinker.task.h"
+
 #include "driver/gpio.h"
 #include "esp_log.h"
+#include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-
-#include "blinker.task.h"
 #include "settings.h"
 #define TAG "BLINKER_TASK"
 
-void vBlinkerTask(void *pvParameter)
-{
-    portTickType xLastWakeTime;
+void vBlinkerTask(void *pvParameter) {
+    TickType_t xLastWakeTime;
 
     ESP_LOGI(TAG, "Initialize blinking");
 
-    /* specify that the function of a given pin 
-    should be that of GPIO as opposed to some other function 
+    /* specify that the function of a given pin
+    should be that of GPIO as opposed to some other function
     */
-    gpio_pad_select_gpio(BLINK_GPIO);
+    esp_rom_gpio_pad_select_gpio(BLINK_GPIO);
     /* Set the GPIO as a push/pull output */
     gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
-    while(true) {
+    while (true) {
         xLastWakeTime = xTaskGetTickCount();
-        vTaskDelayUntil(&xLastWakeTime,1000/portTICK_RATE_MS);
+        vTaskDelayUntil(&xLastWakeTime, 1000 / portTICK_PERIOD_MS);
         gpio_set_level(BLINK_GPIO, 0);
-        vTaskDelayUntil(&xLastWakeTime,1000/portTICK_RATE_MS);
+        vTaskDelayUntil(&xLastWakeTime, 1000 / portTICK_PERIOD_MS);
         gpio_set_level(BLINK_GPIO, 1);
     }
 }

main/Tasks/core/calcRideParamsOnISR.task.c

@@ -1,84 +1,81 @@
 
+#include "calcRideParamsOnISR.task.h"
+
+#include "esp_log.h"
 #include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
 #include "freertos/queue.h"
-#include "esp_log.h"
-
-#include "calcRideParamsOnISR.task.h"
-#include "settings.h"
+#include "freertos/task.h"
 #include "obc.h"
+#include "settings.h"
 
 #define TAG "RIDE_CALC"
 
 bool ignoreReed = false;
 
 // handle server sychronization start event and set flags to block data
 // during synchronization, calculations should be blocked
-static void vOnSyncStartHandle(void* handler_args, esp_event_base_t base, int32_t id, void* event_data) {
+static void vOnSyncStartHandle(void *handler_args, esp_event_base_t base, int32_t id, void *event_data) {
     ignoreReed = true;
 }
 
 // handle server sychronization start event and set flags to block data
 // if synchronization finishes with success, finish the ride, by resseting rideParams, otherwise continue
-static void vOnSyncFinishHandle(void* handler_args, esp_event_base_t base, int32_t id, void* event_data) {
+static void vOnSyncFinishHandle(void *handler_args, esp_event_base_t base, int32_t id, void *event_data) {
+    bool reset = *((bool *)event_data);
 
-    bool reset = *((bool*) event_data);
-
-    if (reset){
+    if (reset) {
         rideParams.rotations = 0;
         rideParams.totalRideTimeMs = 0;
         rideParams.speed = 0.0;
         rideParams.distance = 0.0;
         rideParams.avgSpeed = 0.0;
         rideParams.prevRotationTickCount = 0.0;
-    } 
+    }
 
     ignoreReed = false;
 }
 
-void vCalcRideParamsOnISRTask(void* data)
-{
+void vCalcRideParamsOnISRTask(void *data) {
     float currentSpeed;
     uint16_t msBetweenRotationTicks;
 
     ESP_LOGI(TAG, "Init reed switch");
-    
+
     ESP_ERROR_CHECK(esp_event_handler_register_with(obc_events_loop, OBC_EVENTS, SYNC_START_EVENT, vOnSyncStartHandle, NULL));
     ESP_ERROR_CHECK(esp_event_handler_register_with(obc_events_loop, OBC_EVENTS, SYNC_STOP_EVENT, vOnSyncFinishHandle, NULL));
 
-    for(;;) {
-        if(xQueueReceive(reed_evt_queue, &rideParams.rotationTickCount, portMAX_DELAY) && !ignoreReed) {
+    for (;;) {
+        if (xQueueReceive(reed_evt_queue, &rideParams.rotationTickCount, portMAX_DELAY) && !ignoreReed) {
             // TODO create buffer for reed time impulses before calculating time and speed
             // TODO block rideParams while calculating?
             if (rideParams.prevRotationTickCount != 0) {
                 if (!rideParams.moving) {
                     esp_event_post_to(obc_events_loop, OBC_EVENTS, RIDE_START_EVENT, NULL, 0, portMAX_DELAY);
                 }
-                msBetweenRotationTicks = ((int) rideParams.rotationTickCount - (int) rideParams.prevRotationTickCount) * (int) portTICK_RATE_MS;
+                msBetweenRotationTicks = ((int)rideParams.rotationTickCount - (int)rideParams.prevRotationTickCount) * (int)portTICK_PERIOD_MS;
                 rideParams.totalRideTimeMs += msBetweenRotationTicks;
                 // TODO sometimes tick count doesn't update even with queue? prevent speed = inf for now
                 if (msBetweenRotationTicks > 0.00) {
-                    currentSpeed = ( (float) CIRCUMFERENCE/1000000 ) / ( (float) msBetweenRotationTicks / 3600000 ); //km/h
+                    currentSpeed = ((float)CIRCUMFERENCE / 1000000) / ((float)msBetweenRotationTicks / 3600000);  // km/h
                     // simple, soft filtering of noise (from cables?) - should't introduce any discrepancy to actual data
                     // and also could be used to detect unplanned, immediate stops
                     // max reasonable acceleration is 5.8 m/s/s
-                    if (abs(currentSpeed - rideParams.speed) > 30) {
+                    if (abs((int)(currentSpeed - rideParams.speed)) > 30) {
                         continue;
                     }
 
                     rideParams.moving = true;
                     rideParams.rotations++;
                     rideParams.speed = currentSpeed;
-                    rideParams.distance += (float)CIRCUMFERENCE/1000000;
-                    rideParams.totalDistance += (float)CIRCUMFERENCE/1000000;
-                    rideParams.avgSpeed = rideParams.distance / ( (float) rideParams.totalRideTimeMs / 3600000 );
+                    rideParams.distance += (float)CIRCUMFERENCE / 1000000;
+                    rideParams.totalDistance += (float)CIRCUMFERENCE / 1000000;
+                    rideParams.avgSpeed = rideParams.distance / ((float)rideParams.totalRideTimeMs / 3600000);
                     if (rideParams.speed > rideParams.maxSpeed) {
                         rideParams.maxSpeed = rideParams.speed;
                     }
                 }
-                
             }
-            rideParams.prevRotationTickCount = rideParams.rotationTickCount;    
+            rideParams.prevRotationTickCount = rideParams.rotationTickCount;
 
             // ESP_LOGI(TAG, "[REED] count: %d, speed: %0.2f, diff: %d, distance: %0.2f", rideParams.rotations, rideParams.speed, msBetweenRotationTicks, rideParams.distance);
             // ESP_LOGI(TAG, "[AVGS] speed: %0.2f", rideParams.avgSpeed);

main/Tasks/core/rideStatusWatchdog.task.c

@@ -1,15 +1,17 @@
+#include "rideStatusWatchdog.task.h"
+
+#include <stdint.h>
+
+#include "esp_event_base.h"
+#include "esp_log.h"
 #include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
 #include "freertos/queue.h"
-#include "esp_log.h"
-#include "esp_event_base.h"
-
-#include "rideStatusWatchdog.task.h"
-#include "settings.h"
+#include "freertos/task.h"
 #include "obc.h"
+#include "settings.h"
 
 #define TAG "RIDE_WATCHDOG"
-/* 
+/*
 Task which checks every second if bike is still moving, by reading number of
 items waiting in reed ISR queue. Posts to obc_event_loop with ride_stop_event
 */
@@ -20,19 +22,19 @@ void vRideStatusWatchdogTask(void *arg) {
 
     ESP_LOGI(TAG, "Initialization");
 
-    while(true) {
+    while (true) {
         msg_count = uxQueueMessagesWaitingFromISR(reed_evt_queue);
         currentTickCount = xTaskGetTickCount();
-        timeInactive = ((int) currentTickCount - (int) rideParams.prevRotationTickCount) * (int) portTICK_RATE_MS;
+        timeInactive = ((int)currentTickCount - (int)rideParams.prevRotationTickCount) * (int)portTICK_PERIOD_MS;
 
-        if(rideParams.moving && !msg_count && timeInactive > RIDE_TIMEOUT_MS) {
+        if (rideParams.moving && !msg_count && timeInactive > RIDE_TIMEOUT_MS) {
             ESP_LOGI(TAG, "[RIDE_STATUS] Stopped moving");
             rideParams.speed = 0.0;
             rideParams.moving = false;
             rideParams.prevRotationTickCount = 0;
 
             esp_event_post_to(obc_events_loop, OBC_EVENTS, RIDE_STOP_EVENT, NULL, 0, portMAX_DELAY);
-        } 
-        vTaskDelayUntil(&currentTickCount, 1000/portTICK_RATE_MS);
+        }
+        vTaskDelayUntil(&currentTickCount, 1000 / portTICK_PERIOD_MS);
     }
 }

main/Tasks/screen_pcd8544/pcd8544_font_utils.c

@@ -11,26 +11,26 @@
  * @TODO validate string, skip special chars, cleanup array sizes!
  * @TODO dynamic rows number calculation
  * */
-static void fillCharsFromBuffer(uint8_t **charArr, char *buffer, int nrOfChars, uint8_t bigCharPositions[6]) {
+static void fillCharsFromBuffer(uint8_t **charArr, char *buffer, int nrOfChars, uint8_t (*bigCharPositions)[6]) {
     for (int i = 0; i <= nrOfChars; i++) {
         // convert to int and fill charArr with pointers to big font characters
         if (*buffer != '.' && *buffer >= '0' && *buffer <= '9') {
             char single_char_buf[1] = {*buffer};
             *charArr = fontDetermination[atoi(single_char_buf)];
-            bigCharPositions[i] = 16;
-        } else if(*buffer == '.'){
+            (*bigCharPositions)[i] = 16;
+        } else if (*buffer == '.') {
             *charArr = fontDetermination[10];
-            bigCharPositions[i] = 3;
+            (*bigCharPositions)[i] = 3;
         } else {
             *charArr = NULL;
-            bigCharPositions[i] = 0;
+            (*bigCharPositions)[i] = 0;
         }
         buffer++;
         charArr++;
     }
 }
 
-void vGetSpeedChars(uint8_t *charArr[4], float *speed, uint8_t *bigCharPositions) {
+void vGetSpeedChars(uint8_t *charArr[4], float *speed, uint8_t (*bigCharPositions)[6]) {
     // create buffer for converted float
     char buffer[10];
     // prevent overflow
@@ -43,26 +43,26 @@ void vGetSpeedChars(uint8_t *charArr[4], float *speed, uint8_t *bigCharPositions
     float tempFrac = *speed - speedInt;
     uint8_t fraction = (tempFrac * 10);
     // pad str with 0 if speed lower than 10
-    if(speedInt < 10) {
-        snprintf(buffer, 10, "0%d.%d", speedInt, fraction);  
+    if (speedInt < 10) {
+        snprintf(buffer, 10, "0%d.%d", speedInt, fraction);
     } else {
         snprintf(buffer, 10, "%d.%d", speedInt, fraction);
     }
-    fillCharsFromBuffer(charArr, buffer, 4, bigCharPositions);
+    fillCharsFromBuffer(charArr, buffer, 4, &bigCharPositions);
 }
 
-void vGetDistanceChars(uint8_t *charArr[6], float *distance, uint8_t *bigCharPositions) {
+void vGetDistanceChars(uint8_t *charArr[6], float *distance, uint8_t (*bigCharPositions)[6]) {
     char buffer[10];
     // @TODO handle distance > 999.9
     // @TODO handle distance > 99.99
     // convert float to int dot int
     uint8_t distanceInt = *distance;
     float tempFrac = *distance - distanceInt;
     uint8_t fraction = (tempFrac * 100);
-    if(fraction < 10) {
+    if (fraction < 10) {
         snprintf(buffer, 10, "%d.0%d", distanceInt, fraction);
     } else {
         snprintf(buffer, 10, "%d.%d", distanceInt, fraction);
     }
-    fillCharsFromBuffer(charArr, buffer, 10, bigCharPositions);
+    fillCharsFromBuffer(charArr, buffer, 10, &bigCharPositions);
 }

main/Tasks/screen_pcd8544/pcd8544_font_utils.h

@@ -2,22 +2,23 @@
 #define TASKS_SCREEN_PCD8544_PCD8544_FONT_UTILS_H
 
 #include <pcd8544_font16x24.h>
-#include "../../utils/macros.h"
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "../../utils/macros.h"
+
 /**
  * @brief convert bike speed from float to included font char array
  * @param charRowsArr pointer to empty array, which will be filled with next chars row number
  * @return pointer to array of binary characters
  * */
-void vGetSpeedChars(uint8_t *charArr[4], float *value, uint8_t charRowsArr[6]);
+void vGetSpeedChars(uint8_t *charArr[4], float *speed, uint8_t (*bigCharPositions)[6]);
 
 /**
  * @brief convert distance measured from float to included font char array
  * @param charRowsArr pointer to empty array, which will be filled with next chars row number
  * @return pointer to array of binary characters
  * */
- void vGetDistanceChars(uint8_t *charArr[4], float *distance, uint8_t charRowsArr[6]);
+void vGetDistanceChars(uint8_t *charArr[6], float *distance, uint8_t (*bigCharPositions)[6]);
 
 #endif