Dmitry Kovalev
fork
Command.c
- Committer:
- Kovalev_D
- Date:
- 2017-09-04
- Revision:
- 216:189b0ea1dc38
- Parent:
- 215:b58b887fd367
- Child:
- 218:b4067cac75c0
File content as of revision 216:189b0ea1dc38:
#include "stdlib.h"
//#include "math.h"
#include "LPC17xx.h"
#include "Global.h"
int tempNH,tempNL;
unsigned int Rate_Flag;
unsigned int CountBuFFIn;
unsigned int N=0,CRC_N;
unsigned int Rate_7=0;
int iRate_7=0;
unsigned int Param1=0;
unsigned int Param2=0;
unsigned int Param3=0;
unsigned int Param4=0;
///unsigned int Consol=123;
unsigned int TempParam=1;
unsigned int CountParam=0;
unsigned int OldCuruAngle;
unsigned int OldCaunPlus=0;
unsigned int OldCaunMin=0;
unsigned int OutDeltaPS;
int IntOutDeltaPS;
int ttemp,temp5=1;
int OLDDAC=0;
int rr = 123;
unsigned int pDestT;
GyroParam *Flash;
//int q;
///////////////flah and boot///////////
void GoBoot(void)
{
/* Prepare Sectors to be flashed */
NVIC_DisableIRQ(TIMER1_IRQn);
NVIC_DisableIRQ(TIMER2_IRQn);
NVIC_DisableIRQ(TIMER3_IRQn);
NVIC_DisableIRQ(EINT3_IRQn);
SystemInitDef();
vIAP_ReinvokeISP();
}
void DropDelay(void)
{
Gyro.DropDelayGLD = DropDelayGLD_0;
switch(Gyro.My_Addres) {
case 1: Gyro.DropDelayGLD = DropDelayGLD_1; break;
case 2: Gyro.DropDelayGLD = DropDelayGLD_2; break;
case 3: Gyro.DropDelayGLD = DropDelayGLD_3; break;
}
}
/*
void WriteFlash(void)
{
SystemInitDef();
WriteCon("\r\n Start Prepare Sectors");
if(u32IAP_PrepareSectors(5, 5) == IAP_STA_CMD_SUCCESS)
{
WriteCon("\r\nPrepare Sectors OK");
WriteCon("\r\n Start Erase");
u32IAP_EraseSectors(IMG_START_SECTOR, IMG_END_SECTOR);
WriteCon("\r\n AND Erase");
}
else WriteCon("\r\nPrepare Sectors ERROR ");
SystemInit1();
Gyro.FlashMod = 0;
}
*/
void EraseFlash(void)
{
rr = u32IAP_PrepareSectors(19, 21);
/*sprintf((Time)," dffddfd <%07d> ",rr);
WriteCon(Time);*/
rr = u32IAP_EraseSectors(19, 21);
/* sprintf((Time)," dffddfd <%07d> ",rr);
WriteCon(Time);*/
}
void WriteFlash(void)
{
Gyro.FlashMod = 0;
//SystemInitDef();
NVIC_DisableIRQ(TIMER1_IRQn);
NVIC_DisableIRQ(TIMER2_IRQn);
NVIC_DisableIRQ(TIMER3_IRQn);
NVIC_DisableIRQ(EINT3_IRQn);
// unsigned int start_address = (unsigned int) & GyroP;
rr = u32IAP_PrepareSectors(19, 21);
rr = u32IAP_EraseSectors (19, 21);
rr = u32IAP_PrepareSectors(19, 21);
rr = u32IAP_CopyRAMToFlash(0x030000, &GyroP , 1024);
// SystemInit1(); // Инициализация контроллера: установка тактовых частот
//SystemCoreClockUpdate1(); // расчет тактовой частоты процессора перед инициализацией UART - 103MHz
NVIC_EnableIRQ(TIMER1_IRQn);
NVIC_EnableIRQ(TIMER2_IRQn);
NVIC_EnableIRQ(TIMER3_IRQn);
NVIC_EnableIRQ(EINT3_IRQn);
//SystemCoreClockUpdate1();
}
void ReadFlash ( void)
{
NVIC_DisableIRQ(TIMER1_IRQn);
NVIC_DisableIRQ(TIMER2_IRQn);
NVIC_DisableIRQ(TIMER3_IRQn);
NVIC_DisableIRQ(EINT3_IRQn);
Gyro.FlashMod = 0;
WriteCon("\r\n Pirivet Flash");
pDestT= (unsigned int) (0x030000);
Flash = (GyroParam*) pDestT;
GyroP = *(Flash);
NVIC_EnableIRQ(TIMER1_IRQn);
NVIC_EnableIRQ(TIMER2_IRQn);
NVIC_EnableIRQ(TIMER3_IRQn);
NVIC_EnableIRQ(EINT3_IRQn);
}
///////////////end flah and boot///////////
void M_RateA(void)
{
switch(Gyro.ModeOut)
{
case 1: if(Gyro.Rate1_Event ) CMD_Rate(); break;
case 2: if(Gyro.Reper_Event ) CMD_Rate2(); break;
case 3: if(Gyro.Event_500Hz ) CMD_Delta_PS(); break;
case 4: if(Gyro.EXT_Latch ) CMD_Delta_PS(); break;
case 5: if(Gyro.Event_500Hz ) CMD_Delta_Bins(); break;
case 6: if(Gyro.EXT_Latch ) CMD_B_Delta(); break;
case 7: if(Gyro.Event_500Hz ) CMD_B_Delta(); break;
case 8: if(Gyro.Rate3_Event ) CMD_Rate3(); break;
case 9: if(Gyro.Reper_Event ){ CMD_Rate2(); Gyro.ModeOut=0;} break;
case 10: if(Gyro.EvenRate7 ){ CMD_Rate7(); Gyro.EvenRate7=0;} break;
}
}
void BuffClear(void)
{
for(int q=0; q<60; q++)
{
BuffTemp[q]=0;
}
}
void CMD_Rate7(void)
{
// (CountV64)&0x3f]*Gyro.ModAmp туды
//BuffADC_64Point[ (CountFaza + Gyro.PLC_Phase) & 0x3f]
BuffClear();
int Temp;
int Temp1;
float Temp2;
int Shift = -11463;
static unsigned int t=16;
BuffTemp[0] = Gyro.SOC_Out;
BuffTemp[1] = Gyro.My_Addres;
iRate_7 =(((BuffADC_64Point[(t - 0 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 2] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 3] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков
iRate_7 = (((BuffADC_64Point[(t - 2 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 4] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 5] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 =(((BuffADC_64Point[(t - 4 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 6] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 7] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((BuffADC_64Point[(t - 6 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 8] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 9] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((BuffADC_64Point[(t - 8 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 10] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 11] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((BuffADC_64Point[(t - 10 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 12] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 13] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((BuffADC_64Point[(t - 12 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 14] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 15] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((BuffADC_64Point[(t - 14 - Gyro.PLC_Phase)&0x3f]) )+ Shift)&0xffff;
BuffTemp[ 16] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 17] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 0)&0x3f])))- 50;
BuffTemp[ 18] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 19] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 2)&0x3f])))- 50;
BuffTemp[ 20] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 21] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 4)&0x3f])))- 50;
BuffTemp[ 22] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 23] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 6)&0x3f])))- 50;
BuffTemp[ 24] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 25] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 8)&0x3f])))- 50;
BuffTemp[ 26] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 27] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 10)&0x3f])))- 50;
BuffTemp[ 28] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 29] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 12)&0x3f])))- 50;
BuffTemp[ 30] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 31] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (((ModArraySin[(t - 14)&0x3f])))- 50;
BuffTemp[ 32] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 33] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
iRate_7 = (Spi.DAC_B - 0x7fff);
BuffTemp[ 34] =(iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 35] =(iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
Rate_7 = Gyro.PLC_Eror_count;
BuffTemp[ 36] =(Rate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 37] =(Rate_7 >> 0) & 0xff;//младший байт разности счетчиков;
Gyro.PLC_Eror_count=0;
switch(Gyro.LG_Type)
{
case 1: iRate_7 =(int)(((float)(Spi.DAC_A)/0.6667)- 0xefff); break;
case 0: Temp2 = (Spi.DAC_A*1.538) - 0xd80f;
iRate_7 = (int)Temp2; break;
}
//Rate_7 = 30000;//(unsigned int)(iRate_7&0xffff);
BuffTemp[ 38] = (iRate_7 >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 39] = (iRate_7 >> 0) & 0xff;//младший байт разности счетчиков;
Check(BuffTemp, 42);
WriteConN (BuffTemp,42);
if(t<47)t+=16;
else t =16;
}
void CMD_M_Param_R(void)
{
unsigned int NP=0;
unsigned int Param;
NP = BuffTemp[3];
for (int i=0;i<8;i++)
{BuffTemp[i]=0;}
BuffTemp[0] = Gyro.SOC_Out;
BuffTemp[1] = Gyro.My_Addres;
/* sprintf((Time),"%d = %d \r\n",NP, GyroP.Array[NP]);
WriteCon(Time);*/
Param = GyroP.Array[NP];
BuffTemp[2] =(GyroP.Array[NP] >> 8) & 0xff;//старший байт требуемого параметра
BuffTemp[3] =(GyroP.Array[NP] >> 0) & 0xff;//младший байт требуемого параметра
Check(BuffTemp, 6);
WriteConN (BuffTemp,6);
/*sprintf((Time),"READ Param = <%07d> GyroP.Array[NP] = <%07d> NP= <%07d> Gyro.CaunPlus+Gyro.CaunMin-5000 <%07d> \r\n",Param, GyroP.Array[NP], NP, GyroP.Str.PLC_Lern);
WriteCon(Time);*/
NP=0;
}
void CMD_M_Param_W(void)
{
unsigned int NP=0;
unsigned int Param,temp,flash;
NP = BuffTemp[3];
Param = (BuffTemp[4]<<8);
Param |= BuffTemp[5];
GyroP.Array[NP] = Param;
flash=GyroP.Array[5];
switch(NP)
{
case 0: Gyro.My_Addres = GyroP.Str.My_Addres; break;
case 1: Gyro.HFO_ref = /*GyroP.Str.HFO_ref>>1;*/(unsigned int)(GyroP.Str.HFO_ref)*0.82; break;
case 2: Gyro.HFO_Gain = GyroP.Str.HFO_Gain; break;
case 3: if(Gyro.LG_Type) Gyro.HFO_Max=((int)(GyroP.Str.DAC_current_Work*0.67)-2000);
else Spi.DAC_A = ((((int)(GyroP.Str.DAC_current_Work+ 0x7fff)&0xffff)+22544)*0.65); break;
case 4: if(Gyro.LG_Type) Gyro.HFO_Min=((int)(GyroP.Str.DAC_current_Start*0.67)-2000); break;
case 7: Gyro.PLC_Phase = GyroP.Str.PLC_Phase; break;
case 8: Gyro.PLC_Gain = GyroP.Str.PLC_Gain; break;
case 12: Gyro.FrqPhase = GyroP.Str.FrqPhase; break;
case 13: Gyro.FrqChengSpeed = GyroP.Str.FrqChengSpeed; break;
case 14: Gyro.FrqHZ = (7680000 / GyroP.Str.FrqHZ);
Gyro.Frq = (7680000 / GyroP.Str.FrqHZ)<<16;
break;
case 15: Gyro.FrqHZmin = (7680000 / GyroP.Str.FrqHZmin)<<16; break;
case 16: Gyro.FrqHZmax = (7680000 / GyroP.Str.FrqHZmax)<<16; break;
case 18: temp=((GyroP.Str.VB_Fdf_Hi<<16) | GyroP.Str.VB_Fdf_Lo);
sprintf((Time),"%d \r\n", temp/32);
WriteCon(Time);
temp=temp*20;
Gyro.AmpTarget=(unsigned int)(temp);
break;
case 19: Gyro.AmpSpeed = GyroP.Str.AmpSpeed; break;
case 20: Gyro.AmpPerMin = GyroP.Str.AmpPerMin; break;
case 21: Gyro.AmpPerMax = GyroP.Str.AmpPerMax; break;
case 22: Gyro.AmpPer = GyroP.Str.AmpPer;
Gyro.Amp = GyroP.Str.AmpPer<<16;
break;
case 23: Gyro.AmpMin = GyroP.Str.AmpMin; break;
case 24: Gyro.AmpTD = GyroP.Str.AmpTD; break;
case 25: Gyro.AmpPerDel = GyroP.Str.AmpPerDel; break;
case 34: Gyro.ModAmp = GyroP.Str.ModAmp; break;
case 56: Gyro.Gain_Sin = GyroP.Str.Gain_Sin;
Out_G_photo(Gyro.Gain_Sin, Gyro.Gain_Cos);
break;
case 57: Gyro.Gain_Cos = GyroP.Str.Gain_Cos;
Out_G_photo(Gyro.Gain_Sin, Gyro.Gain_Cos);
break;
case 60: Gyro.GLD_Serial = GyroP.Str.GLD_Serial; break;
case 10: Gyro.DownTreshold =0x7fff+GyroP.Str.DownTreshold; break;
case 11: Gyro.HighTreshold =0x7fff+GyroP.Str.HighTreshold; break;
case 9: Gyro.PLCDelay = GyroP.Str.PLCDelay/10; break;
/*case 105: Gyro.ResetLevelCool = GyroP.Str.ResetLevelCool; break;
case 55: Gyro.ResetLevelHeat = GyroP.Str.ResetLevelHeat; break;*/
case 39: Gyro.ResetLevelCool = 0x7fff+GyroP.Str.ResetLevelCool; break;
case 31: Gyro.ResetLevelHeat = 0x7fff+GyroP.Str.ResetLevelHeat; break; //27
//105
}
NP=0;
BuffTemp[0] = Gyro.SOC_Out;
BuffTemp[1] = Gyro.My_Addres;
BuffTemp[2] = Gyro.CMD_In;
BuffTemp[3] =0; //(//GyroP.Array[NP]>> 8) & 0xff;//старший байт требуемого параметра
Check(BuffTemp, 6);
WriteConN (BuffTemp,6);
if(flash){GyroP.Array[5]=0; flash=0; WriteFlash(); ReadFlash ();}
}
void CMD_Maintenance(void)
{
Gyro.ModeOut=0;
//Gyro.DropDelayGLD = DropDelayGLD_0;//задержка на выдачу 45 микросекунд для любого адреса ГЛД
BuffTemp[0] = Gyro.SOC_Out;
BuffTemp[1] = Gyro.My_Addres;
BuffTemp[2] = Gyro.Firmware_Version;
/* sprintf((Time),"%d \r\n", Gyro.Firmware_Version);
WriteCon(Time);*/
BuffTemp[3] = Gyro.GLD_Serial;
BuffTemp[4]=0x00;
BuffTemp[5]=0x00;
Check(BuffTemp, 8);
/* sprintf((Time),"%d %d %d %d %d %d %d %d\r\n",BuffTemp[0], BuffTemp[1],BuffTemp[2],BuffTemp[3],BuffTemp[4],BuffTemp[5],BuffTemp[6],BuffTemp[7]);
WriteCon(Time);*/
WriteConN (BuffTemp,8);
}
void CMD_B_Delta(void)
{
Gyro.Event_500Hz=0;
Gyro.EXT_Latch=0;
unsigned int Temp;
BuffTemp[ 0] = Gyro.SOC_Out;
BuffTemp[ 1] = Gyro.My_Addres;
Temp = Gyro.CuruAngle;
Gyro.CuruAngle = 0;
BuffTemp[ 2] =(Temp >> 16) & 0xff;//младший байт разности счетчиков
BuffTemp[ 3] =(Temp >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 4] =(Temp >> 0) & 0xff;//младший байт разности счетчиков
BuffTemp[ 5] = 0x00000000;
Check(BuffTemp, 8);
WriteConN (BuffTemp,8);
}
void CMD_Delta_Bins(void)
{ Gyro.Event_500Hz=0;
unsigned int Temp;
BuffTemp[ 0] = Gyro.SOC_Out;
BuffTemp[ 1] = Gyro.My_Addres;
Temp = Gyro.CuruAngle;
Gyro.CuruAngle = 0;
BuffTemp[ 2] =(Temp >> 24) & 0xff;//старший байт разности счетчиков
BuffTemp[ 3] =(Temp >> 16) & 0xff;//младший байт разности счетчиков
BuffTemp[ 4] =(Temp >> 8) & 0xff;//младший байт разности счетчиков
BuffTemp[ 5] =(Temp >> 0) & 0xff;//младший байт разности счетчиков
BuffTemp[ 6] = 0x0000;
Check(BuffTemp, 9);
WriteConN (BuffTemp,9);
}
void CMD_Delta_PS(void)
{ int drob,Temp1;
float Temp2=0;
Gyro.EXT_Latch=0;
Gyro.Event_500Hz=0;
unsigned int Temp;
BuffTemp[ 0] = Gyro.SOC_Out;
BuffTemp[ 1] = Gyro.My_Addres;
Gyro.CuruAngle = Gyro.CuruAngle + OldCuruAngle; //(72 град/с)
OldCuruAngle=Gyro.CuruAngle & 0xf; //сохраняем 3 бит для след измирений
Temp=Gyro.CuruAngle>>4; //приводим к форме вывода
Gyro.CuruAngle = 0;
BuffTemp[ 2] =(Temp >> 8) & 0xff;//старший байт разности счетчиков
BuffTemp[ 3] =(Temp >> 0) & 0xff;//младший байт разности счетчиков
BuffTemp[ 4] = CountParam;
switch(CountParam) {
//F_ras
case 0:
OutDeltaPS = Gyro.F_ras;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 1:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//HFO
case 2:
/* Temp2 = ((Spi.DAC_A/0.65)-22544)-0x7fff;
Temp1= (int)Temp2;*/
if(Gyro.LG_Type) {OutDeltaPS =(int)(((Spi.DAC_A/0.6667)-30000)-0x7fff);}
else {OutDeltaPS =(unsigned int)(0x7fff-Spi.ADC5)*0.79;}
// Temp = Spi.DAC_A-0x7fff;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 3:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//T_Vibro
case 4:
OutDeltaPS = (unsigned int)(7680000/(Gyro.Frq>>16));
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 5:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//L_Vibro
case 6:
//Temp = Gyro.L_vibro>>1;
OutDeltaPS = Gyro.L_vibro;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 7:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//Напряжение на регуляторе периметра
case 8:
OutDeltaPS = (Spi.DAC_B - 0x7fff);
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 9:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//темпкратурный канал 0
case 10:
OutDeltaPS = 0;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 11:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//f
case 12:
OutDeltaPS =0;//(unsigned int)(0x7fff-Spi.ADC5)*0.79;
// Temp = Gyro.AD_Slow >> 16;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;
break;
case 13:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//ток 1
case 14:
//Temp = Gyro.In1;
IntOutDeltaPS = ((Gyro.In1>>1)*0.800875)-0x3e0b;
BuffTemp[5] = (IntOutDeltaPS >> 8) & 0xff;//in1//2
break;
case 15:
BuffTemp[5] = (IntOutDeltaPS >> 0) & 0xff;
break;
//ток 2
case 16:
// Temp = Gyro.In2;
IntOutDeltaPS = ((Gyro.In2>>1)*0.800875)-0x3e0b;
BuffTemp[5] = (IntOutDeltaPS >> 8) & 0xff;
break;
case 17:
BuffTemp[5] = (IntOutDeltaPS >> 0) & 0xff;//in2//3
break;
//разностный температурный канал Delta Temp
case 18:
OutDeltaPS = 0;
OutDeltaPS = Gyro.DeltaT;
BuffTemp[5] = (OutDeltaPS >> 8) & 0xff;//дельта
break;
case 19:
BuffTemp[5] = (OutDeltaPS >> 0) & 0xff;
break;
//температурный канал 5
case 20:
OutDeltaPS = 0;
OutDeltaPS = Gyro.TermLM;//Spi.ADC1;// //Gyro.Termo;//0xa4=164
BuffTemp[5] =(OutDeltaPS >> 8) & 0xff;//температура
break;
case 21:
BuffTemp[5] =(OutDeltaPS >> 0) & 0xff;//ADC6 sesnsor 5
/* sprintf((Time),"%d %d \r\n", Spi.ADC1, Spi.ADC5 );
WriteCon(Time);*/
break;
}
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
if(CountParam>20)CountParam=0;//зацикливания буфера от 0 до 21
else CountParam++;
}
void CMD_Rate(void)
{
Gyro.Rate1_Event=0;
unsigned int Temp;
int Temp1;
float Temp2;
BuffTemp[ 0] = Gyro.SOC_Out; //1 --старт данных
BuffTemp[ 1] = Gyro.My_Addres; //2 --адрес отвечающего устройствва
BuffTemp[ 2] =( Gyro.CaunPlusReper >> 8) & 0xff;//старший байт счетчика +. 3 --сарший байт счентчика +
BuffTemp[ 3] =( Gyro.CaunPlusReper >> 0) & 0xff;//младший байт счетчика +. 4 --младший байт счетчика +
BuffTemp[ 4] =( Gyro.CaunMinReper >> 8) & 0xff;//старший байт счетчика -. 5 --сарший байт счентчика -
BuffTemp[ 5] =( Gyro.CaunMinReper >> 0) & 0xff;//младший байт счетчика -. 6 --младший байт счетчика -
Gyro.CuruAngle = Gyro.CuruAngle + OldCuruAngle; //(72 град/с)
OldCuruAngle=Gyro.CuruAngle & 0x3f; //сохраняем 5 бит для след измирений
Temp=Gyro.CuruAngle>>6; //приводим к форме вывода
Gyro.CuruAngle = 0;
BuffTemp[ 6] =(Temp >> 8) & 0xff;//старший байт разности счетчиков 7 --младший байт разности счетчиков
BuffTemp[ 7] =(Temp >> 0) & 0xff;//младший байт разности счетчиков 8 --старший байт разности счетчиков
BuffTemp[38] =(Temp >> 24) & 0xff;; //39 приращение угла
BuffTemp[39] =(Temp >> 16) & 0xff;; //40 формат 22.10
BuffTemp[40] =(Temp >> 8) & 0xff;; //41 1бит знак
BuffTemp[41] =(Temp >> 0) & 0xff;; //42
Temp = Gyro.F_ras;
//Gyro.F_ras=0;
BuffTemp[ 8] = (Temp >> 8) & 0xff;//расщипление частота 9 --частота расщипления
BuffTemp[ 9] = (Temp >> 0) & 0xff;// 10 --частота расщипления
//(unsigned int)((Gyro.DacIn+30000)*0.6667);
switch(Gyro.LG_Type)
{
case 1: Temp1 =(int)(((float)(Spi.DAC_A)/0.6667)- 0xefff); break;
case 0: Temp2 = (Spi.DAC_A*1.538) - 0xd80f;
Temp1= (int)Temp2; break;
}
//Temp1=Gyro.DacIn/*-0x7fff*/;
BuffTemp[10] = (Temp1 >> 8) & 0xff;//выход регулятора гвч; 11 --выход регулятора ГВЧ
BuffTemp[11] = (Temp1 >> 0) & 0xff; //12 --выход регулятора ГВЧ
if(Gyro.LG_Type) Temp =(int)(tempDeltaRegul);
else Temp =(unsigned int)(0x7fff-Spi.ADC5)*0.79;
BuffTemp[12]=(Temp >> 8) & 0xff;//// HFO 13 --сигнал ошибки регулятора ГВЧ
BuffTemp[13]=(Temp >> 0) & 0xff;//// 14 --сигнал ошибки регулятора ГВЧ
//Temp = (unsigned int)((7675000*16/(Gyro.Frq>>12)));
Temp = (unsigned int)(7680000/(Gyro.Frq>>16));
BuffTemp[14] = (Temp >> 8) & 0xff; //15 период вибропривода.(частота) T_Vibro
BuffTemp[15] = (Temp >> 0) & 0xff; //16 период вибропривода.
Temp = Gyro.FrqPhaseEror<<2;//Spi.DAC_A-0x7fff;
BuffTemp[16] = (Temp >> 8) & 0xff; //17 старший байт ФД регулятора периода вибропривода
BuffTemp[17] = (Temp >> 0) & 0xff;
/*sprintf((Time),"%d %d\r\n",Gyro.FrqPhaseEror, Gyro.FrqPhaseEror<<2);
WriteCon(Time); */ //18
Temp =Gyro.L_vibro/*>>1*/;//(unsigned int)(((7675000*16/200) * Gyro.AmpPer /(Gyro.Frq>>12)));
BuffTemp[18] = (Temp >> 8) & 0xff; //19 длительность импулься вибропривода(амплитуда)
BuffTemp[19] = (Temp >> 0) & 0xff; //20
Temp = 0x0;//Gyro.L_vibro<<2;
BuffTemp[20] = (Temp >> 8) & 0xff;//регулятор датчика угла поворота //21 старший байт регулятора датчика угла поворота
BuffTemp[21] = (Temp >> 0) & 0xff; //22
Temp1 =(Spi.DAC_B-0x7fff);
BuffTemp[22] = (Temp1 >> 8) & 0xff; //23 Выход регулятора рабочего периметра
BuffTemp[23] = (Temp1 >> 0) & 0xff;
//24
Temp = Gyro.PLC_Eror_count; //Gyro.AD_Slow >> 16;
Gyro.PLC_Eror_count = 0;
BuffTemp[24] = (Temp >> 8) & 0xff;// //25 ФД СРП
BuffTemp[25] = (Temp >> 0) & 0xff;// //26 ФД СРП
Temp =0;/* Gyro.AD_Slow >> 16*/;
BuffTemp[26] = (Temp >> 8) & 0xff; //27 ADC 0
BuffTemp[27] = (Temp >> 0) & 0xff; //28
Temp =0; /*Gyro.AD_Slow >> 16*/;
BuffTemp[28] = (Temp >> 8) & 0xff; //29 ADC 1
BuffTemp[29] = (Temp >> 0) & 0xff; //30
Temp1 = ((Gyro.In1>>1)*0.800875)-0x3e0b;
BuffTemp[30] = (Temp1 >> 8) & 0xff;//in1//2 //31 ADC 2
BuffTemp[31] = (Temp1 >> 0) & 0xff; //32
Temp1 =((Gyro.In2>>1)*0.800875)-0x3e0b;// - 0x4FFF;
BuffTemp[32] = (Temp1 >> 8) & 0xff; //33 ADC 3
BuffTemp[33] = (Temp1 >> 0) & 0xff;//in2//3 //34
Temp = (Gyro.DeltaT);
BuffTemp[34] = (Temp >> 8) & 0xff;//дельта //35 ADC 4
BuffTemp[35] = (Temp >> 0) & 0xff; //36
// Temp = 000;
Temp = Gyro.Termo;
BuffTemp[36] =(Temp >> 8) & 0xff;//температура //37 ADC 5
BuffTemp[37] =(Temp >> 0) & 0xff;//ADC6 sesnsor 5 //38
Check(BuffTemp, 44);
WriteConN (BuffTemp,44);
for(int i=0; i<45;i++) {BuffTemp[i]=0;}
}
void CMD_Rate2(void)
{
unsigned int Temp;
Gyro.Reper_Event=0;
for(int q=0; q<64; q++)
{
BuffTemp[q]=0;
}
BuffTemp[ 0] = Gyro.SOC_Out;
BuffTemp[ 1] = Gyro.My_Addres;
Temp=Gyro.CaunPlusReper;
BuffTemp[ 2] =(Temp >> 8) & 0xff;//старший байт счетчика +.
BuffTemp[ 3] =(Temp >> 0) & 0xff;//младший байт счетчика +.
//сохраняем 5 бит для след измирений
Temp= Gyro.CaunMinReper;
BuffTemp[ 4] =(Temp >> 8) & 0xff;//старший байт счетчика -.
BuffTemp[ 5] =(Temp >> 0) & 0xff;//младший байт счетчика -.
Check(BuffTemp, 8);
WriteConN (BuffTemp,8);
}
void CMD_Rate3(void)
{
Gyro.Rate3_Event=0;
BuffTemp[ 0] = Gyro.SOC_Out;
BuffTemp[ 1] = Gyro.My_Addres;
BuffTemp[ 2] = 0xcc;//старший байт счетчика +.
BuffTemp[ 3] = 0xcc;//младший байт счетчика +.
BuffTemp[ 4] =0xBB;//старший байт счетчика -.
BuffTemp[ 5] =0xBB;//младший байт счетчика -.
Check(BuffTemp, 8);
WriteConN (BuffTemp,8);
}
void CMD_M_Stymul()
{
int temp,Consol=0,HFO,b4;
float Temp1;
temp=BuffTemp[3];
b4 = temp;
Consol = temp>>7;
HFO = temp&0x3;// // (номер (код) ЦАПа 0...3, HFO - 3dac, PLC - 0DAC
temp = (((BuffTemp[4]<<8) | BuffTemp[5])&0xFFFF);
if(HFO)
{
Gyro.DacIn=temp;
if(Gyro.LG_Type==1) Spi.DAC_A = ((unsigned int)((Gyro.DacIn+0x7011)*0.6667));
else Spi.DAC_A = (unsigned int)((temp));
}
else Spi.DAC_B = (unsigned int)temp;
/*
sprintf((Time),"%d %d %f \r\n", temp, Spi.DAC_A, (temp+10744)*0.79);
WriteCon(Time);
*/
/*{
DACF =(temp*K_DAC)+deltaDAC;
Spi.DAC_B =(unsigned int)(DACF) (unsigned int)(temp*K_DAC+deltaDAC); // K_DAC);
}*/
if(Consol)
{
BuffTemp[0] = Gyro.SOC_Out; //DD
BuffTemp[1] = Gyro.My_Addres; //00
BuffTemp[2] = Gyro.CMD_In; //D9
BuffTemp[3] =0;
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
}
}
void CMD_M_vib()
{
unsigned int temp1,temp2,anser;
// anser = BuffTemp[3]>>7;
temp1 = (((BuffTemp[4]<<8) | BuffTemp[5])&0xFFFF);
Gyro.Frq = (122780000/temp1)<<12;
// Gyro.Frq = (103200000/temp1)<<12;
F_vib=103200000/((Gyro.Frq>>16)*2);
temp2 = (((BuffTemp[6]<<8) | BuffTemp[7])&0xFFFF);
Gyro.AmpPer = ((((((Gyro.Frq>>12)*200)/16)*temp2)/7680000)/2);
Gyro.Amp = (Gyro.AmpPer)<<15;
/*sprintf((Time),"%d \r\n",Gyro.AmpPer);
WriteCon(Time); */
// if(anser)
// {
BuffTemp[0] = Gyro.SOC_Out;
BuffTemp[1] = Gyro.My_Addres;
BuffTemp[2] = Gyro.CMD_In;
BuffTemp[3] = 0x0;
BuffTemp[4] = 0x0;
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
// }
}
void CMD_M_Control_D8()///установка\сброс регистров управления
{
unsigned int bit=0,Pa=0;
unsigned int SR=0,V=0,Bit_num=0,A=0;
Pa = BuffTemp[3];
SR = Pa >> 7;
V = (Pa>>5)&0x3;
A = (Pa>>4)&0x1;
Bit_num = Pa & 0xf;
switch (SR)
{
case 0:
switch (A)
{
case 0:
switch (Bit_num)
{
case 0x06: FrqOFF break;
case 0x05: AVibOFF break;
case 0x01: HFOOFF break;
case 0x03: PlcOFF break;
}
break;
case 1:
switch (Bit_num)
{
case 0x00: Gyro.RgConB &= ~(1<<0); break;
case 0x01: Gyro.RgConB &= ~(1<<1); break;
case 0x02: Gyro.RgConB &= ~(1<<2); break;
}
break;
}
break;
case 1:
switch (A)
{
case 0:
switch (Bit_num)
{
case 0x06: FrqON break;
case 0x05: AVibON break;
case 0x01: HFOON break;
case 0x03: PlcON break;
}
break;
case 1:
switch (Bit_num)
{
case 0x00: Gyro.RgConB |= (1<<0); break;
case 0x01: Gyro.RgConB |= (1<<1); break;
case 0x02: Gyro.RgConB |= (1<<2); break;
}
break;
}
break;
}
BuffTemp[0] = Gyro.SOC_Out; //DD
BuffTemp[1] = Gyro.My_Addres; //00
BuffTemp[2] = Gyro.CMD_In; //D8
switch (A)
{
case 0:
BuffTemp[ 4] =(Gyro.RgConA >> 8) & 0xff;
BuffTemp[ 5] =(Gyro.RgConA >> 0) & 0xff;
break;
case 1:
BuffTemp[ 4] =(Gyro.RgConB >> 8) & 0xff;
BuffTemp[ 5] =(Gyro.RgConB >> 0) & 0xff;
break;
}
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
}
void CMD_M_Control_D9()///чтение регистров управления
{
int bit,NReg,param=0;
BuffTemp[0] = Gyro.SOC_Out; //DD
BuffTemp[1] = Gyro.My_Addres; //00
BuffTemp[2] = Gyro.CMD_In; //D9
param = BuffTemp[3];
if (param)
{
BuffTemp[3]=1<<4;
BuffTemp[4] = (Gyro.RgConB>>8 ) & 0xff;
BuffTemp[5] = Gyro.RgConB & 0xff;
}
else
{
BuffTemp[3]=0<<4;
BuffTemp[4] = (Gyro.RgConA>>8 )& 0xff;
BuffTemp[5] = Gyro.RgConA & 0xff;
}
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
}
// (номер (код) ЦАПа 0...3, старший байт требуемого ЦАПа, младший байт треб ЦАПа)
void GLDStartDischarg(void)
{ TimeDischarg=0;
Try=0;
switch(Gyro.My_Addres)
{//смещение поджига и подсветки в зависимости от адреса ГЛД
case 0:
Gyro.Discharg = StartDischarg << ShiftStart0;
Gyro.BackLight = StartBackLight << ShiftStart0;
break;
case 1:
Gyro.Discharg = StartDischarg << ShiftStart1;
Gyro.BackLight = StartBackLight << ShiftStart1;
break;
case 2:
Gyro.Discharg = StartDischarg << ShiftStart2;
Gyro.BackLight = StartBackLight << ShiftStart2;
break;
case 3:
Gyro.Discharg = StartDischarg << ShiftStart3;
Gyro.BackLight = StartBackLight << ShiftStart3;
break;
}
}
void Gph_W()
{
//Gyro.flagGph_W=3;
Out_G_photo(BuffTemp[4],BuffTemp[5]);
BuffTemp[0] = Gyro.SOC_Out; //DD
BuffTemp[1] = Gyro.My_Addres; //00
BuffTemp[2] = Gyro.CMD_In; //D9
BuffTemp[3] = 0;
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
}
void DeviceMode()
{
int TempMod=1;
BuffTemp[0] = Gyro.SOC_Out; //DD
BuffTemp[1] = Gyro.My_Addres; //00
BuffTemp[2] = Gyro.CMD_In; //D9
TempMod = BuffTemp[3] & 0xf;
Gyro.RgConMod = TempMod;
BuffTemp[3]=Gyro.RgConMod & 0xff;
BuffTemp[4]=0;
BuffTemp[5]=0;
Check(BuffTemp, CRC_N);
WriteConN (BuffTemp,CRC_N);
}
unsigned int Check(char *c, unsigned int Count)
{
int i=1;
unsigned int temp,CRC;
temp=1;
CRC=0;
for(; i<Count-2; i++) {
CRC+=c[i];
}
if(c[Count-2]!=((CRC>>8)&0xFF)) {
temp=0;
Gyro.RsErrLine = (Gyro.RsErrLine)&=0x2;
}
if(c[Count-1]!=((CRC>>0)&0xFF)) {
temp=0;
// Gyro.RsErrLine= (Gyro.RsErrLine)=0x2;
}
c[Count-2]=(CRC>>8)&0xFF;
c[Count-1]=(CRC>>0)&0xFF;
return temp;
}
int Getlengf(void)
{
unsigned int lengf;
lengf = 1;
switch(Gyro.CMD_In)
{
case 0x99: lengf=6; CRC_N=8; break; //Mintainance
case 0xB0: lengf=6; CRC_N=9; break; //Delta_Bins
case 0x0F: lengf=6; CRC_N=8; break; //Delta_Bins
case 0xA0: lengf=6; CRC_N=8; break; //Delta_PS
case 0xDD: lengf=6; CRC_N=44; break; //m_rate
case 0x0A: lengf=8; CRC_N=6; break; //m_stymul
case 0xE9: lengf=6; CRC_N=8; break; //DeviceMode
case 0xE8: lengf=6; CRC_N=8; break; //DeviceMode
case 0xA5: lengf=6; CRC_N=8; break; //DeviceMode
case 0xD8: lengf=6; CRC_N=8; break; //m_control
case 0xD9: lengf=6; CRC_N=8; break; //m_control
case 0xE4: lengf=8; CRC_N=6; break; //M_VIB_W
case 0xE6: lengf=8; CRC_N=6; break; //M_Gph_W
} return lengf;
}
void Read_CMD(void)
{
Gyro.RsErrLine = (Gyro.RsErrLine)& 0xffff;//для сброса ошибки
CountBuFFIn=ReadChekCon1(BuffTemp);
// чтение данных из консоли
if(CountBuFFIn==1) {
// если есть первый байт
if (BuffTemp[0] != SOC_In)
{
ReadCon1(BuffTemp);
Gyro.RsErrLine += 0x100;
//BuffTemp[99]=Gyro.RsErrLine;
ReadCon1(BuffTemp);
}
}
else if(CountBuFFIn==2) //если второй байт
{ // широковещаительный
if (BuffTemp[1] != Gyro.My_Addres /*|| BuffTemp[1] !=0x1f*/)
{
ReadCon1(BuffTemp);
Gyro.RsErrLine += 0x1;
ReadCon1(BuffTemp);
}
}
else if(CountBuFFIn==3) // если третий байт
{
Gyro.CMD_In=BuffTemp[2];
N=Getlengf();
}
else if(CountBuFFIn==4 && (N==6))
{ // N - длина посылки аскглд(для записи параметров). определяется по коду команды в Getlengf();
Param1=BuffTemp[3];
}
else if((CountBuFFIn==5)&&(N==7))
{
Param1=BuffTemp[3];
Param2=BuffTemp[4];
}
else if((CountBuFFIn==6)&&(N==8))
{
Param1=BuffTemp[3];
Param2=BuffTemp[4];
Param3=BuffTemp[5];
}
else if((CountBuFFIn==8)&&(N==10))
{
Param1=BuffTemp[4];
Param2=BuffTemp[5];
Param3=BuffTemp[6];
Param4=BuffTemp[7];
}
else if(CountBuFFIn > (N-1))
{
ReadCon1(BuffTemp);
//if(SA)CMD_M_Stymul_Answer();
// if(d8_anser)D8_Answer();
switch(Gyro.CMD_In) {
case 0x99: /*Gyro.ModeOut=0;*/CMD_Maintenance(); break;
case 0xD8: CMD_M_Control_D8(); break;
case 0xE9: CMD_M_Param_R(); break; //чтение параметров
case 0xE8: CMD_M_Param_W(); break; //запись параметра
case 0xDA: GLDStartDischarg(); break;
case 0xD9: CMD_M_Control_D9(); break;
case 0x0A: CMD_M_Stymul(); break;
case 0xDD: TempParam=(BuffTemp[3]) & 0x9f; //Rate
switch(TempParam) {
case Rate1 : CMD_Rate(); break;
case Rate2 : Gyro.ModeOut=9; break;
case Rate3 : CMD_Rate3(); break;
case PRate1 : Gyro.ModeOut=1; break;
case PRate2 : Gyro.ModeOut=2; break;
case PRate3 : Gyro.ModeOut=8; break;
case Rate7 : CMD_Rate7(); break;
case PRate7 : Gyro.ModeOut=10; break;
}
break; //DropDelay(); выставка задержки для мультидропа сбрасывается в команде CMD_Maintenance() на () микросекунд;
case 0xA0: /*DropDelay();*/ TempParam=(BuffTemp[3]) & 0x90; //Delta_PS
switch(TempParam) {
case Delta_500 : CMD_Delta_PS(); break;
case Delta_EXT : CMD_Delta_PS(); break;
case PDelta_500 : Gyro.ModeOut=3; Gyro.Event_500Hz=0; break;
case PDelta_EXT : Gyro.ModeOut=4; break;
}
break;
case 0xB0: DropDelay(); TempParam = TempParam=(BuffTemp[3]>>7); //Delta_Bins
switch(TempParam) {
case PDelta_Bins: Gyro.ModeOut=5; Gyro.Event_500Hz=0; break;
case Delta_Bins : CMD_Delta_Bins(); break;
}
break;
case 0x0F: DropDelay(); TempParam = (((BuffTemp[3])>>4) & 0x9); //B_Delta
switch(TempParam) {
case PB_Delta_EXT: Gyro.ModeOut=6; break;
case PB_Delta_INT: Gyro.ModeOut=7; Gyro.Event_500Hz=0; break;
case B_Delta_EXT: CMD_B_Delta(); break;
case B_Delta_INT: CMD_B_Delta(); break;
}
break;
case 0xE4: CMD_M_vib(); break;
case 0xA5: DeviceMode(); break;
case 0xE6: Gph_W(); break;
Gyro.RsErrLine = 0;
}
}
}
void TechLog(void)
{
unsigned int temp=0;
if (ReadCon (Time))
{
int a=0;
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//////////////////////Выбор FlashMod///////////////////////////
////////////////////////////////////////////////////////////////
if (Time[0] == 'B') Gyro.FlashMod=1;
if (Time[0] == 'R') {Gyro.FlashMod=3;}
if (Time[0] == 'E') {Gyro.FlashMod=4;}
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
/* if (Time[0] == 'f') { // выдача технологическая
Gyro.ModAmp += 1;
sprintf((Time),"%d \r\n", Gyro.ModAmp);
WriteCon(Time);
}*/
/* if (Time[0] == 'd') { // выдача технологическая
Gyro.ModAmp -= 1;
sprintf((Time),"%d \r\n", Gyro.ModAmp);
WriteCon(Time);
}*/
if (Time[0] == 'V') { // выдача технологическая
F_vib += 1;
LPC_MCPWM->LIM1 = F_vib;
LPC_MCPWM->LIM2 = F_vib;
sprintf((Time),"%d \r\n", F_vib);
WriteCon(Time);
}
if (Time[0] == 'v') { // выдача технологическая
F_vib -= 1;
LPC_MCPWM->LIM1 = F_vib;
LPC_MCPWM->LIM2 = F_vib;
}
if (Time[0] == 'C') { // выдача технологическая
AmpP += 1;
T_vibP = F_vib/10000;
T_vib_1 = AmpP * T_vibP;
T_vib_2 = T_vibP * (10000-AmpP +1);
LPC_MCPWM->MAT2 = T_vib_2;
LPC_MCPWM->MAT1 = T_vib_1;
}
if (Time[0] == 'c') { // выдача технологическая
AmpP -= 1;
T_vibP = F_vib/10000;
T_vib_1 = AmpP * T_vibP;
T_vib_2 = T_vibP * (10000-AmpP+1 );
LPC_MCPWM->MAT2 = T_vib_2;
LPC_MCPWM->MAT1 = T_vib_1;
}
if (Time[0] == 'X') { // выдача технологическая
faza += 1;
sprintf((Time),"%d \r\n", Spi.DAC_A);
WriteCon(Time);
}
if (Time[0] == 'x') { // выдача технологическая
if(TypeMod>2) TypeMod=0;
else TypeMod=4;
}
if (Time[0] == 'p') { // выдача технологическая
// PlcOFF //Gyro.RgConA&0x8=0;
if(Gyro.LogMod) Gyro.LogMod=0;
else Gyro.LogMod=5;
// MODFlag=1;
// Spi.DAC_B = 32767;
}
if (Time[0] == 'o') { // выдача технологическая
if(Gyro.LogMod==2)Gyro.LogMod=0;
else Gyro.LogMod=2;
// Spi.DAC_B = 32000;
}
if (Time[0] == 'h')
{ // выдача технологическая
for(int q=0; q<64; q++)
{
sprintf((Time),"%i \r\n",(BuffADC_znak[q]));
WriteCon(Time);
}
}
if (Time[0] == 'm')
{ // выдача технологическая
for(int q=0; q<64; q++)
{
sprintf((Time),"%d \r\n", BuffADC_64Point[q]>>7);
WriteCon(Time);
}
}
if (Time[0] == 'n')
{ // выдача технологическая
for(int q=0; q<64; q++)
{
sprintf((Time),"%d \r\n", BuffADC_1Point[q]);
WriteCon(Time);
}
}
if (Time[0] == 'b')
{
for(int q=0; q<64; q++)
{
sprintf((Time),"%d \r\n", Buff_Restored_Mod[q]);
WriteCon(Time);
}
}
if (Time[0] == 'u')
{ // выдача технологическая
MODFlag=0; //Mod vibro Hz
}
if (Time[0] == 'y')
{ //Mod 250 Hz PLCRegul250();
MODFlag=2;
}
if (Time[0] == 'f')
{ // выдача технологическая
Gyro.CuruAngleLog = 0; //Mod vibro Hz
}
if (Time[0] == 'd')
{ // выдача технологическая
Gyro.CuruAngleLog = 1; //Mod vibro Hz
}
if (Time[0] == 'l')
{ // выдача технологическая
Gyro.My_Addres = GyroP.Str.My_Addres; // Gyro.My_Addres = 0;
Gyro.GLD_Serial = GyroP.Str.GLD_Serial;
Gyro.FrqHZ = GyroP.Str.FrqHZ;
Gyro.Frq = GyroP.Str.FrqHZ<<16;
Gyro.FrqHZmin = GyroP.Str.FrqHZmin<<16;
Gyro.FrqHZmax = GyroP.Str.FrqHZmax<<16;
Gyro.FrqChengSpeed = GyroP.Str.FrqChengSpeed;
Gyro.PLC_Gain = GyroP.Str.PLC_Gain;
Gyro.PLC_Phase = GyroP.Str.PLC_Phase;
Gyro.ModAmp = GyroP.Str.ModAmp;
Gyro.FrqPhase = GyroP.Str.FrqPhase;
Gyro.AmpPer = GyroP.Str.AmpPer;
Gyro.Amp = GyroP.Str.AmpPer<<16;
Gyro.AmpSpeed = GyroP.Str.AmpSpeed;
Gyro.AmpPerDel = GyroP.Str.AmpPerDel;
temp=((GyroP.Str.VB_Fdf_Hi<<16) | GyroP.Str.VB_Fdf_Lo);
temp=temp/18.2;
Gyro.AmpTarget=(unsigned int)(temp);
Gyro.AmpPerMin = GyroP.Str.AmpPerMin;
Gyro.AmpPerMax = GyroP.Str.AmpPerMax;
Gyro.AmpMin = GyroP.Str.AmpMin;
Gyro.AmpTD = GyroP.Str.AmpTD;
Spi.DAC_A = GyroP.Str.DAC_current_Work;
Gyro.Gain_Sin = GyroP.Str.Gain_Sin;
Gyro.Gain_Cos = GyroP.Str.Gain_Cos;
Out_G_photo(Gyro.Gain_Sin, Gyro.Gain_Cos);
}
}
}