//Task2
...
        IrState.ctim10ms = IrState.bRxTx[pValue->nComm][0];
...

void TIM10_IRQHandler(void)
{
....
        if(IrState.ctim10ms) IrState.ctim10ms--;
....
}

void TIM10_IRQHandler(void)
{
    static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
    
    if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
    {
        TIM_ClearFlag(TIM10, TIM_FLAG_Update);
        if(ctim10ms) ctim10ms--;
        else
        {
//disableInterruptTIM10();
            xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
            portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
        }
    }
}

#define enableInterruptTIM10() NVIC->ISER[TIM10_IRQn >> 0x05] = (uint32_t)0x01 << (TIM10_IRQn & (uint8_t)0x1F)
#define disableInterruptTIM10() NVIC->ICER[TIM10_IRQn >> 0x05] = (uint32_t)0x01 << (TIM10_IRQn & (uint8_t)0x1F)

xSemaphoreHandle xSemNx; //управление задачей
volatile uint32_t ctim10ms; //счетчик отсчетов по 10 мксек

void Tx_Init(void);
void Tx_DeInit (void);

void Task_temp(void *pParams);

int main(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
NVIC_InitTypeDef NVIC_InitStruct;

RCC_HSICmd(ENABLE);
while (RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);

RCC_HSEConfig(RCC_HSE_OFF);
while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) != RESET);

SystemCoreClockUpdate();
SysTick_Config(SystemCoreClock/1000);//TO=1мс

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
NVIC_InitStruct.NVIC_IRQChannel = TIM10_IRQn;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//NVIC_InitStruct.NVIC_IRQChannelCmd = DISABLE;
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 11;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
NVIC_Init(&NVIC_InitStruct);

RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStruct);


xTaskCreate(Task_temp, "Temp-handler", configMINIMAL_STACK_SIZE, NULL, 2, NULL);

vTaskStartScheduler();

}

void Task_temp(void *pParams)
{
uint32_t c = 0;
vSemaphoreCreateBinary(xSemNx);

while(1){
xSemaphoreTake(xSemNx, 0);
ctim10ms = 100;
Tx_Init();

while(1)
{
//enableInterruptTIM10();
if(xSemaphoreTake(xSemNx, 10) != pdTRUE) break;
c++;
ctim10ms = 100;
GPIO_ToggleBits(GPIOB, GPIO_Pin_5);//пин контроля работы программы
if(c > 200) break;
}
//disableInterruptTIM10();
TIM_DeInit(TIM10);

}
}

void Tx_Init(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM10, ENABLE);

TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInitStruct.TIM_Period = 160-1;
TIM_TimeBaseInitStruct.TIM_Prescaler = 0;
TIM_TimeBaseInit(TIM10, &TIM_TimeBaseInitStruct);
TIM_ITConfig(TIM10, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM10, ENABLE);
}

void TIM10_IRQHandler(void)
{
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
{
TIM_ClearFlag(TIM10, TIM_FLAG_Update);
if(ctim10ms) ctim10ms--;
else
{
xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
}
}

void Task_temp(void *pParams)
{
vSemaphoreCreateBinary(xSemNx);

xSemaphoreTake(xSemNx, 0);
ctim10ms = 10;
Tx_Init();

while(1)
{
xSemaphoreTake(xSemNx, 10);
ctim10ms = 10;
GPIO_ToggleBits(GPIOB, GPIO_Pin_5);//пин контроля работы программы
}

}

void TIM10_IRQHandler(void)
{
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
{
TIM_ClearFlag(TIM10, TIM_FLAG_Update);
if(ctim10ms) ctim10ms--;
else
{
disableInterruptTIM10();
xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
}
}

void Task_temp(void *pParams)
{
vSemaphoreCreateBinary(xSemNx);

xSemaphoreTake(xSemNx, 0);
ctim10ms = 10;
Tx_Init();

while(1)
{
enableInterruptTIM10();
xSemaphoreTake(xSemNx, 10);
ctim10ms = 10;
GPIO_ToggleBits(GPIOB, GPIO_Pin_5);//пин контроля работы программы
}

}

void TIM10_IRQHandler(void)
{
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
{
TIM_ClearFlag(TIM10, TIM_FLAG_Update);
xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);

}
}

void Task_temp(void *pParams)
{
vSemaphoreCreateBinary(xSemNx);

xSemaphoreTake(xSemNx, 0);
Tx_Init();

while(1)
{
xSemaphoreTake(xSemNx, 10);
GPIO_ToggleBits(GPIOB, GPIO_Pin_5);//пин контроля работы программы
}

}

static u8 volatile ctim10ms = 0;
void ISR()
{
...
int i = ctim10ms;
if (--i < 0) return;
ctim10ms = i;
if (i) return;
xSemaphoreGiveFromISR(...);
portEND_SWITCHING_ISR(...);
}

#define portEND_SWITCHING_ISR( xSwitchRequired ) if( xSwitchRequired != pdFALSE ) portYIELD()

xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);

void TIM10_IRQHandler(void)
{
    static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
    
    if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
    {
        TIM_ClearFlag(TIM10, TIM_FLAG_Update);
        if(ctim10ms) ctim10ms--;
        else
        {
            if(xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken) != pdFAIL) portEND_SWITCHING_ISR(1);
        }
    }
}

            xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
            portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);

if(xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken) != pdFAIL) portEND_SWITCHING_ISR(1);

void TIM10_IRQHandler(void)
{
    static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE, fGiveResult = pdFALSE;
    
    if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
    {
        TIM_ClearFlag(TIM10, TIM_FLAG_Update);
        if(ctim10ms) ctim10ms--;
        else
        {
            fGiveResult = xSemaphoreGiveFromISR(xSemNx, &xHigherPriorityTaskWoken);
            portEND_SWITCHING_ISR(xHigherPriorityTaskWoken & fGiveResult);
        }
    }
}

void TIM10_IRQHandler(void)
{
    static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE, fGiveResult = pdFALSE;
    
    if(TIM_GetFlagStatus(TIM10, TIM_FLAG_Update) != RESET)
    {
        TIM_ClearFlag(TIM10, TIM_FLAG_Update);
        if(ctim10ms) ctim10ms--;
        else
        {
            fGiveResult = xQueueSendToBackFromISR(xQueue, (const void *)0, &xHigherPriorityTaskWoken);
            if(xHigherPriorityTaskWoken & fGiveResult)
            {
                portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
            }
                else cal_ctim10ms++;
        }
    }
}
void Task_temp(void *pParams)
{
    uint32_t newValue = 100;
    uint32_t q_buf;
    
    xQueue = xQueueCreate(1, sizeof(uint32_t));


    ctim10ms = newValue;
    Tx_Init();

    while(1)
    {
        xQueuePeek(xQueue, &q_buf, 10);
    taskENTER_CRITICAL();
        ctim10ms = newValue - cal_ctim10ms;
        cal_ctim10ms = 0;
    taskEXIT_CRITICAL();
        GPIO_ToggleBits(GPIOB, GPIO_Pin_5);//пин контроля работы программы
        xQueueReceive(xQueue, &q_buf, 0);
    }
}

if(xHigherPriorityTaskWoken & fGiveResult)

if( (xHigherPriorityTaskWoken != 0) && (fGiveResult != 0))

if ( (xHigherPriorityTaskWoken != pdFALSE) && (fGiveResult != pdFALSE) )

int main(void)
{
    HW_MCUInit();
    
    SampleSemaphoreHandle = xSemaphoreCreateBinary();
    
    xTaskCreate(&SampleHandlingTask, "SampleHandlingTask", 512, NULL, SAMPLE_HANLING_TASK_PRIORITY, &SampleHandlingTaskHandle);
    
    vTaskStartScheduler();
    
    return 0;
}

void SampleHandlingTask(void *Parameters)
{
    HW_TIMER_START();
    
    while(1)
    {
        xSemaphoreTake(SampleSemaphoreHandle, 10);
        
        unsigned int ReshedulingTime = DWT_CYCCNT - CYCCNT_ISR_Vale;

        ctim10ms = 10;
        
        GPIOG->ODR ^= GPIO_Pin_13;
    }
}

volatile unsigned int ctim10ms = 10000;
volatile unsigned int CYCCNT_ISR_Vale = 0;

void TIM1_UP_TIM10_IRQHandler(void)
{
    static BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(TIM1->SR & TIM_IT_Update)
    {
        if(ctim10ms)
            ctim10ms--;
        else
        {
            xSemaphoreGiveFromISR(SampleSemaphoreHandle, &xHigherPriorityTaskWoken);
            portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
            
            CYCCNT_ISR_Vale = DWT_CYCCNT;
        }
        TIM1->SR = (uint16_t)~TIM_IT_Update;
    }
}

ctim10ms = 10;

portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);

#define configTICK_RATE_HZ                        ( ( TickType_t ) 1000 )
#define configCPU_CLOCK_HZ                        ( SystemCoreClock )
#define configUSE_PREEMPTION                    1
#define configUSE_PORT_OPTIMISED_TASK_SELECTION    1
#define configUSE_IDLE_HOOK                        1
#define configUSE_TICK_HOOK                        1
#define configMAX_PRIORITIES                    ( 5 )
#define configMINIMAL_STACK_SIZE                ( ( unsigned short ) 170 )
#define configTOTAL_HEAP_SIZE                    ( ( size_t ) ( 14 * 1024 ) )
#define configMAX_TASK_NAME_LEN                    ( 16 )
#define configUSE_TRACE_FACILITY                1
#define configUSE_16_BIT_TICKS                    0
#define configIDLE_SHOULD_YIELD                    1
#define configUSE_MUTEXES                        1
#define configQUEUE_REGISTRY_SIZE                5
#define configCHECK_FOR_STACK_OVERFLOW            2
#define configUSE_RECURSIVE_MUTEXES                1
#define configUSE_MALLOC_FAILED_HOOK            1
#define configUSE_APPLICATION_TASK_TAG            0
#define configUSE_COUNTING_SEMAPHORES            1

/* Software timer related definitions. */
#define configUSE_TIMERS                        1
#define configTIMER_TASK_PRIORITY                ( configMAX_PRIORITIES - 1 )
#define configTIMER_QUEUE_LENGTH                10
#define configTIMER_TASK_STACK_DEPTH            configMINIMAL_STACK_SIZE

/* Co-routine definitions. */
#define configUSE_CO_ROUTINES             0
#define configMAX_CO_ROUTINE_PRIORITIES ( 2 )

/* Set the following definitions to 1 to include the API function, or zero
to exclude the API function. */

#define INCLUDE_vTaskPrioritySet        1
#define INCLUDE_uxTaskPriorityGet        1
#define INCLUDE_vTaskDelete                1
#define INCLUDE_vTaskCleanUpResources    0
#define INCLUDE_vTaskSuspend            1
#define INCLUDE_vTaskDelayUntil            1
#define INCLUDE_vTaskDelay                1

/* Standard assert semantics. */
//#define configASSERT( x ) if( ( x ) == 0 ) { taskDISABLE_INTERRUPTS(); for(;; ); }    

/* Use the system definition, if there is one */
#ifdef __NVIC_PRIO_BITS
    #define configPRIO_BITS       __NVIC_PRIO_BITS
#else
    #define configPRIO_BITS       4        /* 15 priority levels */
#endif

#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY            15
#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY    5

/* The lowest priority. */
#define configKERNEL_INTERRUPT_PRIORITY     ( configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
/* Priority 5, or 95 as only the top four bits are implemented. */
/* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!
See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */
#define configMAX_SYSCALL_INTERRUPT_PRIORITY     ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )

/* Run time stats related macros. */
#define configGENERATE_RUN_TIME_STATS    0

/* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS
standard names. */
#define vPortSVCHandler SVC_Handler
#define xPortPendSVHandler PendSV_Handler
#define xPortSysTickHandler SysTick_Handler