void TIM4_Alarm_Config (void)
{
RCC->APB1ENR |= RCC_APB1ENR_TIM4EN; // подача тактов на TIM4 от шины тактирования APB1

TIM4->PSC = 1 - 1; // Предварительный делитель: значения счетчика будут инкрементироваться с частотой 35 MГц
TIM4->ARR = 65534 - 1; // Максимальное значение, до которого будет считать таймер, равно 65535

// канал 3 (1Гц)
TIM4->CCMR2 |= TIM_CCMR2_CC3S_0; // выбор активного входа, канал 3 TIM4_CH3 (PB8) <<------ подать на этот канал 1Гц
TIM4->CCER &=~ TIM_CCER_CC3P; // срабатывание по переднему фронту
TIM4->CCMR2 &=~ TIM_CCMR2_IC3PSC; // захват каждого импульса
// TIM4->CCER |= TIM_CCER_CC3E; // включить захват из счётчика // в EXTI1
TIM4->DIER |= TIM_DIER_CC3IE; // включение прерывания от захвата

// канал 4 (1PPS)
TIM4->CCMR2 |= TIM_CCMR2_CC4S_0; // выбор активного входа, канал 4 TIM4_CH4 (PB9) <<------ подать на этот канал 1PPS
TIM4->CCER &=~ TIM_CCER_CC4P; // срабатывание по переднему фронту
TIM4->CCMR2 &=~ TIM_CCMR2_IC4PSC; // захват каждого импульса
// TIM4->CCER |= TIM_CCER_CC4E; // включить захват из счётчика // в EXTI1
TIM4->DIER |= TIM_DIER_CC4IE; // включение прерывания от захвата
}

void TIM4_IRQHandler(void)
{

if (TIM4->SR&TIM_SR_CC3IF) // 1Гц
{
TIM4->SR &=~ TIM_SR_CC3IF; // очиcтка флага прерывания
count1 = TIM4->CCR3; // считываем значение счётчика в переменную count1, если выставлен флаг прерывания
}

if (TIM4->SR&TIM_SR_CC4IF) // 1PPS
{
TIM4->SR &=~ TIM_SR_CC4IF; // очиcтка флага прерывания
count2 = TIM4->CCR4; // считываем значение счётчика в переменную count1, если выставлен флаг прерывания
}

if((count1>0)&&(count2>0))
{
if(count1>count2)
{
razn = count1 - count2;
}
if(count2>count1)
{
razn = count2 - count1;
}

count1=0;
count2=0;

if (razn >(bias+1000)){razn = 65534 - razn;}

// if(bias>razn)
// {
rash = razn + 100;// - bias; // добавил биас rash - unsigned int
// }
// if(razn>bias)
// {
// rash = razn - bias;
// }

//while (!(USART2->SR & USART_SR_TXE)) {} // Ждать освобождения буфера.
//USART2->DR=rash;

union {
unsigned int Mylong2;
char buf3[2]; // рассогласование в микросекундах
}MyUnion2;
MyUnion2.Mylong2 = rash;


while (!(USART2->SR & USART_SR_TXE)) {} // Ждать освобождения буфера.
USART2->DR=MyUnion2.buf3[1]; // рассогласование в микросекундах
while (!(USART2->SR & USART_SR_TXE)) {} // Ждать освобождения буфера.
USART2->DR=MyUnion2.buf3[0];

if (rash<90)

{GPIOA->BSRR |= GPIO_BSRR_BS7;} // генерация импульса, который подаётся на GPIOA_PIN6 (PA7), <<----- импульс сигнализации}

if (rash>110)

{GPIOA->BSRR |= GPIO_BSRR_BS7;} // генерация импульса, который подаётся на GPIOA_PIN6 (PA7), <<----- импульс сигнализации}
}
}

if (count1>count2)
{
    razn = count1 - count2;
}
else
{
    razn = count2 - count1;
}

//********************************************************************************
*
// Функция TIM2_Divider_Config: Делитель на таймере
//********************************************************************************
*
void TIM2_Divider_Config (void)
{
RCC->APB1ENR |= RCC_APB1ENR_TIM2EN; // подача тактов на TIM2 от шины тактирования APB1

TIM2->PSC = 35000 - 1; // предделитель до частоты 2000 Гц
TIM2->ARR = 2000 - 1; // выход в прерывание каждую секунду
TIM2->DIER |= TIM_DIER_UIE; // После того как таймер достигнет своего максимального значения генерируется прерываие
TIM2->CR1 |= TIM_CR1_ARPE; // сброс по достижении максимального значения
// TIM2->CR1 |= TIM_CR1_CEN; // Разрешить работу таймера
}
//********************************************************************************
*
// Функция TIM2_IRQHandler: Обработчик прерываний для TIM2
//********************************************************************************
*
void TIM2_IRQHandler(void)
{
if (TIM2->SR&TIM_SR_UIF)
{
GPIOE->BSRR |= GPIO_BSRR_BS0; // генерация импульса, который подаётся на (PE0), его надо принять на TIM4_CH3 (PB8)
GPIOE->BSRR |= GPIO_BSRR_BR0;
TIM2->SR &=~ TIM_SR_UIF; // очиcтка флага прерывания
}
}

TIM2->EGR = TIM_EGR_UG;

unsigned char InitHSEBYP(void)
{
unsigned long int TimeOut = 10000000;

//Запустить HSEBYP
RCC->CR |= RCC_CR_HSEBYP; //Включить генератор HSEBYP
RCC->CR |= RCC_CR_HSEON; //Включить генератор HSE
while((RCC->CR & RCC_CR_HSERDY)==0) //Ожидание готовности HSE
if(TimeOut) TimeOut--;
if(TimeOut==0) return 1; // Генератор HSE не запустился
RCC->CR |= RCC_CR_CSSON; //Разрешить работу системы защиты от сбоя HSE

RCC->CFGR &= ~RCC_CFGR_PLLXTPRE; //Не использовать делитель HSE

//Частота SystemCoreClock выше 24 MHz - разрешить буфер предварительной выборки FLASH
FLASH->ACR|= FLASH_ACR_PRFTBE; //Включить буфер предварительной выборки
FLASH->ACR&= ~FLASH_ACR_LATENCY; //Очистить FLASH_ACR_LATENCY
FLASH->ACR |= FLASH_ACR_LATENCY_2; //Пропускать 2 такта

//Настройка PLL
RCC->CFGR |= RCC_CFGR_PLLSRC; //Источником сигнала для PLL выбран HSE
RCC->CR &= ~RCC_CR_PLLON; //Отключить генератор PLL
RCC->CFGR &= ~RCC_CFGR_PLLMULL; //Очистить PLLMULL
RCC->CFGR |= RCC_CFGR_PLLMULL7; //Коефициент умножения = 7
RCC->CR |= RCC_CR_PLLON; //Включить генератор PLL
while((RCC->CR & RCC_CR_PLLRDY)==0) {} //Ожидание готовности PLL

//Переключиться на тактирование от PLL
RCC->CFGR &= ~RCC_CFGR_SW; //Очистка битов выбора источника тактового сигнала
RCC->CFGR |= RCC_CFGR_SW_PLL; //Выбрать источником тактового сигнала PLL
while((RCC->CFGR&RCC_CFGR_SWS)!=0x08){}//Ожидание переключения на PLL

// apb1
RCC->CFGR &=~RCC_CFGR_PPRE1; // Очистка битов предделителя "APB1 Prescaler"
// RCC->CFGR |= RCC_CFGR_PPRE1_DIV1; // HCLK not divided
RCC->CFGR |= RCC_CFGR_PPRE1_DIV2; // HCLK divided by 2

// apb2
RCC->CFGR &= ~RCC_CFGR_PPRE2; // Очистка битов предделителя "APB2 Prescaler"
// RCC->CFGR |= RCC_CFGR_PPRE2_DIV1; // HCLK not divided
RCC->CFGR |= RCC_CFGR_PPRE2_DIV2; // HCLK divided by 2

return 0; // HSE готов к работе
}
}

  while((RCC->CR & RCC_CR_HSERDY)==0)    //Ожидание готовности HSE
  if(TimeOut) TimeOut--;
  if(TimeOut==0) return 1;               // Генератор HSE не запустился

void EXTI1_1PPS_Config(void)
{
AFIO->EXTICR [0] |= AFIO_EXTICR1_EXTI1_PE; // Прерывание на (PE1)
EXTI->IMR |= EXTI_IMR_MR1; // Разрешить запрос от EXTI1
EXTI->RTSR |= EXTI_RTSR_TR1; // Прерывание от EXTI1 по переднему фронту

// ширина приходящего по EXTI импульса должна быть минимум --> 10 нс(см. datasheet стр 90)
}
//********************************************************************************
*
// Функция EXTI1_IRQHandler: Синхронизация от импульса 1PPS
//********************************************************************************
*
void EXTI1_IRQHandler (void)
{
if (EXTI->PR & EXTI_PR_PR1) // Прерывание от (PE1) по приходу 1PPS
{
TIM2->CR1 |= TIM_CR1_CEN; // Разрешить работу таймера генерации 1Гц

if (TimeGlobalFlag==1)
{// Cинхронизация

TIM5->CNT = 0; // обнулить счётчик, чтобы его значение после синхронизации равнялось 0x00
TIM5secs=secs; // если время по NMEA получено, присвоить TIM5secs значения secs

TIM3->CNT = 0; // обнулить счётчик, чтобы его значение после синхронизации равнялось 0x00
TIM3microsecs = 0; // если время по NMEA получено, TIM3microsecs = 0

TIM5->CR1 |= TIM_CR1_CEN; // Разрешить работу секундного таймера TIM5
TIM3->CR1 |= TIM_CR1_CEN; // Разрешить работу микроcекундного TIM3 таймера

// TIM2->CR1 |= TIM_CR1_CEN; // Разрешить работу таймера генерации 1Гц

TIM1->CCER |= TIM_CCER_CC1E; // включить захват из счётчика

TimeGlobalFlag=0; // устанавливаем флаг успешного получения времени
// flagEXTI=1;
flagSynchro=0; // флаг синхронизации - в ПК будут слаться ответы с временем

AFIO->EXTICR [0] &=~ AFIO_EXTICR1_EXTI1_PE; // Отключиться от (PE1) ////////

EXTI->IMR &=~ EXTI_IMR_MR1; // Запретить запрос от EXTI1
}
EXTI->PR |= EXTI_PR_PR1; // Сбросить флаг
}
}

ЗЫ. Кстати, код
Код
  while((RCC->CR & RCC_CR_HSERDY)==0)    //Ожидание готовности HSE
  if(TimeOut) TimeOut--;
  if(TimeOut==0) return 1;               // Генератор HSE не запустился

никогда не вернёт 1. Вместо этого он наглухо зависнет в ожидании HSERDY.