main.cpp

00001 // 11.11.2020 Продолжение (клон )mbed-os5-press20
00002 // Вместо pc.printf("Reset ALARM \r\n") теперь plotter.printf("Reset ALARM \r\n") это нужно для парсера программы  Setup_EEPROM
00003 // Удалена команда pc.printf, посылающая пустую строку раз в секунду и связанный с ней timer_4, т.к. изменена программа оператора (Loc()).
00004 // Суммирование значений каналов А0 А1 А2 было 9 раз, исправлено на 10.
00005 // Передаваемые через pc.printf сообщения в РС дополнены контрольными суммами для увеличения надёжности связи.
00006 //    Введена команда pc.printf, посылающая пустую строку раз в секунду, на случай потери (порчи )данных при пересылке и
00007 //    возможного зависания программы оператора при ожидании символа из serial порта (для этого добавлен timer_4).
00008 // Значения уставок EEPROM2  выводяться в pc.print в специальной строке с текущими данными диагностики
00009 // Сделан дополнительный блок в парсере для декодирования приходящих аварийных уставок, они пишутся в  EEPROM2
00010 // Сделан timer_2 для отсчёта времени открытого состояния вентиля 1
00011 // Сделан timer_3 для отсчёта времени открытого состояния вентиля 2
00012 // Подключены цифровые входы D11,D12,D13. Реализованы условия остановки по 10 аварийным событиям.
00013 // Реализован  сброс события (event_N = 255) через кнопку Стоп в программе оператора 
00014 // Принимается флаг от кнопки Стоп - полной остановки регулятора - закрытие всех 4-х клапанов и передача статуса кнопки в программу оператора
00015 // Принимается флаг от кнопок включения - выключения компрессора, - идет команда на дискретный выход digital_6(PB_10)
00016 // Принимается новая уставка num_chan - переключение номера  активного измерительного канала для обратной связи регулятора. 
00017 // Эта уставка, как и все остальные,  пишется в EEPROM.
00018 // Включены все шесть аналоговых входа, читаются пять
00019 // при получении командной строки с нулевой суммой, по новому флагу flag_zerostart, передаётся в сериал текущие уставки и величины
00020 // (важно для старта программы на PC), эти нулевые уставки не вводятся в регулятор и не записываются в EEPROM.
00021 // сторожевой таймер,  истекает через 100мс
00022 // 
00023 
00024 #include "mbed.h"
00025 #include "_24LCXXX.h"
00026 
00027 I2C i2c(PB_9,PB_8);        // sda, scl
00028 _24LCXXX eeprom(&i2c, 0x50);
00029 
00030 AnalogIn analog_value_0(A0);                                                      //подключение аналогового входа A0
00031 AnalogIn analog_value_1(A1);                                                      //подключение аналогового входа A1
00032 AnalogIn analog_value_2(A2);                                                      //подключение аналогового входа A2
00033 AnalogIn analog_value_3(A3);                                                      //подключение аналогового входа A3
00034 AnalogIn analog_value_4(A4);                                                      //подключение аналогового входа A4
00035 AnalogIn analog_value_5(A5);                                                      //подключение аналогового входа A5
00036 //DigitalOut led(LED1);
00037 DigitalOut digital_4(PB_5);                                                     //initialize digital pin 4 as an output (high pressure air bulb charge).
00038 DigitalOut digital_7(PA_8);                                                     //initialize digital pin 7 as an output. (high pressure air bulb discharge)
00039 DigitalOut digital_5(PB_4);                                                     //initialize digital pin 5 as an output (valve3,4)
00040 DigitalOut digital_6(PB_10);                                                    //initialize digital pin 6 as an output (compressor on/off)
00041 DigitalIn idigital_11(PA_7);                                                     //initialize digital pin 11 as an input концевик при растяжении сильфона
00042 DigitalIn idigital_12(PA_6);                                                     //initialize digital pin 12 as an input концевик при сжатии сильфона
00043 DigitalIn idigital_13(PA_5);                                                     //initialize digital pin 13 as an input внутрь опрессовщика попала вода 
00044 
00045 RawSerial plotter(USBTX, USBRX, 115200);                                        // tx, rx for F411RE    port for serial_plotter and temporary messages
00046 RawSerial pc(PA_9, PA_10, 115200);                                              // tx, rx for F411RE     port  for  command string distance PC
00047 EventQueue *queue = mbed_event_queue();                                         //инициализация очереди событий RTOS mbed5
00048 Timer timer;                                                                    //инициализация таймера для определения частот переключений вентилей 1 и 2
00049 Timer timer_2;                                                                  //инициализация таймера 2 для отсчёта времени открытого состояния вентиля 1
00050 Timer timer_3;                                                                  //инициализация таймера 3 для отсчёта времени открытого состояния вентиля 2
00051 //Timer timer_4;                                                                  //инициализация таймера 4 для отсчёта периода времени отсылки в порт компьютера пустой строки.
00052 //========УСТАВКИ_1 EEPROM========
00053 uint8_t delta_value = 0;                                                        //set delta pressure 1...99
00054 uint8_t flag_compressor = 0;                                                    //флаг компрессора. При 0 - выключение компрессора, при 1 - включение компрессора
00055 uint8_t flag_stopRegulator = 0;                                                 //Stop- флаг . При 0 - разрешение работы регулятора, при 1 - запрет и запиране всех клапанов
00056 uint8_t num_chan = 1;                                                           //set номер аналогового канала 0...5 (1-as default = Pa)
00057 int value = 0;                                                                  //set begin value "pressure"   1...3300
00058 //========УСТАВКИ_2 EEPROM========
00059 int Pd_eeprom = 2000;                                                           // mV,  максимальное дифференциальное давление (беззнаковое)
00060 int frequencyValve1_eeprom = 5;                                                 // Гц, максимальная частота переключений клапана 1 
00061 int frequencyValve2_eeprom = 5;                                                 // Гц, максимальная частота переключений клапана 2 
00062 int WL01_eeprom = 10;                                                           // mV, минимальный вес опрессовщика
00063 int WL99_eeprom = 2000;                                                         // mV, максимальный вес опрессовщика
00064 int T_1 = 4000;                                                                 // ms, максимальное время открытого состояния для клапана 1 
00065 int T_2 = 4000;                                                                 // ms, максимальное время открытого состояния для клапана 2 
00066 uint8_t event_N = 255;                                                          // номер события , по умолчанию 255 - событий нет
00067 uint8_t flag_stopRegulatorEEPROM = 0;                                           //если 1 остановка регулятора, когда вручную управляют клапанами через программу SetUp_EEPROM
00068 //======temporary set=====
00069 int numSet, anySet;
00070 //=================================
00071 int value_auto=250 ;                                                            //set begin value auto "pressure"
00072 int WL = 0;                                                                     //напряжение с аналогового входа А0 (WL - вес опресовщика)
00073 int sensor_value =0;                                                            //напряжение с аналогового входа А1 (Pa - текущее давление)
00074 int Pb = 0;                                                                     //напряжение с аналогового входа А2 (Pb - давление в баллоне)
00075 int Pw1 = 0;                                                                    //напряжение с аналогового входа А3 (Pw1 - давление воды на входе опрессовщика)
00076 int Pw2 = 0;                                                                    //напряжение с аналогового входа А4 (Pw2 - давление воды в контуре макета)
00077 int Pd = 0;                                                                     //напряжение с аналогового входа А5 (Pd - дифференциальное давление опресовщика)
00078 int counter_cycle1 = 0;                                                         //счётчик цикла while(true)
00079 int counter_cycle2 = 0;                                                         //счётчик внутри функции auto_set
00080 int sig = 1;                                                                    //знак инкримента для автоустаки
00081 
00082 //                       FIFO_buffer must be full (only char  and '\0') 
00083 //#define maxnsym 26                                                             // maximum nbr of symbols FIFO_buffer (вариант без символов окончания)
00084 #define maxnsym 28                                     // maximum nbr of symbols FIFO_buffer +CR+LF (символы окончания должны быть включены на передаче)
00085 char Source[maxnsym]="$press,1000,25,0,0,1,2050**";      //25 char- string ,весь массив со строкой для поиска 25+1(null terminal)=26 
00086                                                       //уставки и контрольная сумма умноженная на два, должны быть больше нуля  
00087 char trueSource[maxnsym];                             //верифицированная строка для callback
00088 char trueSourceOld[maxnsym];                          //предыдущая верифицированная строка для callback
00089 char trueSource2[maxnsym];                             //верифицированная строка для callback
00090 char trueSource2Old[maxnsym];                          //предыдущая верифицированная строка для callback
00091 
00092 volatile char chr_a;                                        //в прерываниях переменные должны быть защищены  при помощи volatile от оптимизации компилятором
00093 volatile bool flag_comand_detected = false;                 //если строка декодирована правильно то true
00094 volatile bool flag_comand2_detected = false;                //если строка в блоке парсинга уставок eeprom декодирована правильно то true
00095 volatile bool flag_zerostart = false;                       //если строка декодирована c нулевой контрольной суммой то true
00096 //volatile bool flag_stopRegulator = true;                    //флаг остановки , закрыть все клапана 
00097 //_____________________________________________________________________________
00098 void save_EEPROM () {
00099     int data2;
00100     plotter.printf("EEPROM write------\r\n");    
00101     eeprom.byte_write(0, delta_value);
00102     eeprom.byte_write(1, flag_compressor);
00103     eeprom.byte_write(2, flag_stopRegulator);
00104     eeprom.byte_write(3, num_chan);
00105     data2 = value;
00106     eeprom.nbyte_write( 10, &data2, sizeof(int));
00107 }
00108 void save_EEPROM2 () {
00109     int data2;
00110     plotter.printf("EEPROM2 write------\r\n"); 
00111    eeprom.nbyte_read( 100, &data2, sizeof(int) );    
00112    if (data2 != Pd_eeprom) {                                                    //записываем в eeprom только изменившиеся значения (одна из семи уставок) 
00113      data2 = Pd_eeprom;
00114      eeprom.nbyte_write( 100, &data2, sizeof(int));
00115    }
00116    eeprom.nbyte_read( 110, &data2, sizeof(int) );
00117    if (data2 != frequencyValve1_eeprom){
00118      data2 = frequencyValve1_eeprom;
00119      eeprom.nbyte_write( 110, &data2, sizeof(int));
00120    }
00121    eeprom.nbyte_read( 120, &data2, sizeof(int) );
00122    if (data2 != frequencyValve2_eeprom){
00123      data2 = frequencyValve2_eeprom;
00124      eeprom.nbyte_write( 120, &data2, sizeof(int));
00125    }
00126    eeprom.nbyte_read( 130, &data2, sizeof(int) );
00127    if (data2 != WL01_eeprom){
00128      data2 = WL01_eeprom;
00129      eeprom.nbyte_write( 130, &data2, sizeof(int));
00130    }
00131    eeprom.nbyte_read( 140, &data2, sizeof(int) );
00132    if (data2 != WL99_eeprom){
00133      data2 = WL99_eeprom;
00134      eeprom.nbyte_write( 140, &data2, sizeof(int));
00135    }
00136    eeprom.nbyte_read( 180, &data2, sizeof(int) );
00137    if (data2 != T_1){
00138      data2 = T_1;
00139      eeprom.nbyte_write( 180, &data2, sizeof(int));
00140    }
00141    eeprom.nbyte_read( 190, &data2, sizeof(int) );
00142    if (data2 != T_2){
00143      data2 = T_2;
00144      eeprom.nbyte_write( 190, &data2, sizeof(int));
00145    }
00146    
00147 }
00148 //_____________________________________________________________________________
00149 void load_EEPROM () {
00150     uint8_t data1;
00151     int data2;
00152     plotter.printf("EEPROM read------\r\n");
00153     eeprom.nbyte_read( 0, &data1, 1 );
00154     plotter.printf("adress 0  =%d \r\n",data1);
00155     delta_value=data1;
00156     eeprom.nbyte_read( 1, &data1, 1 );
00157     plotter.printf("adress 1  =%d \r\n",data1);
00158     flag_compressor=data1;
00159     eeprom.nbyte_read( 2, &data1, 1 );
00160     plotter.printf("adress 2  =%d \r\n",data1);
00161     flag_stopRegulator=data1;
00162     eeprom.nbyte_read( 3, &data1, 1 );
00163     plotter.printf("adress 3  =%d \r\n",data1);
00164     num_chan=data1;
00165     eeprom.nbyte_read( 10, &data2, sizeof(int) );
00166     plotter.printf("adress 10  = %d \r\n",data2);
00167     value=data2;
00168     }
00169 void load_EEPROM2 () {
00170     int data2;
00171     plotter.printf("EEPROM2 read------\r\n");
00172     eeprom.nbyte_read( 100, &data2, sizeof(int) );
00173     //pc.printf("$adress,100,%d,*\r\n",data2);
00174     Pd_eeprom=data2;
00175     eeprom.nbyte_read( 110, &data2, sizeof(int) );
00176     //pc.printf("$adress,110,%d,*\r\n",data2);
00177     frequencyValve1_eeprom=data2;
00178     eeprom.nbyte_read( 120, &data2, sizeof(int) );
00179     //pc.printf("$adress,120,%d,*\r\n",data2);
00180     frequencyValve2_eeprom=data2;
00181     eeprom.nbyte_read( 130, &data2, sizeof(int) );
00182     //pc.printf("$adress,130,%d,*\r\n",data2);
00183     WL01_eeprom=data2;
00184     eeprom.nbyte_read( 140, &data2, sizeof(int) );
00185     //pc.printf("$adress,140,%d,*\r\n",data2);
00186     WL99_eeprom=data2;
00187     eeprom.nbyte_read( 180, &data2, sizeof(int) );
00188     //pc.printf("$adress,180,%d,*\r\n",data2);
00189     T_1=data2;
00190     eeprom.nbyte_read( 190, &data2, sizeof(int) );
00191     //pc.printf("$adress,190,%d,*\r\n",data2);
00192     T_2=data2;
00193     //pc.printf("$adress,%d,%d,%d,%d,%d,%d,%d,*\r\n",Pd_eeprom,frequencyValve1_eeprom,frequencyValve2_eeprom,WL01_eeprom,WL99_eeprom,T_1,T_2);
00194     }
00195 //______________________________________________________________________________
00196 void substring(char *s,char *d,int pos,int len) {
00197 //usage: substring(Source,Destination,pos,len);
00198     char *t;
00199     s=s+(pos-1);
00200     t=s+len;
00201     while (s!=t) {
00202         *d=*s;
00203         s++;
00204         d++;
00205     }
00206     *d='\0';
00207 }
00208 //______________________________________________________________________________
00209 void onDataReceived();                                                          // callback
00210 //______________________________________________________________________________ 
00211 void read_serial(void) {
00212   char Destination[50];
00213   int pos,len;
00214   int controlSum1, controlSum2;
00215   int value_, delta_value_, flag_compressor_, flag_stopRegulator_, num_chan_;
00216   int controlSumSet1, controlSumSet2;
00217   int numSet_, anySet_;
00218   int ch = '$';    // Код искомого символа
00219   int indexCh;       // Char on position
00220   char *ach;       // Указатель на искомую переменную в строке, по которой осуществляется поиск.
00221     while(pc.readable()) {
00222        chr_a = pc.getc();
00223        //_____FIFO_buffer_begin_____
00224        for ( int i = 2; i < maxnsym; i++) {
00225        Source[i-2]=Source[i-1];
00226        }
00227        Source[maxnsym-2]=chr_a;                     //предпоследний элемент
00228        Source[maxnsym-1] ='\0';                     //последний элемент массива это нуль-терминал для формирования конца строки в Си
00229        //_____FIFO_buffer_end_______
00230     }
00231    ach=strchr (Source,ch);   //поиск первого вхождения символа в строку , ищем указатель символа ‘$’
00232    if (ach==NULL) {
00233      //pc.printf ("Char  not finded \r\n");                   //Символ $ в строке не найден
00234      goto endParsing;        //пропускаем парсинг
00235    }
00236    else {
00237      indexCh = ach-Source+1;                                //вычитаем указатель из указателя!
00238      //pc.printf ("Char '$' on position  %d\r\n",indexCh);   //Искомый символ в строке на позиции 
00239    } 
00240    if (indexCh!=1) {                           //позиция символа $ не 1
00241      //pc.printf ("$ position not 1 \r\n");
00242      goto endParsing;       //пропускаем парсинг
00243    }
00244    
00245     pos=1;  //начало подстроки $press - на 1 позиции
00246     len=6;   //длина подстроки $press равна 6
00247     substring(Source,Destination,pos,len);
00248     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s\r\n", pos, len, Destination);
00249     
00250     if (strcmp(Destination,"$press" ) != 0) {                                   //функция возвращает ноль если строки совпадают
00251       //pc.printf("wrong Destination=%s\r\n",Destination);                         //печать "неправильной" нулевой строки 
00252       goto eepromSet ;                                                         //в начале сообщения нет $press , переход с следующему блоку приёма
00253     }
00254     pos=8;  //начало подстроки 1000 - на 8 позиции
00255     len=4;   //длина подстроки 1000 равна 4
00256     substring(Source,Destination,pos,len);
00257     value_=atoi(Destination);
00258     //if (value_==0) {
00259     //  flag_zerostart = true;    //индикатор первого пуска удаленной программы на PC без введенных уставок, надо передать текущее состояние на PC
00260     //  goto endParsing;          //уставка должна быть больше еденицы, пропускаем парсинг
00261     //}
00262     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, value_);
00263     pos=13;  //начало подстроки 25 - на 13 позиции
00264     len=2;   //длина подстроки 25 равна 2
00265     substring(Source,Destination,pos,len);
00266     delta_value_=atoi(Destination);
00267     //if (delta_value_==0) {
00268     //  flag_zerostart = true;    //индикатор первого пуска удаленной программы на PC без введенных уставок, надо передать текущее состояние на PC
00269     //  goto endParsing;       //уставка отклонения должна быть больше еденицы, пропускаем парсинг
00270     //}
00271     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, delta_value_);
00272     pos=16;  //начало подстроки 0 - на 16 позиции
00273     len=1;   //длина подстроки 0 равна 1
00274     substring(Source,Destination,pos,len);
00275     flag_compressor_=atoi(Destination);
00276     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, flag_compressor_);
00277     pos=18;  //начало подстроки 0 - на 18 позиции
00278     len=1;   //длина подстроки 0 равна 1
00279     substring(Source,Destination,pos,len);
00280     flag_stopRegulator_=atoi(Destination);
00281     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, flag_stopRegulator_);
00282     
00283     pos=20;  //начало подстроки 1 - на 20 позиции
00284     len=1;   //длина подстроки 1 равна 1
00285     substring(Source,Destination,pos,len);
00286     num_chan_=atoi(Destination);
00287     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, num_chan_);
00288     
00289     pos=22;  //начало подстроки 1025 - на 22 позиции
00290     len=4;   //длина подстроки 1025 равна 4
00291     substring(Source,Destination,pos,len);
00292     controlSum1=atoi(Destination);
00293     if (controlSum1==2) {
00294       flag_zerostart = true;       //индикатор первого пуска удаленной программы на PC без введенных уставок, надо передать текущее состояние на PC
00295       flag_compressor=flag_compressor_;  //здесь можно включать-выключать компрессор, но без записи в EEPROM
00296       goto endParsing;             //контрольная сумма должна быть больше двух, пропускаем парсинг
00297     }
00298     //pc.printf("for pos=%d and  len=%d  resultat is  d= %s atoi=%d\r\n", pos, len, Destination, controlSum1);
00299     controlSum2=(value_+delta_value_+flag_compressor_+flag_stopRegulator_+num_chan_)*2;            //удвоение чтобы не было одинаковых чисел в сообщении
00300     //pc.printf("controlSum1=%d   controlSum2=%d\r\n", controlSum1, controlSum2);
00301     if (controlSum1!=controlSum2) {                                             //не совпала контрольная сумма
00302       //pc.printf ("controlSum1!=controlSum2 \r\n");
00303       goto endParsing;                                                          //пропускаем парсинг
00304     }
00305     //*********присваиваем проверенные значения глобальным переменным***********
00306     strcpy(trueSource,Source);                                                  //копировать из Source в trueSource
00307     if (value_==0 || delta_value_==0) {                                         //при старте с пустой уставкой не изменяем их в регуляторе и не пишем в EEPROM
00308       flag_compressor=flag_compressor_;
00309       flag_stopRegulator=flag_stopRegulator_;                                               //для работы кнопки Stop
00310       } else {
00311       value=value_;
00312       delta_value=delta_value_;
00313       flag_compressor=flag_compressor_;
00314       flag_stopRegulator=flag_stopRegulator_;
00315       num_chan=num_chan_;  
00316     }      
00317     flag_stopRegulatorEEPROM = 0;                                               //флаг остановки только релейного  регулятора (теперь регулятор управляет клапанами!)
00318     flag_comand_detected=true;        //если флаг true, то всем переменным  присвоены новые значения уставок
00319  goto endParsing ;                    //завершение блока приема рабочих уставок для работяющего релейного регулятора  
00320 
00321   //========Начало блока приёма аварийных граничных (максимальных) уставок для записи в EEPROM ===================
00322  eepromSet:
00323     if (strcmp(Destination,"$setup" ) != 0) {                                      //функция возвращает ноль если строки совпадают
00324       //pc.printf("wrong Destination=%s\r\n",Destination);                         //печать "неправильной" нулевой строки 
00325       goto endParsing ;                                                         //в начале сообщения нет $setup , пропускаем парсинг
00326     }
00327     pos=8;  //начало подстроки 123 - на 8 позиции
00328     len=3;   //длина подстроки 123 равна 3
00329     substring(Source,Destination,pos,len);
00330     numSet_=atoi(Destination);
00331     pos=12;  //начало подстроки 123456 - на 12 позиции
00332     len=6;   //длина подстроки 123456 равна 6
00333     substring(Source,Destination,pos,len);
00334     anySet_ =atoi(Destination);
00335     pos=19;  //начало подстроки 1234567 - на 19 позиции
00336     len=7;   //длина подстроки 1234567 равна 7
00337     substring(Source,Destination,pos,len);
00338     controlSumSet1 =atoi(Destination);
00339     controlSumSet2=(numSet_+anySet_)*2;
00340     if (controlSumSet1!=controlSumSet2) {                                       //не совпала контрольная сумма
00341       //pc.printf ("controlSumSet1!=controlSumSet2 \r\n");
00342       goto endParsing;                                                          //пропускаем парсинг
00343     }
00344     //*********присваиваем проверенные значения глобальным переменным***********
00345     strcpy(trueSource2,Source);                                                 //копировать из Source в trueSource2
00346     if (numSet_==0) {                                                           //при старте с пустым номером не изменяем уставки  и не пишем в EEPROM
00347       goto endParsing;                                                          //пропускаем парсинг
00348       } else {
00349       numSet=numSet_;
00350       anySet=anySet_;  
00351     }      
00352     //При первом входе в режим $setup из режима $press - Закрываются все клапана
00353     if (flag_stopRegulatorEEPROM == 0) {
00354       digital_4.write(0);                                                       //valve1  off
00355       digital_7.write(0);                                                       //valve2  off
00356       digital_5.write(0);                                                       //valve3,4 off
00357       digital_6.write(0);                                                       //выключение компрессора
00358     }
00359     
00360     switch ( numSet ) {
00361         case 1:            // это двоеточие
00362             digital_4.write(anySet);                                            //valve1
00363             plotter.printf("1 Valve1=%d\r\n",anySet);
00364             break;
00365         case 2:
00366             digital_7.write(anySet);                                            //valve2
00367             plotter.printf("2 Valve2=%d\r\n",anySet);
00368             break;
00369         case 3:
00370             digital_5.write(anySet);                                            //valve3,4
00371             plotter.printf("3 Valve3,4=%d\r\n",anySet);
00372             break;
00373         case 4:
00374             digital_6.write(anySet);                                            //компрессор
00375             plotter.printf("4 Compressor=%d\r\n",anySet );
00376             break;
00377         case 9:
00378             if (anySet == 0) {
00379               flag_stopRegulator=0;
00380               plotter.printf("Reset ALARM \r\n");
00381             } else {
00382               flag_stopRegulator = 1;       
00383             }  
00384             break;  
00385         case 10:
00386             Pd_eeprom = anySet;
00387             plotter.printf( "10 Pd_eeprom=%d\r\n",anySet );
00388             break;
00389         case 11:
00390             frequencyValve1_eeprom = anySet;
00391             plotter.printf( "11 frequencyValve1_eeprom=%d\r\n",anySet );
00392             break;
00393         case 12:
00394             frequencyValve2_eeprom = anySet;
00395             plotter.printf( "12 frequencyValve2_eeprom=%d\r\n",anySet );
00396             break;
00397         case 13:
00398             WL01_eeprom = anySet;
00399             plotter.printf( "13 WL01_eeprom=%d\r\n",anySet );
00400             break;
00401         case 14:
00402             WL99_eeprom = anySet;
00403             plotter.printf( "14 WL99_eeprom=%d\r\n",anySet );
00404             break;
00405         case 18:
00406             T_1 = anySet;
00407             plotter.printf( "18 T_1=%d\r\n",anySet );
00408             break;
00409         case 19:
00410             T_2 = anySet;
00411             plotter.printf( "19 T_2=%d\r\n",anySet );
00412             break;                            
00413         default:
00414             plotter.printf( "Wrong case.\r\n" );
00415     } 
00416  
00417     flag_stopRegulatorEEPROM = 1;                                               //флаг остановки только релейного  регулятора (теперь оператор вручную управляет клапанами!)  
00418     flag_comand2_detected=true;                                                 //если флаг true, то всем переменным  присвоены новые значения уставок
00419   //========Конец блока приёма аварийных граничных (максимальных) уставок для записи в EEPROM ===================
00420  
00421  endParsing:   
00422     
00423         
00424 pc.attach(&onDataReceived, Serial::RxIrq);                             // reattach interrupt - переподключение прерывания перед выходом из функции
00425 }
00426 //______________________________________________________________________________
00427 void onDataReceived() {
00428     pc.attach(nullptr, Serial::RxIrq);                                          // detach interrupt
00429     queue->call(read_serial);                                                   // process in a non ISR context - переход к функции приема строки -
00430 }                                                                               // - в статусе отключенного прерывания (учим указатели!)
00431 //______________________________________________________________________________
00432 void auto_set () {                                                              //подпрограмма управления компрессором
00433     
00434     if (flag_stopRegulatorEEPROM == 0) {
00435       digital_6.write(flag_compressor);                                              //включение-выкючение компрессора   
00436     }
00437 }
00438 //******************************************************************************************************************
00439 //****************************************************************************************************************** 
00440 
00441 int main() {
00442     
00443     pc.attach(&onDataReceived, Serial::RxIrq);
00444     int time, time_2, time_3, time_4, ks, valve1, valve2, countValve1=0, countValve2=0, temp_valueSensor;
00445     int frequencyValve1, frequencyValve2;
00446     float raw_value_sum_0=0, raw_value_sum_1=0, raw_value_sum_2=0, raw_value_sum_3=0, raw_value_sum_4=0, raw_value_sum_5=0;
00447     digital_4.write(0);                                                         //valve1  off;
00448     digital_7.write(0);                                                         //valve2  off;    
00449     digital_5.write(0);                                                         //valve3,4  off; 
00450     digital_6.write(0);                                                         //выключение компрессора
00451     load_EEPROM ();                                                             //загрузка уставок из EEPROM
00452     load_EEPROM2 ();                                                            //загрузка граничных уставок (аварийных событий)из EEPROM2
00453     if (value >= 1 && delta_value >= 1 && flag_compressor < 2 && flag_stopRegulator < 2 && num_chan < 6) {
00454       flag_stopRegulator=0;                                                     //уставки из EEPROM похожи на правду, разрешаем работу регулятора 
00455     } else {
00456       flag_stopRegulator = 1;                                                   //флаг остановки установлен 
00457       pc.printf("Regulator stopped, error in EEPROM \r\n");       
00458     }
00459       
00460     pc.printf("Program started \r\n");
00461     Watchdog &watchdog = Watchdog::get_instance();
00462     watchdog.start(100);                                                        //WDlimit = 100  ms 
00463     timer.start();
00464     timer_2.start();
00465     timer_3.start();
00466    // timer_4.start();
00467     
00468   while (true){                                                                 //бесконечный цикл
00469     // kick watchdog regularly within provided timeout (сброс собаки в начало счёта)
00470     watchdog.kick();
00471     
00472     if (flag_stopRegulator == 1){ event_N = 255;}                               //сброс события через кнопку Стоп в программе оператора 
00473     
00474     if (flag_stopRegulator == 1 || event_N < 255) {                             //полный останов регулятора и принудительное запирание всех клапанов
00475       digital_4.write(0);                                                       //valve1  off
00476       digital_7.write(0);                                                       //valve2  off
00477       digital_5.write(0);                                                       //valve3,4 off
00478       //digital_6.write(0);                                                       //выключение компрессора
00479     }
00480     
00481     if (flag_comand_detected) {                                                 //пришла правильная командная строка
00482       ks=(value+delta_value+flag_compressor+flag_stopRegulator+
00483         sensor_value+frequencyValve1+frequencyValve2+
00484         WL+Pb+Pw1+Pw2+Pd+
00485         digital_4.read()+digital_7.read()+digital_5.read()+digital_6.read()+event_N+idigital_11.read()+idigital_12.read()+idigital_13.read())*2;
00486       pc.printf("$press,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,*\r\n",
00487         value,delta_value,flag_compressor,flag_stopRegulator,
00488         sensor_value,frequencyValve1,frequencyValve2,
00489         WL,Pb,Pw1,Pw2,Pd,
00490         digital_4.read(),digital_7.read(),digital_5.read(),digital_6.read(),event_N,idigital_11.read(),idigital_12.read(),idigital_13.read(),
00491         ks);        //передача текущих значений в РС
00492              
00493       //pc.printf("%s\r\n",trueSource);                                         //эхо для отладки канала связи
00494       flag_comand_detected = false;                                               //в последующих обращениях не печатать пока нет новых уставок из СОМ-порта
00495       
00496       if (strcmp(trueSourceOld,trueSource) != 0) {                              //функция возвращает ноль если командные строки совпадают
00497         save_EEPROM ();                                                         //пишем в память уставки отличные от старых
00498         load_EEPROM ();
00499       }
00500       
00501       strcpy(trueSourceOld,trueSource);        //копировать из trueSource в trueSourceOld 
00502     }
00503     
00504     if (flag_comand2_detected ) {                                //пришла правильная строка из программы SetUp_EEPROM и передана уставка
00505       ks=(value+delta_value+flag_compressor+flag_stopRegulator+
00506         sensor_value+frequencyValve1+frequencyValve2+
00507         WL+Pb+Pw1+Pw2+Pd+
00508         digital_4.read()+digital_7.read()+digital_5.read()+digital_6.read()+
00509         event_N+idigital_11.read()+idigital_12.read()+idigital_13.read()+
00510         Pd_eeprom+frequencyValve1_eeprom+frequencyValve2_eeprom+WL01_eeprom+WL99_eeprom+T_1+T_2)*2;
00511       pc.printf("$press,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,*\r\n",
00512         value,delta_value,flag_compressor,flag_stopRegulator,                                             //1,2,3,4
00513         sensor_value,frequencyValve1,frequencyValve2,                                                     //5,6,7
00514         WL,Pb,Pw1,Pw2,Pd,                                                                                 //8,9,10,11,12
00515         digital_4.read(),digital_7.read(),digital_5.read(),digital_6.read(),                              //13,14,15,16
00516         event_N,idigital_11.read(),idigital_12.read(),idigital_13.read(),                                 //17,18,19,20
00517         Pd_eeprom,frequencyValve1_eeprom,frequencyValve2_eeprom,WL01_eeprom,WL99_eeprom,T_1,T_2,
00518         ks);        //21,22,23,24,25,26,27,28
00519       flag_comand2_detected = false;                                            //в последующих обращениях не печатать пока нет нового сообщения из СОМ-порта
00520       
00521       if (strcmp(trueSource2Old,trueSource2) != 0 && numSet >= 10) {            //функция возвращает ноль если командные строки совпадают
00522       
00523         save_EEPROM2 ();                                                        //пишем в память все уставки от SetUp_EEPROM если хоть одна изменилась
00524         load_EEPROM2 ();
00525       }
00526     strcpy(trueSource2Old,trueSource2);        //копировать из trueSource2 в trueSource2Old 
00527     //pc.printf("$adress,%d,%d,%d,%d,%d,%d,%d,*\r\n",Pd_eeprom,frequencyValve1_eeprom,frequencyValve2_eeprom,WL01_eeprom,WL99_eeprom,T_1,T_2);
00528     }
00529     
00530     if (flag_zerostart) {                                            //пришла командная строка с пустыми уставками (актуально для получения данных на PC при первом запуске)
00531       ks=(value+delta_value+flag_compressor+flag_stopRegulator+
00532         sensor_value+frequencyValve1+frequencyValve2+
00533         WL+Pb+Pw1+Pw2+Pd+
00534         digital_4.read()+digital_7.read()+digital_5.read()+digital_6.read()+event_N+idigital_11.read()+idigital_12.read()+idigital_13.read())*2;
00535       pc.printf("$press,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,*\r\n",
00536         value,delta_value,flag_compressor,flag_stopRegulator,
00537         sensor_value,frequencyValve1,frequencyValve2,
00538         WL,Pb,Pw1,Pw2,Pd,
00539         digital_4.read(),digital_7.read(),digital_5.read(),digital_6.read(),event_N,idigital_11.read(),idigital_12.read(),idigital_13.read(),
00540         ks);        //передача текущих значений в РС  
00541         flag_zerostart = false;
00542     }   
00543     //счет counter_cycle1 идет от еденицы
00544     if (counter_cycle1 < 11 ) {
00545       float raw_value_0 = analog_value_0.read();                                     // Чтение аналогового входа 0 (0.0 to 1.0 = full ADC диапазон)
00546       raw_value_sum_0 = raw_value_sum_0 + raw_value_0;
00547       float raw_value_1 = analog_value_1.read();                                     // Чтение аналогового входа 1 (0.0 to 1.0 = full ADC диапазон)
00548       raw_value_sum_1 = raw_value_sum_1 + raw_value_1;
00549       float raw_value_2 = analog_value_2.read();                                     // Чтение аналогового входа 2 (0.0 to 1.0 = full ADC диапазон)
00550       raw_value_sum_2 = raw_value_sum_2 + raw_value_2;
00551     }
00552     if (counter_cycle1 >= 11 ) {
00553       float raw_value_3 = analog_value_3.read();                                     // Чтение аналогового входа 3 (0.0 to 1.0 = full ADC диапазон)
00554       raw_value_sum_3 = raw_value_sum_3 + raw_value_3;
00555       float raw_value_4 = analog_value_4.read();                                     // Чтение аналогового входа 4 (0.0 to 1.0 = full ADC диапазон)
00556       raw_value_sum_4 = raw_value_sum_4 + raw_value_4;
00557       //float raw_value_5 = analog_value_5.read();                                     // Чтение аналогового входа 5 (0.0 to 1.0 = full ADC диапазон)
00558       //raw_value_sum_5 = raw_value_sum_5 + raw_value_5;
00559     }
00560        
00561     if (counter_cycle1 >= 20 ) {
00562       counter_cycle1=0;
00563       
00564       WL = raw_value_sum_0/10 * 3300;                                           // преобразование в напряжение 0-3300 mV  с усреднением
00565       raw_value_sum_0 = 0 ;
00566       sensor_value = raw_value_sum_1/10 * 3300;                                 // преобразование в напряжение 0-3300 mV  с усреднением
00567       raw_value_sum_1 = 0 ;
00568       Pb = raw_value_sum_2/10 * 3300;                                           // преобразование в напряжение 0-3300 mV  с усреднением
00569       raw_value_sum_2 = 0 ;
00570       Pw1 = raw_value_sum_3/10 * 3300;                                          // преобразование в напряжение 0-3300 mV  с усреднением
00571       raw_value_sum_3 = 0 ;
00572       Pw2 = raw_value_sum_4/10 * 3300;                                          // преобразование в напряжение 0-3300 mV  с усреднением
00573       raw_value_sum_4 = 0 ;
00574       //Pd = raw_value_sum_5/20 * 3300;                                           // преобразование в напряжение 0-3300 mV  с усреднением
00575       //raw_value_sum_5 = 0 ;
00576       Pd = abs(sensor_value - Pw1);
00577       
00578       if (num_chan == 1) {temp_valueSensor = sensor_value;}                     //теперь источник сигнала для регулятора - канал 1
00579       if (num_chan == 3) {temp_valueSensor = Pw1;}                              //теперь источник сигнала для регулятора - канал 3
00580       if (num_chan == 4) {temp_valueSensor = Pw2;}                              //теперь источник сигнала для регулятора - канал 4
00581       
00582       if (flag_stopRegulator == 0 && event_N == 255 && flag_stopRegulatorEEPROM == 0) {                          // можно запускать регулятор
00583         digital_5.write(1);                                                                //valve3,4 открыты - подключаемся к контуру охлаждения макета
00584         //--------------regulator begin-----------------------
00585         if (temp_valueSensor > value + delta_value) {
00586           valve2 = digital_7.read();
00587           digital_7.write(1);                                                     //valve2  on;
00588           if (valve2 < digital_7.read()) {countValve2++;}                         //счётчик передних фронтов напряжения (срабатывания клапана 2)
00589           digital_4.write(0);                                                     //valve1  off;
00590         } else  if (temp_valueSensor < value - delta_value) {
00591           valve1 = digital_4.read();
00592           digital_4.write(1);                                                     //valve1  on;
00593           if (valve1 < digital_4.read()) {countValve1++;}                         //счётчик передних фронтов напряжения (срабатывания клапана 1)
00594           digital_7.write(0);                                                     //valve2  off; 
00595         } else {
00596           digital_4.write(0);                                                     //valve1  off;
00597           digital_7.write(0);                                                     //valve2  off; 
00598         }
00599         //--------------regulator end-------------------------
00600       }
00601       time=timer.read_us();
00602       if (time > 1000000) {
00603         timer.reset();                                                          //начало счёта времени
00604         frequencyValve1 =  countValve1;                                         //частота (Гц) срабатывания клапана 1 
00605         frequencyValve2 =  countValve2;                                         //частота (Гц) срабатывания клапана 2 
00606         countValve1=0;
00607         countValve2=0;
00608       }
00609       //--------------------==_ALARM_scope_Begin==----------------------
00610        if (Pd >= Pd_eeprom) {
00611              event_N = 0;
00612        }
00613        if (frequencyValve1 >= frequencyValve1_eeprom) {
00614              event_N = 1;
00615        }
00616        if (frequencyValve2 >= frequencyValve2_eeprom) {
00617              event_N = 2;
00618        }
00619        if (WL <= WL01_eeprom) {
00620              event_N = 3;
00621        }
00622        if (WL >= WL99_eeprom) {
00623              event_N = 4;
00624        }
00625        if (idigital_11.read()==0) {
00626              event_N = 5;
00627        }
00628        if (idigital_12.read()==0) {
00629              event_N = 6;
00630        }
00631        if (idigital_13.read()==0) {
00632              event_N = 7;
00633        }
00634       
00635       //-----------------Valve1 open time----------------------
00636         if (digital_4.read() == 0 || flag_stopRegulatorEEPROM == 1 ) {          // для режима $setup отключаем счёт времени
00637             timer_2.reset(); 
00638             time_2 = 0;
00639         } else {
00640           time_2 = timer_2.read_ms();   
00641         }
00642         if (time_2 >= T_1) {
00643              event_N = 8;
00644         }
00645      //-----------------Valve2 open time----------------------
00646         if (digital_7.read() == 0 || flag_stopRegulatorEEPROM == 1) {           // для режима $setup отключаем счёт времен
00647             timer_3.reset();
00648             time_3 = 0;
00649         } else {
00650           time_3 = timer_3.read_ms();   
00651         }
00652         if (time_3 >= T_2) {
00653              event_N = 9;
00654         }
00655       //--------------------==_ALARM_scope_End==----------------------          
00656      
00657       
00658       auto_set();                                                               //включение-выкючение компрессора  через flag_compressor
00659       //led = !led;                                                               //гасим/зажигаем индикаторный светодиод
00660     } 
00661     
00662     //---------------------print void string to PC----------------------------
00663     //time_4 = timer_4.read_ms();  
00664     //if (time_4 >= 1000) {
00665     //    timer_4.reset();
00666     //    pc.printf("$\r\n");                                                     //отправка пустой (символ $ обязателен!)строки раз в 1000 мс в PC
00667     //}
00668     
00669     
00670     ThisThread::sleep_for(1);                                                   // (mc) правильный оператор задержки для mbed5
00671     counter_cycle1++;
00672     
00673   }
00674 }