Subversion Repositories DashDisplay

Rev

Rev 57 | Rev 59 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 57 Rev 58
Line 24... Line 24...
24
/* USER CODE BEGIN Includes */
24
/* USER CODE BEGIN Includes */
25
 
25
 
26
#include "libPLX/plx.h"
26
#include "libPLX/plx.h"
27
#include "libSerial/serial.H"
27
#include "libSerial/serial.H"
28
#include "libSmallPrintf/small_printf.h"
28
#include "libSmallPrintf/small_printf.h"
-
 
29
#include "libNMEA/nmea.h"
29
#include "switches.h"
30
#include "switches.h"
30
 
31
 
31
/* USER CODE END Includes */
32
/* USER CODE END Includes */
32
 
33
 
33
/* Private typedef -----------------------------------------------------------*/
34
/* Private typedef -----------------------------------------------------------*/
Line 76... Line 77...
76
 
77
 
77
int PLXItems;
78
int PLXItems;
78
 
79
 
79
uint32_t Latch_Timer = IGNITION_OFF_TIMEOUT;
80
uint32_t Latch_Timer = IGNITION_OFF_TIMEOUT;
80
 
81
 
-
 
82
// location for GPS data
-
 
83
Location loc;
-
 
84
 
81
/* USER CODE END PV */
85
/* USER CODE END PV */
82
 
86
 
83
/* Private function prototypes -----------------------------------------------*/
87
/* Private function prototypes -----------------------------------------------*/
84
void
-
 
85
SystemClock_Config (void);
88
void SystemClock_Config(void);
86
static void
-
 
87
MX_GPIO_Init (void);
89
static void MX_GPIO_Init(void);
88
static void
-
 
89
MX_SPI1_Init (void);
90
static void MX_SPI1_Init(void);
90
static void
-
 
91
MX_USART1_UART_Init (void);
91
static void MX_USART1_UART_Init(void);
92
static void
-
 
93
MX_USART2_UART_Init (void);
92
static void MX_USART2_UART_Init(void);
94
static void
-
 
95
MX_USART3_UART_Init (void);
93
static void MX_USART3_UART_Init(void);
96
static void
-
 
97
MX_TIM3_Init (void);
94
static void MX_TIM3_Init(void);
98
static void
-
 
99
MX_TIM9_Init (void);
95
static void MX_TIM9_Init(void);
100
static void
-
 
101
MX_TIM2_Init (void);
96
static void MX_TIM2_Init(void);
102
/* USER CODE BEGIN PFP */
97
/* USER CODE BEGIN PFP */
103
 
98
 
104
// the dial is the switch number we are using.
99
// the dial is the switch number we are using.
105
// suppress is the ItemIndex we wish to suppress on this display
100
// suppress is the ItemIndex we wish to suppress on this display
106
int
101
int
Line 109... Line 104...
109
  if (contexts[dial].knobPos < 0)
104
  if (contexts[dial].knobPos < 0)
110
    return -1;
105
    return -1;
111
  return cc_display (dial, suppress);
106
  return cc_display (dial, suppress);
112
}
107
}
113
 
108
 
114
void
-
 
115
setBaud (usart_ctl *ctl, uint32_t baud)
-
 
116
{
-
 
117
  ctl->handle->Init.BaudRate = baud;
-
 
118
  __disable_irq ();
-
 
119
  HAL_UART_Init (ctl->handle);
-
 
120
  __enable_irq ();
-
 
121
}
-
 
122
 
109
 
123
void
110
void
124
sendString (usart_ctl *ctl, char *string, int length)
111
sendString (usart_ctl *ctl, char *string, int length)
125
{
112
{
126
  int i;
113
  int i;
Line 136... Line 123...
136
{
123
{
137
  char initBuf[30];
124
  char initBuf[30];
138
  // switch to command mode
125
  // switch to command mode
139
  HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_RESET);
126
  HAL_GPIO_WritePin (BT_BUTTON_GPIO_Port, BT_BUTTON_Pin, GPIO_PIN_RESET);
140
  HAL_Delay (500);
127
  HAL_Delay (500);
141
  int initLen = small_sprintf (initBuf, "AT+UART=%l,1,2\n", baudRate);
128
  int initLen = small_sprintf (initBuf, "AT+UART=%ul,1,2\n", baudRate);
142
  setBaud (ctl, 38400);
129
  setBaud (ctl, 38400);
143
  sendString (ctl, initBuf, initLen);
130
  sendString (ctl, initBuf, initLen);
144
  TxWaitEmpty (ctl);
131
  TxWaitEmpty (ctl);
145
  // switch back to normal comms at new baud rate
132
  // switch back to normal comms at new baud rate
146
 
133
 
Line 156... Line 143...
156
/* USER CODE BEGIN 0 */
143
/* USER CODE BEGIN 0 */
157
 
144
 
158
/* USER CODE END 0 */
145
/* USER CODE END 0 */
159
 
146
 
160
/**
147
/**
161
 * @brief  The application entry point.
148
  * @brief  The application entry point.
162
 * @retval int
149
  * @retval int
163
 */
150
  */
164
int
-
 
165
main (void)
151
int main(void)
166
{
152
{
167
  /* USER CODE BEGIN 1 */
153
  /* USER CODE BEGIN 1 */
168
  __HAL_RCC_SPI1_CLK_ENABLE()
154
  __HAL_RCC_SPI1_CLK_ENABLE()
169
  ;
155
  ;
170
  __HAL_RCC_USART1_CLK_ENABLE()
156
  __HAL_RCC_USART1_CLK_ENABLE()
Line 181... Line 167...
181
  /* USER CODE END 1 */
167
  /* USER CODE END 1 */
182
 
168
 
183
  /* MCU Configuration--------------------------------------------------------*/
169
  /* MCU Configuration--------------------------------------------------------*/
184
 
170
 
185
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
171
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
186
  HAL_Init ();
172
  HAL_Init();
187
 
173
 
188
  /* USER CODE BEGIN Init */
174
  /* USER CODE BEGIN Init */
189
 
175
 
190
  /* USER CODE END Init */
176
  /* USER CODE END Init */
191
 
177
 
192
  /* Configure the system clock */
178
  /* Configure the system clock */
193
  SystemClock_Config ();
179
  SystemClock_Config();
194
 
180
 
195
  /* USER CODE BEGIN SysInit */
181
  /* USER CODE BEGIN SysInit */
196
 
182
 
197
  /* USER CODE END SysInit */
183
  /* USER CODE END SysInit */
198
 
184
 
199
  /* Initialize all configured peripherals */
185
  /* Initialize all configured peripherals */
200
  MX_GPIO_Init ();
186
  MX_GPIO_Init();
201
  MX_SPI1_Init ();
187
  MX_SPI1_Init();
202
  MX_USART1_UART_Init ();
188
  MX_USART1_UART_Init();
203
  MX_USART2_UART_Init ();
189
  MX_USART2_UART_Init();
204
  MX_USART3_UART_Init ();
190
  MX_USART3_UART_Init();
205
  MX_TIM3_Init ();
191
  MX_TIM3_Init();
206
  MX_TIM9_Init ();
192
  MX_TIM9_Init();
207
  MX_TIM2_Init ();
193
  MX_TIM2_Init();
208
  /* USER CODE BEGIN 2 */
194
  /* USER CODE BEGIN 2 */
209
 
195
 
210
  /* Turn on USART1 IRQ */
196
  /* Turn on USART1 IRQ */
211
  HAL_NVIC_SetPriority (USART1_IRQn, 2, 0);
197
  HAL_NVIC_SetPriority (USART1_IRQn, 2, 0);
212
  HAL_NVIC_EnableIRQ (USART1_IRQn);
198
  HAL_NVIC_EnableIRQ (USART1_IRQn);
Line 235... Line 221...
235
  // Switch handler called on sysTick interrupt.
221
  // Switch handler called on sysTick interrupt.
236
  InitSwitches ();
222
  InitSwitches ();
237
 
223
 
238
  initModule (&uc3, 9600);
224
  initModule (&uc3, 9600);
239
 
225
 
-
 
226
  // Initialise UART for 4800 baud NMEA
-
 
227
  setBaud (&uc2, 4800);
-
 
228
 
240
  cc_init ();
229
  cc_init ();
241
 
230
 
242
  int i;
231
  int i;
243
  for (i = 0; i < 2; i++)
232
  for (i = 0; i < 2; i++)
244
    {
233
    {
Line 255... Line 244...
255
  /* Infinite loop */
244
  /* Infinite loop */
256
  /* USER CODE BEGIN WHILE */
245
  /* USER CODE BEGIN WHILE */
257
  while (1)
246
  while (1)
258
    {
247
    {
259
 
248
 
-
 
249
 
-
 
250
 
-
 
251
      bool stat = updateLocation (&loc, &uc2);
-
 
252
      if (loc.good)
-
 
253
        {
-
 
254
 
-
 
255
          loc.good = false;
-
 
256
        }
-
 
257
      if (loc.valid == 'V')
-
 
258
        memset (loc.time, '-', 6);
-
 
259
 
-
 
260
 
-
 
261
 
-
 
262
 
-
 
263
 
260
      /* while ignition is on, keep resetting power latch timer */
264
      /* while ignition is on, keep resetting power latch timer */
261
      if (HAL_GPIO_ReadPin (IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
265
      if (HAL_GPIO_ReadPin (IGNITION_GPIO_Port, IGNITION_Pin) == GPIO_PIN_RESET)
262
        {
266
        {
263
          Latch_Timer = HAL_GetTick () + IGNITION_OFF_TIMEOUT;
267
          Latch_Timer = HAL_GetTick () + IGNITION_OFF_TIMEOUT;
264
        }
268
        }
Line 342... Line 346...
342
                    {
346
                    {
343
                      // we can now decode the selected parameter
347
                      // we can now decode the selected parameter
344
                      PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
348
                      PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
345
                      // saturate the rotary switch position
349
                      // saturate the rotary switch position
346
 
350
 
347
                      int DataVal;
-
 
348
                      // process min/max
351
                      // process min/max
349
                      for (i = 0; i < PLXItems; i++)
352
                      for (i = 0; i < PLXItems; i++)
350
                        {
353
                        {
351
                          Info[i].observation = ConvPLX (Data.Sensor[i].AddrH,
354
                          Info[i].observation = ConvPLX (Data.Sensor[i].AddrH,
352
                                                         Data.Sensor[i].AddrL);
355
                                                         Data.Sensor[i].AddrL);
Line 425... Line 428...
425
              cc_check_nvram (i);
428
              cc_check_nvram (i);
426
              if (contexts[i].knobPos >= 0)
429
              if (contexts[i].knobPos >= 0)
427
                dial_pos[i] = contexts[i].knobPos;
430
                dial_pos[i] = contexts[i].knobPos;
428
            }
431
            }
429
        }
432
        }
430
      /* USER CODE END WHILE */
433
    /* USER CODE END WHILE */
431
 
434
 
432
      /* USER CODE BEGIN 3 */
435
    /* USER CODE BEGIN 3 */
433
    }
436
    }
434
  /* USER CODE END 3 */
437
  /* USER CODE END 3 */
435
}
438
}
436
 
439
 
437
/**
440
/**
438
 * @brief System Clock Configuration
441
  * @brief System Clock Configuration
439
 * @retval None
442
  * @retval None
440
 */
443
  */
441
void
-
 
442
SystemClock_Config (void)
444
void SystemClock_Config(void)
443
{
445
{
444
  RCC_OscInitTypeDef RCC_OscInitStruct =
446
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
445
    { 0 };
-
 
446
  RCC_ClkInitTypeDef RCC_ClkInitStruct =
447
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
447
    { 0 };
-
 
448
 
448
 
449
  /** Configure the main internal regulator output voltage
449
  /** Configure the main internal regulator output voltage
450
   */
450
  */
451
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
451
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
452
  /** Initializes the RCC Oscillators according to the specified parameters
452
  /** Initializes the RCC Oscillators according to the specified parameters
453
   * in the RCC_OscInitTypeDef structure.
453
  * in the RCC_OscInitTypeDef structure.
454
   */
454
  */
455
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
455
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
456
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
456
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
457
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
457
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
458
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
458
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
459
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12;
459
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12;
460
  RCC_OscInitStruct.PLL.PLLDIV = RCC_PLL_DIV3;
460
  RCC_OscInitStruct.PLL.PLLDIV = RCC_PLL_DIV3;
461
  if (HAL_RCC_OscConfig (&RCC_OscInitStruct) != HAL_OK)
461
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
462
    {
462
  {
463
      Error_Handler ();
463
    Error_Handler();
464
    }
464
  }
465
  /** Initializes the CPU, AHB and APB buses clocks
465
  /** Initializes the CPU, AHB and APB buses clocks
466
   */
466
  */
467
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
467
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
468
      | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
468
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
469
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
469
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
470
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
470
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
471
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
471
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
472
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
472
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
473
 
473
 
474
  if (HAL_RCC_ClockConfig (&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
474
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
475
    {
475
  {
476
      Error_Handler ();
476
    Error_Handler();
477
    }
477
  }
478
}
478
}
479
 
479
 
480
/**
480
/**
481
 * @brief SPI1 Initialization Function
481
  * @brief SPI1 Initialization Function
482
 * @param None
482
  * @param None
483
 * @retval None
483
  * @retval None
484
 */
484
  */
485
static void
-
 
486
MX_SPI1_Init (void)
485
static void MX_SPI1_Init(void)
487
{
486
{
488
 
487
 
489
  /* USER CODE BEGIN SPI1_Init 0 */
488
  /* USER CODE BEGIN SPI1_Init 0 */
490
 
489
 
491
  /* USER CODE END SPI1_Init 0 */
490
  /* USER CODE END SPI1_Init 0 */
Line 504... Line 503...
504
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
503
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
505
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
504
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
506
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
505
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
507
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
506
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
508
  hspi1.Init.CRCPolynomial = 10;
507
  hspi1.Init.CRCPolynomial = 10;
509
  if (HAL_SPI_Init (&hspi1) != HAL_OK)
508
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
510
    {
509
  {
511
      Error_Handler ();
510
    Error_Handler();
512
    }
511
  }
513
  /* USER CODE BEGIN SPI1_Init 2 */
512
  /* USER CODE BEGIN SPI1_Init 2 */
514
 
513
 
515
  /* USER CODE END SPI1_Init 2 */
514
  /* USER CODE END SPI1_Init 2 */
516
 
515
 
517
}
516
}
518
 
517
 
519
/**
518
/**
520
 * @brief TIM2 Initialization Function
519
  * @brief TIM2 Initialization Function
521
 * @param None
520
  * @param None
522
 * @retval None
521
  * @retval None
523
 */
522
  */
524
static void
-
 
525
MX_TIM2_Init (void)
523
static void MX_TIM2_Init(void)
526
{
524
{
527
 
525
 
528
  /* USER CODE BEGIN TIM2_Init 0 */
526
  /* USER CODE BEGIN TIM2_Init 0 */
529
 
527
 
530
  /* USER CODE END TIM2_Init 0 */
528
  /* USER CODE END TIM2_Init 0 */
531
 
529
 
532
  TIM_ClockConfigTypeDef sClockSourceConfig =
530
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
533
    { 0 };
-
 
534
  TIM_MasterConfigTypeDef sMasterConfig =
531
  TIM_MasterConfigTypeDef sMasterConfig = {0};
535
    { 0 };
-
 
536
 
532
 
537
  /* USER CODE BEGIN TIM2_Init 1 */
533
  /* USER CODE BEGIN TIM2_Init 1 */
538
 
534
 
539
  /* USER CODE END TIM2_Init 1 */
535
  /* USER CODE END TIM2_Init 1 */
540
  htim2.Instance = TIM2;
536
  htim2.Instance = TIM2;
541
  htim2.Init.Prescaler = 0;
537
  htim2.Init.Prescaler = 0;
542
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
538
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
543
  htim2.Init.Period = 65535;
539
  htim2.Init.Period = 65535;
544
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
540
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
545
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
541
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
546
  if (HAL_TIM_Base_Init (&htim2) != HAL_OK)
542
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
547
    {
543
  {
548
      Error_Handler ();
544
    Error_Handler();
549
    }
545
  }
550
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
546
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
551
  if (HAL_TIM_ConfigClockSource (&htim2, &sClockSourceConfig) != HAL_OK)
547
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
552
    {
548
  {
553
      Error_Handler ();
549
    Error_Handler();
554
    }
550
  }
555
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
551
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
556
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
552
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
557
  if (HAL_TIMEx_MasterConfigSynchronization (&htim2, &sMasterConfig) != HAL_OK)
553
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
558
    {
554
  {
559
      Error_Handler ();
555
    Error_Handler();
560
    }
556
  }
561
  /* USER CODE BEGIN TIM2_Init 2 */
557
  /* USER CODE BEGIN TIM2_Init 2 */
562
 
558
 
563
  /* USER CODE END TIM2_Init 2 */
559
  /* USER CODE END TIM2_Init 2 */
564
 
560
 
565
}
561
}
566
 
562
 
567
/**
563
/**
568
 * @brief TIM3 Initialization Function
564
  * @brief TIM3 Initialization Function
569
 * @param None
565
  * @param None
570
 * @retval None
566
  * @retval None
571
 */
567
  */
572
static void
-
 
573
MX_TIM3_Init (void)
568
static void MX_TIM3_Init(void)
574
{
569
{
575
 
570
 
576
  /* USER CODE BEGIN TIM3_Init 0 */
571
  /* USER CODE BEGIN TIM3_Init 0 */
577
 
572
 
578
  /* USER CODE END TIM3_Init 0 */
573
  /* USER CODE END TIM3_Init 0 */
579
 
574
 
580
  TIM_Encoder_InitTypeDef sConfig =
575
  TIM_Encoder_InitTypeDef sConfig = {0};
581
    { 0 };
-
 
582
  TIM_MasterConfigTypeDef sMasterConfig =
576
  TIM_MasterConfigTypeDef sMasterConfig = {0};
583
    { 0 };
-
 
584
 
577
 
585
  /* USER CODE BEGIN TIM3_Init 1 */
578
  /* USER CODE BEGIN TIM3_Init 1 */
586
 
579
 
587
  /* USER CODE END TIM3_Init 1 */
580
  /* USER CODE END TIM3_Init 1 */
588
  htim3.Instance = TIM3;
581
  htim3.Instance = TIM3;
Line 598... Line 591...
598
  sConfig.IC1Filter = 15;
591
  sConfig.IC1Filter = 15;
599
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
592
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
600
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
593
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
601
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
594
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
602
  sConfig.IC2Filter = 15;
595
  sConfig.IC2Filter = 15;
603
  if (HAL_TIM_Encoder_Init (&htim3, &sConfig) != HAL_OK)
596
  if (HAL_TIM_Encoder_Init(&htim3, &sConfig) != HAL_OK)
604
    {
597
  {
605
      Error_Handler ();
598
    Error_Handler();
606
    }
599
  }
607
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
600
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
608
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
601
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
609
  if (HAL_TIMEx_MasterConfigSynchronization (&htim3, &sMasterConfig) != HAL_OK)
602
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
610
    {
603
  {
611
      Error_Handler ();
604
    Error_Handler();
612
    }
605
  }
613
  /* USER CODE BEGIN TIM3_Init 2 */
606
  /* USER CODE BEGIN TIM3_Init 2 */
614
 
607
 
615
  /* USER CODE END TIM3_Init 2 */
608
  /* USER CODE END TIM3_Init 2 */
616
 
609
 
617
}
610
}
618
 
611
 
619
/**
612
/**
620
 * @brief TIM9 Initialization Function
613
  * @brief TIM9 Initialization Function
621
 * @param None
614
  * @param None
622
 * @retval None
615
  * @retval None
623
 */
616
  */
624
static void
-
 
625
MX_TIM9_Init (void)
617
static void MX_TIM9_Init(void)
626
{
618
{
627
 
619
 
628
  /* USER CODE BEGIN TIM9_Init 0 */
620
  /* USER CODE BEGIN TIM9_Init 0 */
629
 
621
 
630
  /* USER CODE END TIM9_Init 0 */
622
  /* USER CODE END TIM9_Init 0 */
631
 
623
 
632
  TIM_Encoder_InitTypeDef sConfig =
624
  TIM_Encoder_InitTypeDef sConfig = {0};
633
    { 0 };
-
 
634
  TIM_MasterConfigTypeDef sMasterConfig =
625
  TIM_MasterConfigTypeDef sMasterConfig = {0};
635
    { 0 };
-
 
636
 
626
 
637
  /* USER CODE BEGIN TIM9_Init 1 */
627
  /* USER CODE BEGIN TIM9_Init 1 */
638
 
628
 
639
  /* USER CODE END TIM9_Init 1 */
629
  /* USER CODE END TIM9_Init 1 */
640
  htim9.Instance = TIM9;
630
  htim9.Instance = TIM9;
Line 650... Line 640...
650
  sConfig.IC1Filter = 15;
640
  sConfig.IC1Filter = 15;
651
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
641
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
652
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
642
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
653
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
643
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
654
  sConfig.IC2Filter = 0;
644
  sConfig.IC2Filter = 0;
655
  if (HAL_TIM_Encoder_Init (&htim9, &sConfig) != HAL_OK)
645
  if (HAL_TIM_Encoder_Init(&htim9, &sConfig) != HAL_OK)
656
    {
646
  {
657
      Error_Handler ();
647
    Error_Handler();
658
    }
648
  }
659
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
649
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
660
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
650
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
661
  if (HAL_TIMEx_MasterConfigSynchronization (&htim9, &sMasterConfig) != HAL_OK)
651
  if (HAL_TIMEx_MasterConfigSynchronization(&htim9, &sMasterConfig) != HAL_OK)
662
    {
652
  {
663
      Error_Handler ();
653
    Error_Handler();
664
    }
654
  }
665
  /* USER CODE BEGIN TIM9_Init 2 */
655
  /* USER CODE BEGIN TIM9_Init 2 */
666
 
656
 
667
  /* USER CODE END TIM9_Init 2 */
657
  /* USER CODE END TIM9_Init 2 */
668
 
658
 
669
}
659
}
670
 
660
 
671
/**
661
/**
672
 * @brief USART1 Initialization Function
662
  * @brief USART1 Initialization Function
673
 * @param None
663
  * @param None
674
 * @retval None
664
  * @retval None
675
 */
665
  */
676
static void
-
 
677
MX_USART1_UART_Init (void)
666
static void MX_USART1_UART_Init(void)
678
{
667
{
679
 
668
 
680
  /* USER CODE BEGIN USART1_Init 0 */
669
  /* USER CODE BEGIN USART1_Init 0 */
681
 
670
 
682
  /* USER CODE END USART1_Init 0 */
671
  /* USER CODE END USART1_Init 0 */
Line 690... Line 679...
690
  huart1.Init.StopBits = UART_STOPBITS_1;
679
  huart1.Init.StopBits = UART_STOPBITS_1;
691
  huart1.Init.Parity = UART_PARITY_NONE;
680
  huart1.Init.Parity = UART_PARITY_NONE;
692
  huart1.Init.Mode = UART_MODE_TX_RX;
681
  huart1.Init.Mode = UART_MODE_TX_RX;
693
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
682
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
694
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
683
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
695
  if (HAL_UART_Init (&huart1) != HAL_OK)
684
  if (HAL_UART_Init(&huart1) != HAL_OK)
696
    {
685
  {
697
      Error_Handler ();
686
    Error_Handler();
698
    }
687
  }
699
  /* USER CODE BEGIN USART1_Init 2 */
688
  /* USER CODE BEGIN USART1_Init 2 */
700
 
689
 
701
  /* USER CODE END USART1_Init 2 */
690
  /* USER CODE END USART1_Init 2 */
702
 
691
 
703
}
692
}
704
 
693
 
705
/**
694
/**
706
 * @brief USART2 Initialization Function
695
  * @brief USART2 Initialization Function
707
 * @param None
696
  * @param None
708
 * @retval None
697
  * @retval None
709
 */
698
  */
710
static void
-
 
711
MX_USART2_UART_Init (void)
699
static void MX_USART2_UART_Init(void)
712
{
700
{
713
 
701
 
714
  /* USER CODE BEGIN USART2_Init 0 */
702
  /* USER CODE BEGIN USART2_Init 0 */
715
 
703
 
716
  /* USER CODE END USART2_Init 0 */
704
  /* USER CODE END USART2_Init 0 */
Line 724... Line 712...
724
  huart2.Init.StopBits = UART_STOPBITS_1;
712
  huart2.Init.StopBits = UART_STOPBITS_1;
725
  huart2.Init.Parity = UART_PARITY_NONE;
713
  huart2.Init.Parity = UART_PARITY_NONE;
726
  huart2.Init.Mode = UART_MODE_TX_RX;
714
  huart2.Init.Mode = UART_MODE_TX_RX;
727
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
715
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
728
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
716
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
729
  if (HAL_UART_Init (&huart2) != HAL_OK)
717
  if (HAL_UART_Init(&huart2) != HAL_OK)
730
    {
718
  {
731
      Error_Handler ();
719
    Error_Handler();
732
    }
720
  }
733
  /* USER CODE BEGIN USART2_Init 2 */
721
  /* USER CODE BEGIN USART2_Init 2 */
734
 
722
 
735
  /* USER CODE END USART2_Init 2 */
723
  /* USER CODE END USART2_Init 2 */
736
 
724
 
737
}
725
}
738
 
726
 
739
/**
727
/**
740
 * @brief USART3 Initialization Function
728
  * @brief USART3 Initialization Function
741
 * @param None
729
  * @param None
742
 * @retval None
730
  * @retval None
743
 */
731
  */
744
static void
-
 
745
MX_USART3_UART_Init (void)
732
static void MX_USART3_UART_Init(void)
746
{
733
{
747
 
734
 
748
  /* USER CODE BEGIN USART3_Init 0 */
735
  /* USER CODE BEGIN USART3_Init 0 */
749
 
736
 
750
  /* USER CODE END USART3_Init 0 */
737
  /* USER CODE END USART3_Init 0 */
751
 
738
 
752
  /* USER CODE BEGIN USART3_Init 1 */
739
  /* USER CODE BEGIN USART3_Init 1 */
753
 
740
 
754
  /* USER CODE END USART3_Init 1 */
741
  /* USER CODE END USART3_Init 1 */
755
  huart3.Instance = USART3;
742
  huart3.Instance = USART3;
756
  huart3.Init.BaudRate = 9600;
743
  huart3.Init.BaudRate = 19200;
757
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
744
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
758
  huart3.Init.StopBits = UART_STOPBITS_1;
745
  huart3.Init.StopBits = UART_STOPBITS_1;
759
  huart3.Init.Parity = UART_PARITY_NONE;
746
  huart3.Init.Parity = UART_PARITY_NONE;
760
  huart3.Init.Mode = UART_MODE_TX_RX;
747
  huart3.Init.Mode = UART_MODE_TX_RX;
761
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
748
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
762
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
749
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
763
  if (HAL_UART_Init (&huart3) != HAL_OK)
750
  if (HAL_UART_Init(&huart3) != HAL_OK)
764
    {
751
  {
765
      Error_Handler ();
752
    Error_Handler();
766
    }
753
  }
767
  /* USER CODE BEGIN USART3_Init 2 */
754
  /* USER CODE BEGIN USART3_Init 2 */
768
 
755
 
769
  /* USER CODE END USART3_Init 2 */
756
  /* USER CODE END USART3_Init 2 */
770
 
757
 
771
}
758
}
772
 
759
 
773
/**
760
/**
774
 * @brief GPIO Initialization Function
761
  * @brief GPIO Initialization Function
775
 * @param None
762
  * @param None
776
 * @retval None
763
  * @retval None
777
 */
764
  */
778
static void
-
 
779
MX_GPIO_Init (void)
765
static void MX_GPIO_Init(void)
780
{
766
{
781
  GPIO_InitTypeDef GPIO_InitStruct =
767
  GPIO_InitTypeDef GPIO_InitStruct = {0};
782
    { 0 };
-
 
783
 
768
 
784
  /* GPIO Ports Clock Enable */
769
  /* GPIO Ports Clock Enable */
785
  __HAL_RCC_GPIOH_CLK_ENABLE();
770
  __HAL_RCC_GPIOH_CLK_ENABLE();
786
  __HAL_RCC_GPIOA_CLK_ENABLE();
771
  __HAL_RCC_GPIOA_CLK_ENABLE();
787
  __HAL_RCC_GPIOC_CLK_ENABLE();
772
  __HAL_RCC_GPIOC_CLK_ENABLE();
788
  __HAL_RCC_GPIOB_CLK_ENABLE();
773
  __HAL_RCC_GPIOB_CLK_ENABLE();
789
 
774
 
790
  /*Configure GPIO pin Output Level */
775
  /*Configure GPIO pin Output Level */
791
  HAL_GPIO_WritePin (SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
776
  HAL_GPIO_WritePin(SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
792
 
777
 
793
  /*Configure GPIO pin Output Level */
778
  /*Configure GPIO pin Output Level */
794
  HAL_GPIO_WritePin (GPIOA, SPI_CD_Pin | BT_BUTTON_Pin, GPIO_PIN_RESET);
779
  HAL_GPIO_WritePin(GPIOA, SPI_CD_Pin|BT_BUTTON_Pin, GPIO_PIN_RESET);
795
 
780
 
796
  /*Configure GPIO pin Output Level */
781
  /*Configure GPIO pin Output Level */
797
  HAL_GPIO_WritePin (GPIOC, SPI_RESET_Pin | POWER_LATCH_Pin | USB_PWR_Pin,
782
  HAL_GPIO_WritePin(GPIOC, SPI_RESET_Pin|POWER_LATCH_Pin|USB_PWR_Pin, GPIO_PIN_RESET);
798
                     GPIO_PIN_RESET);
-
 
799
 
783
 
800
  /*Configure GPIO pin Output Level */
784
  /*Configure GPIO pin Output Level */
801
  HAL_GPIO_WritePin (SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
785
  HAL_GPIO_WritePin(SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
802
 
786
 
803
  /*Configure GPIO pins : SPI_NSS1_Pin SPI_CD_Pin */
787
  /*Configure GPIO pins : SPI_NSS1_Pin SPI_CD_Pin */
804
  GPIO_InitStruct.Pin = SPI_NSS1_Pin | SPI_CD_Pin;
788
  GPIO_InitStruct.Pin = SPI_NSS1_Pin|SPI_CD_Pin;
805
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
789
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
806
  GPIO_InitStruct.Pull = GPIO_NOPULL;
790
  GPIO_InitStruct.Pull = GPIO_NOPULL;
807
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
791
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
808
  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
792
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
809
 
793
 
810
  /*Configure GPIO pins : SPI_RESET_Pin SPI_NSS2_Pin POWER_LATCH_Pin USB_PWR_Pin */
794
  /*Configure GPIO pins : SPI_RESET_Pin SPI_NSS2_Pin POWER_LATCH_Pin USB_PWR_Pin */
811
  GPIO_InitStruct.Pin = SPI_RESET_Pin | SPI_NSS2_Pin | POWER_LATCH_Pin
795
  GPIO_InitStruct.Pin = SPI_RESET_Pin|SPI_NSS2_Pin|POWER_LATCH_Pin|USB_PWR_Pin;
812
      | USB_PWR_Pin;
-
 
813
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
796
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
814
  GPIO_InitStruct.Pull = GPIO_NOPULL;
797
  GPIO_InitStruct.Pull = GPIO_NOPULL;
815
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
798
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
816
  HAL_GPIO_Init (GPIOC, &GPIO_InitStruct);
799
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
817
 
800
 
818
  /*Configure GPIO pins : SW1_PUSH_Pin SW2_PUSH_Pin */
801
  /*Configure GPIO pins : SW1_PUSH_Pin SW2_PUSH_Pin */
819
  GPIO_InitStruct.Pin = SW1_PUSH_Pin | SW2_PUSH_Pin;
802
  GPIO_InitStruct.Pin = SW1_PUSH_Pin|SW2_PUSH_Pin;
820
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
803
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
821
  GPIO_InitStruct.Pull = GPIO_PULLUP;
804
  GPIO_InitStruct.Pull = GPIO_PULLUP;
822
  HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
805
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
823
 
806
 
824
  /*Configure GPIO pin : IGNITION_Pin */
807
  /*Configure GPIO pin : IGNITION_Pin */
825
  GPIO_InitStruct.Pin = IGNITION_Pin;
808
  GPIO_InitStruct.Pin = IGNITION_Pin;
826
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
809
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
827
  GPIO_InitStruct.Pull = GPIO_NOPULL;
810
  GPIO_InitStruct.Pull = GPIO_NOPULL;
828
  HAL_GPIO_Init (IGNITION_GPIO_Port, &GPIO_InitStruct);
811
  HAL_GPIO_Init(IGNITION_GPIO_Port, &GPIO_InitStruct);
829
 
812
 
830
  /*Configure GPIO pin : BT_BUTTON_Pin */
813
  /*Configure GPIO pin : BT_BUTTON_Pin */
831
  GPIO_InitStruct.Pin = BT_BUTTON_Pin;
814
  GPIO_InitStruct.Pin = BT_BUTTON_Pin;
832
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
815
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
833
  GPIO_InitStruct.Pull = GPIO_NOPULL;
816
  GPIO_InitStruct.Pull = GPIO_NOPULL;
834
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
817
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
835
  HAL_GPIO_Init (BT_BUTTON_GPIO_Port, &GPIO_InitStruct);
818
  HAL_GPIO_Init(BT_BUTTON_GPIO_Port, &GPIO_InitStruct);
836
 
819
 
837
}
820
}
838
 
821
 
839
/* USER CODE BEGIN 4 */
822
/* USER CODE BEGIN 4 */
840
 
823
 
841
/* USER CODE END 4 */
824
/* USER CODE END 4 */
842
 
825
 
843
/**
826
/**
844
 * @brief  This function is executed in case of error occurrence.
827
  * @brief  This function is executed in case of error occurrence.
845
 * @retval None
828
  * @retval None
846
 */
829
  */
847
void
-
 
848
Error_Handler (void)
830
void Error_Handler(void)
849
{
831
{
850
  /* USER CODE BEGIN Error_Handler_Debug */
832
  /* USER CODE BEGIN Error_Handler_Debug */
851
  /* User can add his own implementation to report the HAL error return state */
833
  /* User can add his own implementation to report the HAL error return state */
852
 
834
 
853
  /* USER CODE END Error_Handler_Debug */
835
  /* USER CODE END Error_Handler_Debug */