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

 #include "Font.h"
 #include "dials.h"
 #include "switches.h"
 #include <math.h>
 #include "plx.h"
-#include "eeprom.h"
 #include "displayinfo.h"
 #include "small_printf.h"
+#include "nvram.h"
 /* USER CODE END Includes */
 /* Private variables ---------------------------------------------------------*/
 SPI_HandleTypeDef hspi1;
 /* timeout when the ignition is switched off */
 #define IGNITION_OFF_TIMEOUT 30000UL
 int OldObservation[2] =
-  { -1, -1 }; // illegal initial value
+{ -1, -1 }; // illegal initial value
 int OldObservationIndex[2] =
-  { -1, -1 }; // if more than one sensor this will be printed
+{ -1, -1 }; // if more than one sensor this will be printed
 int16_t dial0[2] =
-  { 0, 0 };
+{ 0, 0 };
 int16_t dial1[2] =
-  { -1, -1 };
+{ -1, -1 };
 uint16_t dial_timer[2] =
-  { 0, 0 };
+{ 0, 0 };
 static const int DialTimeout = 50; // about 20 seconds after twiddle, save the dial position.
-/* Virtual address defined by the user: 0xFFFF value is prohibited */
+uint16_t dial_nvram[2] __attribute__((section(".NVRAM_Data")));
-uint16_t VirtAddVarTab[NumbOfVar] =
-  { 0x1111, 0x2222 };
 union
+{
-  PLX_SensorInfo Sensor[MAXRDG];
+        PLX_SensorInfo Sensor[MAXRDG];
-  char Bytes[MAXRDG * sizeof(PLX_SensorInfo)];
+        char Bytes[MAXRDG * sizeof(PLX_SensorInfo)];
 } Data;
 int Max[MAXRDG];
 int Min[MAXRDG];
 int PLXItems;
 /* USER CODE END PFP */
 /* USER CODE BEGIN 0 */
 /* dummy function */
-void
-_init (void)
+void _init(void)
+{
+}
 // the dial is the switch number we are using.
 // suppress is the ItemIndex we wish to suppress on this display
-int
-DisplayCurrent (int dial, int suppress)
+int DisplayCurrent(int dial, int suppress)
+{
-  char buff[10];
+        char buff[10];
-  int i;
+        int i;
-  int rc;
+        int rc;
-  select_display (dial); // pick the display we are using
+        select_display(dial); // pick the display we are using
-  int ItemIndex = dial_pos[dial] / 4;
+        int ItemIndex = dial_pos[dial] / 4;
-  // wrap around count if dial too far to the right
-  if (ItemIndex >= PLXItems)
-    {
-      dial_pos[dial] = 0;
-      ItemIndex = 0;
-    }
-  if (ItemIndex < 0)
-    {
-      ItemIndex = PLXItems - 1;
-      dial_pos[dial] = (PLXItems - 1) * 4;
-    }
-  // check for item suppression
-  if (ItemIndex == suppress)
-    {
-      dial1[dial] = -1;
-      OldObservation[dial] = -1;
-      OldObservationIndex[dial] = -1;
-      clearDisplay ();
-      display ();
-      return -1; // we suppressed this display
-    }
-  // do not try to convert if no items in buffer
-  if (PLXItems > 0)
-    {
-      int DataVal = ConvPLX (Data.Sensor[ItemIndex].ReadingH,
-                             Data.Sensor[ItemIndex].ReadingL); // data reading
-      int Observation = ConvPLX (Data.Sensor[ItemIndex].AddrH,
-                                 Data.Sensor[ItemIndex].AddrL);
-      int ObservationIndex = ConvPLX (0, Data.Sensor[ItemIndex].Instance);
-      // now to convert the readings and format strings
-      // find out limits
-      char * msg;
-      int len;
-      // if the user presses the dial then reset min/max to current value
+        // wrap around count if dial too far to the right
-      if (push_pos[dial] == 1)
+        if (ItemIndex >= PLXItems)
+        {
-          Max[ItemIndex] = DataVal;
+                dial_pos[dial] = 0;
-          Min[ItemIndex] = DataVal; // 12 bit max value
+                ItemIndex = 0;
+        }
-      if (Observation < PLX_MAX_OBS)
+        if (ItemIndex < 0)
+        {
-          if (Observation != OldObservation[dial]
-              || ObservationIndex != OldObservationIndex[dial])
-            {
-              dial_timer[dial] = DialTimeout;
-              dial1[dial] = -1;
-              clearDisplay ();
-              dial_draw_scale (DisplayInfo[Observation].Low,
-                               DisplayInfo[Observation].High, 12, 1,
-                               DisplayInfo[Observation].TickScale);
-              msg = DisplayInfo[Observation].name;
-              len = 7;
-              int len1 = ObservationIndex > 0 ? len - 1 : len;
-              for (i = 0; i < len1 && msg[i]; i++)
-                {
-                  buff[i] = msg[i];
+                ItemIndex = PLXItems - 1;
-                }
-              if (ObservationIndex > 0 && i < len)
-                {
-                  buff[i++] = ObservationIndex + '1';
+                dial_pos[dial] = (PLXItems - 1) * 4;
-                }
+        }
+        // check for item suppression
+        if (ItemIndex == suppress)
+        {
+                dial1[dial] = -1;
+                OldObservation[dial] = -1;
+                OldObservationIndex[dial] = -1;
+                clearDisplay();
+                display();
+                return -1; // we suppressed this display
+        }
+        // do not try to convert if no items in buffer
+        if (PLXItems > 0)
+        {
+                int DataVal = ConvPLX(Data.Sensor[ItemIndex].ReadingH,
+                                Data.Sensor[ItemIndex].ReadingL); // data reading
+                int Observation = ConvPLX(Data.Sensor[ItemIndex].AddrH,
+                                Data.Sensor[ItemIndex].AddrL);
-              print_large_string (buff, 64 - i * 4, 48, i); // this prints spaces for \0 at end of string
+                int ObservationIndex = ConvPLX(0, Data.Sensor[ItemIndex].Instance);
+                // now to convert the readings and format strings
+                // find out limits
+                char * msg;
+                int len;
-              // print suffix if present.
+                // if the user presses the dial then reset min/max to current value
-              font_gotoxy (15, 4);
+                if (push_pos[dial] == 1)
-              int i = 0;
-              while (DisplayInfo[Observation].suffix[i])
+                {
+                        Max[ItemIndex] = DataVal;
-                  font_putchar (DisplayInfo[Observation].suffix[i++]);
+                        Min[ItemIndex] = DataVal; // 12 bit max value
+                }
-              OldObservation[dial] = Observation;
+                if (Observation < PLX_MAX_OBS)
-              OldObservationIndex[dial] = ObservationIndex;
-              //
-              display ();
-            }
-          else
-            {
-              // check for timer timeout on consistent timer
-              if (dial_timer[dial])
+                {
+                        if (Observation != OldObservation[dial]
+                                        || ObservationIndex != OldObservationIndex[dial])
+                        {
+                                dial_timer[dial] = DialTimeout;
-                  dial_timer[dial]--;
+                                dial1[dial] = -1;
+                                clearDisplay();
+                                dial_draw_scale(DisplayInfo[Observation].Low,
+                                                DisplayInfo[Observation].High, 12, 1,
+                                                DisplayInfo[Observation].TickScale);
+                                msg = DisplayInfo[Observation].name;
+                                len = 7;
+                                int len1 = ObservationIndex > 0 ? len - 1 : len;
+                                for (i = 0; i < len1 && msg[i]; i++)
+                                {
+                                        buff[i] = msg[i];
+                                }
+                                if (ObservationIndex > 0 && i < len)
+                                {
+                                        buff[i++] = ObservationIndex + '1';
+                                }
+                                print_large_string(buff, 64 - i * 4, 48, i); // this prints spaces for \0 at end of string
+                                // print suffix if present.
+                                font_gotoxy(15, 4);
+                                int i = 0;
+                                while (DisplayInfo[Observation].suffix[i])
+                                {
+                                        font_putchar(DisplayInfo[Observation].suffix[i++]);
+                                }
+                                OldObservation[dial] = Observation;
+                                OldObservationIndex[dial] = ObservationIndex;
+                                //
+                                display();
-                  if (dial_timer[dial] == 0)
+                        }
-                    {
+                        else
-                      uint16_t curr_val = dial_pos[dial];
-                      rc = EE_ReadVariable (VirtAddVarTab[dial], &curr_val);
-                      if ((rc != 0) || (curr_val != dial_pos[dial]))
+                        {
+                                // check for timer timeout on consistent timer
+                                if (dial_timer[dial])
+                                {
-                          //__disable_irq();
+                                        dial_timer[dial]--;
-                          HAL_FLASH_Unlock ();
+                                        if (dial_timer[dial] == 0)
+                                        {
+                                                uint16_t curr_val = dial_pos[dial];
+                                                uint8_t * ptr = (uint8_t *) (&dial_nvram[dial]);
+                                                WriteNVRAM(ptr, curr_val & 0xFF);
+                                                WriteNVRAM(ptr + 1, curr_val >> 8);
-                          rc = EE_WriteVariable (VirtAddVarTab[dial],
-                                                 dial_pos[dial]);
+                                        }
-                          HAL_FLASH_Lock ();
-                          //__enable_irq();
+                                }
+                        }
-                    }
+                }
+                double max_rdg;
+                double min_rdg;
+                double cur_rdg;
+                int int_rdg;
+                int int_max;
+                int int_min;
+                max_rdg = ConveriMFDRaw2Data(Observation,
+                                DisplayInfo[Observation].Units, Max[ItemIndex]);
+                min_rdg = ConveriMFDRaw2Data(Observation,
+                                DisplayInfo[Observation].Units, Min[ItemIndex]);
+                cur_rdg = ConveriMFDRaw2Data(Observation,
+                                DisplayInfo[Observation].Units, DataVal);
+                int dp_pos;  // where to print the decimal place
+                float scale = 1.0;
+                switch (DisplayInfo[Observation].DP)
+                {
+                case 0:
+                        scale = 1.0;
+                        dp_pos = 100;
+                        break;
+                case 1:
+                        scale = 10.0;
+                        dp_pos = 1;
+                        break;
+                case 2:
+                        scale = 100.0;
+                        dp_pos = 2;
+                        break;
-            }
+                }
+                int_rdg = (int) (cur_rdg * scale);
+                int_max = (int) (max_rdg * scale);
+                int_min = (int) (min_rdg * scale);
+                cur_rdg -= DisplayInfo[Observation].Low;
+                cur_rdg =
+* cur_rdg
+                                                / (DisplayInfo[Observation].High
+                                                                - DisplayInfo[Observation].Low);
+                dial0[dial] = (int) cur_rdg;
-          double max_rdg;
-          double min_rdg;
-          double cur_rdg;
-          int int_rdg;
-          int int_max;
-          int int_min;
-          max_rdg = ConveriMFDRaw2Data (Observation,
-                                        DisplayInfo[Observation].Units,
-                                        Max[ItemIndex]);
-          min_rdg = ConveriMFDRaw2Data (Observation,
-                                        DisplayInfo[Observation].Units,
-                                        Min[ItemIndex]);
-          cur_rdg = ConveriMFDRaw2Data (Observation,
-                                        DisplayInfo[Observation].Units,
-                                        DataVal);
-          int dp_pos;  // where to print the decimal place
-          float scale = 1.0;
-          switch (DisplayInfo[Observation].DP)
-            {
-            case 0:
-              scale = 1.0;
-              dp_pos = 100;
-              break;
-            case 1:
-              scale = 10.0;
-              dp_pos = 1;
-              break;
-            case 2:
-              scale = 100.0;
-              dp_pos = 2;
-              break;
-            }
-          int_rdg = (int) (cur_rdg * scale);
-          int_max = (int) (max_rdg * scale);
-          int_min = (int) (min_rdg * scale);
-          cur_rdg -= DisplayInfo[Observation].Low;
-          cur_rdg = 100 * cur_rdg
-              / (DisplayInfo[Observation].High - DisplayInfo[Observation].Low);
-          dial0[dial] = (int) cur_rdg;
-          /* old needle un-draw */
+                /* old needle un-draw */
-          if (dial1[dial] >= 0)
+                if (dial1[dial] >= 0)
-            {
+                {
-              dial_draw_needle (dial1[dial]);
+                        dial_draw_needle(dial1[dial]);
-            }
+                }
-          dial_draw_needle (dial0[dial]);
+                dial_draw_needle(dial0[dial]);
-          // print value overlaid by needle
+                // print value overlaid by needle
-          // this is actual reading
+                // this is actual reading
-          print_digits (30, 30, 5, dp_pos, int_rdg);
+                print_digits(30, 30, 5, dp_pos, int_rdg);
-          font_gotoxy (0, 0);
+                font_gotoxy(0, 0);
-          font_digits (5, dp_pos, int_min);
+                font_digits(5, dp_pos, int_min);
-          font_gotoxy (0, 1);
+                font_gotoxy(0, 1);
-          font_puts ("Min");
+                font_puts("Min");
-          font_gotoxy (15, 0);
+                font_gotoxy(15, 0);
-          font_digits (5, dp_pos, int_max);
+                font_digits(5, dp_pos, int_max);
-          font_gotoxy (18, 1);
+                font_gotoxy(18, 1);
-          font_puts ("Max");
+                font_puts("Max");
-          dial1[dial] = dial0[dial];
+                dial1[dial] = dial0[dial];
-          display ();
+                display();
+        }
-    }
-  return ItemIndex;
+return ItemIndex;
+}
 /* USER CODE END 0 */
 int main(void)
+{
   /* USER CODE BEGIN 1 */
-  GPIO_InitTypeDef GPIO_InitStruct;
+GPIO_InitTypeDef GPIO_InitStruct;
-  __HAL_RCC_SPI1_CLK_ENABLE()
+__HAL_RCC_SPI1_CLK_ENABLE()
-  ;
+;
-  __HAL_RCC_USART1_CLK_ENABLE()
+__HAL_RCC_USART1_CLK_ENABLE()
-  ; // PLX main port
+; // PLX main port
-  __HAL_RCC_USART2_CLK_ENABLE()
+__HAL_RCC_USART2_CLK_ENABLE()
-  ; // debug port
+; // debug port
-  __HAL_RCC_USART3_CLK_ENABLE (); // Bluetooth port
+__HAL_RCC_USART3_CLK_ENABLE ()
+; // Bluetooth port
   /* USER CODE END 1 */
   /* MCU Configuration----------------------------------------------------------*/
   MX_USART2_UART_Init();
   MX_USART3_UART_Init();
   /* USER CODE BEGIN 2 */
-  /* Turn on USART1 IRQ */
+/* Turn on USART1 IRQ */
-  HAL_NVIC_SetPriority (USART1_IRQn, 2, 0);
+HAL_NVIC_SetPriority(USART1_IRQn, 2, 0);
-  HAL_NVIC_EnableIRQ (USART1_IRQn);
+HAL_NVIC_EnableIRQ(USART1_IRQn);
-  /* Turn on USART2 IRQ  */
-  HAL_NVIC_SetPriority (USART2_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ (USART2_IRQn);
-  /* turn on USART3 IRQ */
-  HAL_NVIC_SetPriority (USART3_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ (USART3_IRQn);
-  /* setup the USART control blocks */
+/* Turn on USART2 IRQ  */
-  init_usart_ctl (&uc1, huart1.Instance);
+HAL_NVIC_SetPriority(USART2_IRQn, 4, 0);
-  init_usart_ctl (&uc2, huart2.Instance);
+HAL_NVIC_EnableIRQ(USART2_IRQn);
-  init_usart_ctl (&uc3, huart3.Instance);
-  EnableSerialRxInterrupt (&uc1);
+/* turn on USART3 IRQ */
-  EnableSerialRxInterrupt (&uc2);
+HAL_NVIC_SetPriority(USART3_IRQn, 4, 0);
-  EnableSerialRxInterrupt (&uc3);
+HAL_NVIC_EnableIRQ(USART3_IRQn);
-  /* Unlock the Flash to enable the flash control register access *************/
+/* setup the USART control blocks */
+init_usart_ctl(&uc1, huart1.Instance);
+init_usart_ctl(&uc2, huart2.Instance);
-  HAL_FLASH_Unlock ();
+init_usart_ctl(&uc3, huart3.Instance);
-  //__disable_irq();
+EnableSerialRxInterrupt(&uc1);
-  EE_Init ();
+EnableSerialRxInterrupt(&uc2);
-  //__enable_irq();
+EnableSerialRxInterrupt(&uc3);
-  HAL_FLASH_Lock ();
-  InitSwitches ();
+InitSwitches();
-  int i;
+int i;
-  uint16_t rc;
+uint16_t rc;
-  for (i = 0; i < 2; i++)
+for (i = 0; i < 2; i++)
-    {
-      uint16_t val;
-      uint16_t rc = EE_ReadVariable (VirtAddVarTab[i], &val);
-      if (rc == 0)
-        {
+{
-          dial_pos[i] = val;
+        dial_pos[i] = dial_nvram[i];
-        }
-      else
-        {
-          break;
-        }
+}
-    }
-  ap_init (); // set up the approximate math library
+ap_init(); // set up the approximate math library
-  int disp;
+int disp;
-  ssd1306_begin (1, 0);
+ssd1306_begin(1, 0);
-  dial_origin (64, 60);
+dial_origin(64, 60);
-  dial_size (60);
+dial_size(60);
-  /* reset the display timeout, latch on power from accessories */
+/* reset the display timeout, latch on power from accessories */
-  Latch_Timer = IGNITION_OFF_TIMEOUT;
+Latch_Timer = IGNITION_OFF_TIMEOUT;
-  HAL_GPIO_WritePin (POWER_LATCH_GPIO_Port, POWER_LATCH_Pin, GPIO_PIN_RESET);
+HAL_GPIO_WritePin(POWER_LATCH_GPIO_Port, POWER_LATCH_Pin, GPIO_PIN_RESET);
-  for (disp = 0; disp < 2; disp++)
+for (disp = 0; disp < 2; disp++)
-    {
+{
-      select_display (disp);
+        select_display(disp);
-      clearDisplay ();
+        clearDisplay();
-      dim (0);
+        dim(0);
-      //font_puts(
+        //font_puts(
-      //                "Hello world !!\rThis text is a test of the text rendering library in a 5*7 font");
+        //              "Hello world !!\rThis text is a test of the text rendering library in a 5*7 font");
-      dial_draw_scale (0, 10, 12, 5, 1);
+        dial_draw_scale(0, 10, 12, 5, 1);
-      char buffer[] = "Display  ";
+        char buffer[] = "Display  ";
-      buffer[8] = disp + '1';
+        buffer[8] = disp + '1';
-      print_large_string (buffer, 20, 30, 9);
+        print_large_string(buffer, 20, 30, 9);
-      display ();
+        display();
-    }
+}
   /* USER CODE END 2 */
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
-  uint32_t Ticks = HAL_GetTick () + 100;
+uint32_t Ticks = HAL_GetTick() + 100;
-  /* while ignition is on, keep resetting power latch timer */
+/* while ignition is on, keep resetting power latch timer */
-  if (HAL_GPIO_ReadPin (IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
+if (HAL_GPIO_ReadPin(IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
-    {
+{
-      Latch_Timer = HAL_GetTick () + IGNITION_OFF_TIMEOUT;
+        Latch_Timer = HAL_GetTick() + IGNITION_OFF_TIMEOUT;
-    }
+}
-  else
+else
-    {
+{
-      /* if the ignition has been off for a while, then turn off power */
+        /* if the ignition has been off for a while, then turn off power */
-      if (HAL_GetTick () > Latch_Timer)
+        if (HAL_GetTick() > Latch_Timer)
+        {
-          HAL_GPIO_WritePin (POWER_LATCH_GPIO_Port, POWER_LATCH_Pin,
+                HAL_GPIO_WritePin(POWER_LATCH_GPIO_Port, POWER_LATCH_Pin,
-                             GPIO_PIN_RESET);
+                                GPIO_PIN_RESET);
+        }
-    }
+}
-  uint32_t timeout = 0;  //
+uint32_t timeout = 0;  //
-  // PLX decoder protocols
+// PLX decoder protocols
-  char PLXPacket = 0;
+char PLXPacket = 0;
-  for (i = 0; i < MAXRDG; i++)
+for (i = 0; i < MAXRDG; i++)
-    {
+{
-      Max[i] = 0;
+        Max[i] = 0;
-      Min[i] = 0xFFF; // 12 bit max value
+        Min[i] = 0xFFF; // 12 bit max value
-    }
+}
-  int PLXPtr = 0;
+int PLXPtr = 0;
-  while (1)
+while (1)
-    {
+{
 // poll switche
-      HandleSwitches ();
+        HandleSwitches();
 // Handle the bluetooth pairing function by pressing both buttons.
-      if ((push_pos[0] == 1) && (push_pos[1] == 1))
+        if ((push_pos[0] == 1) && (push_pos[1] == 1))
+        {
-          HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_SET);
+                HAL_GPIO_WritePin(BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_SET);
+        }
-      else
+        else
+        {
-          HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin,
+                HAL_GPIO_WritePin(BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_RESET);
-                             GPIO_PIN_RESET);
+        }
-      uint16_t cc = SerialCharsReceived (&uc1);
+        uint16_t cc = SerialCharsReceived(&uc1);
-      int chr;
+        int chr;
-      if (cc == 0)
+        if (cc == 0)
+        {
-          timeout++;
+                timeout++;
-          if (timeout % 1000 == 0)
+                if (timeout % 1000 == 0)
-            {
+                {
-              PutCharSerial (&uc3, '+');
+                        PutCharSerial(&uc3, '+');
-            }
+                }
-          if (timeout > 60000)
+                if (timeout > 60000)
-            {
+                {
-              // do turn off screen
+                        // do turn off screen
-            }
+                }
+        }
-      for (chr = 0; chr < cc; chr++)
+        for (chr = 0; chr < cc; chr++)
+        {
-          char c = GetCharSerial (&uc1);
+                char c = GetCharSerial(&uc1);
-          timeout = 0;
+                timeout = 0;
-          if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
+                if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
-            {
-              PLXPtr = 0;    // reset the pointer
-              PLXPacket = 1;
-            }
-          else if (c == PLX_Stop)
-            {
-              if (PLXPacket)
+                {
-                  // we can now decode the selected parameter
-                  PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
-                  // saturate the rotary switch position
-                  int DataVal;
-                  // process min/max
-                  for (i = 0; i < PLXItems; i++)
-                    {
-                      // Send item to BT
+                        PLXPtr = 0;    // reset the pointer
-                      uint16_t addr = ConvPLX (Data.Sensor[i].AddrH,
-                                               Data.Sensor[i].AddrL);
-                      uint8_t inst = Data.Sensor[i].Instance;
-                      uint16_t reading = ConvPLX (Data.Sensor[i].ReadingH,
-                                                  Data.Sensor[i].ReadingL);
-                      char outbuff[100];
-                      int cnt = simple_sprintf (outbuff, "%d,%d,%d\n", addr, inst,
-                                         reading);
-                      int i;
+                        PLXPacket = 1;
-                      for (i = 0; i < cnt; i++)
-                        {
-                          PutCharSerial (&uc3, outbuff[i]);
-                        }
+                }
-                      DataVal = ConvPLX (Data.Sensor[i].ReadingH,
-                                         Data.Sensor[i].ReadingL);
-                      if (DataVal > Max[i])
+                else if (c == PLX_Stop)
-                        {
+                {
-                          Max[i] = DataVal;
+                        if (PLXPacket)
-                        }
-                      if (DataVal < Min[i])
+                        {
+                                // we can now decode the selected parameter
+                                PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
+                                // saturate the rotary switch position
+                                int DataVal;
+                                // process min/max
+                                for (i = 0; i < PLXItems; i++)
+                                {
+                                        // Send item to BT
+                                        uint16_t addr = ConvPLX(Data.Sensor[i].AddrH,
+                                                        Data.Sensor[i].AddrL);
+                                        uint8_t inst = Data.Sensor[i].Instance;
+                                        uint16_t reading = ConvPLX(Data.Sensor[i].ReadingH,
+                                                        Data.Sensor[i].ReadingL);
+                                        char outbuff[100];
+                                        int cnt = small_sprintf(outbuff, "%d,%d,%d\n", addr, inst,
+                                                        reading);
+                                        int i;
+                                        for (i = 0; i < cnt; i++)
+                                        {
+                                                PutCharSerial(&uc3, outbuff[i]);
+                                        }
+                                        DataVal = ConvPLX(Data.Sensor[i].ReadingH,
+                                                        Data.Sensor[i].ReadingL);
+                                        if (DataVal > Max[i])
+                                        {
+                                                Max[i] = DataVal;
+                                        }
+                                        if (DataVal < Min[i])
+                                        {
-                          Min[i] = DataVal;
+                                                Min[i] = DataVal;
+                                        }
+                                }
+                                // now to display the information
+                                int suppress = DisplayCurrent(0, -1);
+                                DisplayCurrent(1, suppress);
+                        }
-                    }
+                        PLXPtr = 0;
+                        PLXPacket = 0;
+                }
-                  // now to display the information
+                else if (c > PLX_Stop) // illegal char, restart reading
+                {
+                        PLXPacket = 0;
+                        PLXPtr = 0;
+                }
-                  int suppress = DisplayCurrent (0, -1);
+                else if (PLXPtr < sizeof(Data.Bytes))
+                {
-                  DisplayCurrent (1, suppress);
+                        Data.Bytes[PLXPtr++] = c;
+                }
-              PLXPtr = 0;
-              PLXPacket = 0;
-            }
-          else if (c > PLX_Stop) // illegal char, restart reading
-            {
-              PLXPacket = 0;
-              PLXPtr = 0;
-            }
-          else if (PLXPtr < sizeof(Data.Bytes))
-            {
-              Data.Bytes[PLXPtr++] = c;
-            }
+        }
-      HAL_Delay (1);
+        HAL_Delay(1);
-    }
+}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
   /* USER CODE END 3 */
   __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOC_CLK_ENABLE();
   __HAL_RCC_GPIOB_CLK_ENABLE();
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOA, SPI1_NSS1_Pin|SPI1CD_Pin|BT_BUTTON_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOA, SPI_NSS1_Pin|SPI1CD_Pin|BT_BUTTON_Pin, GPIO_PIN_RESET);
   /*Configure GPIO pin Output Level */
   HAL_GPIO_WritePin(GPIOC, SPI_RESET_Pin|SPI_NSS2_Pin|POWER_LATCH_Pin|USB_PWR_Pin, GPIO_PIN_RESET);
-  /*Configure GPIO pins : SPI1_NSS1_Pin SPI1CD_Pin BT_BUTTON_Pin */
+  /*Configure GPIO pins : SPI_NSS1_Pin SPI1CD_Pin BT_BUTTON_Pin */
-  GPIO_InitStruct.Pin = SPI1_NSS1_Pin|SPI1CD_Pin|BT_BUTTON_Pin;
+  GPIO_InitStruct.Pin = SPI_NSS1_Pin|SPI1CD_Pin|BT_BUTTON_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
   GPIO_InitStruct.Pin = SW1_PUSH_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   HAL_GPIO_Init(SW1_PUSH_GPIO_Port, &GPIO_InitStruct);
-  /*Configure GPIO pins : SW_I_Pin SW1_Q_Pin SW2_PUSH_Pin */
+  /*Configure GPIO pins : SW1_I_Pin SW1_Q_Pin SW2_PUSH_Pin */
-  GPIO_InitStruct.Pin = SW_I_Pin|SW1_Q_Pin|SW2_PUSH_Pin;
+  GPIO_InitStruct.Pin = SW1_I_Pin|SW1_Q_Pin|SW2_PUSH_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
   /*Configure GPIO pins : SW2_I_Pin SW2_Q_Pin IGNITION_Pin */
   * @retval None
   */
 void Error_Handler(void)
+{
   /* USER CODE BEGIN Error_Handler */
-  /* User can add his own implementation to report the HAL error return state */
+/* User can add his own implementation to report the HAL error return state */
-  while (1)
+while (1)
-    {
+{
-    }
+}
   /* USER CODE END Error_Handler */
+}
 #ifdef USE_FULL_ASSERT
    * @retval None
    */
 void assert_failed(uint8_t* file, uint32_t line)
+{
   /* USER CODE BEGIN 6 */
-    /* User can add his own implementation to report the file name and line number,
+/* User can add his own implementation to report the file name and line number,
-     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
+ ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
   /* USER CODE END 6 */
+}
 #endif

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152/Src/main.c – Rev 29 → 30