.....
while (1)
{
if(g_read_usart == 1)
{
f.wx = s.XGYRO_OUT * 0.0008726646259972;
f.wy = s.YGYRO_OUT * 0.0008726646259972;
f.wz = s.ZGYRO_OUT * 0.0008726646259972;

adis_f.ax = s.XACCL_OUT * 0.033;
adis_f.ay = s.YACCL_OUT * 0.033;
adis_f.az = s.ZACCL_OUT * 0.033;

if(g_coarse == 1)
{
ca.bias_wx += adis_f.wx;
ca.bias_wx += adis_f.wx;
ca.bias_wx += adis_f.wx;

ca.m_ax += adis_f.ax;
ca.m_ay += adis_f.ay;
ca.m_az += adis_f.az;
}
........
}

static void Default_Handler(void)
{
    /* Go into an infinite loop. */
    while (1)
    {
    }
}

while (1)
{
if(g_read_usart == 1)
{
f.wx = s.XGYRO_OUT * 0.0008726646259972;
f.wy = s.YGYRO_OUT * 0.0008726646259972;
f.wz = s.ZGYRO_OUT * 0.0008726646259972;

f.ax = s.XACCL_OUT * 0.033;
f.ay = s.YACCL_OUT * 0.033;
f.az = s.ZACCL_OUT * 0.033;

if(g_coarse == 1)
{
ca.bias_wx += f.wx;
ca.bias_wx += f.wx;
ca.bias_wx += f.wx;

ca.m_ax += f.ax;
ca.m_ay += f.ay;
ca.m_az += f.az;
}
........
}

#include "stdafx.h"

#pragma pack(push, 4)
typedef struct
{
uint32_t r0;
uint32_t r1;
uint32_t r2;
uint32_t r3;
uint32_t r12;
uint32_t lr;
uint32_t pc;
uint32_t psr;
} stacked_regs_t;
#pragma pack(pop)

//=============================================================================
// This is called from the HardFault_HandlerAsm with a pointer the Fault stack as the parameter.
// We can then read the values from the stack and place them into local variables for ease of reading.
//=============================================================================
void hard_fault_debug_print(stacked_regs_t* stack) // prints 8 regs saved on the stack and so on
{
dprintf("\n\nHard fault:\n");
dprintf("R0 : %#08lx\n", stack->r0);
dprintf("R1 : %#08lx\n", stack->r1);
dprintf("R2 : %#08lx\n", stack->r2);
dprintf("R3 : %#08lx\n", stack->r3);
dprintf("R12 : %#08lx\n", stack->r12);
dprintf("LR : %#08lx\n", stack->lr);
dprintf("PC : %#08lx\n", stack->pc);
dprintf("PSR : %#08lx\n", stack->psr);
dprintf("BFAR: %#08lx\n", *((volatile uint32_t*)0xE000ED38));
dprintf("CFSR: %#08lx\n", *((volatile uint32_t*)0xE000ED28));
dprintf("HFSR: %#08lx\n", *((volatile uint32_t*)0xE000ED2C));
dprintf("DFSR: %#08lx\n", *((volatile uint32_t*)0xE000ED30));
dprintf("AFSR: %#08lx\n", *((volatile uint32_t*)0xE000ED3C));
}

//=============================================================================
// Alternative Hard Fault handler to help debug the reason for a fault.
// To use, edit the vector table to reference this function in the HardFault vector
// This code is suitable for Cortex-M3 and Cortex-M0 cores
//=============================================================================
__asm void HardFault_Handler(void) // __irq __attribute__((naked))
{
EXPORT HardFault_Handler

IMPORT hard_fault_debug_print

movs r0, #(1<<2)
mov r1, lr
tst r0, r1
beq do_msp
mrs r0, psp
B (hard_fault_debug_print)
B .
do_msp
mrs r0, msp
B (hard_fault_debug_print)
B .
}

#include <misc.h>
#include <stm32f4xx.h>
#include <stm32f4xx_rcc.h>
#include <stm32f4xx_gpio.h>
#include <stm32f4xx_tim.h>
#include <stm32f4xx_usart.h>

#include "Structurs.h"

#define SizeUsart 18
#define Coarse 200

uint32_t xbeg = 0, xend = 0;
float res = 0.0;

// Признаки
volatile char g_read_usart = 0;
volatile char g_read_adis = 0;
volatile char g_coarse = 1, g_con_coarse = 0;

volatile uint8_t pos = 0;

// Переменные для AHRS
uint16_t ADISword = 0x0000;
volatile _ADIS ADIS;
volatile _ADIS_f adis_f;
volatile _AHRS_coarse_alignment ahrs_ca;

void RCC_Configuration(void);
void TIM_init(void);
void GPIO_Configuration(void);
void USART2_Configuration(void);

void USART2_IRQHandler(void)
{
static int8_t data;
if(USART_GetITStatus(USART2, USART_IT_RXNE))
{
USART_ClearITPendingBit(USART2, USART_IT_RXNE);
data = (int8_t)(USART_ReceiveData(USART2) & 0x00FF);

ADISword |= (int16_t)data;

if(g_read_adis == 1)
{
ADIS.data[pos++] = data;

if(pos > (SizeUsart-1))
{
g_read_adis = 0;
g_read_usart = 1;
pos = 0;
}
}

if(ADISword == 16405)
{
g_read_adis = 1; ADISword = 0x0000; pos = 0;
}

ADISword <<= 8;
}
}

int main(void)
{
RCC_Configuration();
// TIM_init();
GPIO_Configuration();
USART2_Configuration();

// Начальная инициализация
ahrs_ca.bias_wx = 0.0;
ahrs_ca.bias_wy = 0.0;
ahrs_ca.bias_wz = 0.0;

ahrs_ca.m_ax = 0.0;
ahrs_ca.m_ay = 0.0;
ahrs_ca.m_az = 0.0;

ahrs_ca.m_mx = 0.0;
ahrs_ca.m_my = 0.0;
ahrs_ca.m_mz = 0.0;

while (1)
{
if(g_read_usart == 1)
{// 1
g_read_usart = 0;

if(ADIS.s.XGYRO_OUT & 0x2000) ADIS.s.XGYRO_OUT |= 0xC000;
else ADIS.s.XGYRO_OUT &= 0x3FFF;
if(ADIS.s.YGYRO_OUT & 0x2000) ADIS.s.YGYRO_OUT |= 0xC000;
else ADIS.s.YGYRO_OUT &= 0x3FFF;
if(ADIS.s.ZGYRO_OUT & 0x2000) ADIS.s.ZGYRO_OUT |= 0xC000;
else ADIS.s.ZGYRO_OUT &= 0x3FFF;

if(ADIS.s.XACCL_OUT & 0x2000) ADIS.s.XACCL_OUT |= 0xC000;
else ADIS.s.XACCL_OUT &= 0x3FFF;
if(ADIS.s.YACCL_OUT & 0x2000) ADIS.s.YACCL_OUT |= 0xC000;
else ADIS.s.YACCL_OUT &= 0x3FFF;
if(ADIS.s.ZACCL_OUT & 0x2000) ADIS.s.ZACCL_OUT |= 0xC000;
else ADIS.s.ZACCL_OUT &= 0x3FFF;

if(ADIS.s.XMAGN_OUT & 0x2000) ADIS.s.XMAGN_OUT |= 0xC000;
else ADIS.s.XMAGN_OUT &= 0x3FFF;
if(ADIS.s.YMAGN_OUT & 0x2000) ADIS.s.YMAGN_OUT |= 0xC000;
else ADIS.s.YMAGN_OUT &= 0x3FFF;
if(ADIS.s.ZMAGN_OUT & 0x2000) ADIS.s.ZMAGN_OUT |= 0xC000;
else ADIS.s.ZMAGN_OUT &= 0x3FFF;

adis_f.wx = ADIS.s.XGYRO_OUT * 0.0008726646259972;
adis_f.wy = ADIS.s.YGYRO_OUT * 0.0008726646259972;
adis_f.wz = ADIS.s.ZGYRO_OUT * 0.0008726646259972;

adis_f.ax = ADIS.s.XACCL_OUT * 0.033;
adis_f.ay = ADIS.s.YACCL_OUT * 0.033;
adis_f.az = ADIS.s.ZACCL_OUT * 0.033;

adis_f.mx = ADIS.s.XMAGN_OUT * 0.0005;
adis_f.my = ADIS.s.YMAGN_OUT * 0.0005;
adis_f.mz = ADIS.s.ZMAGN_OUT * 0.0005;


if(g_coarse == 1)
{// нач. выставка
ahrs_ca.bias_wx = ahrs_ca.bias_wx + adis_f.wx;
ahrs_ca.bias_wx += adis_f.wx;
ahrs_ca.bias_wx += adis_f.wx;

ahrs_ca.m_ax += adis_f.ax;
ahrs_ca.m_ay += adis_f.ay;
ahrs_ca.m_az += adis_f.az;

ahrs_ca.m_mx += adis_f.mx;
ahrs_ca.m_my += adis_f.my;
ahrs_ca.m_mz += adis_f.mz;

if(g_con_coarse++ > Coarse)
{
ahrs_ca.bias_wx /= Coarse;
ahrs_ca.bias_wx /= Coarse;
ahrs_ca.bias_wx /= Coarse;

ahrs_ca.m_ax /= Coarse;
ahrs_ca.m_ay /= Coarse;
ahrs_ca.m_az /= Coarse;

ahrs_ca.m_mx /= Coarse;
ahrs_ca.m_my /= Coarse;
ahrs_ca.m_mz /= Coarse;

g_coarse = 0;
}

}// нач. выставка

}// 1
}
}

//--------------------------------------------------------------------------
void RCC_Configuration(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
}
//--------------------------------------------------------------------------
void TIM_init(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_BDTRInitTypeDef TIM_BDTRInitStructure;

uint16_t TimerPeriod = 0;

TimerPeriod = (SystemCoreClock / 1500) - 1;

TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = TimerPeriod;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;

TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);

TIM_Cmd(TIM1, ENABLE);
TIM_CtrlPWMOutputs(TIM1, ENABLE);
}
//--------------------------------------------------------------------------
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);
}
//--------------------------------------------------------------------------
void USART2_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;

USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

USART_Init(USART2, &USART_InitStructure);

NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);

USART_Cmd(USART2, ENABLE);
}