// FILE: Tools.c
#include "params.h"
#include "DSP281x_Device.h"     // DSP281x Headerfile Include File
#include "Archives.h" 
#include "tools.h"
#include "DriveControl.h"
#include "modbus.h"
#include "RemoteControl.h"
#include "FRAM.h"

const _iq RadToDeg 						= _IQ(57.295779513082320876798154814105);
const _iq Fur_Koef 						= _IQ(0.016666666666666666666666666666667);

const _iq VoltageAC_Scale_K 			= _IQ(0.28029772329246935201401050788091);
const _iq Current_Scale_K 				= _IQ(0.0062);
const _iq Pressure_Scale_K 				= _IQ(0.00915331807780320366132723112128);
const _iq Temperature_Scale_K 			= _IQ(0.09441087613293051359516616314199);

const _iq DoublePi 						= _IQ(6.283185307179586476925286766559);
const _iq Pi 							= _IQ(3.1415926535897932384626433832795);

const _iq TrueRMS_DownK					= _IQ(0.01666666666666666666666666666667);// 1/(64*sqrt(60))=0.00201717882614969629436420072905  1/(64*sqrt(120))=0.0014263608268363700871275254760438

TrueRMS CompressorPressure_TrueRMS;
TrueRMS CompressorTemperature_TrueRMS;
TrueRMS AmbientTemperature_TrueRMS;

unsigned short ADC_ready_timer = 5;

short AC_Signals[6];

short CompressorPressure_Signal		[2][60];
short CompressorTemperature_Signal	[2][60];
short AmbientTemperature_Signal		[2][60];

unsigned short Uac_PhaseA_On 			= 0;
unsigned short Uac_PhaseB_On 			= 0;
unsigned short Uac_PhaseC_On 			= 0;

unsigned short Uac_Sync		 			= 0;
unsigned short Uac_PhaseOrder 			= 0;

unsigned short active_ac_signals_mass	= 1;
unsigned short active_60_signals_mass	= 1;
unsigned short analize_dc_signals		= 1;
unsigned short angle 					= 0; //Угол виртуальной синусоиды

unsigned short PowerValuesCalc_flag 	= 0;

_iq MYsin[120];
_iq MYcos[120];

ADC_VAL Ia;
ADC_VAL Ib;
ADC_VAL Ic;

ADC_VAL Uab;
ADC_VAL Uba;
ADC_VAL Ubc;
ADC_VAL Ucb;
ADC_VAL Uca;
ADC_VAL Uac;

ADC_VAL CompressorPressure;
ADC_VAL CompressorTemperature;
ADC_VAL AmbientTemperature;

_iq UabUbc_Shifting;
_iq UbcUca_Shifting;
_iq UcaUab_Shifting;

extern void furie_calc(void);

void SIN_COS_INIT(void)
{
	unsigned short SinCosDot;
	for( SinCosDot = 0; SinCosDot < 120; SinCosDot++ )
	{
		MYsin[SinCosDot] = _IQsin(_IQ(SinCosDot * 0.052359877559829887307710723054658));
		MYcos[SinCosDot] = _IQcos(_IQ(SinCosDot * 0.052359877559829887307710723054658));
	}
}

void PowerCalc()
{
		_iq Power1;
		_iq Power2;

		_iq ActivePower;

		Power1 = _IQmag(_IQmpy(Ubc.Furie_A, Ib.Furie_A) - _IQmpy(Ubc.Furie_B, Ib.Furie_B), _IQmpy(Ubc.Furie_A, Ib.Furie_B) + _IQmpy(Ubc.Furie_B, Ib.Furie_A));
		Power2 = _IQmag(_IQmpy(Uca.Furie_B, Ia.Furie_B) - _IQmpy(Uca.Furie_A, Ia.Furie_A), _IQmpy(Uca.Furie_A, Ia.Furie_B) + _IQmpy(Uca.Furie_B, Ia.Furie_A));

		ActivePower = Power1 + Power2;
}

void TruePWM_init(void)
{
	CompressorPressure_TrueRMS.Integral=_IQ(0);
	CompressorPressure_TrueRMS.Counter = 0;

	CompressorTemperature_TrueRMS.Integral=_IQ(0);
	CompressorTemperature_TrueRMS.Counter = 0;

	AmbientTemperature_TrueRMS.Integral=_IQ(0);
	AmbientTemperature_TrueRMS.Counter = 0;
}

void ADCtools_timer1ms(void)
{
	if (Uab.Sync_T)
	{
		Uab.Sync_T--;
	}
	if (Uba.Sync_T)
	{
		Uba.Sync_T--;
	}
	if (Ubc.Sync_T)
	{
		Ubc.Sync_T--;
	}
	if (Ucb.Sync_T)
	{
		Ucb.Sync_T--;
	}
	if (Uca.Sync_T)
	{
		Uca.Sync_T--;
	}
	if (Uac.Sync_T)
	{
		Uac.Sync_T--;
	}
}

void SetADCValue(ADC_VAL *V) //Установка значений
	{
	unsigned char MedianFilter_FieldId;

	for( MedianFilter_FieldId = 0; MedianFilter_FieldId < MEDIAN_FILTER_WINDOW_SIZE; MedianFilter_FieldId++ )
		{
		V->m_f[MedianFilter_FieldId] = 0;
		}

	V->Sync_T 	= 0;
	V->Desync 	= 0;
	V->Furie_A 	= _IQ(0);
	V->Furie_B 	= _IQ(0);
	V->freq 	= _IQ(50);
	V->MeanVal 	= _IQ(0);
	V->PhiReal 	= _IQ(0);
	V->m_f_cnt 	= 0;	//Текущее количество элементов в массиве для обработки медианным фильтром
	}

void ADCtools_init(void)
{
	SIN_COS_INIT();

	SetADCValue(&Ia);
	SetADCValue(&Ib);
	SetADCValue(&Ic);

	SetADCValue(&Uab);
	SetADCValue(&Uba);

	SetADCValue(&Ubc);
	SetADCValue(&Uca);

	SetADCValue(&Ucb);
	SetADCValue(&Uac);

	SetADCValue(&CompressorPressure);
	SetADCValue(&CompressorTemperature);
	SetADCValue(&AmbientTemperature);

	TruePWM_init();
}

void IQ_Power_Parameters_Calc(void)
	{
	_iq rezult;

	Uab.K = _IQmpy(FRAM_Iq32Inp[FI_f32_Uab_K],VoltageAC_Scale_K);
	Ubc.K = _IQmpy(FRAM_Iq32Inp[FI_f32_Ubc_K],VoltageAC_Scale_K);
	Uca.K = _IQmpy(FRAM_Iq32Inp[FI_f32_Uca_K],VoltageAC_Scale_K);

	rezult = FRAM_Iq32Inp[FI_f32_Ia_K];
	rezult = _IQmpy(rezult, FRAM_Iq32Inp[FI_f32_Ia_KT]);
	rezult = _IQmpy(rezult, Current_Scale_K);
	Ia.K = rezult;

	Ib.TransformK = FRAM_Iq32Inp[FI_f32_Ib_KT];
	rezult = FRAM_Iq32Inp[FI_f32_Ib_K];
	rezult = _IQmpy(rezult, Ib.TransformK);
	rezult = _IQmpy(rezult, Current_Scale_K);
	Ib.K = rezult;

	Ic.TransformK = FRAM_Iq32Inp[FI_f32_Ic_KT];
	rezult = FRAM_Iq32Inp[FI_f32_Ic_K];
	rezult = _IQmpy(rezult, Ic.TransformK);
	rezult = _IQmpy(rezult, Current_Scale_K);
	Ic.K = rezult;

	CompressorPressure.K    = _IQmpy(FRAM_Iq32Inp[FI_f32_CompressorPressure_K], Pressure_Scale_K);
	CompressorTemperature.K = _IQmpy(FRAM_Iq32Inp[FI_f32_CompressorTemperature_K], Temperature_Scale_K);
	AmbientTemperature.K    = _IQmpy(FRAM_Iq32Inp[FI_f32_AmbientTemperature_K], Temperature_Scale_K);
	}

void TrueRMS_IntegralCalc(TrueRMS *Var_TrueRMS, _iq Integral_d)
	{
	_iq DownVal;

	DownVal = _IQmpy(Integral_d, TrueRMS_DownK); //Защита от переполнения переменной IQ
	Var_TrueRMS->Integral += DownVal;
	}

_iq TrueRMS_Calc(TrueRMS *Var_TrueRMS)
	{
	Var_TrueRMS->MeanValue = Var_TrueRMS->Integral;
	Var_TrueRMS->Integral = _IQ(0);

	return Var_TrueRMS->MeanValue;
	}

void Furie_factors_calc(ADC_VAL *V, int ActualValue, unsigned short DotId) //Вычисление коефициентов Фурье
 	{
	V->Furie_tmpA += _IQmpy(_IQmpy(_IQ((float)ActualValue),MYcos[DotId]),Fur_Koef);
	V->Furie_tmpB += _IQmpy(_IQmpy(_IQ((float)ActualValue),MYsin[DotId]),Fur_Koef);
	}

void ADC_median_filter(ADC_VAL *V)
{
	unsigned char MF_i, MF_n;
	_iq tmp;
	_iq sort_m_f[MEDIAN_FILTER_WINDOW_SIZE];

	if (V->m_f_cnt < MEDIAN_FILTER_WINDOW_SIZE)
	{
		V->m_f[V->m_f_cnt] = V->Val;
		V->m_f_cnt++; //Добавление элементов в массив при первоначальной инициализации
	}
	else
	{
		for( MF_n = 0; MF_n < MEDIAN_FILTER_WINDOW_SIZE - 1; MF_n++ )
		{
			V->m_f[MF_n] = V->m_f[MF_n + 1];
		}
		V->m_f[MEDIAN_FILTER_WINDOW_SIZE - 1] = V->Val; //Внедряем текущее значение
	}

	if (V->m_f_cnt > MEDIAN_FILTER_WINDOW_SIZE)
	{
		V->m_f_cnt = MEDIAN_FILTER_WINDOW_SIZE;
	}

	for(MF_n = 0; MF_n < V->m_f_cnt; MF_n++)
	{
		sort_m_f[MF_n] = V->m_f[MF_n];
	}

	for(MF_i = 0; MF_i < V->m_f_cnt - 1; MF_i++) //Сортировка пузырьком
	{
		for(MF_n = MF_i + 1; MF_n < V->m_f_cnt; MF_n++)
		{
			if (sort_m_f[MF_i] > sort_m_f[MF_n]) //Если текущее значение меньше сравниваемого (массив сравниваемых элементов отсортирован в порядке возрастания)
			{
				tmp = sort_m_f[MF_n];
				sort_m_f[MF_n] = sort_m_f[MF_i];
				sort_m_f[MF_i] = tmp;
			}
		}
	}
	V->MeanVal = sort_m_f[(V->m_f_cnt-1) / 2];
}

void ADC_Furie_final(ADC_VAL *V)//unsigned char ActualKoefNumber, unsigned char ActualTauNumber, float ActualTransformKoef) //ДлЯ рассчета действующего значениЯ
{
	V->UnscaleVal 	= _IQmag(V->Furie_A,V->Furie_B);
	V->PhiReal 		= _IQatan2(V->Furie_A,V->Furie_B);
}

void Furie_factors_fixation(ADC_VAL *V)//unsigned char ActualKoefNumber, unsigned char ActualTauNumber, float ActualTransformKoef) //ДлЯ рассчета действующего значениЯ
{
	V->Furie_A = V->Furie_tmpA;
	V->Furie_B = V->Furie_tmpB;

	V->Furie_tmpA = 0;
	V->Furie_tmpB = 0;
}


void ADC_Scaling(ADC_VAL *a_ADC_Val, _iq a_ADC_ZeroRef )
{
	a_ADC_Val->Val = _IQmpy(a_ADC_Val->UnscaleVal - a_ADC_ZeroRef, a_ADC_Val->K);
}

void DC_Filter(void)
{
	unsigned short DCFilter_DotId;

	for( DCFilter_DotId = 0; DCFilter_DotId < 60; DCFilter_DotId++ )
		{
		TrueRMS_IntegralCalc(&CompressorPressure_TrueRMS,_IQ((float)CompressorPressure_Signal[!active_60_signals_mass][DCFilter_DotId]));
		TrueRMS_IntegralCalc(&CompressorTemperature_TrueRMS,_IQ((float)CompressorTemperature_Signal[!active_60_signals_mass][DCFilter_DotId]));
		TrueRMS_IntegralCalc(&AmbientTemperature_TrueRMS,_IQ((float)AmbientTemperature_Signal[!active_60_signals_mass][DCFilter_DotId]));
		}

	CompressorPressure.UnscaleVal    = TrueRMS_Calc(&CompressorPressure_TrueRMS);
	CompressorTemperature.UnscaleVal = TrueRMS_Calc(&CompressorTemperature_TrueRMS);
	AmbientTemperature.UnscaleVal    = TrueRMS_Calc(&AmbientTemperature_TrueRMS);

	ADC_Scaling(&CompressorPressure, 	FRAM_Iq32Inp[FI_f32_CompressorPressure_ZeroRef]);
	ADC_Scaling(&CompressorTemperature, FRAM_Iq32Inp[FI_f32_CompressorTemperature_ZeroRef]);
	ADC_Scaling(&AmbientTemperature, 	FRAM_Iq32Inp[FI_f32_AmbientTemperature_ZeroRef]);

	ADC_median_filter(&CompressorPressure);
	ADC_median_filter(&CompressorTemperature);
	ADC_median_filter(&AmbientTemperature);
}

void PhaseDesync_Analize(ADC_VAL *V)//Разделить на две процедуры (фильтрацию и анализ рассинхронизации (включить VS_Sync))
{
	if (V->DelPhiReal > FRAM_Iq32Inp[FI_f32_Uac_VS_DesyncAngle])
	{
		V->Desync = 1;
		V->Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //В противном случае обнуляем время до полной синхронизации
	}
	else
	{
		if (V->Sync_T == 0)//Если синосоида рассинхронизирована
		{
			V->Desync = 0; //Выходим из режима виртуализации синусоиды
		}
	}
}

_iq PhaseShifting(_iq Phase1, _iq Phase2, unsigned short MeasureType)
{
	_iq Rezult;
	if (Phase1 > Phase2) //Сектор переходит через ноль
	{
		Rezult = DoublePi - Phase1 + Phase2;
	}
	else
	{
		Rezult = (Phase2 - Phase1);
	}
	if ((Rezult > Pi) && (MeasureType == BIPOLAR))
	{
		Rezult = Rezult - DoublePi;
	}

	Rezult = _IQmpy(Rezult, RadToDeg);//Перевод смещения из радиан в градусы

	return Rezult;
}

unsigned short PhaseOrder(_iq Phase1, _iq Phase2, _iq Phase3)
{
	return (PhaseShifting(Phase1, Phase2, UNIPOLAR) >= PhaseShifting(Phase1, Phase3, UNIPOLAR));
}

void DelPhiRealCalc(ADC_VAL *V)
{
	_iq del_fi0;

	if (V->PhiReal < _IQ(0.0))
	{
		V->PhiReal += DoublePi;
	}

	del_fi0 = _IQabs(V->PhiReal-V->PhiRealOld);

	if (del_fi0 > Pi)
	{
		del_fi0 -= DoublePi;
		if (V->PhiReal > V->PhiRealOld)
		{
			V->PhiRealOld += DoublePi;
		}
		else
		{
			V->PhiReal += DoublePi;
		}

		if (V->PhiReal >= DoublePi)
		{
			V->PhiReal -= DoublePi;
		}
	}

	V->DelPhiReal = _IQmpy(_IQabs(del_fi0),RadToDeg);
	V->PhiRealOld = V->PhiReal;
}

void Uac_PhaseOff_Analize(void)
{
	Uac_PhaseA_On = (_IQabs(UcaUab_Shifting) > FRAM_Iq32Inp[FI_f32_Uac_PhaseOff_v]);
	Uac_PhaseB_On = (_IQabs(UabUbc_Shifting) > FRAM_Iq32Inp[FI_f32_Uac_PhaseOff_v]);
	Uac_PhaseC_On = (_IQabs(UbcUca_Shifting) > FRAM_Iq32Inp[FI_f32_Uac_PhaseOff_v]);
}

void PhaseDesync_PhaseOffProcessing(void)
{
	if (!Uac_PhaseA_On)//Ложная синусоида при пропаже фазы A (CA===CB, AC===BC)
	{
		Uac.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uac.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Uca.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uca.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации

		Uab.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uab.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Uba.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uba.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
	}

	if (!Uac_PhaseB_On)//Ложные синусоиды при пропаже фазы B
	{
		Uab.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uab.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Uba.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uba.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации

		Ucb.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Ucb.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Ubc.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Ubc.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
	}
	
	if (!Uac_PhaseC_On) //Ложная синусоида при пропаже фазы C (AC===AB, CA===BA)
	{
		Uac.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uac.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Uca.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Uca.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации

		Ubc.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Ubc.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
		Ucb.Desync = 1; //устанавливаем режим виртуальной синусоиды
		Ucb.Sync_T = FRAM.Inp.i16[FI_i16_Uac_VS_SyncT]; //обнуляем время до полной синхронизации
	}
}

void voltage_phase_angle_calc(void)
{
	Uba.PhiReal = Uab.PhiReal + Pi;

	Ucb.PhiReal = Ubc.PhiReal + Pi;
	Uac.PhiReal = Uca.PhiReal + Pi;

	DelPhiRealCalc(&Uab);	//Рассчет приращения фазофого двига за периад синусоиды
	DelPhiRealCalc(&Ubc);
	DelPhiRealCalc(&Uca);
	DelPhiRealCalc(&Uba);
	DelPhiRealCalc(&Ucb);
	DelPhiRealCalc(&Uac);

	PhaseDesync_Analize(&Uab);//Анализ рассинхронизации синусоид напряжения по приращению фазофого двига
	PhaseDesync_Analize(&Ubc);
	PhaseDesync_Analize(&Uca);
	PhaseDesync_Analize(&Uba);
	PhaseDesync_Analize(&Ucb);
	PhaseDesync_Analize(&Uac);

	Uac_Sync = ! ((Uab.Desync||Uba.Desync||Ubc.Desync||Ucb.Desync||Uca.Desync||Uac.Desync));

	UabUbc_Shifting = PhaseShifting(Uab.PhiReal,Ubc.PhiReal, BIPOLAR);
	UbcUca_Shifting = PhaseShifting(Ubc.PhiReal,Uca.PhiReal, BIPOLAR);
	UcaUab_Shifting = PhaseShifting(Uca.PhiReal,Uab.PhiReal, BIPOLAR);

	Uac_PhaseOrder = PhaseOrder(Uab.PhiReal,Ubc.PhiReal,Uca.PhiReal);

	Uac_PhaseOff_Analize();
	PhaseDesync_PhaseOffProcessing();
}


/*********************************************************************************************************************************/
/******************************************ФУНКЦИЯ ПРОВЕРКИ ПОДКЛЮЧЕНИЯ ДАТЧИКА 4-20mA********************************************/
/*********************************************************************************************************************************/
#define SENSOR_OFF						0
#define SENSOR_ON						1
#define SENSOR_OFF_PRESCALE				200.0

unsigned char ADC_Sensor_4_20mA_State(ADC_VAL *a_ADC_Val)
{
	unsigned char SensorState = SENSOR_OFF;

	if (a_ADC_Val->UnscaleVal > _IQ(SENSOR_OFF_PRESCALE))
	{
		SensorState = SENSOR_ON;
	}

	return SensorState;
}
/*********************************************************************************************************************************/

void Tools_ADC(void) //Архививирование рассчитанных значений для внешнего доступа других процессоров
{
	IQ_Power_Parameters_Calc();

	furie_calc();
	voltage_phase_angle_calc();

	ADC_median_filter(&Uab);
	ADC_median_filter(&Ubc);
	ADC_median_filter(&Uca);
	ADC_median_filter(&Ia);
	ADC_median_filter(&Ib);
	ADC_median_filter(&Ic);

	//Сохранение данных длЯ последующей передачи на экран
	if ((Uab.MeanVal > FRAM_Iq32Inp[FI_f32_Uab_Min]) && (SRAM_Out.b01[RO_b01_Power_PhaseA_On]) && (SRAM_Out.b01[RO_b01_Power_PhaseB_On]))
	{
		 SRAM_Out.f32[RO_f32_Uab_V] = _IQtoF(Uab.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Uab_V] = 0;
	}

	if ((Ubc.MeanVal > FRAM_Iq32Inp[FI_f32_Ubc_Min]) && (SRAM_Out.b01[RO_b01_Power_PhaseB_On]) && (SRAM_Out.b01[RO_b01_Power_PhaseC_On]))
	{
	 	SRAM_Out.f32[RO_f32_Ubc_V] = _IQtoF(Ubc.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Ubc_V] = 0;
	}

	if ((Uca.MeanVal > FRAM_Iq32Inp[FI_f32_Uca_Min]) && (SRAM_Out.b01[RO_b01_Power_PhaseC_On]) && (SRAM_Out.b01[RO_b01_Power_PhaseA_On]))
	{
		SRAM_Out.f32[RO_f32_Uca_V] = _IQtoF(Uca.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Uca_V] = 0;
	}

	if (Ia.MeanVal > FRAM_Iq32Inp[FI_f32_Ia_Min])
	{
	 	SRAM_Out.f32[RO_f32_Ia_V] = _IQtoF(Ia.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Ia_V] = 0;
	}

	if (Ib.MeanVal > FRAM_Iq32Inp[FI_f32_Ib_Min])
	{
	 	SRAM_Out.f32[RO_f32_Ib_V] = _IQtoF(Ib.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Ib_V] = 0;
	}

	if (Ic.MeanVal > FRAM_Iq32Inp[FI_f32_Ic_Min])
	{
	 	SRAM_Out.f32[RO_f32_Ic_V] = _IQtoF(Ic.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_Ic_V] = 0;
	}

	SRAM_Out.f32[RO_f32_I0_V] = 0;

	if (Uab.MeanVal > FRAM_Iq32Inp[FI_f32_Uab_Min])
	{
		Uab.freq = _IQdiv(_IQ(314.15926535897932384626433832795), (DoublePi - Uab.DelPhiReal));
	}
	else
	{
		Uab.freq = 0;
	}

	if (Ubc.MeanVal > FRAM_Iq32Inp[FI_f32_Ubc_Min])
	{
		Ubc.freq = _IQdiv(_IQ(314.15926535897932384626433832795), (DoublePi - Ubc.DelPhiReal));
	}
	else
	{
		Ubc.freq = 0;
	}

	if (Uca.MeanVal > FRAM_Iq32Inp[FI_f32_Uca_Min])
	{
		Uca.freq = _IQdiv(_IQ(314.15926535897932384626433832795), (DoublePi - Uca.DelPhiReal));
	}
	else
	{
		Uca.freq = 0;
	}

	SRAM_Out.f32[RO_f32_Uab_Frq] = _IQtoF(Uab.freq);
	SRAM_Out.f32[RO_f32_Ubc_Frq] = _IQtoF(Uab.freq);
	SRAM_Out.f32[RO_f32_Uca_Frq] = _IQtoF(Uab.freq);

	if (CompressorPressure.MeanVal > FRAM_Iq32Inp[FI_f32_CompressorPressure_Min])
	{
		SRAM_Out.f32[RO_f32_CompressorPressure_Ref] 	= _IQtoF(CompressorPressure.MeanVal);
	}
	else
	{
		SRAM_Out.f32[RO_f32_CompressorPressure_Ref] 	= 0.0;
	}

	SRAM_Out.b01[RO_b01_CompressorPressure_SensorState] 		= ADC_Sensor_4_20mA_State(&CompressorPressure);
	CompressorPressure_Hight.SensorOn 						= SRAM_Out.b01[RO_b01_CompressorPressure_SensorState];
	CompressorPressure_Low.SensorOn 						= SRAM_Out.b01[RO_b01_CompressorPressure_SensorState];

	SRAM_Out.f32[RO_f32_CompressorTemperature_Ref] 			= _IQtoF(CompressorTemperature.MeanVal);
	SRAM_Out.b01[RO_b01_CompressorTemperature_SensorState] 	= ADC_Sensor_4_20mA_State(&CompressorTemperature);
	CompressorTemperature_Hight.SensorOn 					= SRAM_Out.b01[RO_b01_CompressorTemperature_SensorState];
	CompressorTemperature_Low.SensorOn 						= SRAM_Out.b01[RO_b01_CompressorTemperature_SensorState];

	SRAM_Out.f32[RO_f32_AmbientTemperature_Ref] 				= _IQtoF(AmbientTemperature.MeanVal);
	SRAM_Out.b01[RO_b01_AmbientTemperature_SensorState] 		= ADC_Sensor_4_20mA_State(&AmbientTemperature);
	AmbientTemperature_Hight.SensorOn 						= SRAM_Out.b01[RO_b01_AmbientTemperature_SensorState];
	AmbientTemperature_Low.SensorOn 						= SRAM_Out.b01[RO_b01_AmbientTemperature_SensorState];

	SRAM_Out.f32[RO_f32_Uab_DeltaPhiReal] 					= _IQtoF(Uab.DelPhiReal);
	SRAM_Out.b01[RO_b01_Power_Uab_Sync] 						= !Uab.Desync;

	SRAM_Out.f32[RO_f32_Ubc_DeltaPhiReal] 					= _IQtoF(Ubc.DelPhiReal);
	SRAM_Out.b01[RO_b01_Power_Ubc_Sync] 						= !Ubc.Desync;

	SRAM_Out.f32[RO_f32_Uca_DeltaPhiReal] 					= _IQtoF(Uca.DelPhiReal);
	SRAM_Out.b01[RO_b01_Power_Uab_Sync] 						= !Uca.Desync;

	SRAM_Out.b01[RO_b01_Power_Uac_Sync]						= Uac_Sync;

	if ((Uab.MeanVal > FRAM_Iq32Inp[FI_f32_Uab_Min]) && (Ubc.MeanVal > FRAM_Iq32Inp[FI_f32_Uab_Min]) && (Uca.MeanVal > FRAM_Iq32Inp[FI_f32_Uab_Min]))
	{
		SRAM_Out.f32[RO_f32_UabUbc_Shifting] 		= _IQtoF(UabUbc_Shifting);
		SRAM_Out.f32[RO_f32_UbcUca_Shifting] 		= _IQtoF(UbcUca_Shifting);
		SRAM_Out.f32[RO_f32_UcaUab_Shifting] 		= _IQtoF(UcaUab_Shifting);

		SRAM_Out.b01[RO_b01_Power_PhaseA_On] 		= Uac_PhaseA_On;
		SRAM_Out.b01[RO_b01_Power_PhaseB_On] 		= Uac_PhaseB_On;
		SRAM_Out.b01[RO_b01_Power_PhaseC_On] 		= Uac_PhaseC_On;

		SRAM_Out.b01[RO_b01_Power_Uac_PhaseOrder]	= Uac_PhaseOrder;
	}
	else
	{
		SRAM_Out.f32[RO_f32_UabUbc_Shifting] 		= 0.0;
		SRAM_Out.f32[RO_f32_UbcUca_Shifting] 		= 0.0;
		SRAM_Out.f32[RO_f32_UcaUab_Shifting] 		= 0.0;

		SRAM_Out.b01[RO_b01_Power_PhaseA_On] 		= 0;
		SRAM_Out.b01[RO_b01_Power_PhaseB_On] 		= 0;
		SRAM_Out.b01[RO_b01_Power_PhaseC_On] 		= 0;

		SRAM_Out.b01[RO_b01_Power_Uac_PhaseOrder]	= 1;
	}

	UserLed1_Val = SRAM_Out.b01[RO_b01_CompressorPressure_SensorState];
	UserLed2_Val = SRAM_Out.b01[RO_b01_CompressorTemperature_SensorState];
	UserLed3_Val = SRAM_Out.b01[RO_b01_AmbientTemperature_SensorState];
}

void furie_calc(void)
{
	Ic.Furie_A = -Ia.Furie_A - Ib.Furie_A;
	Ic.Furie_B = -Ia.Furie_B - Ib.Furie_B;

	ADC_Furie_final(&Uab);
	ADC_Furie_final(&Ubc);
	ADC_Furie_final(&Uca);
	ADC_Furie_final(&Ia);
	ADC_Furie_final(&Ib);
	ADC_Furie_final(&Ic);

	ADC_Scaling (&Uab, 	_IQ(0.0));
	ADC_Scaling (&Ubc, 	_IQ(0.0));
	ADC_Scaling (&Uca, 	_IQ(0.0));
	ADC_Scaling (&Ia,	_IQ(0.0));
	ADC_Scaling (&Ib, 	_IQ(0.0));
	ADC_Scaling (&Ic, 	_IQ(0.0));
	}

interrupt void  adc_isr(void)
	{
		static unsigned short angle60 = 0;

		//Получение значений с аналого-цифрового преобразователЯ
		AC_Signals[Cur_Uab] 	= (AdcRegs.ADCRESULT0 >> 4) 	- 	(AdcRegs.ADCRESULT1 >> 4);
		AC_Signals[Cur_Ubc] 	= (AdcRegs.ADCRESULT2 >> 4) 	- 	(AdcRegs.ADCRESULT3 >> 4);
		AC_Signals[Cur_Uca] 	= (AdcRegs.ADCRESULT4 >> 4) 	- 	(AdcRegs.ADCRESULT5 >> 4);
		AC_Signals[Cur_Ia] 		= (AdcRegs.ADCRESULT8 >> 4) 	- 	(AdcRegs.ADCRESULT9 >> 4);
		AC_Signals[Cur_Ib] 		= (AdcRegs.ADCRESULT10 >> 4) 	- 	(AdcRegs.ADCRESULT11 >> 4);
		AC_Signals[Cur_Ic] 		= -AC_Signals[Cur_Ia] 			-  	AC_Signals[Cur_Ib];

		CompressorPressure_Signal[active_60_signals_mass][angle60]    = (AdcRegs.ADCRESULT14 >> 4) - (AdcRegs.ADCRESULT15 >> 4);
		CompressorTemperature_Signal[active_60_signals_mass][angle60] = (AdcRegs.ADCRESULT12 >> 4) - (AdcRegs.ADCRESULT13 >> 4);
		AmbientTemperature_Signal[active_60_signals_mass][angle60]    = (AdcRegs.ADCRESULT6  >> 4) - (AdcRegs.ADCRESULT7  >> 4);

		Furie_factors_calc(&Uab, AC_Signals[Cur_Uab],	angle);
		Furie_factors_calc(&Ubc, AC_Signals[Cur_Ubc], 	angle);
		Furie_factors_calc(&Uca, AC_Signals[Cur_Uca],	angle);
		Furie_factors_calc(&Ia,  AC_Signals[Cur_Ia], 	angle);
		Furie_factors_calc(&Ib,  AC_Signals[Cur_Ib], 	angle);

		angle++; //рассчет угла виртуальной синусоиды
		angle60++;

		if ((angle == 30) || (angle == 90)) //Задаем период квантования регулятора 10 ms (два раза за синусоиду)
		{
			if (ADC_ready_timer == 0)
			{
				DriveControl_flag = 1;
			}
			active_60_signals_mass = !active_60_signals_mass;
			angle60 = 0;
		}

	if (angle >= 120)
	{
		if (ADC_ready_timer)
		{
			ADC_ready_timer--;
		}
		else
		{
			Furie_factors_fixation(&Uab);
			Furie_factors_fixation(&Ubc);
			Furie_factors_fixation(&Uca);
			Furie_factors_fixation(&Ia);
			Furie_factors_fixation(&Ib);
			PowerValuesCalc_flag = 1;
		}
		active_ac_signals_mass = !active_ac_signals_mass;
		angle = 0;
	}

	//КВИТИРОВАНИЕ ПРЕРЫВАНИЯ

 	AdcRegs.ADCTRL2.bit.RST_SEQ1 	= 1;         		// Reset SEQ1
 	AdcRegs.ADCST.bit.INT_SEQ1_CLR 	= 1;       			// Clear INT SEQ1 bit
	AdcRegs.ADCTRL2.bit.RST_SEQ2 	= 1;         		// Reset SEQ2
	AdcRegs.ADCST.bit.INT_SEQ2_CLR 	= 1;       			// Clear INT SEQ2 bit
	PieCtrlRegs.PIEACK.all 			= PIEACK_GROUP1;   	// Acknowledge interrupt to PIE
}

