WebSVN – DashDisplay – Diff – /branches/Dashboard_L152_v2/Src/main.c

  */
 /* USER CODE END Header */
 /* Includes ------------------------------------------------------------------*/
 #include "main.h"
+#include <stdlib.h>
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
 #include "libPLX/plx.h"
+#include "libPLX/displayinfo.h"
-#include "libSerial/serial.H"
+#include "libSerial/serialUtils.H"
 #include "libSmallPrintf/small_printf.h"
 #include "libNMEA/nmea.h"
 #include "switches.h"
 #include <string.h>
 UART_HandleTypeDef huart3;
 /* USER CODE BEGIN PV */
 /* Private variables ---------------------------------------------------------*/
-context_t contexts[MAX_DISPLAYS];
 ///@brief  timeout when the ignition is switched off
-#define IGNITION_OFF_TIMEOUT 30000UL
+uint32_t const IGNITION_OFF_TIMEOUT = 30000UL;
 /// @brief 1000mS per logger period, print average per period
-#define LOGGER_INTERVAL 500UL
+uint32_t const LOGGER_INTERVAL = 250UL;
 /// @brief  about 10 seconds after twiddle, save the dial position.
 const int DialTimeout = 100;
-/// @brief Data storage for readings
+/// @brief Unused Observation
+uniqueObs_t const nullObs = {PLX_MAX_OBS,
+                             PLX_MAX_INST};
-info_t Info[MAXRDG];
+/// @brief Null context
+context_t const nullContext = {.knobPos = -1,
+                               .dial_timer = 0,
+                               .dial0 = -1,
+                               .dial1 = -1,
+                               .OldObservation = nullObs};
 /// @brief Define a null item
-const info_t nullInfo = {.Max = 0,
+info_t const nullInfo = {.Max = 0,
                          .Min = 0xFFF,
                          .sum = 0,
                          .count = 0,
                          .updated = 0,
                          .lastUpdated = 0,
-                         .observation.Obs = PLX_MAX_OBS,
+                         .observation = nullObs};
+context_t contexts[MAX_DISPLAYS];
-                         .observation.Instance = PLX_MAX_INST};
+/// @brief Data storage for readings
+info_t Info[MAXRDG];
 /// \brief storage for incoming data
 data_t Data;
-uint32_t Latch_Timer = IGNITION_OFF_TIMEOUT;
+uint32_t Latch_Timer;
 // location for GPS data
 Location loc;
 /// @brief Time when the logged data will be sent
-uint32_t nextTickReload = 0;
+uint32_t nextTickReload;
 /* USER CODE END PV */
 /* Private function prototypes -----------------------------------------------*/
 void SystemClock_Config(void);
   // Initialuse UART4 for 4800 baud NMEA.
   setBaud(&uc4, 4800);
   cc_init();
-  int i;
-  for (i = 0; i < 2; i++)
+  for (int i = 0; i < MAX_DISPLAYS; ++i)
+  {
-    contexts[i].knobPos = -1; // set the knob position
+    contexts[i] = nullContext; // set the knob position
+  }
   /* reset the display timeout, latch on power from accessories */
   Latch_Timer = IGNITION_OFF_TIMEOUT;
   HAL_GPIO_WritePin(POWER_LATCH_GPIO_Port, POWER_LATCH_Pin, GPIO_PIN_RESET);
+  /// @brief Time when the logged data will be sent
   setRmcCallback(&rmc_callback);
   // data timeout
   uint32_t timeout = 0; //
   // used in NMEA style logging
-  uint32_t nextTick = 0;    ///< time to send next
+  uint32_t nextTick = 0; ///< time to send next
+  nextTickReload = 0;
   uint32_t offsetTicks = 0; ///< time to print as offset in mS for each loop
   // PLX decoder protocols
   char PLXPacket = 0;
+  int PLXPtr = 0;
-  for (i = 0; i < MAXRDG; i++)
+  for (int i = 0; i < MAXRDG; ++i)
+  {
     Info[i] = nullInfo;
+  }
-  int PLXPtr = 0;
   uint32_t resetCounter = 0; // record time at which both reset buttons were first pressed.
   /* USER CODE END 2 */
   /* Infinite loop */
       if (resetCounter != 0)
+      {
         // Held down reset button for 10 seconds, clear NVRAM.
         if ((HAL_GetTick() - resetCounter) > 10000)
+        {
-          for (i = 0; i < 2; i++)
+          for (int i = 0; i < MAX_DISPLAYS; i++)
+          {
-            contexts[i].knobPos = -1;   // set the knob position
+            contexts[i] = nullContext;
             contexts[i].dial_timer = 1; // timeout immediately when decremented
+          }
           erase_nvram();
+        }
         resetCounter = 0;
       memset(loc.time, '-', 6);
     // if permitted, log data from RMC packet
     if (btConnected())
+    {
-      // Any RMC data, send it, reset the logger timeout
       // Timeout for data logging regularly
       if (HAL_GetTick() > nextTick)
+      {
         nextTick = nextTickReload;
         nextTickReload += LOGGER_INTERVAL;
         // Send items  to BT if it is in connected state
         // print timestamp as a $PLTIM record.
         char linebuff[20];
         strftime(linebuff, sizeof(linebuff), "%H%M%S", &loc.tv);
         char outbuff[100];
         int cnt = small_sprintf(outbuff, "$PLTIM,%s.%03lu\n", linebuff, offsetTicks);
         sendString(&uc3, outbuff, cnt);
         offsetTicks += LOGGER_INTERVAL;
+        // increment timer
-               if (offsetTicks >= (1000))
+        if (offsetTicks >= (1000))
+        {
-          offsetTicks = 0;
+          offsetTicks -= 1000;
           loc.tv.tm_sec++;
           if (loc.tv.tm_sec >= 60)
+          {
             loc.tv.tm_sec = 0;
             loc.tv.tm_min++;
               if (loc.tv.tm_hour >= 24)
                 loc.tv.tm_hour = 0;
+            }
+          }
+        }
         for (int i = 0; i < MAXRDG; ++i)
+        {
           if (!isValid(i))
             continue;
+          // format output
+          // avoid division by zero for items with no sample data this iteration
+          if (Info[i].count == 0)
+            continue;
+          double average = (double)Info[i].sum / Info[i].count;
+          enum PLX_Observations Observation = Info[i].observation.Obs;
+          double cur_rdg = ConveriMFDRaw2Data((enum PLX_Observations)Observation, DisplayInfo[Observation].Units,
+                                              average);
+          int cnt;
+          int intPart;
+          switch (DisplayInfo[Observation].DP)
+          {
+          default:
+          case 0:
+            cnt = small_sprintf(outbuff,
-          // print logger items as $PLLOG record
+                                "$PLLOG,%s,%d,%d",
+                                DisplayInfo[Info[i].observation.Obs].name,
+                                Info[i].observation.Instance,
+                                (int)cur_rdg);
+            break;
+          case 1:
+            intPart = (int)(cur_rdg * 10);
-          int cnt = small_sprintf(outbuff,
+            cnt = small_sprintf(outbuff,
-                                  "$PLLOG,%d,%d,%ld",
+                                "$PLLOG,%s,%d,%d.%1d",
+                                DisplayInfo[Info[i].observation.Obs].name,
-                                  Info[i].observation.Obs,
+                                Info[i].observation.Instance,
+                                intPart / 10, abs(intPart) % 10);
+            break;
+          case 2:
+            intPart = (int)(cur_rdg * 100);
+            cnt = small_sprintf(outbuff,
+                                "$PLLOG,%s,%d,%d.%02d",
+                                DisplayInfo[Info[i].observation.Obs].name,
-                                  Info[i].observation.Instance,
+                                Info[i].observation.Instance,
-                                  Info[i].count == 0 ? 0 : Info[i].sum / Info[i].count);
+                                intPart / 100, abs(intPart) % 100);
+            break;
+          }
           Info[i].count = 0;
           Info[i].sum = 0;
           // NMEA style checksum
           int ck;
+        {
           // we can now decode the selected parameter
           int PLXNewItems = PLXPtr / sizeof(PLX_SensorInfo); // total items in last reading batch
           // process items
-          for (i = 0; i < PLXNewItems; i++)
+          for (int dataItem = 0; dataItem < PLXNewItems; ++dataItem)
+          {
             // search to see if the item already has a slot in the Info[] array
             // match the observation and instance: if found, update entry
-            enum PLX_Observations observation = ConvPLX(Data.Sensor[i].AddrH,
+            enum PLX_Observations observation = ConvPLX(Data.Sensor[dataItem].AddrH,
-                                                        Data.Sensor[i].AddrL);
+                                                        Data.Sensor[dataItem].AddrL);
-            char instance = Data.Sensor[i].Instance;
+            char instance = Data.Sensor[dataItem].Instance;
+            int16_t data = ConvPLX(Data.Sensor[dataItem].ReadingH,
+                                   Data.Sensor[dataItem].ReadingL);
             // validate the current item, discard out of range
             if ((instance > PLX_MAX_INST) || (observation > PLX_MAX_OBS))
               continue;
             // search for the item in the list
-            int j;
+            int currentSlot;
-            for (j = 0; j < MAXRDG; ++j)
+            for (currentSlot = 0; currentSlot < MAXRDG; ++currentSlot)
+            {
-              if ((Info[j].observation.Obs == observation) && (Info[j].observation.Instance == instance))
+              if ((Info[currentSlot].observation.Obs == observation) && (Info[currentSlot].observation.Instance == instance))
                 break;
+            }
             // fallen off the end of the list of existing items without a match, so j points at next new item
             //
             // Find an unused slot
-            if (j == MAXRDG)
+            if (currentSlot == MAXRDG)
+            {
               int k;
+              {
                 for (k = 0; k < MAXRDG; ++k)
                   if (!isValid(k))
+                  {
-                    j = k; // found a spare slot
+                    currentSlot = k; // found a spare slot
                     break;
+                  }
+              }
               if (k == MAXRDG)
                 continue; // abandon this iteration
+            }
             // give up if we are going to fall off the end of the array
-            if (j > MAXRDG)
+            if (currentSlot >= MAXRDG)
               break;
-            Info[j].observation.Obs = observation;
+            Info[currentSlot].observation.Obs = observation;
-            Info[j].observation.Instance = instance;
+            Info[currentSlot].observation.Instance = instance;
-            Info[j].data = ConvPLX(Data.Sensor[j].ReadingH,
+            Info[currentSlot].data = data;
-                                   Data.Sensor[j].ReadingL);
-            if (Info[j].data > Info[j].Max)
+            if (data > Info[currentSlot].Max)
+            {
-              Info[j].Max = Info[j].data;
+              Info[currentSlot].Max = data;
+            }
-            if (Info[j].data < Info[j].Min)
+            if (data < Info[currentSlot].Min)
+            {
-              Info[j].Min = Info[j].data;
+              Info[currentSlot].Min = data;
+            }
             // take an average
-            Info[j].sum += Info[j].data;
+            Info[currentSlot].sum += data;
-            Info[j].count++;
+            Info[currentSlot].count++;
             // note the last update time
-            Info[j].lastUpdated = HAL_GetTick();
+            Info[currentSlot].lastUpdated = HAL_GetTick();
-            Info[j].updated = 1; // it has been updated
+            Info[currentSlot].updated = 1; // it has been updated
+          }
           PLXPtr = 0;
           PLXPacket = 0;
           // scan through and invalidate all old items
         Data.Bytes[PLXPtr++] = c;
+      }
+    }
     // handle switch rotation
-    for (i = 0; i < MAX_DIALS; ++i)
+    for (int i = 0; i < MAX_DIALS; ++i)
+    {
       int delta = get_dial_diff(i);
       int pos = contexts[i].knobPos;
       if (pos < 0)
         break; // dont process until we have read NVRAM for the first time .
           break;
+      }
       // move in negative direction
       while (delta < 0)
+      {
         // skip invalid items, dont count
         if (pos > 0)
           pos--;
         else
       if (pos != start)
         contexts[i].dial_timer = DialTimeout;
+    }
     int suppress = -1;
-    for (i = 0; i < MAX_DISPLAYS; i++)
+    for (int i = 0; i < MAX_DISPLAYS; ++i)
     { // now to display the information
       suppress = DisplayCurrent(i, suppress);
       cc_check_nvram(i);
+    }

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Src/main.c – Rev 74 → 75