WebSVN – EngineBay2 – Diff – /branches/stm32f103/Core/Src/main.c

 ADC_HandleTypeDef hadc1;
 DMA_HandleTypeDef hdma_adc1;
 CAN_HandleTypeDef hcan;
+IWDG_HandleTypeDef hiwdg;
 SPI_HandleTypeDef hspi1;
 TIM_HandleTypeDef htim2;
 TIM_HandleTypeDef htim3;
 TIM_HandleTypeDef htim4;
 UART_HandleTypeDef huart1;
 /* USER CODE BEGIN PV */
+// Storage for USART
+#define USART_TX_BUFF_SIZE 256
+#define USART_RX_BUFF_SIZE 256
+uint8_t usartTxBuff[USART_TX_BUFF_SIZE];
+uint8_t usartRxBuff[USART_RX_BUFF_SIZE];
 // storage for ADC
 uint16_t ADC_Samples[ADC_CHANNELS] = {[0 ... ADC_CHANNELS - 1] = 0};
 uint32_t FILT_Samples[ADC_CHANNELS] = {[0 ... ADC_CHANNELS - 1] = 0}; // filtered ADC samples * Scale
 static void MX_SPI1_Init(void);
 static void MX_TIM2_Init(void);
 static void MX_TIM3_Init(void);
 static void MX_TIM4_Init(void);
 static void MX_USART1_UART_Init(void);
+static void MX_IWDG_Init(void);
 /* USER CODE BEGIN PFP */
 /* USER CODE END PFP */
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
-void plx_sendword(int x)
+void libPLXcallbackRecievedData(PLX_SensorInfo * data)
+{
-  PutCharSerial(&uc1, ((x) >> 6) & 0x3F);
-  PutCharSerial(&uc1, (x)&0x3F);
+  (void )data;
+}
 void filter_ADC_samples()
+{
   int i;
   for (i = 0; i < ADC_CHANNELS; i++)
+  {
 void ProcessRPM(void)
+{
   static unsigned int Coded_RPM = 0;
   int32_t rpm = CalculateRPM();
+  // suppress the EDIS "heartbeat" 90 RPM
-  if (rpm >= 0)
+  if (rpm >= 100)
     Coded_RPM = rpm / 19.55;
   // send the current RPM *calculation
-  plx_sendword(PLX_RPM);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_RPM));
-  plx_sendword(Coded_RPM / Scale);
+  sendPlxInfo(& uc1, PLX_RPM, Coded_RPM/ Scale);
+}
 // this uses a MAX6675 which is a simple 16 bit read
 // SPI is configured for 8 bits so I can use an OLED display if I need it
 // must wait > 0.22 seconds between conversion attempts as this is the measurement time
 /// \param type the code to use for this observation
 void ProcessTemp(char item, enum PLX_Observations type)
+{
   if (item > NUM_SPI_TEMP_SENS)
     return;
-  plx_sendword(type);
-  PutCharSerial(&uc1, libPLXgetNextInstance(type));
-  plx_sendword(Temp_Observations[(int)item]);
+  sendPlxInfo(& uc1, type , Temp_Observations[(int)item]);
+}
 /// \brief Reset the temperature chip select system
 void resetTempCS(void)
+{
+{
   float reading = FILT_Samples[item] * ADC_Scale;
   reading = reading * 7.8125; // real voltage
   reading = reading * 51.15;  // PLC scaling =  1023/20
-  plx_sendword(PLX_Volts);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_Volts));
-  plx_sendword((uint16_t)reading);
+  sendPlxInfo(& uc1, PLX_Volts, reading);
+}
 void ProcessCPUTemperature(void)
+{
   // this is defined in the STM32F103 reference manual . #
   /* renormalise temperature value to account for different ADC Vref  : normalise to that which we would get for a 3000mV reference */
   temp_val = (1.43 - temp_val) / 4.3e-3 + 25;
   int32_t result = temp_val;
-  //  int32_t result = 800 * ((int32_t) temp_val - TS_CAL30);
-  //  result = result / (TS_CAL110 - TS_CAL30) + 300;
+  sendPlxInfo(& uc1, PLX_FluidTemp, result);
-  plx_sendword(PLX_FluidTemp);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_FluidTemp));
-  plx_sendword(result);
+}
 // the MAP sensor is giving us a reading of
 // 4.6 volts for 1019mB or 2.27 volts at the ADC input (resistive divider by 2.016)
 // I believe the sensor reads  4.5V at 1000kPa and 0.5V at  0kPa
   float reading = FILT_Samples[ADC_MAP_CHAN] * ADC_Scale;
   reading = reading * 2.016; // real voltage
   // values computed from slope / intercept of map.ods
   // reading = (reading) * 56.23 + 743.2; // do not assume 0.5 volt offset : reading from 0 to 4.5 instead of 0.5 to 4.5
   // using a pressure gauge.
-  reading = (reading)*150 + 326;
+  reading = (reading) * 150 + 326;
+  sendPlxInfo(& uc1, PLX_MAP, reading);
-  plx_sendword(PLX_MAP);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_MAP));
-  plx_sendword((uint16_t)reading);
+}
 // the Oil pressi sensor is giving us a reading of
 // 4.5 volts for 100 PSI or  2.25 volts at the ADC input (resistive divider by 2.016)
 // I believe the sensor reads  4.5V at 100PSI and 0.5V at  0PSI
   // Using ADC_Samples[2] as the MAP input
   float reading = FILT_Samples[ADC_PRESSURE_CHAN] * ADC_Scale;
   reading = reading * 2.00;            // real voltage
   reading = (reading - 0.5) * 512 / 4; // this is 1023 * 100/200
-  plx_sendword(PLX_FluidPressure);
+  sendPlxInfo(& uc1, PLX_FluidPressure, reading);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_FluidPressure));
-  plx_sendword((uint16_t)reading);
-}
-void ProcessTiming(void)
-{
-  plx_sendword(PLX_Timing);
-  PutCharSerial(&uc1, libPLXgetNextInstance(PLX_Timing));
-  plx_sendword(64 - 15); // make it negative
+}
 void libPLXcallbackSendUserData()
+{
   MX_SPI1_Init();
   MX_TIM2_Init();
   MX_TIM3_Init();
   MX_TIM4_Init();
   MX_USART1_UART_Init();
+  MX_IWDG_Init();
   /* USER CODE BEGIN 2 */
   HAL_MspInit();
   // Not using HAL USART code
   __HAL_RCC_USART1_CLK_ENABLE(); // PLX comms port
   /* setup the USART control blocks */
-  init_usart_ctl(&uc1, &huart1);
+  init_usart_ctl(&uc1, &huart1,
+                 usartTxBuff,
+                 usartRxBuff,
+                 USART_TX_BUFF_SIZE,
+                 USART_RX_BUFF_SIZE);
   EnableSerialRxInterrupt(&uc1);
   HAL_SPI_MspInit(&hspi1);
     // check to see if we have any incoming data, copy and append if so, if no data then create our own frames.
     // poll the input data and produce automatic output if the timer expires and no serial input data
     libPLXpollData(&uc1);
+    HAL_IWDG_Refresh(&hiwdg);
+  }
   /* USER CODE END 3 */
+}
   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
   /** Initializes the RCC Oscillators according to the specified parameters
    * in the RCC_OscInitTypeDef structure.
    */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
+  RCC_OscInitStruct.LSIState = RCC_LSI_ON;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
+  {
   /* USER CODE END CAN_Init 2 */
+}
 /**
+ * @brief IWDG Initialization Function
+ * @param None
+ * @retval None
+ */
+static void MX_IWDG_Init(void)
+{
+  /* USER CODE BEGIN IWDG_Init 0 */
+  /* USER CODE END IWDG_Init 0 */
+  /* USER CODE BEGIN IWDG_Init 1 */
+  /* USER CODE END IWDG_Init 1 */
+  hiwdg.Instance = IWDG;
+  hiwdg.Init.Prescaler = IWDG_PRESCALER_64;
+  hiwdg.Init.Reload = 4095;
+  if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN IWDG_Init 2 */
+  /* USER CODE END IWDG_Init 2 */
+}
+/**
  * @brief SPI1 Initialization Function
  * @param None
  * @retval None
  */
 static void MX_SPI1_Init(void)
  * @retval None
  */
 static void MX_GPIO_Init(void)
+{
   GPIO_InitTypeDef GPIO_InitStruct = {0};
+  /* USER CODE BEGIN MX_GPIO_Init_1 */
+  /* USER CODE END MX_GPIO_Init_1 */
   /* GPIO Ports Clock Enable */
   __HAL_RCC_GPIOC_CLK_ENABLE();
   __HAL_RCC_GPIOD_CLK_ENABLE();
   __HAL_RCC_GPIOA_CLK_ENABLE();
   /*Configure GPIO pin : STARTER_ON_Pin */
   GPIO_InitStruct.Pin = STARTER_ON_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   HAL_GPIO_Init(STARTER_ON_GPIO_Port, &GPIO_InitStruct);
+  /* USER CODE BEGIN MX_GPIO_Init_2 */
+  /* USER CODE END MX_GPIO_Init_2 */
+}
 /* USER CODE BEGIN 4 */
 /* USER CODE END 4 */

Subversion Repositories EngineBay2

(root)/branches/stm32f103/Core/Src/main.c – Rev 52 → 53