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

 /* USER CODE BEGIN Header */
 /**
-  ******************************************************************************
+ ******************************************************************************
-  * @file           : main.c
+ * @file           : main.c
-  * @brief          : Main program body
+ * @brief          : Main program body
-  ******************************************************************************
+ ******************************************************************************
-  * @attention
+ * @attention
-  *
+ *
-  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
+ * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
-  * All rights reserved.</center></h2>
+ * All rights reserved.</center></h2>
-  *
+ *
-  * This software component is licensed by ST under BSD 3-Clause license,
+ * This software component is licensed by ST under BSD 3-Clause license,
-  * the "License"; You may not use this file except in compliance with the
+ * the "License"; You may not use this file except in compliance with the
-  * License. You may obtain a copy of the License at:
+ * License. You may obtain a copy of the License at:
-  *                        opensource.org/licenses/BSD-3-Clause
+ *                        opensource.org/licenses/BSD-3-Clause
-  *
+ *
-  ******************************************************************************
+ ******************************************************************************
-  */
+ */
 /* USER CODE END Header */
 /* Includes ------------------------------------------------------------------*/
 #include "main.h"
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
 #include "libPLX/plx.h"
 #include "libSerial/serial.H"
 #include "libSmallPrintf/small_printf.h"
 #include "switches.h"
 context_t contexts[MAX_DISPLAYS];
 /* timeout when the ignition is switched off */
 #define IGNITION_OFF_TIMEOUT 30000UL
+#define LOGGER_INTERVAL 500UL
 const int DialTimeout = 50; // about 20 seconds after twiddle, save the dial position.
 uint16_t dial_nvram[MAX_DISPLAYS] __attribute__((section(".NVRAM_Data")));
 data_t Data;
 int Max[MAXRDG];
 int Min[MAXRDG];
 int PLXItems;
 uint32_t Latch_Timer = IGNITION_OFF_TIMEOUT;
 /* USER CODE END PV */
 /* Private function prototypes -----------------------------------------------*/
+void
-void SystemClock_Config(void);
+SystemClock_Config (void);
+static void
-static void MX_GPIO_Init(void);
+MX_GPIO_Init (void);
+static void
-static void MX_SPI1_Init(void);
+MX_SPI1_Init (void);
+static void
-static void MX_USART1_UART_Init(void);
+MX_USART1_UART_Init (void);
+static void
-static void MX_USART2_UART_Init(void);
+MX_USART2_UART_Init (void);
+static void
-static void MX_USART3_UART_Init(void);
+MX_USART3_UART_Init (void);
+static void
-static void MX_TIM3_Init(void);
+MX_TIM3_Init (void);
+static void
-static void MX_TIM9_Init(void);
+MX_TIM9_Init (void);
+static void
-static void MX_TIM2_Init(void);
+MX_TIM2_Init (void);
 /* USER CODE BEGIN PFP */
 // the dial is the switch number we are using.
 // suppress is the ItemIndex we wish to suppress on this display
+int
-int DisplayCurrent(int dial, int suppress)
+DisplayCurrent (int dial, int suppress)
+{
   if (PLXItems == 0)
     return -1;
   int itemIndex = dial_pos[dial] % PLXItems;
-  return cc_display(dial, itemIndex, suppress);
+  return cc_display (dial, itemIndex, suppress);
+}
 /* USER CODE END PFP */
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
 /* USER CODE END 0 */
 /**
-  * @brief  The application entry point.
+ * @brief  The application entry point.
-  * @retval int
+ * @retval int
-  */
+ */
+int
-int main(void)
+main (void)
+{
   /* USER CODE BEGIN 1 */
   __HAL_RCC_SPI1_CLK_ENABLE()
+  ;
   __HAL_RCC_USART1_CLK_ENABLE()
   /* USER CODE END 1 */
   /* MCU Configuration--------------------------------------------------------*/
   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
-  HAL_Init();
+  HAL_Init ();
   /* USER CODE BEGIN Init */
   /* USER CODE END Init */
   /* Configure the system clock */
-  SystemClock_Config();
+  SystemClock_Config ();
   /* USER CODE BEGIN SysInit */
   /* USER CODE END SysInit */
   /* Initialize all configured peripherals */
-  MX_GPIO_Init();
+  MX_GPIO_Init ();
-  MX_SPI1_Init();
+  MX_SPI1_Init ();
-  MX_USART1_UART_Init();
+  MX_USART1_UART_Init ();
-  MX_USART2_UART_Init();
+  MX_USART2_UART_Init ();
-  MX_USART3_UART_Init();
+  MX_USART3_UART_Init ();
-  MX_TIM3_Init();
+  MX_TIM3_Init ();
-  MX_TIM9_Init();
+  MX_TIM9_Init ();
-  MX_TIM2_Init();
+  MX_TIM2_Init ();
   /* USER CODE BEGIN 2 */
   /* 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_SetPriority (USART2_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ(USART2_IRQn);
+  HAL_NVIC_EnableIRQ (USART2_IRQn);
   /* turn on USART3 IRQ */
-  HAL_NVIC_SetPriority(USART3_IRQn, 4, 0);
+  HAL_NVIC_SetPriority (USART3_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ(USART3_IRQn);
+  HAL_NVIC_EnableIRQ (USART3_IRQn);
   /* setup the USART control blocks */
-  init_usart_ctl(&uc1, huart1.Instance);
+  init_usart_ctl (&uc1, huart1.Instance);
-  init_usart_ctl(&uc2, huart2.Instance);
+  init_usart_ctl (&uc2, huart2.Instance);
-  init_usart_ctl(&uc3, huart3.Instance);
+  init_usart_ctl (&uc3, huart3.Instance);
-  EnableSerialRxInterrupt(&uc1);
-  EnableSerialRxInterrupt(&uc2);
-  EnableSerialRxInterrupt(&uc3);
+  EnableSerialRxInterrupt (&uc1);
+  EnableSerialRxInterrupt (&uc2);
-  HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_ALL);
+  EnableSerialRxInterrupt (&uc3);
-  HAL_TIM_Encoder_Start(&htim9, TIM_CHANNEL_ALL);
+  HAL_TIM_Encoder_Start (&htim3, TIM_CHANNEL_ALL);
+  HAL_TIM_Encoder_Start (&htim9, TIM_CHANNEL_ALL);
   // Switch handler called on sysTick interrupt.
-  InitSwitches();
+  InitSwitches ();
-  cc_init();
+  cc_init ();
   int i;
   for (i = 0; i < 2; i++)
-  {
+    {
-        dial_pos[i] = dial_nvram[i];
+      dial_pos[i] = dial_nvram[i];
-  }
+    }
   /* 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);
+  HAL_GPIO_WritePin (POWER_LATCH_GPIO_Port, POWER_LATCH_Pin, GPIO_PIN_RESET);
   /* USER CODE END 2 */
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
- while(1){
-  /* while ignition is on, keep resetting power latch timer */
-  if (HAL_GPIO_ReadPin(IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
-  {
-        Latch_Timer = HAL_GetTick() + IGNITION_OFF_TIMEOUT;
-  }
-  else
-  {
-        /* if the ignition has been off for a while, then turn off power */
-        if (HAL_GetTick() > Latch_Timer)
-        {
-                HAL_GPIO_WritePin(POWER_LATCH_GPIO_Port, POWER_LATCH_Pin,
-                                GPIO_PIN_RESET);
-        }
-  }
-  uint32_t timeout = 0;  //
-  // PLX decoder protocols
-  char PLXPacket = 0;
-  for (i = 0; i < MAXRDG; i++)
-  {
-        Max[i] = 0;
-        Min[i] = 0xFFF; // 12 bit max value
-  }
-  int PLXPtr = 0;
   while (1)
-  {
+    {
-  // Handle the bluetooth pairing function by pressing both buttons.
-        if ((push_pos[0] == 1) && (push_pos[1] == 1))
+      /* while ignition is on, keep resetting power latch timer */
-        {
+      if (HAL_GPIO_ReadPin (IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
-                HAL_GPIO_WritePin(BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_SET);
+        {
-        }
+          Latch_Timer = HAL_GetTick () + IGNITION_OFF_TIMEOUT;
-        else
+        }
-        {
+      else
-                HAL_GPIO_WritePin(BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_RESET);
+        {
-        }
+          /* if the ignition has been off for a while, then turn off power */
+          if (HAL_GetTick () > Latch_Timer)
-        uint16_t cc = SerialCharsReceived(&uc1);
+            {
-        int chr;
+              HAL_GPIO_WritePin (POWER_LATCH_GPIO_Port, POWER_LATCH_Pin,
-        if (cc == 0)
+                                 GPIO_PIN_RESET);
-        {
+            }
-                timeout++;
+        }
-                if (timeout % 1000 == 0)
-                {
+      uint32_t timeout = 0;  //
-                        const char msg[] = "Timeout\r\n";
-                        char * p = msg;
+      uint32_t nextTick = HAL_GetTick () + LOGGER_INTERVAL;
-                        while(*p)
+      uint8_t log = 0;
-                        {
+      // PLX decoder protocols
-                                PutCharSerial(&uc3,*p++);
+      char PLXPacket = 0;
-                        }
+      for (i = 0; i < MAXRDG; i++)
+        {
-                }
+          Max[i] = 0;
+          Min[i] = 0xFFF; // 12 bit max value
-                if (timeout > 60000)
+        }
-                {
+      int PLXPtr = 0;
-                    // do turn off screen
-                }
+      while (1)
+        {
-        }
+          // Handle the bluetooth pairing function by pressing both buttons.
-        for (chr = 0; chr < cc; chr++)
+          if ((push_pos[0] == 1) && (push_pos[1] == 1))
-        {
+            {
-                char c = GetCharSerial(&uc1);
+              HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin,
+                                 GPIO_PIN_RESET);
+            }
-                if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
+          else
-                {
+            {
-                        PLXPtr = 0;    // reset the pointer
+              HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin,
-                        PLXPacket = 1;
+                                 GPIO_PIN_SET);
-                        timeout = 0;    // Reset the timer
+            }
-                }
-                else if (c == PLX_Stop)
+          uint16_t cc = SerialCharsReceived (&uc1);
-                {
+          int chr;
-                        if (PLXPacket)
+          if (cc == 0)
-                        {
+            {
-                                // we can now decode the selected parameter
+              timeout++;
-                                PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
+              if (timeout % 1000 == 0)
-                                // saturate the rotary switch position
+                {
+                  const char msg[] = "Timeout\r\n";
-                                int DataVal;
+                  char *p = msg;
-                                // process min/max
+                  while (*p)
-                                for (i = 0; i < PLXItems; i++)
+                    {
-                                {
+                      PutCharSerial (&uc3, *p++);
-                                        // 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,
+              if (timeout > 60000)
-                                                        Data.Sensor[i].ReadingL);
+                {
-                                        char outbuff[100];
+                  // do turn off screen
-                                        small_sprintf(outbuff, "%d,%d,%d\n\r", addr, inst,
+                }
-                                                        reading);
-                                        int ck=0;
+            }
-                                        while(outbuff[ck] && ck < 100)
+          for (chr = 0; chr < cc; chr++)
+            {
-                                        {
+              char c = GetCharSerial (&uc1);
-                                                PutCharSerial(&uc2, outbuff[ck++]);
-                                        }
+              if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
-                                        DataVal = ConvPLX(Data.Sensor[i].ReadingH,
+                {
-                                                        Data.Sensor[i].ReadingL);
+                  PLXPtr = 0;    // reset the pointer
-                                        if (DataVal > Max[i])
+                  PLXPacket = 1;
-                                        {
+                  timeout = 0;    // Reset the timer
-                                                Max[i] = DataVal;
+                  if (HAL_GetTick () > nextTick)
-                                        }
+                    {
-                                        if (DataVal < Min[i])
+                      nextTick = HAL_GetTick () + LOGGER_INTERVAL;
-                                        {
+                      log = 1;
-                                                Min[i] = DataVal;
+                    }
-                                        }
+                  else
-                                }
+                    log = 0;
+                }
-                                // now to display the information
+              else if (c == PLX_Stop)
-                                int suppress = DisplayCurrent(0, -1);
+                {
-                                DisplayCurrent(1, suppress);
+                  if (PLXPacket)
-                        }
+                    {
-                        PLXPtr = 0;
+                      // we can now decode the selected parameter
-                        PLXPacket = 0;
+                      PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
-                }
+                      // saturate the rotary switch position
-                else if (c > PLX_Stop) // illegal char, restart reading
-                {
+                      int DataVal;
-                        PLXPacket = 0;
+                      // process min/max
-                        PLXPtr = 0;
+                      for (i = 0; i < PLXItems; i++)
-                }
+                        {
-                else if (PLXPacket && PLXPtr < sizeof(Data.Bytes))
+                          // Send item to BT
-                {
+                          uint16_t addr = ConvPLX (Data.Sensor[i].AddrH,
-                        Data.Bytes[PLXPtr++] = c;
+                                                   Data.Sensor[i].AddrL);
-                }
+                          uint8_t inst = Data.Sensor[i].Instance;
+                          uint16_t reading = ConvPLX (Data.Sensor[i].ReadingH,
-        }
+                                                      Data.Sensor[i].ReadingL);
+                          if (log)
+                            {
+                              char outbuff[100];
+                              int cnt = small_sprintf (outbuff, "$LOG%d,%d,%d", addr,
+                                             inst, reading);
+                              int ck;
+                              int sum = 0;
+                              for (ck=1 ; ck < cnt ; ck++)
+                                sum += outbuff[ck];
+                              cnt += small_sprintf(outbuff+cnt,"*%02X\n",sum & 0xFF);
+                              for (ck = 0; ck <cnt; ck++)
+                                PutCharSerial (&uc3, outbuff[ck]);
+                            }
+                          DataVal = ConvPLX (Data.Sensor[i].ReadingH,
+                                             Data.Sensor[i].ReadingL);
+                          if (DataVal > Max[i])
+                            {
+                              Max[i] = DataVal;
+                            }
+                          if (DataVal < Min[i])
+                            {
+                              Min[i] = DataVal;
+                            }
+                        }
+                      // now to display the information
+                      int suppress = DisplayCurrent (0, -1);
+                      DisplayCurrent (1, suppress);
+                    }
+                  PLXPtr = 0;
+                  PLXPacket = 0;
+                }
+              else if (c > PLX_Stop) // illegal char, restart reading
+                {
+                  PLXPacket = 0;
+                  PLXPtr = 0;
+                }
+              else if (PLXPacket && PLXPtr < sizeof(Data.Bytes))
+                {
+                  Data.Bytes[PLXPtr++] = c;
+                }
+            }
-        HAL_Delay(1);
+          HAL_Delay (1);
-  }
+        }
-    /* USER CODE END WHILE */
+      /* USER CODE END WHILE */
-    /* USER CODE BEGIN 3 */
+      /* USER CODE BEGIN 3 */
-  }
+    }
   /* USER CODE END 3 */
+}
 /**
-  * @brief System Clock Configuration
+ * @brief System Clock Configuration
-  * @retval None
+ * @retval None
-  */
+ */
+void
-void SystemClock_Config(void)
+SystemClock_Config (void)
 {
-  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
+  RCC_OscInitTypeDef RCC_OscInitStruct =
+    { 0 };
-  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
+  RCC_ClkInitTypeDef RCC_ClkInitStruct =
+    { 0 };
   /** Configure the main internal regulator output voltage
-  */
+   */
   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
   /** Initializes the RCC Oscillators according to the specified parameters
-  * in the RCC_OscInitTypeDef structure.
+   * in the RCC_OscInitTypeDef structure.
-  */
+   */
   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12;
   RCC_OscInitStruct.PLL.PLLDIV = RCC_PLL_DIV3;
-  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
+  if (HAL_RCC_OscConfig (&RCC_OscInitStruct) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /** Initializes the CPU, AHB and APB buses clocks
-  */
+   */
-  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
+  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
-                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
+      | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
-  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
+  if (HAL_RCC_ClockConfig (&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
+}
 /**
-  * @brief SPI1 Initialization Function
+ * @brief SPI1 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_SPI1_Init(void)
+MX_SPI1_Init (void)
+{
   /* USER CODE BEGIN SPI1_Init 0 */
   /* USER CODE END SPI1_Init 0 */
   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
   hspi1.Init.CRCPolynomial = 10;
-  if (HAL_SPI_Init(&hspi1) != HAL_OK)
+  if (HAL_SPI_Init (&hspi1) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN SPI1_Init 2 */
   /* USER CODE END SPI1_Init 2 */
+}
 /**
-  * @brief TIM2 Initialization Function
+ * @brief TIM2 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_TIM2_Init(void)
+MX_TIM2_Init (void)
+{
   /* USER CODE BEGIN TIM2_Init 0 */
   /* USER CODE END TIM2_Init 0 */
-  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
+  TIM_ClockConfigTypeDef sClockSourceConfig =
+    { 0 };
-  TIM_MasterConfigTypeDef sMasterConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig =
+    { 0 };
   /* USER CODE BEGIN TIM2_Init 1 */
   /* USER CODE END TIM2_Init 1 */
   htim2.Instance = TIM2;
   htim2.Init.Prescaler = 0;
   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
   htim2.Init.Period = 65535;
   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
-  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
+  if (HAL_TIM_Base_Init (&htim2) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
-  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
+  if (HAL_TIM_ConfigClockSource (&htim2, &sClockSourceConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
-  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
+  if (HAL_TIMEx_MasterConfigSynchronization (&htim2, &sMasterConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN TIM2_Init 2 */
   /* USER CODE END TIM2_Init 2 */
+}
 /**
-  * @brief TIM3 Initialization Function
+ * @brief TIM3 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_TIM3_Init(void)
+MX_TIM3_Init (void)
+{
   /* USER CODE BEGIN TIM3_Init 0 */
   /* USER CODE END TIM3_Init 0 */
-  TIM_Encoder_InitTypeDef sConfig = {0};
+  TIM_Encoder_InitTypeDef sConfig =
+    { 0 };
-  TIM_MasterConfigTypeDef sMasterConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig =
+    { 0 };
   /* USER CODE BEGIN TIM3_Init 1 */
   /* USER CODE END TIM3_Init 1 */
   htim3.Instance = TIM3;
   sConfig.IC1Filter = 15;
   sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
   sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
   sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
   sConfig.IC2Filter = 15;
-  if (HAL_TIM_Encoder_Init(&htim3, &sConfig) != HAL_OK)
+  if (HAL_TIM_Encoder_Init (&htim3, &sConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
-  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
+  if (HAL_TIMEx_MasterConfigSynchronization (&htim3, &sMasterConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN TIM3_Init 2 */
   /* USER CODE END TIM3_Init 2 */
+}
 /**
-  * @brief TIM9 Initialization Function
+ * @brief TIM9 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_TIM9_Init(void)
+MX_TIM9_Init (void)
+{
   /* USER CODE BEGIN TIM9_Init 0 */
   /* USER CODE END TIM9_Init 0 */
-  TIM_Encoder_InitTypeDef sConfig = {0};
+  TIM_Encoder_InitTypeDef sConfig =
+    { 0 };
-  TIM_MasterConfigTypeDef sMasterConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig =
+    { 0 };
   /* USER CODE BEGIN TIM9_Init 1 */
   /* USER CODE END TIM9_Init 1 */
   htim9.Instance = TIM9;
   sConfig.IC1Filter = 15;
   sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
   sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
   sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
   sConfig.IC2Filter = 0;
-  if (HAL_TIM_Encoder_Init(&htim9, &sConfig) != HAL_OK)
+  if (HAL_TIM_Encoder_Init (&htim9, &sConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
-  if (HAL_TIMEx_MasterConfigSynchronization(&htim9, &sMasterConfig) != HAL_OK)
+  if (HAL_TIMEx_MasterConfigSynchronization (&htim9, &sMasterConfig) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN TIM9_Init 2 */
   /* USER CODE END TIM9_Init 2 */
+}
 /**
-  * @brief USART1 Initialization Function
+ * @brief USART1 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_USART1_UART_Init(void)
+MX_USART1_UART_Init (void)
+{
   /* USER CODE BEGIN USART1_Init 0 */
   /* USER CODE END USART1_Init 0 */
   huart1.Init.StopBits = UART_STOPBITS_1;
   huart1.Init.Parity = UART_PARITY_NONE;
   huart1.Init.Mode = UART_MODE_TX_RX;
   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
-  if (HAL_UART_Init(&huart1) != HAL_OK)
+  if (HAL_UART_Init (&huart1) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN USART1_Init 2 */
   /* USER CODE END USART1_Init 2 */
+}
 /**
-  * @brief USART2 Initialization Function
+ * @brief USART2 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_USART2_UART_Init(void)
+MX_USART2_UART_Init (void)
+{
   /* USER CODE BEGIN USART2_Init 0 */
   /* USER CODE END USART2_Init 0 */
   huart2.Init.StopBits = UART_STOPBITS_1;
   huart2.Init.Parity = UART_PARITY_NONE;
   huart2.Init.Mode = UART_MODE_TX_RX;
   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
-  if (HAL_UART_Init(&huart2) != HAL_OK)
+  if (HAL_UART_Init (&huart2) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN USART2_Init 2 */
   /* USER CODE END USART2_Init 2 */
+}
 /**
-  * @brief USART3 Initialization Function
+ * @brief USART3 Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_USART3_UART_Init(void)
+MX_USART3_UART_Init (void)
+{
   /* USER CODE BEGIN USART3_Init 0 */
   /* USER CODE END USART3_Init 0 */
   /* USER CODE BEGIN USART3_Init 1 */
   /* USER CODE END USART3_Init 1 */
   huart3.Instance = USART3;
-  huart3.Init.BaudRate = 19200;
+  huart3.Init.BaudRate = 9600;
   huart3.Init.WordLength = UART_WORDLENGTH_8B;
   huart3.Init.StopBits = UART_STOPBITS_1;
   huart3.Init.Parity = UART_PARITY_NONE;
   huart3.Init.Mode = UART_MODE_TX_RX;
   huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   huart3.Init.OverSampling = UART_OVERSAMPLING_16;
-  if (HAL_UART_Init(&huart3) != HAL_OK)
+  if (HAL_UART_Init (&huart3) != HAL_OK)
-  {
+    {
-    Error_Handler();
+      Error_Handler ();
-  }
+    }
   /* USER CODE BEGIN USART3_Init 2 */
   /* USER CODE END USART3_Init 2 */
+}
 /**
-  * @brief GPIO Initialization Function
+ * @brief GPIO Initialization Function
-  * @param None
+ * @param None
-  * @retval None
+ * @retval None
-  */
+ */
+static void
-static void MX_GPIO_Init(void)
+MX_GPIO_Init (void)
+{
-  GPIO_InitTypeDef GPIO_InitStruct = {0};
+  GPIO_InitTypeDef GPIO_InitStruct =
+    { 0 };
   /* GPIO Ports Clock Enable */
   __HAL_RCC_GPIOH_CLK_ENABLE();
   __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOC_CLK_ENABLE();
   __HAL_RCC_GPIOB_CLK_ENABLE();
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin (SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOA, SPI_CD_Pin|BT_BUTTON_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin (GPIOA, SPI_CD_Pin | BT_BUTTON_Pin, GPIO_PIN_RESET);
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOC, SPI_RESET_Pin|POWER_LATCH_Pin|USB_PWR_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin (GPIOC, SPI_RESET_Pin | POWER_LATCH_Pin | USB_PWR_Pin,
+                     GPIO_PIN_RESET);
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin (SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
   /*Configure GPIO pins : SPI_NSS1_Pin SPI_CD_Pin */
-  GPIO_InitStruct.Pin = SPI_NSS1_Pin|SPI_CD_Pin;
+  GPIO_InitStruct.Pin = SPI_NSS1_Pin | SPI_CD_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);
+  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
   /*Configure GPIO pins : SPI_RESET_Pin SPI_NSS2_Pin POWER_LATCH_Pin USB_PWR_Pin */
-  GPIO_InitStruct.Pin = SPI_RESET_Pin|SPI_NSS2_Pin|POWER_LATCH_Pin|USB_PWR_Pin;
+  GPIO_InitStruct.Pin = SPI_RESET_Pin | SPI_NSS2_Pin | POWER_LATCH_Pin
+      | USB_PWR_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+  HAL_GPIO_Init (GPIOC, &GPIO_InitStruct);
   /*Configure GPIO pins : SW1_PUSH_Pin SW2_PUSH_Pin */
-  GPIO_InitStruct.Pin = SW1_PUSH_Pin|SW2_PUSH_Pin;
+  GPIO_InitStruct.Pin = SW1_PUSH_Pin | SW2_PUSH_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   GPIO_InitStruct.Pull = GPIO_PULLUP;
-  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+  HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
   /*Configure GPIO pin : IGNITION_Pin */
   GPIO_InitStruct.Pin = IGNITION_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
-  HAL_GPIO_Init(IGNITION_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init (IGNITION_GPIO_Port, &GPIO_InitStruct);
   /*Configure GPIO pin : BT_BUTTON_Pin */
   GPIO_InitStruct.Pin = BT_BUTTON_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(BT_BUTTON_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init (BT_BUTTON_GPIO_Port, &GPIO_InitStruct);
+}
 /* USER CODE BEGIN 4 */
 /* USER CODE END 4 */
 /**
-  * @brief  This function is executed in case of error occurrence.
+ * @brief  This function is executed in case of error occurrence.
-  * @retval None
+ * @retval None
-  */
+ */
+void
-void Error_Handler(void)
+Error_Handler (void)
+{
   /* USER CODE BEGIN Error_Handler_Debug */
   /* User can add his own implementation to report the HAL error return state */
   /* USER CODE END Error_Handler_Debug */

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Src/main.c – Rev 50 → 52