You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
409 lines
7.3 KiB
409 lines
7.3 KiB
#include "chip_helper.hpp"
|
|
|
|
#include "cmsis_os.h"
|
|
#include "sdk\basic\logger.hpp"
|
|
extern "C" {
|
|
static uint8_t g_port_exit_critical_count;
|
|
|
|
void chip_critical_enter(void) { portENTER_CRITICAL(); }
|
|
void chip_critical_exit(void) { portEXIT_CRITICAL(); }
|
|
|
|
GPIO_TypeDef* chip_get_gpio(Pin_t pin) {
|
|
int port = pin >> 4;
|
|
|
|
switch (port) {
|
|
case (PA0 >> 4):
|
|
#ifdef GPIOA
|
|
return GPIOA;
|
|
#endif
|
|
break;
|
|
case (PB0 >> 4):
|
|
#ifdef GPIOB
|
|
return GPIOB;
|
|
#endif
|
|
break;
|
|
case (PC0 >> 4):
|
|
#ifdef GPIOC
|
|
return GPIOC;
|
|
#endif
|
|
break;
|
|
case (PD0 >> 4):
|
|
#ifdef GPIOD
|
|
return GPIOD;
|
|
#endif
|
|
break;
|
|
|
|
case (PE0 >> 4):
|
|
#ifdef GPIOE
|
|
return GPIOE;
|
|
#endif
|
|
break;
|
|
case (PF0 >> 4):
|
|
#ifdef GPIOF
|
|
return GPIOF;
|
|
#endif
|
|
break;
|
|
case (PG0 >> 4):
|
|
#ifdef GPIOG
|
|
return GPIOG;
|
|
#endif
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
uint16_t chip_get_pinoff(Pin_t pin) {
|
|
uint16_t pinoff = pin & 0x0F;
|
|
switch (pinoff) {
|
|
case 0:
|
|
return GPIO_PIN_0;
|
|
case 1:
|
|
return GPIO_PIN_1;
|
|
case 2:
|
|
return GPIO_PIN_2;
|
|
case 3:
|
|
return GPIO_PIN_3;
|
|
case 4:
|
|
return GPIO_PIN_4;
|
|
case 5:
|
|
return GPIO_PIN_5;
|
|
case 6:
|
|
return GPIO_PIN_6;
|
|
case 7:
|
|
return GPIO_PIN_7;
|
|
case 8:
|
|
return GPIO_PIN_8;
|
|
case 9:
|
|
return GPIO_PIN_9;
|
|
case 10:
|
|
return GPIO_PIN_10;
|
|
case 11:
|
|
return GPIO_PIN_11;
|
|
case 12:
|
|
return GPIO_PIN_12;
|
|
case 13:
|
|
return GPIO_PIN_13;
|
|
case 14:
|
|
return GPIO_PIN_14;
|
|
case 15:
|
|
return GPIO_PIN_15;
|
|
default:
|
|
break;
|
|
};
|
|
return 0;
|
|
}
|
|
|
|
// TIM2
|
|
// TIM3
|
|
// TIM4
|
|
// TIM5
|
|
// TIM6
|
|
// TIM7
|
|
// TIM12
|
|
// TIM13
|
|
// TIM14
|
|
// TIM1
|
|
// TIM8
|
|
// TIM9
|
|
// TIM10
|
|
// TIM11
|
|
// TIM_CR1_CEN_Pos
|
|
|
|
const char* chip_tim_get_name(TIM_TypeDef* tim) {
|
|
#ifdef TIM1
|
|
if (tim == TIM1) {
|
|
return "TIM1";
|
|
}
|
|
#endif
|
|
#ifdef TIM2
|
|
if (tim == TIM2) {
|
|
return "TIM2";
|
|
}
|
|
#endif
|
|
#ifdef TIM3
|
|
if (tim == TIM3) {
|
|
return "TIM3";
|
|
}
|
|
#endif
|
|
#ifdef TIM4
|
|
if (tim == TIM4) {
|
|
return "TIM4";
|
|
}
|
|
#endif
|
|
#ifdef TIM5
|
|
if (tim == TIM5) {
|
|
return "TIM5";
|
|
}
|
|
#endif
|
|
#ifdef TIM6
|
|
if (tim == TIM6) {
|
|
return "TIM6";
|
|
}
|
|
#endif
|
|
#ifdef TIM7
|
|
if (tim == TIM7) {
|
|
return "TIM7";
|
|
}
|
|
#endif
|
|
#ifdef TIM8
|
|
if (tim == TIM8) {
|
|
return "TIM8";
|
|
}
|
|
#endif
|
|
#ifdef TIM9
|
|
if (tim == TIM9) {
|
|
return "TIM9";
|
|
}
|
|
#endif
|
|
#ifdef TIM10
|
|
if (tim == TIM10) {
|
|
return "TIM10";
|
|
}
|
|
#endif
|
|
#ifdef TIM11
|
|
if (tim == TIM11) {
|
|
return "TIM11";
|
|
}
|
|
#endif
|
|
#ifdef TIM12
|
|
if (tim == TIM12) {
|
|
return "TIM12";
|
|
}
|
|
#endif
|
|
#ifdef TIM13
|
|
if (tim == TIM13) {
|
|
return "TIM13";
|
|
}
|
|
#endif
|
|
#ifdef TIM14
|
|
if (tim == TIM14) {
|
|
return "TIM14";
|
|
}
|
|
#endif
|
|
|
|
return "unknowntim";
|
|
}
|
|
|
|
const char* chip_gpio_group_get_name(GPIO_TypeDef* gpio_group) {
|
|
if (gpio_group == GPIOA) {
|
|
return "GPIOA";
|
|
}
|
|
if (gpio_group == GPIOB) {
|
|
return "GPIOB";
|
|
}
|
|
if (gpio_group == GPIOC) {
|
|
return "GPIOC";
|
|
}
|
|
if (gpio_group == GPIOD) {
|
|
return "GPIOD";
|
|
}
|
|
if (gpio_group == GPIOE) {
|
|
return "GPIOE";
|
|
}
|
|
if (gpio_group == GPIOF) {
|
|
return "GPIOF";
|
|
}
|
|
if (gpio_group == GPIOG) {
|
|
return "GPIOG";
|
|
}
|
|
return "unknown gpio group";
|
|
}
|
|
const char* chip_pinoff_get_name(uint16_t pinoff) {
|
|
if (pinoff == GPIO_PIN_0) {
|
|
return "0";
|
|
}
|
|
if (pinoff == GPIO_PIN_1) {
|
|
return "1";
|
|
}
|
|
if (pinoff == GPIO_PIN_2) {
|
|
return "2";
|
|
}
|
|
if (pinoff == GPIO_PIN_3) {
|
|
return "3";
|
|
}
|
|
if (pinoff == GPIO_PIN_4) {
|
|
return "4";
|
|
}
|
|
if (pinoff == GPIO_PIN_5) {
|
|
return "5";
|
|
}
|
|
if (pinoff == GPIO_PIN_6) {
|
|
return "6";
|
|
}
|
|
if (pinoff == GPIO_PIN_7) {
|
|
return "7";
|
|
}
|
|
if (pinoff == GPIO_PIN_8) {
|
|
return "8";
|
|
}
|
|
if (pinoff == GPIO_PIN_9) {
|
|
return "9";
|
|
}
|
|
if (pinoff == GPIO_PIN_10) {
|
|
return "10";
|
|
}
|
|
if (pinoff == GPIO_PIN_11) {
|
|
return "11";
|
|
}
|
|
if (pinoff == GPIO_PIN_12) {
|
|
return "12";
|
|
}
|
|
if (pinoff == GPIO_PIN_13) {
|
|
return "13";
|
|
}
|
|
if (pinoff == GPIO_PIN_14) {
|
|
return "14";
|
|
}
|
|
if (pinoff == GPIO_PIN_15) {
|
|
return "15";
|
|
}
|
|
return "unknown pinoff";
|
|
}
|
|
|
|
// // no tim1
|
|
// TIM2_IRQn
|
|
// TIM3_IRQn
|
|
// TIM4_IRQn
|
|
// TIM5_IRQn
|
|
// TIM6_DAC_IRQn
|
|
// TIM7_IRQn
|
|
// //no tim8
|
|
// TIM1_BRK_TIM9_IRQn
|
|
// TIM1_UP_TIM10_IRQn
|
|
// TIM1_TRG_COM_TIM11_IRQn
|
|
// TIM8_BRK_TIM12_IRQn
|
|
// TIM8_UP_TIM13_IRQn
|
|
// TIM8_TRG_COM_TIM14_IRQn
|
|
|
|
IRQn_Type chip_tim_get_irq(TIM_HandleTypeDef* tim) {
|
|
if (tim->Instance == TIM1) {
|
|
EARLY_ASSERT(false);
|
|
}
|
|
if (tim->Instance == TIM2) {
|
|
return TIM2_IRQn;
|
|
}
|
|
if (tim->Instance == TIM3) {
|
|
return TIM3_IRQn;
|
|
}
|
|
if (tim->Instance == TIM4) {
|
|
return TIM4_IRQn;
|
|
}
|
|
if (tim->Instance == TIM5) {
|
|
return TIM5_IRQn;
|
|
}
|
|
if (tim->Instance == TIM6) {
|
|
return TIM6_DAC_IRQn;
|
|
}
|
|
if (tim->Instance == TIM7) {
|
|
return TIM7_IRQn;
|
|
}
|
|
if (tim->Instance == TIM8) {
|
|
EARLY_ASSERT(false);
|
|
}
|
|
if (tim->Instance == TIM9) {
|
|
return TIM1_BRK_TIM9_IRQn;
|
|
}
|
|
if (tim->Instance == TIM10) {
|
|
return TIM1_UP_TIM10_IRQn;
|
|
}
|
|
if (tim->Instance == TIM11) {
|
|
return TIM1_TRG_COM_TIM11_IRQn;
|
|
}
|
|
if (tim->Instance == TIM12) {
|
|
return TIM8_BRK_TIM12_IRQn;
|
|
}
|
|
if (tim->Instance == TIM13) {
|
|
return TIM8_UP_TIM13_IRQn;
|
|
}
|
|
if (tim->Instance == TIM14) {
|
|
return TIM8_TRG_COM_TIM14_IRQn;
|
|
}
|
|
//
|
|
EARLY_ASSERT(false);
|
|
return (IRQn_Type)0;
|
|
}
|
|
|
|
uint32_t chip_get_timer_clock_sorce_freq(TIM_HandleTypeDef* tim) {
|
|
uint32_t timClkFreq = 0;
|
|
#if 0
|
|
uint32_t pclk1Freq = HAL_RCC_GetPCLK1Freq();
|
|
uint32_t pclk2Freq = HAL_RCC_GetPCLK2Freq();
|
|
uint32_t sysClkFreq = HAL_RCC_GetSysClockFreq();
|
|
#endif
|
|
|
|
uint32_t pFLatency;
|
|
RCC_ClkInitTypeDef clkconfig;
|
|
HAL_RCC_GetClockConfig(&clkconfig, &pFLatency);
|
|
bool isAPB2 = false;
|
|
|
|
#ifdef TIM1
|
|
if (tim->Instance == TIM1) isAPB2 = true;
|
|
#endif
|
|
#ifdef TIM8
|
|
if (tim->Instance == TIM8) isAPB2 = true;
|
|
#endif
|
|
#ifdef TIM9
|
|
if (tim->Instance == TIM9) isAPB2 = true;
|
|
#endif
|
|
#ifdef TIM10
|
|
if (tim->Instance == TIM10) isAPB2 = true;
|
|
#endif
|
|
#ifdef TIM11
|
|
if (tim->Instance == TIM11) isAPB2 = true;
|
|
#endif
|
|
if (isAPB2) {
|
|
if (clkconfig.APB2CLKDivider == RCC_HCLK_DIV1) {
|
|
timClkFreq = HAL_RCC_GetPCLK2Freq();
|
|
} else {
|
|
timClkFreq = 2 * HAL_RCC_GetPCLK2Freq();
|
|
}
|
|
} else {
|
|
if (clkconfig.APB1CLKDivider == RCC_HCLK_DIV1) {
|
|
timClkFreq = HAL_RCC_GetPCLK1Freq();
|
|
} else {
|
|
timClkFreq = 2 * HAL_RCC_GetPCLK1Freq();
|
|
}
|
|
}
|
|
return timClkFreq;
|
|
}
|
|
}
|
|
|
|
static float zfeq(float val0, float val1, float eps = 0.0001) {
|
|
float dv = val0 - val1;
|
|
if (dv < 0) dv = -dv;
|
|
if (dv < eps) return true;
|
|
return false;
|
|
}
|
|
|
|
bool chip_calculate_prescaler_and_autoreload_by_expect_freq(uint32_t timerInClk, float infreqhz, uint32_t* prescaler, uint32_t* autoreload) {
|
|
/**
|
|
* @brief 计算寄存器数值
|
|
*/
|
|
ZEARLY_ASSERT(!zfeq(infreqhz, 0, 0.01));
|
|
float psc_x_arr = timerInClk / infreqhz;
|
|
uint32_t psc = 0;
|
|
uint32_t arr = 65534;
|
|
for (; arr > 2; arr--) {
|
|
psc = psc_x_arr / arr;
|
|
if (psc >= 1) {
|
|
uint32_t tmparr = psc_x_arr / psc;
|
|
if (tmparr >= 65534) continue;
|
|
break;
|
|
}
|
|
}
|
|
if (psc == 0) return false;
|
|
if (arr <= 3) return false; // 定时器一周期的分辨率太小了
|
|
arr = psc_x_arr / psc;
|
|
|
|
int psc_x_arr_real = arr * psc;
|
|
float realfreq = timerInClk / psc_x_arr_real;
|
|
|
|
arr = arr - 1;
|
|
psc = psc - 1;
|
|
// uint16_t comparevalue = 50 / 100.0 * arr;
|
|
|
|
*prescaler = psc;
|
|
*autoreload = arr;
|
|
return true;
|
|
}
|