Changeset 23 for trunk/firmware_v2/Core


Ignore:
Timestamp:
Aug 21, 2025, 3:14:57 PM (6 days ago)
Author:
f.jahn
Message:

Änderung neuer Controller mit mehr Speicher

Location:
trunk/firmware_v2/Core
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/firmware_v2/Core/Inc/main.h

    r17 r23  
    4747#define BLINK_CODE_ERROR_FAULT_INPUT    3       
    4848#define BLINK_CODE_ERROR_VOLTAGE_DROP   4
    49 
     49#define BLINK_CODE_ERROR_TEMP                   5
    5050
    5151
    … …  
    5656#define LED_RT_ON_TIME_WARN_OVP_AND_LVP_INPUT 200
    5757#define LED_RT_ON_TIME_WARN_VOLTAGE_DROP          200
     58#define LED_RT_ON_TIME_WARN_TEMP                          200
    5859
    5960#define LED_GN_OFF_TIME                       1000

  • trunk/firmware_v2/Core/Inc/stm32c0xx_it.h

    r20 r23  
    5353void SysTick_Handler(void);
    5454void DMA1_Channel1_IRQHandler(void);
    55 void DMA1_Channel2_3_IRQHandler(void);
    56 void TIM3_IRQHandler(void);
     55void TIM16_IRQHandler(void);
    5756/* USER CODE BEGIN EFP */
    5857

  • trunk/firmware_v2/Core/Inc/tim.h

    r20 r23  
    3333/* USER CODE END Includes */
    3434
    35 extern TIM_HandleTypeDef htim3;
     35extern TIM_HandleTypeDef htim16;
    3636
    3737extern TIM_HandleTypeDef htim17;
    … …  
    3939/* USER CODE BEGIN Private defines */
    4040
     41#define STATE_NUM       (3U)
     42
    4143/* USER CODE END Private defines */
    4244
    43 void MX_TIM3_Init(void);
     45void MX_TIM16_Init(void);
    4446void MX_TIM17_Init(void);
    4547
    … …  
    4850/* USER CODE BEGIN Prototypes */
    4951
    50 void SetFANSpeed(unsigned speed);
     52void SetFANSpeed(unsigned speed);                 // Von 0 bis 100
     53unsigned GetLastSpeed(void);
    5154
    5255/* USER CODE END Prototypes */

  • trunk/firmware_v2/Core/Src/dma.c

    r19 r23  
    4747  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
    4848  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
    49   /* DMA1_Channel2_3_IRQn interrupt configuration */
    50   HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
    51   HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
    5249
    5350}

  • trunk/firmware_v2/Core/Src/main.c

    r20 r23  
    9595  MX_TIM17_Init();
    9696  MX_USART1_UART_Init();
    97   MX_TIM3_Init();
     97  MX_TIM16_Init();
    9898  /* USER CODE BEGIN 2 */
    9999

  • trunk/firmware_v2/Core/Src/stm32c0xx_it.c

    r22 r23  
    2626#include <stdio.h>
    2727
     28#include "tim.h"
     29
    2830/* USER CODE END Includes */
    2931
    … …  
    6062/* External variables --------------------------------------------------------*/
    6163extern DMA_HandleTypeDef hdma_adc1;
    62 extern DMA_HandleTypeDef hdma_tim3_ch1;
    63 extern TIM_HandleTypeDef htim3;
     64extern TIM_HandleTypeDef htim16;
    6465/* USER CODE BEGIN EV */
    6566
    … …  
    161162
    162163/**
    163   * @brief This function handles DMA1 channel 2 and channel 3 interrupts.
    164   */
    165 void DMA1_Channel2_3_IRQHandler(void)
    166 {
    167   /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */
    168 
    169   /* USER CODE END DMA1_Channel2_3_IRQn 0 */
    170   HAL_DMA_IRQHandler(&hdma_tim3_ch1);
    171   /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */
    172 
    173   /* USER CODE END DMA1_Channel2_3_IRQn 1 */
    174 }
    175 
    176 /**
    177   * @brief This function handles TIM3 global interrupt.
    178   */
    179 void TIM3_IRQHandler(void)
    180 {
    181   /* USER CODE BEGIN TIM3_IRQn 0 */
    182 
    183   /* USER CODE END TIM3_IRQn 0 */
    184   HAL_TIM_IRQHandler(&htim3);
    185   /* USER CODE BEGIN TIM3_IRQn 1 */
    186 
    187   /* USER CODE END TIM3_IRQn 1 */
     164  * @brief This function handles TIM16 global interrupt.
     165  */
     166void TIM16_IRQHandler(void)
     167{
     168  /* USER CODE BEGIN TIM16_IRQn 0 */
     169
     170  /* USER CODE END TIM16_IRQn 0 */
     171  HAL_TIM_IRQHandler(&htim16);
     172  /* USER CODE BEGIN TIM16_IRQn 1 */
     173
     174  /* USER CODE END TIM16_IRQn 1 */
    188175}
    189176
    190177/* USER CODE BEGIN 1 */
    191178
    192 
    193 
    194 //uint32_t capturedValue;
    195 //uint32_t previousCaptureValue;
    196 //uint32_t frequency;
    197 //uint32_t overflowCnt;
    198 //uint32_t T[STATE_NUM];
    199 
    200 //static uint32_t avg;
    201 //static uint32_t psc;
    202 //static uint32_t freq;
    203 //static uint32_t rpm;
    204 
    205 
    206179void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef* htim)
    207180{
    208         extern uint32_t ic_overflows;
    209 
    210         if (htim->Instance == TIM3)
     181        extern uint32_t ic_overflows, freq;
     182        extern uint32_t period[STATE_NUM];
     183
     184        if (htim->Instance == TIM16)
    211185        {
    212                 printf("Full\n");
     186                static unsigned state;
     187               
     188                period[state] = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1) + 65536 * ic_overflows;
     189                //__HAL_TIM_SetCounter(htim, 0U);
    213190                ic_overflows = 0U;
    214                 /*static unsigned stateCnt;
    215  
    216                 capturedValue = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
    217                 T[stateCnt++] = capturedValue + 65536U * overflowCnt;
    218                 overflowCnt = 0U;
    219                
    220                 if (stateCnt >= STATE_NUM - 1)
     191                state++;
     192                if (state >= STATE_NUM)
    221193                {
    222                         static uint32_t i;
    223 
    224                         ibuf[i++] = T[0] + T[1] + T[2] + T[3];
    225 
    226                         if (i >= AVG_NUM)
    227                         {
    228                                 uint32_t sum = 0U;
    229                                 for (unsigned j = 0U; j < AVG_NUM; j++) sum += ibuf[j];
    230                                 avg = sum / AVG_NUM;
    231                                 psc = htim->Instance->PSC + 1;
    232                                 freq = HAL_RCC_GetPCLK1Freq() / (psc * avg);
    233                                 rpm = freq * 60U;
    234                                 printf("%u\n", rpm);
    235                         }
    236 
    237                         stateCnt = 0U;
    238                 }*/
    239         }
    240 }
    241 
    242 //-----------------------------------------------------------------------------
    243 
    244 void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim)
    245 {
    246         extern uint32_t ic_overflows;
    247 
    248         if (htim->Instance == TIM3)
    249         {
    250                 if (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1OF))
    251                 {
    252                         ic_overflows++;
    253                         //printf("Ovf\n");
    254                         //ic_overflows %=
     194                        state = 0;
     195                        HAL_TIM_Base_Stop_IT(htim);
     196                        HAL_TIM_IC_Stop_IT(htim, TIM_CHANNEL_1);
     197                        uint32_t timerClock_Hz = HAL_RCC_GetPCLK1Freq();
     198                        uint32_t icClock_Hz = timerClock_Hz / (htim->Instance->PSC + 1);
     199                        freq = (icClock_Hz * 30U) / (period[2] - period[1]);
    255200                }
    256201        }
    … …  
    259204//-----------------------------------------------------------------------------
    260205
    261 void HAL_TIM_IC_CaptureHalfCpltCallback(TIM_HandleTypeDef *htim)
    262 {
    263         extern uint32_t ic_overflows;
    264 
    265         if (htim->Instance == TIM3)
     206void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim)
     207{
     208        extern uint32_t ic_overflows, freq;
     209
     210        if (htim->Instance == TIM16)
    266211        {
    267                 printf("Half\n");
    268                 ic_overflows = 0U;
     212                ic_overflows++;
     213                if (ic_overflows > 10U) freq = 0;
    269214        }
    270215}

  • trunk/firmware_v2/Core/Src/tim.c

    r22 r23  
    2323/* USER CODE BEGIN 0 */
    2424
    25 #define STATE_NUM       (2U)
    26 #define AVG_NUM         (8U)
    27 
    28 uint16_t ic_buf[AVG_NUM][STATE_NUM];
     25#include <stdio.h>
     26
     27uint32_t period[STATE_NUM];
     28uint32_t freq;
    2929uint32_t ic_overflows;
    3030
    3131/* USER CODE END 0 */
    3232
    33 TIM_HandleTypeDef htim3;
     33TIM_HandleTypeDef htim16;
    3434TIM_HandleTypeDef htim17;
    35 DMA_HandleTypeDef hdma_tim3_ch1;
    36 
    37 /* TIM3 init function */
    38 void MX_TIM3_Init(void)
    39 {
    40 
    41   /* USER CODE BEGIN TIM3_Init 0 */
    42 
    43   /* USER CODE END TIM3_Init 0 */
    44 
    45   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    46   TIM_SlaveConfigTypeDef sSlaveConfig = {0};
    47   TIM_MasterConfigTypeDef sMasterConfig = {0};
     35
     36/* TIM16 init function */
     37void MX_TIM16_Init(void)
     38{
     39
     40  /* USER CODE BEGIN TIM16_Init 0 */
     41
     42  /* USER CODE END TIM16_Init 0 */
     43
    4844  TIM_IC_InitTypeDef sConfigIC = {0};
    4945
    50   /* USER CODE BEGIN TIM3_Init 1 */
    51 
    52   /* USER CODE END TIM3_Init 1 */
    53   htim3.Instance = TIM3;
    54   htim3.Init.Prescaler = 1;
    55   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    56   htim3.Init.Period = 65535;
    57   htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    58   htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    59   if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
    60   {
    61     Error_Handler();
    62   }
    63   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    64   if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
    65   {
    66     Error_Handler();
    67   }
    68   if (HAL_TIM_IC_Init(&htim3) != HAL_OK)
    69   {
    70     Error_Handler();
    71   }
    72   sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
    73   sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
    74   sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
    75   sSlaveConfig.TriggerFilter = 0;
    76   if (HAL_TIM_SlaveConfigSynchro(&htim3, &sSlaveConfig) != HAL_OK)
    77   {
    78     Error_Handler();
    79   }
    80   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    81   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
    82   if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
     46  /* USER CODE BEGIN TIM16_Init 1 */
     47
     48  /* USER CODE END TIM16_Init 1 */
     49  htim16.Instance = TIM16;
     50  htim16.Init.Prescaler = 23;
     51  htim16.Init.CounterMode = TIM_COUNTERMODE_UP;
     52  htim16.Init.Period = 65535;
     53  htim16.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     54  htim16.Init.RepetitionCounter = 0;
     55  htim16.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
     56  if (HAL_TIM_Base_Init(&htim16) != HAL_OK)
     57  {
     58    Error_Handler();
     59  }
     60  if (HAL_TIM_IC_Init(&htim16) != HAL_OK)
    8361  {
    8462    Error_Handler();
    … …  
    8866  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
    8967  sConfigIC.ICFilter = 0;
    90   if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
    91   {
    92     Error_Handler();
    93   }
    94   /* USER CODE BEGIN TIM3_Init 2 */
    95 
    96   __HAL_TIM_ENABLE_IT(&htim3, TIM_IT_UPDATE);
    97   HAL_TIM_IC_Start_DMA(&htim3, TIM_CHANNEL_1, (uint32_t*)ic_buf, STATE_NUM * AVG_NUM);
    98 
    99   /* USER CODE END TIM3_Init 2 */
     68  if (HAL_TIM_IC_ConfigChannel(&htim16, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
     69  {
     70    Error_Handler();
     71  }
     72  /* USER CODE BEGIN TIM16_Init 2 */
     73
     74  /* USER CODE END TIM16_Init 2 */
    10075
    10176}
    … …  
    132107  }
    133108  sConfigOC.OCMode = TIM_OCMODE_PWM1;
    134   sConfigOC.Pulse = 64;
     109  sConfigOC.Pulse = 0;
    135110  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
    136111  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
    … …  
    167142
    168143  GPIO_InitTypeDef GPIO_InitStruct = {0};
    169   if(tim_baseHandle->Instance==TIM3)
    170   {
    171   /* USER CODE BEGIN TIM3_MspInit 0 */
    172 
    173   /* USER CODE END TIM3_MspInit 0 */
    174     /* TIM3 clock enable */
    175     __HAL_RCC_TIM3_CLK_ENABLE();
     144  if(tim_baseHandle->Instance==TIM16)
     145  {
     146  /* USER CODE BEGIN TIM16_MspInit 0 */
     147
     148  /* USER CODE END TIM16_MspInit 0 */
     149    /* TIM16 clock enable */
     150    __HAL_RCC_TIM16_CLK_ENABLE();
    176151
    177152    __HAL_RCC_GPIOA_CLK_ENABLE();
    178     /**TIM3 GPIO Configuration
    179     PA6     ------> TIM3_CH1
     153    /**TIM16 GPIO Configuration
     154    PA6     ------> TIM16_CH1
    180155    */
    181156    GPIO_InitStruct.Pin = FAN_TACHO_Pin;
    … …  
    183158    GPIO_InitStruct.Pull = GPIO_PULLUP;
    184159    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    185     GPIO_InitStruct.Alternate = GPIO_AF1_TIM3;
     160    GPIO_InitStruct.Alternate = GPIO_AF5_TIM16;
    186161    HAL_GPIO_Init(FAN_TACHO_GPIO_Port, &GPIO_InitStruct);
    187162
    188     /* TIM3 DMA Init */
    189     /* TIM3_CH1 Init */
    190     hdma_tim3_ch1.Instance = DMA1_Channel2;
    191     hdma_tim3_ch1.Init.Request = DMA_REQUEST_TIM3_CH1;
    192     hdma_tim3_ch1.Init.Direction = DMA_PERIPH_TO_MEMORY;
    193     hdma_tim3_ch1.Init.PeriphInc = DMA_PINC_DISABLE;
    194     hdma_tim3_ch1.Init.MemInc = DMA_MINC_ENABLE;
    195     hdma_tim3_ch1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    196     hdma_tim3_ch1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
    197     hdma_tim3_ch1.Init.Mode = DMA_CIRCULAR;
    198     hdma_tim3_ch1.Init.Priority = DMA_PRIORITY_LOW;
    199     if (HAL_DMA_Init(&hdma_tim3_ch1) != HAL_OK)
    200     {
    201       Error_Handler();
    202     }
    203 
    204     __HAL_LINKDMA(tim_baseHandle,hdma[TIM_DMA_ID_CC1],hdma_tim3_ch1);
    205 
    206     /* TIM3 interrupt Init */
    207     HAL_NVIC_SetPriority(TIM3_IRQn, 0, 0);
    208     HAL_NVIC_EnableIRQ(TIM3_IRQn);
    209   /* USER CODE BEGIN TIM3_MspInit 1 */
    210 
    211   /* USER CODE END TIM3_MspInit 1 */
     163    /* TIM16 interrupt Init */
     164    HAL_NVIC_SetPriority(TIM16_IRQn, 0, 0);
     165    HAL_NVIC_EnableIRQ(TIM16_IRQn);
     166  /* USER CODE BEGIN TIM16_MspInit 1 */
     167
     168  /* USER CODE END TIM16_MspInit 1 */
    212169  }
    213170  else if(tim_baseHandle->Instance==TIM17)
    … …  
    256213{
    257214
    258   if(tim_baseHandle->Instance==TIM3)
    259   {
    260   /* USER CODE BEGIN TIM3_MspDeInit 0 */
    261 
    262   /* USER CODE END TIM3_MspDeInit 0 */
     215  if(tim_baseHandle->Instance==TIM16)
     216  {
     217  /* USER CODE BEGIN TIM16_MspDeInit 0 */
     218
     219  /* USER CODE END TIM16_MspDeInit 0 */
    263220    /* Peripheral clock disable */
    264     __HAL_RCC_TIM3_CLK_DISABLE();
    265 
    266     /**TIM3 GPIO Configuration
    267     PA6     ------> TIM3_CH1
     221    __HAL_RCC_TIM16_CLK_DISABLE();
     222
     223    /**TIM16 GPIO Configuration
     224    PA6     ------> TIM16_CH1
    268225    */
    269226    HAL_GPIO_DeInit(FAN_TACHO_GPIO_Port, FAN_TACHO_Pin);
    270227
    271     /* TIM3 DMA DeInit */
    272     HAL_DMA_DeInit(tim_baseHandle->hdma[TIM_DMA_ID_CC1]);
    273 
    274     /* TIM3 interrupt Deinit */
    275     HAL_NVIC_DisableIRQ(TIM3_IRQn);
    276   /* USER CODE BEGIN TIM3_MspDeInit 1 */
    277 
    278   /* USER CODE END TIM3_MspDeInit 1 */
     228    /* TIM16 interrupt Deinit */
     229    HAL_NVIC_DisableIRQ(TIM16_IRQn);
     230  /* USER CODE BEGIN TIM16_MspDeInit 1 */
     231
     232  /* USER CODE END TIM16_MspDeInit 1 */
    279233  }
    280234  else if(tim_baseHandle->Instance==TIM17)
    … …  
    293247/* USER CODE BEGIN 1 */
    294248
     249static unsigned lastSpeed;
     250
    295251void SetFANSpeed(unsigned speed)
    296252{
    297         const unsigned MAX_RPM = 1000U;                                                                                 // 100.0%
     253        const unsigned MAX_RPM = 100U;                                                                                  // 100.0%
    298254
    299255        if (speed > MAX_RPM) speed = MAX_RPM;
    300256
    301         const unsigned MAX_PWM = __HAL_TIM_GET_AUTORELOAD(&htim17);
     257        lastSpeed = speed;
     258
     259        const unsigned MAX_PWM = __HAL_TIM_GET_AUTORELOAD(&htim17) + 1U;
     260        //printf("%u", MAX_PWM);
    302261        const unsigned newPWM = (MAX_PWM * speed/ MAX_RPM);
    303262
    … …  
    305264}
    306265
     266//-----------------------------------------------------------------------------
     267
     268unsigned GetLastSpeed(void)
     269{
     270        return lastSpeed;
     271}
     272
    307273/* USER CODE END 1 */
Note: See TracChangeset for help on using the changeset viewer.