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



void
ProcessRPM (int instance)
{
// compute the timer values
// snapshot timers
   unsigned short RPM_Pulsewidth;
  // current RPM pulse next slot index
  unsigned short RPM_Count_Val;
  __disable_irq (); // copy the counter value
  RPM_Count_Val = RPM_Count;
  __enable_irq ();
// do calculations
// if there is only one entry, cannot get difference

          unsigned int next_count = (RPM_Count_Latch + 1) % RPM_SAMPLES;
          if (next_count == RPM_Count_Val)
            {
              break; // completed loop
            }
          char pulse_level = RPM_Level[RPM_Count_Latch];
          base_time = RPM_Time[RPM_Count_Latch];
          new_time = RPM_Time[next_count];
          RPM_Count_Latch = next_count;
 
          RPM_Pulsewidth = new_time - base_time; // not wrapped
 
          // if the pulse was low,
          if (pulse_level == 0 && RPM_Pulsewidth > BREAKER_MIN)
            {
 
              RPM_Diff = new_time - last_dwell_end;
 
              RPM_Period[RPM_Period_Ptr] = RPM_Diff;

 
  // initialise all the STMCubeMX stuff
  HAL_TIM_Base_MspInit (&htim2);
  // Start the counter
  HAL_TIM_Base_Start (&htim2);
  // Start the input capture and the rising edge interrupt
  HAL_TIM_IC_Start_IT (&htim2, TIM_CHANNEL_1);
  // Start the input capture and the falling edge interrupt
  HAL_TIM_IC_Start_IT (&htim2, TIM_CHANNEL_2);
 
  HAL_TIM_Base_MspInit (&htim3);
  __HAL_TIM_ENABLE_IT(&htim3, TIM_IT_UPDATE);
  uint32_t Ticks = HAL_GetTick () + 100;
  int CalCounter = 0;

  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  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)

 
  /* USER CODE BEGIN TIM2_Init 1 */
 
  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 719;
  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)

  sConfigIC.ICFilter = 15;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */
 
  /* USER CODE END TIM2_Init 2 */
 
}

 
  /* USER CODE BEGIN TIM3_Init 1 */
 
  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 719;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 199;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();

  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_TIMING;
  sConfigOC.Pulse = 198;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_OC_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();

 
  /* USER CODE BEGIN TIM4_Init 1 */
 
  /* USER CODE END TIM4_Init 1 */
  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 719;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 9999;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)

Rev 40	Rev 41
Line 197...	Line 197...
197	void	197	void
198	ProcessRPM (int instance)	198	ProcessRPM (int instance)
199	{	199	{
200	// compute the timer values	200	// compute the timer values
201	// snapshot timers	201	// snapshot timers
202	unsigned long RPM_Pulsewidth;	202	unsigned short RPM_Pulsewidth;
203	// current RPM pulse next slot index	203	// current RPM pulse next slot index
204	unsigned long RPM_Count_Val;	204	unsigned short RPM_Count_Val;
205	__disable_irq (); // copy the counter value	205	__disable_irq (); // copy the counter value
206	RPM_Count_Val = RPM_Count;	206	RPM_Count_Val = RPM_Count;
207	__enable_irq ();	207	__enable_irq ();
208	// do calculations	208	// do calculations
209	// if there is only one entry, cannot get difference	209	// if there is only one entry, cannot get difference
Line 217...	Line 217...
217	unsigned int next_count = (RPM_Count_Latch + 1) % RPM_SAMPLES;	217	unsigned int next_count = (RPM_Count_Latch + 1) % RPM_SAMPLES;
218	if (next_count == RPM_Count_Val)	218	if (next_count == RPM_Count_Val)
219	{	219	{
220	break; // completed loop	220	break; // completed loop
221	}	221	}
-		222	char pulse_level = RPM_Level[RPM_Count_Latch];
222	base_time = RPM_Time[RPM_Count_Latch];	223	base_time = RPM_Time[RPM_Count_Latch];
223	new_time = RPM_Time[next_count];	224	new_time = RPM_Time[next_count];
224	RPM_Count_Latch = next_count;	225	RPM_Count_Latch = next_count;
225		226
226	RPM_Pulsewidth = new_time - base_time; // not wrapped	227	RPM_Pulsewidth = new_time - base_time; // not wrapped
227		228
-		229	// if the pulse was low,
228	if (RPM_Pulsewidth > BREAKER_MIN)	230	if (pulse_level == 0 && RPM_Pulsewidth > BREAKER_MIN)
229	{	231	{
230		232
231	RPM_Diff = new_time - last_dwell_end;	233	RPM_Diff = new_time - last_dwell_end;
232		234
233	RPM_Period[RPM_Period_Ptr] = RPM_Diff;	235	RPM_Period[RPM_Period_Ptr] = RPM_Diff;
Line 495...	Line 497...
495		497
496	// initialise all the STMCubeMX stuff	498	// initialise all the STMCubeMX stuff
497	HAL_TIM_Base_MspInit (&htim2);	499	HAL_TIM_Base_MspInit (&htim2);
498	// Start the counter	500	// Start the counter
499	HAL_TIM_Base_Start (&htim2);	501	HAL_TIM_Base_Start (&htim2);
500	// Start the input capture and the interrupt	502	// Start the input capture and the rising edge interrupt
501	HAL_TIM_IC_Start_IT (&htim2, TIM_CHANNEL_1);	503	HAL_TIM_IC_Start_IT (&htim2, TIM_CHANNEL_1);
-		504	// Start the input capture and the falling edge interrupt
-		505	HAL_TIM_IC_Start_IT (&htim2, TIM_CHANNEL_2);
502		506
503	HAL_TIM_Base_MspInit (&htim3);	507	HAL_TIM_Base_MspInit (&htim3);
504	__HAL_TIM_ENABLE_IT(&htim3, TIM_IT_UPDATE);	508	__HAL_TIM_ENABLE_IT(&htim3, TIM_IT_UPDATE);
505	uint32_t Ticks = HAL_GetTick () + 100;	509	uint32_t Ticks = HAL_GetTick () + 100;
506	int CalCounter = 0;	510	int CalCounter = 0;
Line 813...	Line 817...
813	hspi1.Init.Direction = SPI_DIRECTION_2LINES;	817	hspi1.Init.Direction = SPI_DIRECTION_2LINES;
814	hspi1.Init.DataSize = SPI_DATASIZE_8BIT;	818	hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
815	hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;	819	hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
816	hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;	820	hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
817	hspi1.Init.NSS = SPI_NSS_SOFT;	821	hspi1.Init.NSS = SPI_NSS_SOFT;
818	hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;	822	hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
819	hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;	823	hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
820	hspi1.Init.TIMode = SPI_TIMODE_DISABLE;	824	hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
821	hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;	825	hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
822	hspi1.Init.CRCPolynomial = 10;	826	hspi1.Init.CRCPolynomial = 10;
823	if (HAL_SPI_Init(&hspi1) != HAL_OK)	827	if (HAL_SPI_Init(&hspi1) != HAL_OK)
Line 848...	Line 852...
848		852
849	/* USER CODE BEGIN TIM2_Init 1 */	853	/* USER CODE BEGIN TIM2_Init 1 */
850		854
851	/* USER CODE END TIM2_Init 1 */	855	/* USER CODE END TIM2_Init 1 */
852	htim2.Instance = TIM2;	856	htim2.Instance = TIM2;
853	htim2.Init.Prescaler = 359;	857	htim2.Init.Prescaler = 719;
854	htim2.Init.CounterMode = TIM_COUNTERMODE_UP;	858	htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
855	htim2.Init.Period = 65535;	859	htim2.Init.Period = 65535;
856	htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;	860	htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
857	htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;	861	htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
858	if (HAL_TIM_Base_Init(&htim2) != HAL_OK)	862	if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
Line 880...	Line 884...
880	sConfigIC.ICFilter = 15;	884	sConfigIC.ICFilter = 15;
881	if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)	885	if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
882	{	886	{
883	Error_Handler();	887	Error_Handler();
884	}	888	}
-		889	sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
-		890	sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
-		891	sConfigIC.ICFilter = 0;
-		892	if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
-		893	{
-		894	Error_Handler();
-		895	}
885	/* USER CODE BEGIN TIM2_Init 2 */	896	/* USER CODE BEGIN TIM2_Init 2 */
886		897
887	/* USER CODE END TIM2_Init 2 */	898	/* USER CODE END TIM2_Init 2 */
888		899
889	}	900	}
Line 906...	Line 917...
906		917
907	/* USER CODE BEGIN TIM3_Init 1 */	918	/* USER CODE BEGIN TIM3_Init 1 */
908		919
909	/* USER CODE END TIM3_Init 1 */	920	/* USER CODE END TIM3_Init 1 */
910	htim3.Instance = TIM3;	921	htim3.Instance = TIM3;
911	htim3.Init.Prescaler = 359;	922	htim3.Init.Prescaler = 719;
912	htim3.Init.CounterMode = TIM_COUNTERMODE_UP;	923	htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
913	htim3.Init.Period = 99;	924	htim3.Init.Period = 199;
914	htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;	925	htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
915	htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;	926	htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
916	if (HAL_TIM_Base_Init(&htim3) != HAL_OK)	927	if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
917	{	928	{
918	Error_Handler();	929	Error_Handler();
Line 935...	Line 946...
935	if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)	946	if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
936	{	947	{
937	Error_Handler();	948	Error_Handler();
938	}	949	}
939	sConfigOC.OCMode = TIM_OCMODE_TIMING;	950	sConfigOC.OCMode = TIM_OCMODE_TIMING;
940	sConfigOC.Pulse = 98;	951	sConfigOC.Pulse = 198;
941	sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;	952	sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
942	sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;	953	sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
943	if (HAL_TIM_OC_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)	954	if (HAL_TIM_OC_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
944	{	955	{
945	Error_Handler();	956	Error_Handler();
Line 967...	Line 978...
967		978
968	/* USER CODE BEGIN TIM4_Init 1 */	979	/* USER CODE BEGIN TIM4_Init 1 */
969		980
970	/* USER CODE END TIM4_Init 1 */	981	/* USER CODE END TIM4_Init 1 */
971	htim4.Instance = TIM4;	982	htim4.Instance = TIM4;
972	htim4.Init.Prescaler = 359;	983	htim4.Init.Prescaler = 719;
973	htim4.Init.CounterMode = TIM_COUNTERMODE_UP;	984	htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
974	htim4.Init.Period = 9999;	985	htim4.Init.Period = 9999;
975	htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;	986	htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
976	htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;	987	htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
977	if (HAL_TIM_Base_Init(&htim4) != HAL_OK)	988	if (HAL_TIM_Base_Init(&htim4) != HAL_OK)

Subversion Repositories EngineBay2

(root)/branches/stm32f103/Core/Src/main.c – Rev 40 → 41