#define APB1_FREQ 24000000

void delay_ms (uint16_t volatile ms) {
  TIM7->CR1 &= ~0xFF;                               // Сбрасываем регистр управления таймера TIM7
  if (ms != 1) {                                    // Если значение задержки НЕ равно 1,
  TIM7->PSC = APB1_FREQ/1000-1;                     // настраиваем таймер TIM7 на период 1 мс,
  TIM7->ARR = ms-1;                                 // установить конечное значение счёта с учетом импульса переполнения;
  } else {                                          // иначе,
      TIM7->PSC = 2*APB1_FREQ/1000-1;               // настраиваем таймер TIM7 на период в 2 раза меньше - 0,5 мс
      TIM7->ARR = 1; }                              // установить конечное значение счёта на 1 с учетом импульса переполнения
  TIM7->CR1 |= (TIM_CR1_OPM | TIM_CR1_CEN);         // Установить режим "одного импульса" и включить таймер TIM7
  while(!(TIM7->SR & TIM_SR_UIF));                  // Дождаться конца задержки
  TIM7->SR &= ~TIM_SR_UIF;                          // Сбросить флаг прерывания
};

RCC->APB1ENR |= RCC_APB1ENR_TIM7EN;   // Тактируем базовый таймер TIM7

volatile uint32 ms_timer;

void ms_interrupt(void)
{
  if(ms_timer)
    ms_timer--;
}

void delay_ms (uint32_t ms)
{
  ms_timer=ms;
  while(ms_timer);
}

TIM7->EGR |= TIM_EGR_UG;

TIM7->CR1 = TIM_CR1_ARPE | TIM_CR1_OPM;

void delay_ms (uint16_t ms) {
  TIM7->PSC = APB1_FREQ/(((ms == 1) ? 2 : 1)*1000)-1;       // Настраиваем таймер TIM7 на период 0.5 мс для задержки в 1 мс
                                                            // и на период 1 мс для всех остальных значений
  TIM7->EGR = TIM_EGR_UG;                                   // Сгенерировать событие для загрузки нового значения предделителя
  TIM7->SR &= ~TIM_SR_UIF;                                  // Сбросить флаг прерывания
  TIM7->ARR = (ms == 1) ? 1 : (ms-1);                       // Установить конечное значение счёта с учетом импульса переполнения
  TIM7->CR1 = TIM_CR1_OPM | TIM_CR1_CEN;                    // Установить режим "одного импульса" и включить таймер TIM7
  while(!(TIM7->SR & TIM_SR_UIF));                          // Дождаться конца задержки
  TIM7->SR &= ~TIM_SR_UIF;                                  // Сбросить флаг прерывания
};

void delay_ms (uint16_t ms) {
  TIM7->PSC = APB1_FREQ/(((ms == 1) ? 2 : 1)*1000)-1;       // Настраиваем таймер TIM7 на период 0.5 мс для задержки в 1 мс
                                                            // и на период 1 мс для всех остальных значений
  TIM7->ARR = (ms == 1) ? 1 : (ms-1);                       // Установить конечное значение счёта с учетом импульса переполнения
  TIM7->EGR = TIM_EGR_UG;                                   // Сгенерировать событие для загрузки нового значения предделителя
  TIM7->SR &= ~TIM_SR_UIF;                                  // Сбросить флаг прерывания
  TIM7->CR1 = TIM_CR1_OPM | TIM_CR1_CEN;                    // Установить режим "одного импульса" и включить таймер TIM7
  while(!(TIM7->SR & TIM_SR_UIF));                          // Дождаться конца задержки
  TIM7->SR &= ~TIM_SR_UIF;                                  // Сбросить флаг прерывания
};

((ms == 1) ? 2 : 1)

(ms == 1) ? 1 : (ms-1)

void Timer3_init(void) {
/* Разрешить тактирование Таймера 3 */
  RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;
/* Prescaler 8 MHz */
  TIM3->PSC = 24 / 8 - 1;
/* Autoreload 2 MHz */
  TIM3->ARR = 8 / 2 - 1;
/* PWM */
  TIM3->CCMR2 = 0x6060 | TIM_CCMR2_OC4PE | TIM_CCMR2_OC3PE;
/* Противоположная полярность активных сигналов (не обязательно) */
  TIM3->CCER = TIM_CCER_CC4E | TIM_CCER_CC4P | TIM_CCER_CC3E;
/* Регистры сравнения */
  TIM3->CCR3 = TIM3->CCR4 = 8 / 2 / 2;  
/* Разрешить счет */
  TIM3->CR1 = TIM_CR1_ARPE | TIM_CR1_URS | TIM_CR1_CEN;
/* Remap TIM3 to PC8, PC9 */
  AFIO->MAPR = 0x00000c00;  
}

/*!
*******************************************************************************
* @brief    Wide time delay start, check, wait in 1, 10, 100, 1000 us steps
* @details    Старт, проверка и ожидание окончания задержки в микросекундаx
* @param    US - delay time (1 ... 65 536 000 us)
*/
#define WDELAY_START(US)                        \
  TIM6->PSC = ((US < 65536)? (24 - 1) :                    \
          ((US < 655360)? (240 - 1) :                 \
          ((US < 6553600)? (2400 - 1) : (24000 - 1))));        \
  TIM6->ARR = ((US < 65536)? (US - 1) :                    \
          ((US < 655360)? (US / 10 - 1) :                \
          ((US < 6553600)? (US / 100 - 1) : (US / 1000 - 1))));    \
  TIM6->EGR = TIM_EGR_UG;                        \
  TIM6->SR = 0;                                \
  TIM6->CR1 |= TIM_CR1_CEN;                        \

#define WDELAY_CHECK    (TIM6->SR)
#define WDELAY_WAIT()    while (!TIM6->SR)

void Timer6_init(void) {
  RCC->APB1ENR |= RCC_APB1ENR_TIM6EN;
  TIM6->CR1 = TIM_CR1_ARPE | TIM_CR1_OPM | TIM_CR1_URS;
}

typedef unsigned long int DWORD; //max 4 294 967 295 delay units
#define mS_TICK 168000 // @ core FREQ = 168 MHz
#define uS_TICK 168 // @ core FREQ = 168 MHz

DWORD DelayTime; //global tick variable

void SysTick_Configure_ms (void)
{
SysTick_Config(mS_TICK); // interrupt 1 ms
}

void SysTick_Configure_us (void)
{
SysTick_Config(uS_TICK); // interrupt 1 us
}

void Delay_ms(DWORD time)
{
DelayTime=time;
while (DelayTime!=0){};
}

void Delay_us(DWORD time)
{
DelayTime=time;
while (DelayTime!=0){};
}

void DelayTime_Decrement (void)
{
if (DelayTime!=0)
{
DelayTime--;
}
}

void SysTick_Handler(void)
{
DelayTime_Decrement();
}

#define FT_MHZ 24
void delay_start(const uint32_t time) {
uint32_t psc, rst, arr;
for (psc = 1; psc < 0x10000; psc++) {
arr = time * FT_MHZ / psc;
rst = time * FT_MHZ % psc;
if ((arr < 0x10000) && (rst == 0)) {
TIM6->PSC = psc - 1;
TIM6->ARR = arr - 1;
TIM6->EGR = TIM_EGR_UG;
TIM6->SR = 0;
TIM6->CR1 |= TIM_CR1_CEN;
return;
}
}
for (psc = 1; psc < 0x10000; psc++) {
arr = (time * FT_MHZ + psc / 2) / psc;
if (arr < 0x10000) {
TIM6->PSC = psc - 1;
TIM6->ARR = arr - 1;
TIM6->EGR = TIM_EGR_UG;
TIM6->SR = 0;
TIM6->CR1 |= TIM_CR1_CEN;
return;
}
}
}

void delay_wait(void) {
while (!TIM6->SR);
}

class FreqIn
{
static std::vector<FreqIn*>tims;
static int timsNum;

public:
FreqIn(TIM_TypeDef *tim_, IRQn irqnUP_, IRQn irqnCC_, uint16_t chan_, uint32_t busDiv_)
: tim(tim_)
, irqnUP(irqnUP_)
, irqnCC(irqnCC_)
, chan(chan_)
, busDiv(busDiv_)
{
prescaler = 0;
tims.push_back(this);
timsNum ++;
reset();
}

void start()
{
stop();
enable = 1;
}
void stop()
{
enable = 0;
}
void reset()
{
timerInit();
stop();
}

inline float freq() {return freq_;}
inline uint16_t holdEdge() {return holdEdge_;}
inline void setEdge(uint16_t t)
{
timerInit();
holdEdge_ = t;
}
inline uint16_t holdPrescaler() {return prescaler;}
inline void setPrescaler(uint16_t t)
{
//timerInit();
prescaler = t;
}

private:
void timerInit()
{
NVIC_DisableIRQ(irqnUP);
NVIC_DisableIRQ(irqnCC);
TIM_Cmd(tim, DISABLE);

TIM_TimeBaseInitTypeDef timer_base;
TIM_TimeBaseStructInit(&timer_base);
timer_base.TIM_Prescaler = prescaler-1; //1,2,3
timer_base.TIM_Period = 0xFFFF;
TIM_TimeBaseInit(tim, &timer_base);

TIM_ICInitTypeDef TIM_ICStructure;
TIM_ICStructure.TIM_Channel = chan; // канал
if (holdEdge_)
{
TIM_ICStructure.TIM_ICPolarity = TIM_ICPolarity_Falling; // по заднему фронту
}
else
{
TIM_ICStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
}
TIM_ICStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; // прямо с ножки
TIM_ICStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1; // без делителя
TIM_ICStructure.TIM_ICFilter = 0; // без фильтра

// эта функция и включает режим PWM input - автоматически настраивает комплементарный канал
// правда в стандартной библиотеке работает на 1 и 2 канале, на 3 и 4 - не умеет
//TIM_PWMIConfig(tim, &TIM_ICStructure);

TIM_ICInit(tim, &TIM_ICStructure);

// Выбираем источник для триггера: вход 1
TIM_SelectInputTrigger(tim, TIM_TS_TI1FP1);
// По событию от триггера счётчик будет сбрасываться.
TIM_SelectSlaveMode(tim, TIM_SlaveMode_Reset);
// Включаем события от триггера
TIM_SelectMasterSlaveMode(tim, TIM_MasterSlaveMode_Enable);

// Разрешаем таймеру генерировать прерывание по захвату
if (chan == TIM_Channel_1) TIM_ITConfig(tim, TIM_IT_CC1, ENABLE);
if (chan == TIM_Channel_2) TIM_ITConfig(tim, TIM_IT_CC2, ENABLE);
if (chan == TIM_Channel_3) TIM_ITConfig(tim, TIM_IT_CC3, ENABLE);
if (chan == TIM_Channel_4) TIM_ITConfig(tim, TIM_IT_CC4, ENABLE);

TIM_ITConfig(tim, TIM_IT_Update, ENABLE);

TIM_ClearFlag(tim, TIM_FLAG_CC1);
TIM_ClearFlag(tim, TIM_FLAG_CC2);
TIM_ClearFlag(tim, TIM_FLAG_CC3);
TIM_ClearFlag(tim, TIM_FLAG_CC4);
TIM_ClearFlag(tim, TIM_IT_Update);

// Включаем таймер
TIM_Cmd(tim, ENABLE);
// разрешаем прерывания
NVIC_SetVector(irqnUP, (uint32_t)irqHandler);
NVIC_SetVector(irqnCC, (uint32_t)irqHandler);
NVIC_EnableIRQ(irqnUP);
NVIC_EnableIRQ(irqnCC);
}

static void irqHandler()
{
for (register int i = 0; i != timsNum; ++i)
{
tims[i]->irq();
}
}

inline void captCh(int ch)
{
}

inline void irq()
{
if (TIM_GetITStatus(tim, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC1);
TIM_ClearITPendingBit(tim, TIM_IT_Update);

cnt = TIM_GetCapture1(tim);
freq_ = float(SystemCoreClock/busDiv)/(float(cnt) + (ovf << 16));
ovf = 0;
}
if (TIM_GetITStatus(tim, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC2);
TIM_ClearITPendingBit(tim, TIM_IT_Update);

cnt = TIM_GetCapture2(tim);
freq_ = float(SystemCoreClock/busDiv)/(float(cnt) + (ovf << 16));
ovf = 0;
}
if (TIM_GetITStatus(tim, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC3);
TIM_ClearITPendingBit(tim, TIM_IT_Update);

cnt = TIM_GetCapture3(tim);
freq_ = float(SystemCoreClock/busDiv)/(float(cnt) + (ovf << 16));
ovf = 0;
}
if (TIM_GetITStatus(tim, TIM_IT_CC4) != RESET) {
TIM_ClearITPendingBit(tim, TIM_IT_CC4);
TIM_ClearITPendingBit(tim, TIM_IT_Update);

cnt = TIM_GetCapture4(tim);
freq_ = float(SystemCoreClock/busDiv)/(float(cnt) + (ovf << 16));
ovf = 0;
}
if (TIM_GetITStatus(tim, TIM_IT_Update) != RESET) {
TIM_ClearITPendingBit(tim, TIM_IT_Update);
ovf++;
}
}

uint32_t ovf;
uint32_t cnt;
uint32_t prescaler;
float freq_;
uint16_t holdEdge_;
uint16_t chan;
uint32_t busDiv;

volatile int enable;
TIM_TypeDef *tim;
IRQn irqnUP;
IRQn irqnCC;
};