p_graphite_digester_sdk/chip/basic/chip_helper.cpp

#include "chip_helper.hpp"

#include "sdk\chip\basic\logger.hpp"
extern "C" {
static uint8_t g_port_exit_critical_count;

void chip_critical_enter(void) {
  if (g_port_exit_critical_count == 0) {
    __disable_irq();
  }
  g_port_exit_critical_count++;
}
void chip_critical_exit(void) {
  g_port_exit_critical_count--;
  if (g_port_exit_critical_count == 0) {
    __enable_irq();
  }
}

GPIO_TypeDef* chip_get_gpio(Pin_t pin) {
  int port = pin >> 4;

  switch (port) {
    case 1:
#ifdef GPIOA
      return GPIOA;
#endif
      break;
    case 2:
#ifdef GPIOB
      return GPIOB;
#endif
      break;
    case 3:
#ifdef GPIOC
      return GPIOC;
#endif
      break;
    case 4:
#ifdef GPIOD
      return GPIOD;
#endif
      break;

    case 5:
#ifdef GPIOE
      return GPIOE;
#endif
      break;
    case 6:
#ifdef GPIOF
      return GPIOF;
#endif
      break;
    case 7:
#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;
}