main.cpp

00001 #include "PerifConfig.h"
00002 #include "PGA280.h"
00003 #include "ADS1259.h"
00004 #include "PGA280ADS1259.h"
00005 #include "main.h"
00006 #include "ad5422_arduino.h"
00007 #include "lm35.h"
00008 #include "LT1446.h"
00009 #include "ads1248.h"
00010 #include "flashwrapper.h"
00011 #include <cmath>
00012 #include "FT_Platform.h"
00013 #include "display.h"
00014 
00015 //коэффициенты по умолчанию температура колонки
00016 #define E_PCOEFF    0.5F    //Пропорциональный коэффициент ПИД регулятора (Из EEPROM)
00017 #define E_ICOEFF    1500.0F //Постоянная времени интегрирования ПИД регулятора в секундах (Из EEPROM) (был 3000)
00018 #define E_DCOEFF    0.1F
00019 #define PID_SAMPLE_TIME 0.25F    //Период ПИД
00020 // --//-- расхода
00021 #define R_PCOEFF    0.11F    //Пропорциональный коэффициент ПИД регулятора (Из EEPROM)
00022 #define R_ICOEFF    3000.0F //Постоянная времени интегрирования ПИД регулятора в секундах (Из EEPROM) (был 3000)
00023 #define R_DCOEFF    0.1F
00024 #define R_PID_SAMPLE_TIME 0.25F
00025 
00026 #define CHKD (0x43484B44) //константа для проверки записанных данных (необходима контрольная сумма)
00027 #define TEMP 35
00028 
00029 
00030 /*Таймер для вызова функции каждые 40 мс*/
00031 Ticker lm_temp;
00032 Ticker adctask;
00033 Ticker PID1; //ПИД для нагрева колонки
00034 Ticker PID2; //ПИД для расхода
00035 /*Конец*/
00036 //InterruptIn button(USER_BUTTON);
00037 InterruptIn ADSRdy(D8);
00038 
00039 //настройка SPI для дисплея
00040 FT813 TFT (PC_12, PC_11, PC_10, PD_2, PG_2, PG_3); //mosi, miso, sck, ss, int, pd
00041 Display disp(&TFT);
00042 //конец
00043 
00044 ADS1248_t ads1;//экземпляр ЦАП 1446 в памяти
00045 LM35_t RAS;
00046 PID_prom_t TempCol;
00047 PID_prom_t Rashod;
00048 PID_defs_t PID_defs={E_PCOEFF,E_ICOEFF,E_DCOEFF,PID_SAMPLE_TIME};
00049 PID_defs_t PID_R_defs={R_PCOEFF,R_ICOEFF,R_DCOEFF,R_PID_SAMPLE_TIME};
00050 volatile uint8_t temp=0;// уставка температуры колонки
00051 volatile float rashod_u=0; //уставка расхода
00052 char mbflag;
00053 unsigned char pga280gain;
00054 char UComandFlag;
00055 volatile unsigned char UComand;
00056 volatile long tempdata=0;
00057 char ch=0;              //адрес на плате ТЭД-2 = 6
00058 float x=0;
00059 float k;
00060 unsigned char str[];
00061 
00062 //указатель для подстановки нужной функции
00063 void (*printer_p)(void);
00064 
00065 //функция чтения АДС для выполнения в задаче
00066 void readADC()
00067 {
00068     tempdata=ads1259_readData(5);       //функция может зависать (надо избавиться от бесконечного цикла)          
00069     x=NormADC(tempdata);
00070     UART.printf("%08f\r\n",x);
00071 }
00072 
00073 void readtemp()
00074 {    
00075     float t;
00076     /*Обработка ошибки*/
00077     //LM35_start(0.25);    
00078     if (LM35_0.ready) //если данные готовы то считать и сбросить флаг (способ многозадачности)
00079     {
00080         LM35_0.ready=0;
00081         t=LM35_0.temp;
00082         TempCol.Error=temp-t;
00083         TempCol.Integral += TempCol.Error;
00084         TempCol.dError = TempCol.Error - TempCol.last_Error;
00085         TempCol.last_Error = TempCol.Error;
00086         //временно записать в калиброванное значение (нельзя так делать)
00087         LT1446_0.dacB.Code=(uint16_t)(PID(&Mem.PID,&TempCol) * 4095);
00088         LTCwrite(&LT1446_0);        
00089     }
00090     
00091 }
00092 
00093 void readRashod()
00094 {
00095     float r;
00096     //Если не настроен, то настраиваем нужный канал чтения
00097     
00098     //используем тот же тип из-за схожести
00099     if(RAS.ready)//Если данные готовы для считывания..
00100     {RAS.ready=0;
00101         r=RAS.temp; 
00102         Rashod.Error=rashod_u-r;
00103         Rashod.Integral += Rashod.Error;//
00104         Rashod.dError = Rashod.Error - Rashod.last_Error;
00105         Rashod.last_Error = Rashod.Error;
00106         LT1446_0.dacA.Code=(uint16_t)(PID(&Mem.PID_R,&Rashod) * 4095);
00107         LTCwrite(&LT1446_0);        
00108     //Pressure.write(PID(&Mem.PID_R,&Rashod));
00109     }
00110 }
00111 
00112 void printtemp()
00113 //отобразить температуру 1 раз
00114 {
00115     if (LM35_0.ready||RAS.ready) //если данные готовы то считать
00116     {
00117     UART.printf("TempCol %0.2f\t|\tRashod %0.4f ml (%0.4fV)\r\n",LM35_0.temp,RAS.temp,RAS.volts);
00118     }
00119     
00120     }
00121 
00122 void printPID()
00123 {
00124     /*функция отобображает в терминале значения не в момент расчёта ПИДа,
00125     но этого по идее достаточно для оценки результата работы, 
00126     так как отображаются последние записанные в переменную данные*/
00127     if ((Mem.PID.enabled==1)&&(Mem.PID_R.enabled==0)) //Если включен только первый ПИД
00128     {
00129         UART.printf("PID_t: Power %04d temp %0.2f\r\n",LT1446_0.dacB.Code,LM35_0.temp);
00130         }
00131     else if ((Mem.PID_R.enabled==1)&&(Mem.PID.enabled==0)) //Если включен только второй ПИД
00132     {
00133     UART.printf("PID_R: Power %04d rashod %0.4f ml (%0.4fV)\r\n",LT1446_0.dacA.Code,RAS.temp,RAS.volts);    
00134         }
00135     else if ((Mem.PID_R.enabled==1)&&(Mem.PID.enabled==1)) //Если включены оба ПИД    
00136         {
00137     UART.printf("PID_t: Power %04d temp %0.2f | ",LT1446_0.dacB.Code,LM35_0.temp);
00138     UART.printf("PID_R: Power %04d rashod %0.4f ml (%0.4fV)\r\n",LT1446_0.dacA.Code,RAS.temp,RAS.volts);    
00139             }    
00140 }
00141 
00142 float inline NormADC(long data)
00143 {
00144     x=data*2.5/0x800000;
00145     //x=x*8/(1<<pga280gain);
00146     return x;
00147 }
00148 
00149 
00150  /*Собственно сам расчёт ПИД. В аргумент подставляется
00151  конкретный ПИД (температура или расход) и его промежуточные значения (вклады)*/
00152  float PID (PID_t *pidx, PID_prom_t *prom)
00153     {         
00154     float P = pidx->kP * prom->Error;
00155     float I = pidx->kP / pidx->kI * pidx->sampleTime * prom->Integral;
00156     float D = pidx->kP * pidx->kD / pidx->sampleTime * prom->dError;
00157     float control = P + I + D;
00158     if (control > 1.0) return 1.0;
00159     if (control < 0.0) return 0.0;
00160     return control;
00161     }
00162 
00163 //включить пид1
00164 void pressed()
00165 {
00166     /*Включить АЦП*/
00167     DS1248_START=1;
00168     ADS1248WakeupCommand();
00169     /*Выключить постоянное оторажение температуры*/
00170     
00171     //запустить ПИД
00172     PID1.attach(&readtemp,0.25);
00173     Mem.PID.enabled=1;
00174     UART.printf("PID is ON\r\n");
00175 }
00176 
00177 //включить пид2
00178 void pid2_start()
00179 {
00180     DS1248_START=1;
00181     ADS1248WakeupCommand();    
00182     PID2.attach(&readRashod,0.25);
00183     Mem.PID_R.enabled=1;
00184     UART.printf("PID_R is ON\r\n");
00185 }
00186 
00187 void readads()
00188 /*чтение АЦП в режиме
00189 -только первый канал
00190 -только второй канал
00191 -оба канала
00192 или как вариант: позиция бита означает какие каналы считываются если их больше чем 2*/
00193 {       
00194     double v=0;    
00195     //температура
00196     
00197     if(ads1.MUX0.MUX_SP!=0){
00198     /*Если не настроено чтение температуры то считать 
00199     текущие показания для предыдущих настроек и записать необходимые*/
00200     v=2.048*ADS1248ReadData(&ads1)/0x800000;
00201     RAS.volts=v;
00202     RAS.temp=v*26.316-0.263;// мл/мин (сделать уставку)
00203     RAS.ready=1;
00204     ads1.MUX0.MUX_SN=1; //AIN1
00205     ads1.MUX0.MUX_SP=0; //AIN0
00206     ads1.VBIAS.all=0;
00207     ADS1248SettingReg(&ads1);
00208     goto end;}
00209     
00210     if(ads1.MUX0.MUX_SP!=2){
00211     /*То же самое для расхода*/
00212     v=2.048*ADS1248ReadData(&ads1)/0x800000;    
00213     LM35_0.temp=v*100;    
00214     LM35_0.ready=1;
00215     ads1.MUX0.MUX_SN=3; //AIN3
00216     ads1.MUX0.MUX_SP=2; //AIN2
00217     ads1.VBIAS.VBIAS3=1;
00218     ADS1248SettingReg(&ads1);}
00219     end:
00220     }
00221     
00222 void Mem_write()
00223 {
00224     flashWrite(0,Mem.w,(sizeof(Mem.w)/sizeof(uint32_t)));
00225 }
00226 
00227 float BufToFloat(unsigned char *buf)
00228 /*Преобразование строки из 16 символов в float*/
00229 /*Нельзя первым символом вводить точку, перед неей обязательно нужна цифра
00230 Числа вводятся в формате 1.0 или 1,0 (точка обяательна даже если дробной части нет)*/
00231 {    
00232     int8_t n=-1; //начало (при старте его нет)
00233     uint8_t i=0;
00234     int8_t j=-1; //счётчик символов до точки
00235     uint8_t p=0; //позиция точки
00236     float result=1;  //временно используем чтобы определить знак числа
00237     
00238     //while(str[i]!=)    
00239     //команда выглядит как "/v0=-123.456" поэтому считаем с символа "-" позиция которого 3 (4 знак в массиве)    
00240     //проверка на отрицательность и первый знак            
00241     for (i=0;i<16;i++)
00242     {
00243         if(buf[i]=='-'){
00244             result=-result;
00245             n=i;
00246             i++;                    
00247             break;
00248             }
00249         if((buf[i]>=0x30)&&(buf[i]<=0x39))
00250         {
00251             n=i;            
00252             break;
00253         }            
00254     }
00255     if(n<0) return 0;
00256     //до тех пор, пока поступают нужные символы и нет превышения длины строки
00257     while((i<16)&&(buf[i]>=0x30)&&(buf[i]<=0x39)||((buf[i]=='.')||(buf[i]==',')||(buf[i]=='-')))
00258         {            
00259             i++;            
00260         //проверять на наличие точки или запятой
00261             if((buf[i]=='.')||(buf[i]==','))
00262             {
00263                 if(p==0){               //если точка ещё не попадалась
00264                 p=i;                    //запоминаем позицию плавающей запятой
00265                 if (result>=0)
00266                 j=i-n;                  //цифр до точки (3 начало)
00267                 else j=i-n-1;}          //на 1 символ больше из-за "-"
00268                 else break;             //если попалась ещё одна точка
00269             }        
00270        }
00271         
00272     /*Добавить проверку на целое число!!
00273     Добавить проверку на первый символ "точка"
00274     */
00275     
00276     //ниже преобразуем информацию в число
00277     if (result>=0){
00278         result=0;
00279         i=i-j-n-1; //знаки после запятой
00280         while(i--){
00281             result+=(buf[p+i+1]-0x30)*powf(10,-i-1);
00282         }
00283         while(j--){
00284         result+=(buf[p-j-1]-0x30)*powf(10,j);        
00285         }
00286     }            
00287     else {//строка на 1 знак больше
00288         result=0;
00289         i=i-j-n-2; //знаки после запятой         
00290         while(i--){
00291             result+=(buf[p+i+1]-0x30)*powf(10,-i-1);
00292         }
00293         while(j--){            
00294         result+=(buf[p-j-1]-0x30)*powf(10,j);        
00295         }
00296         result=-result;
00297     }
00298     if (result>-9999.9&&result<9999.99)//заменить на проверку адекватности
00299     return result;
00300     else if (result<=-9999.99)
00301     return (-9999.99);
00302     else if (result>=9999.99)//заменить на проверку адекватности
00303     return (9999.99);
00304     else return 0;
00305 }    
00306 
00307 void setPIDdefault(PID_t *pidx,PID_defs_t *defs)
00308 /*Установка для нужного пида его настроек по умолчанию*/
00309 {
00310         pidx->kP=defs->kp;
00311         pidx->kI=defs->ki;
00312         pidx->kD=defs->kd;
00313         pidx->sampleTime=defs->st;
00314         pidx->chkd=CHKD;
00315     }
00316   
00317 int main()
00318 {       
00319     UART.printf("SystemClock %d\r\n",SystemCoreClock);
00320     //считывание данных настроек из памяти
00321     for (int i=0;i<sizeof(Mem.w)/sizeof(uint32_t);i++)
00322     {    
00323     Mem.w[i]=flashRead(i*4);//sizeof(uint32_t)=4;
00324     }
00325     if ((Mem.PID.chkd!=CHKD)||(Mem.PID_R.chkd!=CHKD))
00326     {
00327     //если метки данных нет то записать настройки ПИД по умолчанию
00328     UART.printf("PID is default\r\n");
00329         setPIDdefault(&Mem.PID,&PID_defs);
00330         setPIDdefault(&Mem.PID_R,&PID_R_defs);
00331         Mem_write();
00332         }
00333     UART.printf("PID:\r\nKp=%0.3f\r\nkI=%0.3f\r\nkD=%0.3f\r\n",Mem.PID.kP,Mem.PID.kI,Mem.PID.kD);
00334     UART.printf("PID_R:\r\nKp=%0.3f\r\nkI=%0.3f\r\nkD=%0.3f\r\n",Mem.PID_R.kP,Mem.PID_R.kI,Mem.PID_R.kD);
00335     UART.printf("%08X\r\n",Mem.PID.chkd);
00336     temp=Mem.temp_u;
00337     rashod_u=Mem.rashod_u;
00338     //Инициализация периферийных устройств
00339     SPI1_MasterInitMode(1);//работают режимы 1 и 2 для платы ТЭД2
00340      //SPI3_MasterInitMode(1);
00341    //запустить задачу проверки команды по прерыванию УАРТ
00342     UART.attach(&ComandCheck,Serial::RxIrq);
00343     /*EN1=1;
00344     
00345      ch=5;
00346     pga280_setAdress(ch);    
00347     pga280_ads1259_init(ch); //инициализировать АЦП по адресу на плате ТЭД-2 = 5 (4)
00348     printf("\r\n");
00349     tempdata=pga280_readOneRegisterDevice(PGA280_BUF_TIMEOUT_ADR,ch);
00350     printf("Timeout %X\n",tempdata);
00351     wait_ms(20);
00352     pga280_setGAIN(GAIN_1_PGA280,ch);
00353     pga280_setMUX(2,ch);
00354     pga280gain=3; //   gain=1 (0x03)
00355     tempdata=pga280_readOneRegisterDevice(PGA280_ERROR_ADR,ch);//чтение ошибок
00356     printf("Errors %X\n",tempdata);
00357     /*Конец*/
00358     
00359 
00360     
00361     
00362     /*Инициализация внешнего АПЦ для LM35*/
00363     //создадим экземпляр АЦП если их несколько
00364     UART.printf("Configuring ADC\r\n");
00365     DS1248_START=0;
00366     wait_ms(20);
00367     DS1248_START=1;
00368     wait_ms(20);
00369     /*Настройка регистров в ОЗУ (описание в заголовочном файле)*/
00370     ads1.MUX0.MUX_SN=1; //AIN1
00371     ads1.MUX0.MUX_SP=0; //AIN0
00372     ads1.MUX0.BCS=0;
00373     
00374     ads1.VBIAS.all=0;
00375     ads1.VBIAS.VBIAS0=0;
00376     
00377     ads1.SYS0.DR=DR10;
00378     ads1.SYS0.PGA=PGA_1; //=log2(PGA) пример: PGA=16 значит значение будет log2(16)=4;
00379     
00380     ads1.MUX1.MUXCAL=0;
00381     ads1.MUX1.REFSELT=2;
00382     ads1.MUX1.VREFCON=1;
00383     
00384     ads1.IDAC0.all=0;
00385         
00386     ads1.IDAC1.all=0xFF;
00387     
00388     ads1.FSC.all=1*(0x400000); //масштаб АЦП (наверное не коэффициент усиления)
00389     /*Конец*/
00390      //Записать в чип
00391     ADS1248SettingReg(&ads1);
00392     if(ads1.SYS0.all==ADS1248ReadRegister(DS1248_REGISTER_SYS0,1))  //30.07.2020/8:40
00393     UART.printf("ADS is configured\r\n");
00394     ADSRdy.fall(&readads);//виснет без платы (решение - закомментить)
00395     wait_ms(20);
00396     //ADS1248SleepCommand();//временно отключаем чтобы при старте не началось считывание
00397     DS1248_START=0;
00398     
00399     /*Инициализация внещнего ЦАП*/
00400     LT1446_0.dacA.Code=0;
00401     LT1446_0.dacA.Code=0;
00402     LTCwrite(&LT1446_0);
00403     UART.printf("DAC is configured\r\n");
00404     
00405     //обнуление режима работы ПИД
00406     Mem.PID.enabled=0;
00407     Mem.PID_R.enabled=0;
00408     /*Тестовая кнопка для включения PID*/
00409     //button.fall(&pressed);
00410     //Калибрануть если есть дисплей
00411     if(TFT.IsOn()){
00412     UART.printf("Process of calibration\r\n");
00413     disp.Calibration(Mem.calibration,0);    
00414     Mem_write();
00415     UART.printf("Calibrated\r\n");}    
00416     disp.activeScreen = PID_SCREEN;
00417     disp.pressedButton = NONE_PRESS;
00418     disp.str_edit[0]='_';
00419     disp.cursor=0;
00420     uint32_t XY=0;
00421     //ADS1248CalibrateSoft(&ads1,BufToFloat); //эксперимент
00422     
00423     // change active screen depending on pressed area
00424     while(1) {
00425         
00426         if(TFT.IsOn())//проверка включения дисплея
00427         {
00428         //получение координат касания
00429         
00430         /*XY=TFT.GetTouchTagXY();
00431         disp.TouchX=-(uint16_t)((XY>>16)*0xFFFF);
00432         disp.TouchY=-(uint16_t)(XY*0xFFFF);*/
00433         disp.TouchX=TFT.GetTouchTagX();
00434         disp.TouchY=TFT.GetTouchTagY();;
00435         disp.pressedButton=TFT.GetTouchTag();
00436         if(disp.TouchX==-32768&&disp.TouchY==-32768)
00437         disp.pressedButton = NONE_PRESS;
00438         else UART.printf("X %d | Y %d\r\n",disp.TouchX,disp.TouchY);        
00439         wait_ms(35);
00440         
00441             
00442         //-------------------------------ChromTestScreen------------------------
00443         if (disp.activeScreen == TEST_CHROM_SCREEN) {
00444             disp.ChromTest(LM35_0.temp,RAS.temp,temp,rashod_u);
00445             if(disp.pressedButton){                
00446                 if(disp.pressedButton==CHROM_TEMP_PRESS){
00447                      disp.pressedButton = NONE_PRESS;
00448                     disp.activeScreen=MENU_SCREEN;
00449                     }
00450                 if(disp.pressedButton==PID_MENU_PRESS){
00451                     disp.pressedButton=NONE_PRESS;
00452                     disp.activeScreen=PID_SCREEN;
00453                     }
00454                 }
00455             }
00456         // ---------------------------------------------------------------------
00457         //=------------------------------PID Screen-----------------------------
00458         if (disp.activeScreen == PID_SCREEN) {
00459             if(disp.pressedButton>=SEL_P1&&disp.pressedButton<=SEL_D2)            
00460             disp.selectedEditor=(selectedEditor_t)disp.pressedButton;            
00461            // else disp.selectedEditor=(selectedEditor_t)NONE_PRESS;
00462                 disp.PidScreen(&BufToFloat,LM35_0.temp,RAS.temp,LT1446_0.dacB.Code,LT1446_0.dacA.Code,&Mem.PID,&Mem.PID_R);}
00463                 
00464                 if(disp.pressedButton==SAVE_PRESS)
00465                 {
00466                     Mem_write();//сохраняем настройки
00467                     }
00468                 if(disp.pressedButton==PID1SW_PRESS&&Mem.PID.enabled)
00469                 {
00470                     lm_temp.detach();
00471                     pressed();
00472                     printer_p=&printPID;
00473                     lm_temp.attach(printer_p,0.25);
00474                     }
00475                 if(disp.pressedButton==PID1SW_PRESS&&Mem.PID.enabled==0)
00476                 {
00477                         lm_temp.detach();                        
00478                         PID1.detach();
00479                         //PID2.detach();
00480                         Mem.PID.enabled=0;
00481                         //Mem.PID_R.enabled=0;
00482                         LT1446_0.dacB.Code=0;
00483                         //LT1446_0.dacA.Code=0;
00484                         LTCwrite(&LT1446_0);
00485                         UART.printf("PID1 is stopped\r\n");
00486                     }
00487                 if(disp.pressedButton==PID2SW_PRESS&&Mem.PID_R.enabled)
00488                 {
00489                         lm_temp.detach();
00490                         pid2_start();
00491                         printer_p=&printPID;
00492                         lm_temp.attach(printer_p,0.25);
00493                     }
00494                 if(disp.pressedButton==PID2SW_PRESS&&Mem.PID_R.enabled==0)
00495                 {
00496                         lm_temp.detach();                        
00497                         //PID1.detach();
00498                         PID2.detach();
00499                         //Mem.PID.enabled=0;
00500                         Mem.PID_R.enabled=0;
00501                         //LT1446_0.dacB.Code=0;
00502                         LT1446_0.dacA.Code=0;
00503                         LTCwrite(&LT1446_0);
00504                         UART.printf("PID2 is stopped\r\n");
00505                     }
00506                 if(disp.pressedButton==BACK_PRESS)
00507                 {
00508                     disp.activeScreen = TEST_CHROM_SCREEN;
00509                     }
00510                 disp.pressedButton = NONE_PRESS;
00511                 
00512         
00513         //=---------------------------------------------------------------------
00514         
00515         // Main menu screen
00516         if (disp.activeScreen == MENU_SCREEN) {
00517             disp.MainMenu(LM35_0.temp, LM35_0.temp);//сюда писать значения (наверное) (расход/температура)
00518             if (disp.pressedButton) {
00519                 //wait_ms(150);
00520                 if (disp.pressedButton == CURR_TEMP_PRESS) {
00521                     disp.activeScreen = CURR_TEMP_SCREEN;
00522                 } else if (disp.pressedButton == CURR_HUM_PRESS) {
00523                     disp.activeScreen = CURR_HUM_SCREEN;
00524                 } 
00525                 disp.pressedButton = NONE_PRESS;
00526             }
00527  
00528         // ---------------------------------------------------------------------
00529         // Any other screen
00530         } else {
00531             // ----------------------------------------------------------------------------------------------
00532             // You can back to main menu from any screen
00533             if (disp.pressedButton == MENU_PRESS) {
00534                 disp.pressedButton = NONE_PRESS;
00535                 disp.activeScreen = MENU_SCREEN;
00536             } else {
00537                 // ----------------------------------------------------------------------------------------------
00538                 // Screen with current temperature / humidity
00539                 if (disp.activeScreen == CURR_TEMP_SCREEN) {
00540                     disp.CurrentTemperature(LM35_0.temp);//и сюда тоже
00541                 } else if (disp.activeScreen == CURR_HUM_SCREEN) {
00542                     disp.CurrentHumidity(LM35_0.temp);//и сюда
00543                 } 
00544             }
00545         }
00546     }//Проверка включения дисплея
00547     }
00548 }
00549 
00550 
00551 
00552 /*команды*/
00553 void ComandCheck()
00554 {      
00555         UART_gets(16); //моя функция на время        
00556         if(str[0]=='/')              
00557         {
00558         UART.printf("%c\r\n",str[1]);
00559         switch (str[1]){
00560              /*Проверка платы SB-1 SWEN*/
00561              case 'i':{
00562                  if (str[2]=='1')
00563                  {SB1_SWEN=1;
00564                  UART.printf("SW is ON\r\n");}
00565                  else if (str[2]=='0')
00566                  {SB1_SWEN=0;
00567                  UART.printf("SW is OFF\r\n");}
00568                  else if (str[2]=='a')
00569                  {
00570                      PosAw=1;
00571                      PosBw=0;
00572                      wait_ms(50);
00573                      PosAw=0;
00574                      PosBw=0;
00575                      }
00576                  else if (str[2]=='b')
00577                  {
00578                      PosAw=0;
00579                      PosBw=1;
00580                      wait_ms(50);
00581                      PosAw=0;
00582                      PosBw=0;
00583                      }
00584                  else if (str[2]=='r')
00585                  {
00586                      char a='0';
00587                      if (PosAr)
00588                      a='a';
00589                      else if (PosBr)
00590                      a='b';                    
00591                      UART.printf("POS is %c",a);
00592                      }
00593                  break;}
00594              case 'k':{//настройки ПИДа температуры колонки
00595                  PID1.detach();
00596                  LT1446_0.dacB.Code=0;
00597                  LT1446_0.dacA.Code=0;                 
00598                  LTCwrite(&LT1446_0);
00599                  switch (str[2]){
00600                  case 'P':{
00601                  Mem.PID.kP=BufToFloat(str);
00602                  Mem_write();
00603                  UART.printf("P=%f\r\n",Mem.PID.kP);
00604                  break;
00605                  }
00606                  case 'I':{
00607                  Mem.PID.kI=BufToFloat(str);
00608                  Mem_write();
00609                  UART.printf("I=%f\r\n",Mem.PID.kI);
00610                  break;
00611                  }
00612                  case 'D':{
00613                  Mem.PID.kD=BufToFloat(str);
00614                  Mem_write();
00615                  UART.printf("D=%f\r\n",Mem.PID.kD);
00616                  break;
00617                  }
00618                  case 'f':{
00619                      setPIDdefault(&Mem.PID,&PID_defs);
00620                      Mem_write();
00621                      UART.printf("PID is default\r\n");
00622                      break;}
00623                  default:break;
00624                  }
00625                  //задание уставки температуры
00626                  if ((str[2]>='0')&&(str[2]<='9')){
00627                  Mem.temp_u=temp=(str[2]-'0')*10+(str[3]-'0');                 
00628                  UART.printf("temp= %d\r\n",temp); }                    
00629                  break;}
00630                  
00631              case 't':{
00632                  //начать чтение температуры
00633                  //отключаем отображение для перенастройки, настраиваем, записываем, включаем обратно отображение с новым параметром
00634                  lm_temp.detach();      
00635                  DS1248_START=1;
00636                  ADS1248WakeupCommand();
00637                  ads1.MUX0.MUX_SN=1; //AIN1
00638                  ads1.MUX0.MUX_SP=0; //AIN0
00639                  ads1.VBIAS.all=0;
00640                  ADS1248SettingReg(&ads1);
00641                  UART.printf("Temperature reading started.\r\n");
00642                  //снять показания термодатчика
00643                  //LM35_start(0.25);
00644                  printer_p=&printtemp;
00645                  lm_temp.attach(printer_p,0.1);
00646                  break;}
00647                  
00648              case 'p':{                
00649                 pga280gain=str[2]; //присваиваем числовое значение команды взятое из символа цифры
00650                 pga280gain-=0x30;
00651                 ch=5;
00652                 pga280_setGAIN(pga280gain,ch);
00653                 ch=0;               
00654                 break;}
00655                 
00656             case 'g': {      //включить нужный ПИД         
00657                 if(str[2]=='p')
00658                 {
00659                     switch(str[3])
00660                     {//gp1
00661                     case '1'://первый - температура
00662                     {
00663                         lm_temp.detach();
00664                         pressed();
00665                         printer_p=&printPID;
00666                         lm_temp.attach(printer_p,0.25);
00667                         break;}
00668                     case '2'://второй - расход
00669                     {//gp2
00670                         lm_temp.detach();
00671                         pid2_start();
00672                         printer_p=&printPID;
00673                         lm_temp.attach(printer_p,0.25);
00674                         break;}
00675                     
00676                     //остановить работу ПИД регуляторов.
00677                     case 's'://  /gps
00678                     {
00679                         lm_temp.detach();                        
00680                         PID1.detach();
00681                         PID2.detach();
00682                         Mem.PID.enabled=0;
00683                         Mem.PID_R.enabled=0;
00684                         LT1446_0.dacB.Code=0;
00685                         LT1446_0.dacA.Code=0;
00686                         LTCwrite(&LT1446_0);
00687                         UART.printf("PIDs is stopped\r\n");
00688                         break;}
00689                     }
00690                 }
00691                 //запустить задачу чтения АЦП каждые 40 мс (25 герц)
00692                 //adctask.attach(&readADC,0.04);
00693                 break;}
00694                 
00695             case's':  {//остановить постоянное отображение
00696                 //adctask.detach();
00697                 lm_temp.detach();
00698                 Mem.PID.enabled=0;
00699                 Mem.PID_R.enabled=0;
00700                 //LM35_stop();
00701                 ADS1248SleepCommand();
00702                 DS1248_START=0;
00703                 break;}
00704                 
00705             case 'd':{//LTC1446 задание значений на ЦАП оба канала
00706                 //MBFlagRegister.DAC=1;
00707                 if (str[2]=='a')//команда = "da=xxxx" где хххх - код ЦАП
00708                 {
00709                     LT1446_0.dacA.Code=(str[3]-0x30)*1000+(str[4]-0x30)*100+(str[5]-0x30)*10+(str[6]-0x30);
00710                     UART.printf("da=%04d\r\n",LT1446_0.dacA.Code);
00711                     }
00712                 if (str[2]=='b')
00713                 {
00714                     LT1446_0.dacB.Code=(str[3]-0x30)*1000+(str[4]-0x30)*100+(str[5]-0x30)*10+(str[6]-0x30);
00715                     UART.printf("db=%04d\r\n",LT1446_0.dacB.Code);
00716                     }
00717                  LTCwrite(&LT1446_0);
00718                 break;}
00719             case 'e':{
00720                 tempdata=pga280_readOneRegisterDevice(PGA280_ERROR_ADR,5);//чтение ошибок                
00721                 printf("ERRORS %X\n",tempdata);                               
00722                 break;}            
00723             case 'r':{//выключить ПИД 2 перед манипуляциями с ним
00724                  PID2.detach();
00725                  //задающее воздействие =0;
00726                  LT1446_0.dacA.Code=0;
00727                  LT1446_0.dacB.Code=0;
00728                  LTCwrite(&LT1446_0);
00729                  //обработка команд
00730                  switch (str[2]){
00731                  case 'P':{
00732                  Mem.PID_R.kP=BufToFloat(str);
00733                  Mem_write();
00734                  UART.printf("P=%f\r\n",Mem.PID_R.kP);
00735                  break;
00736                  }
00737                  case 'I':{
00738                  Mem.PID_R.kI=BufToFloat(str);
00739                  Mem_write();
00740                  UART.printf("I=%f\r\n",Mem.PID_R.kI);
00741                  break;
00742                  }
00743                  case 'D':{
00744                  Mem.PID_R.kD=BufToFloat(str);
00745                  Mem_write();
00746                  UART.printf("D=%f\r\n",Mem.PID_R.kD);
00747                  break;
00748                  }
00749                  case 'f':{//  /rf
00750                      setPIDdefault(&Mem.PID_R,&PID_defs);
00751                      Mem_write();
00752                      UART.printf("PID is default\r\n");
00753                      break;}
00754                  case 'g':{//запуск чтения расхода /rg
00755                  lm_temp.detach();
00756                      DS1248_START=1;
00757                  ADS1248WakeupCommand();
00758                  ads1.MUX0.MUX_SN=3; //AIN3
00759                  ads1.MUX0.MUX_SP=2; //AIN2
00760                  ads1.VBIAS.VBIAS3=1;
00761                  ADS1248SettingReg(&ads1);
00762                  UART.printf("Rashod reading started.\r\n");
00763                  printer_p=&printtemp;
00764                  lm_temp.attach(printer_p,0.1);
00765                      break;}
00766                      
00767                      case 'u':{ // ru=xx.xx; точка обязательна
00768                          //задание уставки расхода
00769                  Mem.rashod_u=rashod_u=BufToFloat(str);
00770                  UART.printf("Rashod = %0.3f\r\n",rashod_u);
00771                          break;}
00772                  default:break;
00773                  }
00774                  
00775                 if((str[2]=='e')&&(str[3]=='s')&&(str[4]=='e')&&(str[5]=='t')){
00776                 //перезагрука
00777                 printf("System Reset\r\n");
00778                 NVIC_SystemReset();}
00779                 if ((str[2]=='e')&&(str[3]=='c')&&(str[4]=='a')&&(str[5]=='l')){
00780                     disp.Calibration(Mem.calibration,1);
00781                     UART.printf("Recalibrated\r\n");
00782                     };
00783                 break;}
00784             default:                                
00785                 //MBFlagRegister.TMLS=0; //починка зависания (не работает)
00786                 break;
00787         }        
00788        }    
00789 }
00790