WebSVN – EngineBay2 – Diff – /trunk/Src/main.c

 // with a dwell angle of 45 degrees , 4 cylinders and a maximum RPM of 5000
 // freq = 5000/60 * 2 = 166Hz. Because the breaker might bounce , we accept the first pulse longer than 1/300 of a second as being a proper closure .
 // the TIM2 counter counts in 10uS increments,
 #define BREAKER_MIN (RPM_COUNT_RATE/300)
+#define STARTER_LIMIT 5
 volatile char TimerFlag = 0;
 volatile char NoSerialInCTR = 0; // Missing characters coming in on USART1
 volatile char NoSerialIn = 0;
 unsigned int Coded_RPM = 0;
 unsigned int Coded_CHT = 0;
 uint32_t Power_CHT_Timer;
+uint16_t Starter_Debounce = 0;
 /* USER CODE END PV */
 /* Private function prototypes -----------------------------------------------*/
 void SystemClock_Config(void);
 void Error_Handler(void);
 // 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
 //
-GPIO_PinState CHT_Enable = GPIO_PIN_SET;
+FunctionalState CHT_Enable = ENABLE;
 uint8_t CHT_Timer[2] =
 { 0, 0 }; // two temperature readings
-uint8_t CHT_Observations[2] =
+uint16_t CHT_Observations[2] =
 { 0, 0 };
 void ProcessCHT(int instance)
+{
         uint8_t buffer[2];
         if (instance > 2)
                 return;
         CHT_Timer[instance]++;
-        if ((CHT_Enable == GPIO_PIN_SET) && (CHT_Timer[instance] >= 4)) // every 300 milliseconds
+        if ((CHT_Enable == ENABLE) && (CHT_Timer[instance] >= 4)) // every 300 milliseconds
+        {
                 CHT_Timer[instance] = 0;
                 uint16_t Pin = (instance == 0) ? SPI_NS_Temp_Pin : SPI_NS_Temp2_Pin;
                 HAL_GPIO_WritePin(SPI_NS_Temp_GPIO_Port, Pin, GPIO_PIN_SET);
                 uint16_t obs = (buffer[0] << 8) | buffer[1];
                 uint8_t good = (obs & 4) == 0;
                 if (good)
+                {
                         CHT_Observations[instance] = obs >> 5;
+                }
-                else
-                {
-                        CHT_Observations[instance] = 1024; // signal fail
-                }
+        }
         plx_sendword(PLX_X_CHT);
         PutCharSerial(&uc1, instance);
         plx_sendword(CHT_Observations[instance]);
+}
-void EnableCHT(GPIO_PinState state)
+void EnableCHT(FunctionalState state)
+{
         GPIO_InitTypeDef GPIO_InitStruct;
         CHT_Enable = state;
-        HAL_GPIO_WritePin(ENA_AUX_5V_GPIO_Port, ENA_AUX_5V_Pin, state);
-        /* drive the NSS to high if the interface is enabled */
         /* enable SPI in live mode : assume it and its GPIOs are already initialised in SPI mode */
-        if (state == GPIO_PIN_SET)
+        if (state == ENABLE)
+        {
+                HAL_GPIO_WritePin(ENA_AUX_5V_GPIO_Port, ENA_AUX_5V_Pin, GPIO_PIN_SET );
                 HAL_GPIO_WritePin(SPI_NS_Temp_GPIO_Port, SPI_NS_Temp_Pin, GPIO_PIN_SET);
                 HAL_GPIO_WritePin(SPI_NS_Temp2_GPIO_Port, SPI_NS_Temp2_Pin,
                                 GPIO_PIN_SET);
                 /* put the SPI pins back into SPI AF mode */
+        }
         else
+        {
                 /*  Power down the SPI interface taking signals all low */
+                HAL_GPIO_WritePin(ENA_AUX_5V_GPIO_Port, ENA_AUX_5V_Pin, GPIO_PIN_RESET );
                 HAL_GPIO_WritePin(SPI_NS_Temp_GPIO_Port, SPI_NS_Temp_Pin,
                                 GPIO_PIN_RESET);
                 HAL_GPIO_WritePin(SPI_NS_Temp2_GPIO_Port, SPI_NS_Temp2_Pin,
                                 GPIO_PIN_RESET);
 uint32_t ADC_VREF_MV = 3300;           // 3.300V typical
 const uint16_t STM32REF_MV = 1224;           // 1.224V typical
 void CalibrateADC(void)
+{
-        uint32_t adc_val = FILT_Samples[6];       // as set up in device config
+        uint32_t adc_val = FILT_Samples[5];       // as set up in device config
         ADC_VREF_MV = (STM32REF_MV * 4096) / adc_val;
+}
 void ProcessCPUTemperature(int instance)
+{
         int32_t temp_val;
-        uint16_t TS_CAL30 = *(uint16_t *) 0x1FF8007A; /* ADC reading for temperature sensor at 30 degrees C with Vref = 3000mV */
+        uint16_t TS_CAL30 = *(uint16_t *) (0x1FF8007AUL); /* ADC reading for temperature sensor at 30 degrees C with Vref = 3000mV */
-        uint16_t TS_CAL110 = *(uint16_t *) 0x1FF8007E; /* ADC reading for temperature sensor at 110 degrees C with Vref = 3000mV */
+        uint16_t TS_CAL110 = *(uint16_t *) (0x1FF8007EUL); /* ADC reading for temperature sensor at 110 degrees C with Vref = 3000mV */
         /* get the ADC reading corresponding to ADC channel 16 after turning on the ADC */
         temp_val = FILT_Samples[5];
         /* renormalise temperature value to account for different ADC Vref  : normalise to that which we would get for a 3000mV reference */
-        temp_val = temp_val * ADC_VREF_MV / 3000UL;
+        temp_val = temp_val * ADC_VREF_MV / (Scale * 3000UL);
         int32_t result = 800 * ((int32_t) temp_val - TS_CAL30);
         result = result / (TS_CAL110 - TS_CAL30) + 300;
         if (result < 0)
                 if (HAL_GetTick() > Ticks)
+                {
                         Ticks += 100;
                         filter_ADC_samples();
                         // delay to calibrate ADC
-                        if (CalCounter < 500)
+                        if (CalCounter < 1000)
+                        {
                                 CalCounter += 100;
+                        }
-                        if (CalCounter == 400)
+                        if (CalCounter == 900)
+                        {
                                 CalibrateADC();
+                        }
+                }
                 /* when the starter motor is on then power down the CHT sensors as they seem to fail */
                 if (HAL_GPIO_ReadPin(STARTER_ON_GPIO_Port, STARTER_ON_Pin)
-                                == GPIO_PIN_RESET)
+                                        == GPIO_PIN_RESET )
+                {
+                        if(Starter_Debounce < STARTER_LIMIT)
+                        {
+                                Starter_Debounce++;
+                        }
+                }
+                else
+                {
+                        if(Starter_Debounce > 0)
+                        {
+                                Starter_Debounce --;
+                        }
+                }
+                if (Starter_Debounce == STARTER_LIMIT)
+                {
-                        EnableCHT(GPIO_PIN_RESET);
+                        EnableCHT(DISABLE);
                         Power_CHT_Timer = HAL_GetTick() + 5000;
+                }
                 else
                 /* if the Power_CHT_Timer is set then wait for it to timeout, then power up CHT */
+                {
                         if ((Power_CHT_Timer > 0) && (HAL_GetTick() > Power_CHT_Timer))
+                        {
-                                EnableCHT(GPIO_PIN_SET);
+                                EnableCHT(ENABLE);
                                 Power_CHT_Timer = 0;
+                        }
+                }
                 // check to see if we have any incoming data, copy and append if so, if no data then create our own frames.
   hspi1.Instance = SPI1;
   hspi1.Init.Mode = SPI_MODE_MASTER;
   hspi1.Init.Direction = SPI_DIRECTION_2LINES;
   hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
-  hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
+  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
   hspi1.Init.NSS = SPI_NSS_SOFT;
   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;

Subversion Repositories EngineBay2

(root)/trunk/Src/main.c – Rev 20 → 21