Command.c

00001 #include "stdlib.h"
00002 #include "LPC17xx.h"
00003 #include "Command.h"
00004 #include "el_lin.h"
00005 #include "vibro.h"
00006 #include "Global.h"
00007 #include "uart_m.h"
00008 #include "CntrlGLD.h"
00009 #include "QEI.h"
00010 #include "InputOutput.h"
00011 #include "SPI.h"
00012 unsigned int Rate_Flag;
00013 unsigned int CountBuFFIn;
00014 unsigned int N=0,CRC_N;
00015 unsigned int Param1=0;
00016 unsigned int Param2=0;
00017 unsigned int Param3=0;
00018 unsigned int Param4=0;
00019 
00020 /*
00021 void exec_CMD(void)       //r. === процедура окончательной дешифрации и исполнения команды
00022 {
00023     unsigned int Comand_code;
00024 
00025     //rx_buf_copy = 1;                  //r. предустанов флага копирования приемного буфера
00026 
00027     Comand_code = (rcv_buf[2] & 0xFF) << 8;
00028     PC_Comand = Comand_code | (rcv_buf[3] & 0xFF);  //e. save it in the memory for echo-transmission //r. сохранить его в памяти для обратной передачи
00029 }*/
00030 void CMD_Maintenance(void)
00031 {
00032     BuffTemp[0] = Main.SOC_Out;
00033     BuffTemp[1] = Main.My_Addres;
00034     BuffTemp[2] = Main.Firmware_Version;
00035     BuffTemp[3] = Main.GLD_Serial;
00036     BuffTemp[4]=0x00;
00037     BuffTemp[5]=0x00;
00038     Check(BuffTemp, 8);
00039     WriteConN (BuffTemp,8);
00040 }
00041 
00042 void CMD_Rate(void)
00043 {
00044 
00045     unsigned int T_VibH   , T_VibL;             // Частота вибропривода.
00046     unsigned int Cnt_PlsL , Cnt_PlsH;           // Счетчик +.
00047     unsigned int Cnt_MnsL , Cnt_MnsH;           // Счетчик -.
00048     unsigned int Cnt_DifL , Cnt_DifH;           // Разность счетчиков.
00049     unsigned int F_rasL   , F_rasH;             // Частота расщепления.
00050 
00051     unsigned int HF_regL  , HF_regH;      // Выход регулятора ГВЧ.               НЕ СДЕЛАНО
00052     unsigned int HF_difL  , HF_difH;      // Сигнал ошибки регулячтора ГВЧ.      НЕ СДЕЛАНО
00053 
00054     unsigned int WP_regL  , WP_regH;
00055 
00056     unsigned int ADC1L, ADC2L, ADC3L, ADC4L, ADC5L;
00057     unsigned int ADC1H, ADC2H, ADC3H, ADC4H, ADC5H;
00058 
00059 
00060     LoopOn
00061 //  Main.T_Vib=(unsigned int)((7680000*16/Main.Frq)*4096);
00062     Main.T_Vib=(unsigned int)((7680000*16/(Main.Frq>>12)));
00063     Main.Firmware_Version=0xff; /// промежуточная затычка
00064 
00065     T_VibH   = ( Main.T_Vib>>8  ) TakeByte;
00066     T_VibL   = ( Main.T_Vib     ) TakeByte;
00067 
00068     Cnt_PlsH = ( Main.Cnt_Pls>>8) TakeByte;
00069     Cnt_PlsL = ( Main.Cnt_Pls   ) TakeByte;
00070 
00071     Cnt_MnsH = ( Main.Cnt_Mns>>8) TakeByte;
00072     Cnt_MnsL = ( Main.Cnt_Mns   ) TakeByte;
00073 
00074     Cnt_DifH = ( Main.Cnt_Dif>>8) TakeByte;
00075     Cnt_DifL = ( Main.Cnt_Dif   ) TakeByte;
00076 
00077     F_rasH   = ( Main.F_ras>>8  ) TakeByte;
00078     F_rasL   = ( Main.F_ras     ) TakeByte;
00079 
00080     ADC1H    = ( Spi.ADC1>>8    ) TakeByte;
00081     ADC1L        = ( Spi.ADC1       ) TakeByte;
00082 
00083     ADC2H    = ( Spi.ADC2>>8    ) TakeByte;
00084     ADC2L        = ( Spi.ADC2       ) TakeByte;
00085 
00086     ADC3H    = ( Spi.ADC3>>8    ) TakeByte;
00087     ADC3L        = ( Spi.ADC3       ) TakeByte;
00088 
00089     ADC4H    = ( Spi.ADC4>>8    ) TakeByte;
00090     ADC4L        = ( Spi.ADC4       ) TakeByte;
00091 
00092     ADC5H    = ( Spi.ADC5>>8    ) TakeByte;
00093     ADC5L        = ( Spi.ADC5       ) TakeByte;
00094 
00095     WP_regH  = ( Spi.DAC_B>>8   ) TakeByte;
00096     WP_regL  = ( Spi.DAC_B      ) TakeByte;
00097 
00098     HF_regH=0xff;
00099     HF_regL=0xff;
00100 
00101     HF_difH=0xff;
00102     HF_difL=0xff;
00103 
00104 
00105     BuffTemp[ 0] = Main.SOC_Out;
00106     BuffTemp[ 1] = Main.My_Addres;
00107 
00108     BuffTemp[ 2] = Cnt_PlsH;//старший байт счетчика +.
00109     BuffTemp[ 3] = Cnt_PlsL;//младший байт счетчика +.
00110 
00111     BuffTemp[ 4] = Cnt_MnsH;//старший байт счетчика -.
00112     BuffTemp[ 5] = Cnt_MnsL;//младший байт счетчика -.
00113 
00114     BuffTemp[ 6] = Cnt_DifH;//старший байт разности счетчиков
00115     BuffTemp[ 7] = Cnt_DifL;//младший байт разности счетчиков
00116 
00117     BuffTemp[ 8] = F_rasH;
00118     BuffTemp[ 9] = F_rasL;
00119 
00120     BuffTemp[10] = HF_regH;
00121     BuffTemp[11] = HF_regL;
00122 
00123     BuffTemp[12] = HF_difH;
00124     BuffTemp[13] = HF_difL;
00125 
00126     BuffTemp[14] = T_VibH ;//
00127     BuffTemp[15] = T_VibL; //?
00128 
00129     BuffTemp[16] = Main.Firmware_Version;//ХЗ
00130     BuffTemp[17] = Main.Firmware_Version;//ХЗ
00131 
00132     BuffTemp[18] = T_VibH>>1;
00133     BuffTemp[19] = T_VibL;
00134 
00135     BuffTemp[20] = Main.Firmware_Version;//ХЗ
00136     BuffTemp[21] = Main.Firmware_Version;//ХЗ
00137 
00138     BuffTemp[22] = WP_regH;              //СРП    Spi.DAC_B
00139     BuffTemp[23] = WP_regL;              //СРП
00140 
00141     BuffTemp[24] = Main.Firmware_Version;// ХЗ
00142     BuffTemp[25] = Main.Firmware_Version;// ХЗ
00143 
00144     BuffTemp[26] = ADC1H;
00145     BuffTemp[27] = ADC1L;
00146 
00147     BuffTemp[28] = ADC1H;
00148     BuffTemp[29] = ADC1L;
00149 
00150     BuffTemp[30] = ADC1H;
00151     BuffTemp[31] = ADC1L;
00152 
00153     BuffTemp[32] = ADC1H;
00154     BuffTemp[33] = ADC1L;
00155 
00156     BuffTemp[34] = ADC1H;
00157     BuffTemp[35] = ADC1L;
00158 
00159     BuffTemp[36] = 0x00;//ADC6
00160     BuffTemp[37] = 0x00;//ADC6
00161 
00162     BuffTemp[38] = Main.Firmware_Version;
00163     BuffTemp[39] = Main.Firmware_Version;
00164     BuffTemp[40] = Main.Firmware_Version;
00165     BuffTemp[41] = Main.Firmware_Version;
00166 
00167 
00168     Check(BuffTemp, 44);
00169     WriteConN (BuffTemp,44);
00170     LoopOff
00171 }
00172 
00173 void CMD_M_Control_D8()///установка\сброс регистров управления
00174 {
00175     int bit,NReg;
00176     BuffTemp[0] = Main.SOC_Out;      //DD
00177     BuffTemp[1] = Main.My_Addres;    //00
00178     BuffTemp[2] = Main.CMD_In;       //D8
00179     //10?
00180     if((Param1&0x80)) {
00181         bit=1;
00182     } else {
00183         bit=0;
00184     }
00185 
00186     if ((Param1 & 0x10) == 0) {
00187         NReg=0;
00188         switch(Param1&0xf) { // Main.RgConA
00189             case 0x0:
00190                 Main.RgConA|=bit;
00191                 break;
00192 
00193             case 0x1:
00194                 Main.RgConA|=bit<<0x1;
00195                 break;
00196 
00197             case 0x2:
00198                 Main.RgConA|=bit<<0x2;
00199                 break;
00200 
00201             case 0x3:
00202                 Main.RgConA|=bit<<0x3;
00203                 break;
00204 
00205             case 0x4:
00206                 Main.RgConA|=bit<<0x4;
00207                 break;
00208 
00209             case 0x5:
00210                 Main.RgConA|=bit<<0x5;
00211                 break;
00212 
00213             case 0x6:
00214                 Main.RgConA|=bit<<0x6;
00215                 break;
00216 
00217             case 0x7:
00218                 Main.RgConA|=bit<<0x7;
00219                 break;
00220         }
00221         BuffTemp[3] = NReg<<4;
00222         BuffTemp[4] = (Main.RgConA>>8 )& 0xff;
00223         BuffTemp[5] =  Main.RgConA     & 0xff;
00224     } else {
00225         NReg=1;            // Main.RgConB
00226         switch(Param1&0xf) { // Main.RgConB
00227             case 0x0:
00228                 Main.RgConB|=bit;
00229                 break;
00230             case 0x1:
00231                 Main.RgConB|=bit<1;
00232                 break;
00233             case 0x2:
00234                 Main.RgConB|=bit<2;
00235                 break;
00236         }
00237         BuffTemp[3] =  NReg<<4;
00238         BuffTemp[4] = (Main.RgConB>>8 ) & 0xff;
00239         BuffTemp[5] =  Main.RgConB      & 0xff;
00240     }
00241 
00242     Check(BuffTemp, CRC_N);
00243     WriteConN (BuffTemp,CRC_N);
00244 }
00245 
00246 void CMD_M_Control_D9()///чтение регистров управления
00247 {
00248     int bit,NReg;
00249     BuffTemp[0] = Main.SOC_Out;      //DD
00250     BuffTemp[1] = Main.My_Addres;    //00
00251     BuffTemp[2] = Main.CMD_In;       //D9
00252     if ((Param1 & 0x10) == 0) {
00253         BuffTemp[3]=0<<4;
00254         BuffTemp[4] = (Main.RgConA>>8 )& 0xff;
00255         BuffTemp[5] =  Main.RgConA     & 0xff;
00256     } else {
00257         BuffTemp[3]=1<<4;
00258         BuffTemp[4] = (Main.RgConB>>8 ) & 0xff;
00259         BuffTemp[5] =  Main.RgConB      & 0xff;
00260     }
00261     Check(BuffTemp, CRC_N);
00262     WriteConN (BuffTemp,CRC_N);
00263 }
00264 // (номер (код) ЦАПа 0...3, старший байт требуемого ЦАПа, младший байт треб ЦАПа)
00265 void CMD_M_Stymul()
00266 {
00267     int temp;
00268     temp =((BuffTemp[4]<<8) | BuffTemp[5]);
00269     // temp=0;
00270     temp=temp&0xFFFF;
00271     DACF =(temp*K_DAC)+deltaDAC;
00272     Spi.DAC_B =(unsigned int)(DACF) /*(unsigned int)(temp*K_DAC+deltaDAC)*/; // K_DAC);
00273 
00274     //int temp;
00275 //  temp =((BuffTemp[4]<<8) | BuffTemp[5]);
00276     //temp = 65535 - temp;
00277     /*if(temp<1000)
00278     {
00279         temp=0;
00280     }
00281     else if(temp>60000)
00282     {
00283         temp=65535;
00284     }*/
00285     //Spi.DAC_B =(((BuffTemp[4]<<8) | BuffTemp[5])*K_DAC+deltaDAC);/*((BuffTemp[4]<<8) | BuffTemp[5])-0xFFFF*///;  //((rcv_buf[4] << 8) | (int)rcv_buf[5]);K_DAC+deltaDAC
00286     //BuffTemp[0] = temp;      //DD
00287     //WriteConN (BuffTemp,1);
00288 }
00289 
00290 unsigned int Check(char *c, unsigned int Count)
00291 {
00292     int i=1;
00293     unsigned int temp,CRC;
00294 
00295 
00296     temp=1;
00297     CRC=0;
00298 
00299 
00300     for(; i<Count-2; i++) {
00301         CRC+=c[i];
00302     }
00303 
00304     if(c[Count-2]!=((CRC>>8)&0xFF)) {
00305         temp=0;
00306         Main.RsErrLine = (Main.RsErrLine)&=0x2;
00307     }
00308 
00309     if(c[Count-1]!=((CRC>>0)&0xFF)) {
00310         temp=0;
00311 //      Main.RsErrLine= (Main.RsErrLine)=0x2;
00312     }
00313 
00314     c[Count-2]=(CRC>>8)&0xFF;
00315     c[Count-1]=(CRC>>0)&0xFF;
00316 
00317 
00318 
00319     return temp;
00320 }
00321 
00322 int Getlengf(void)
00323 {
00324     unsigned int lengf=0;
00325     switch(Main.CMD_In) {
00326         case 0x99://maintainance
00327             lengf=6;
00328             CRC_N=8;
00329             break;
00330 
00331         case 0x0A: //m_stymul
00332             lengf=8;
00333             break;
00334 
00335         case 0xA5://DeviceMode
00336 
00337             lengf=6;
00338             CRC_N=8;
00339             break;
00340 
00341         case 0xDD://m_rate
00342 
00343             lengf=6;
00344             CRC_N=44;
00345             break;
00346 
00347         case 0xB0://DeviceMode
00348 
00349             lengf=6;
00350             CRC_N=8;
00351             break;
00352 
00353         case 0xD8://m_control
00354 
00355             lengf=6;
00356             CRC_N=8;
00357             break;
00358 
00359         case 0xD9://m_control
00360 
00361             lengf=6;
00362             CRC_N=8;
00363             break;
00364     }
00365     return lengf;
00366 }
00367 
00368 void Read_CMD(void)
00369 {
00370     Main.SOC_Out=0xDD;
00371     Main.RsErrLine = (Main.RsErrLine)& 0xffff;
00372 
00373 
00374     CountBuFFIn=ReadChekCon(BuffTemp);
00375     if(CountBuFFIn==1) {
00376         if (BuffTemp[0] != SOC_In) {
00377             ReadCon(BuffTemp);
00378             Main.RsErrLine += 0x100;//WriteCon("\n\r ...Error.... ");
00379             BuffTemp[99]=Main.RsErrLine;
00380         }
00381     } else if(CountBuFFIn==2) {
00382         if (BuffTemp[1] != Main.My_Addres) {
00383             ReadCon(BuffTemp);
00384             Main.RsErrLine += 0x1;//WriteCon("\n\r ...Error_ADDRES.... ");
00385         }
00386     } else if(CountBuFFIn==3) {
00387         Main.CMD_In=BuffTemp[2];
00388         N=Getlengf();
00389     } else if(CountBuFFIn==4 && N==6) {
00390         Param1=BuffTemp[3];
00391     } else if((CountBuFFIn==5)&&(N==7)) {
00392         //LoopOn
00393         Param1=BuffTemp[3];
00394         Param2=BuffTemp[4];
00395 
00396     } else if((CountBuFFIn==6)&&(N==8)) {
00397         Param1=BuffTemp[3];
00398         Param2=BuffTemp[4];
00399         Param3=BuffTemp[5];
00400     } else if(CountBuFFIn > (N-1)) {
00401         ReadCon(BuffTemp);
00402         if(Check(BuffTemp, CountBuFFIn)) {
00403             switch(Main.CMD_In) {
00404                 case CMD_MAINT:
00405                     CMD_Maintenance();
00406                     break;
00407                 case 0xD8:
00408                     CMD_M_Control_D8();
00409                 case 0xD9:
00410                     CMD_M_Control_D9();
00411                     break;
00412                 case 0x0A:
00413                     CMD_M_Stymul(Param1,Param2,Param3);
00414                     break;
00415                 case 0xDD:
00416                     Rate_Flag=1;
00417                     break;
00418                     Main.RsErrLine = 0;
00419             }
00420 
00421         }
00422     }
00423 }
00424 
00425 
00426