main_filtration.cpp

00001 /*
00002     ****************************************************************************
00003     ****************************************************************************
00004     ** DEVINT BİLİŞİM YAZILIM DONANIM TİC. LTD. ŞTİ. TARAFINDAN GELİŞTİRİLMİŞTİR
00005     ** İzmir / TÜRKİYE
00006     **
00007     ** Copyright (C) 2015
00008     ****************************************************************************
00009     ****************************************************************************
00010 */
00011 
00012 #include "mbed.h"
00013 #include "define.h"
00014 #include "i2c.h"
00015 #include "function.h"
00016 #include "alerts.h"
00017 
00018 int main ()
00019 {
00020 // RF Modül açık
00021     rfPower = 1;
00022     wait_ms(50);
00023 
00024 // RF UART: 38400 Kbit, 8 Data Bits, No Parity, 1 Stop Bit
00025     rf.baud(BAUD_SERIAL_RF);
00026     rf.format(8, SerialBase::None, 1);
00027 
00028 // MASTER UART: 115200 Kbit, 8 Data Bits, No Parity, 1 Stop Bit
00029     master.baud(BAUD_MASTER);
00030     master.format(8, SerialBase::None, 1);
00031 
00032 // UART Rx ISR
00033     rf.attach(&rf_rx_isr, Serial::RxIrq);
00034 
00035 // MASTER Rx ISR
00036     master.attach(&master_rx_isr, Serial::RxIrq);
00037 
00038 // EEPROM frekansı 100 KHz
00039     i2c.frequency(EEPROM_FREQUENCY);
00040     wait_ms(1500);
00041 
00042 // EEPROM'a ilk çalışma için varsayılan konfigürasyonları yaz
00043     configure_eeprom_default_values();
00044 
00045 // EEPROM'dan konfigürasyonu oku
00046     init_node();
00047 
00048 // PCF pinleri LOW
00049     io_send(fnode.filterByte_1, fnode.filterByte_2);
00050     wait_ms(1500);
00051 
00052     check_and_close_valves();
00053 
00054     while(1) {
00055     
00056 
00057         if (fnode.flush_isr == true) {
00058 
00059             fnode.flush_isr = false;
00060 
00061             if (fnode.globalFlushPhase != fnode.lastFlushPhase) {
00062 
00063                 fnode.globalFlushPhase ++;
00064                 fnode.currentFlushPhase ++;
00065 
00066                 if (fnode.currentFlushPhase > 4) {
00067 
00068                     fnode.globalFlushingFilter ++;
00069                     fnode.currentFlushingFilter ++;
00070 
00071                     fnode.currentFlushPhase = 1;
00072                 }
00073 
00074                 if (fnode.currentFlushingFilter > 4) {
00075 
00076                     fnode.currentWorkingSlave ++;
00077                     fnode.currentFlushingFilter = 1;
00078 
00079                 }
00080             }
00081 
00082             fnode.flushStarted = true;
00083         }
00084 
00085         // 30 sn aralıkla 10 kez veri gönderim koşulu oluşmuşsa
00086         if (fnode.transmit_rtData == true) {
00087 
00088             if (fnode.irrigation == true) {
00089 
00090                 fnode.rWIC = 0;
00091                 fnode.rWI = (fnode.rtPulseFirst - fnode.pulse) * fnode.watermeterCoefficient;
00092                 fnode.rQI = (float)fnode.rWI / (float)RT_DATA_TRANSMIT_INTERVAL;
00093                 fnode.rtPulseFirst = fnode.pulse;
00094 
00095             } else {
00096 
00097                 fnode.rWDC = 0;
00098                 fnode.rWD = (fnode.rtPulseFirst - fnode.pulse) * fnode.watermeterCoefficient;
00099                 fnode.rQD = (float)fnode.rWD / (float)RT_DATA_TRANSMIT_INTERVAL;
00100                 fnode.rtPulseFirst = fnode.pulse;
00101 
00102             }
00103 
00104             fnode.transmit_rtData = false;
00105 
00106             prepare_data_fread();
00107 
00108             send_to_coordinator(fnode.dataBuffer);
00109             memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00110 
00111             if (fnode.rtCounter >= 10) {
00112                 rtDataTransmitTicker.detach();
00113                 fnode.rtCounter = 0;
00114                 fnode.rtActive = false;
00115                 fnode.rtPulseFirst = 0;
00116 
00117                 send_to_coordinator("{CMD:\"FRTOFFOK\"}");
00118                 memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00119                 wait_ms(50);
00120             }
00121         }
00122 
00123         // Otomatik veri aktarım koşulu oluşmuşsa
00124         if (fnode.transmitData == true) {
00125 
00126             fnode.transmitData = false;
00127 
00128             if (fnode.irrigation == true) {
00129 
00130                 fnode.WIC = fnode.pulse * fnode.watermeterCoefficient;
00131                 fnode.WI = fnode.pulseTransmit * fnode.watermeterCoefficient;
00132                 fnode.QI = (float)fnode.WI / timer.read();
00133 
00134             } else {
00135 
00136                 fnode.WDC = fnode.pulse * fnode.watermeterCoefficient;
00137                 fnode.WD = fnode.pulseTransmit * fnode.watermeterCoefficient;
00138                 fnode.QD = (float)fnode.WD / timer.read();
00139 
00140             }
00141 
00142             fnode.pulseTransmit = 0;
00143 
00144             timer.reset();
00145 
00146             prepare_data();
00147 
00148             // Otomatik veri aktarımı açıksa veriyi gönder
00149             if (fnode.autosend == true) {
00150                 send_to_coordinator(fnode.dataBuffer);
00151             }
00152 
00153             memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00154         }
00155 
00156         // İki DP yıkaması arasında min bekleme süresinin hesaplanması
00157         if (fnode.minFlushEnabled == true && (fnode.minFlushCounter >= fnode.minFlushInterval * 60)) {
00158 
00159             minFlushTicker.detach();
00160             fnode.isMinTimePassed = true;
00161             fnode.minFlushCounter = 0;
00162         }
00163 
00164         // PERIYODIK YIKAMA
00165         // Filtrasyon nodunda ters yıkamalara izin verilmişse && şu an ters yıkama yoksa (manual ya da DP ile aktiflenmiş) && sulama varsa && önceden hata oluşmamışsa && periyodik yıkamanın kullanımı aktif edilmişse
00166         //if (fnode.flushEnabled == 1 && fnode.flushing == false && fnode.irrigation == true && fnode.errorOccured == false && fnode.periodicFlushEnabled == true) {
00167         if (fnode.flushEnabled == 1 && fnode.flushing == false && fnode.errorOccured == false && fnode.periodicFlushEnabled == true) {
00168 
00169             // Periyodik sayaç periyot değerine ulaşmışsa yıkamayı başlat
00170             if (fnode.periodicFlushCounter >= fnode.periodicFlushInterval * 60 * 60) {
00171 
00172                 // Periyot zamanlayıcısını iptal et ve periyot sayaç değerini sıfırla
00173                 periodicFlushTicker.detach();
00174                 fnode.periodicFlushCounter = 0;
00175 
00176                 // Yıkama zamanlayıcısını iptal et ve minimum zaman sayacını sıfırla
00177                 minFlushTicker.detach();
00178                 //fnode.isMinTimePassed = true;
00179                 fnode.minFlushCounter = 0;
00180 
00181                 // Şu an periyodik yıkama yapılıyor koşuluna geç
00182                 fnode.flushing = true;
00183 
00184                 fnode.checkDp = false;
00185                 fnode.flushStarted = true;
00186 
00187                 // Yıkama fazı 1
00188                 fnode.globalFlushPhase = 1;
00189                 fnode.currentFlushPhase = 1;
00190                 fnode.globalFlushingFilter = 1;
00191                 fnode.currentFlushingFilter = 1;
00192                 fnode.currentWorkingSlave = 0;
00193 
00194                 send_alarm(BACKFLUSH_PERIODIC_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00195             }
00196         }
00197 
00198         if (fnode.checkPressure == true) {
00199 
00200             fnode.checkPressure = false;
00201 
00202             fnode.pressure = read_pressure();
00203             fnode.dpPressure = read_pressure_dp();
00204 
00205             // Eğer basınç sensörü filtre girişinde ise basınç ve DP değerine göre giriş ve çıkış basıncını hesapla
00206             // Giriş basıncı = Okunan basınç
00207             // Çıkış basıncı = Okunan basınç - Fark basınç
00208             if (fnode.pressureSensorPosition == 0) {
00209 
00210                 fnode.inletPressure = fnode.pressure;
00211                 fnode.outletPressure = fnode.pressure - fnode.dpPressure;
00212 
00213                 if (fnode.outletPressure < 0) {
00214 
00215                     fnode.outletPressure = 0;
00216 
00217                 }
00218 
00219                 // Eğer basınç sensörü filtre çıkışında ise basınç ve DP değerine göre giriş ve çıkış basıncını hesapla
00220                 // Giriş basıncı = Okunan basınç + Fark basınç
00221                 // Çıkış basıncı = Okunan basınç
00222             } else {
00223 
00224                 fnode.inletPressure = fnode.pressure + fnode.dpPressure;
00225                 fnode.outletPressure = fnode.pressure;
00226 
00227             }
00228 
00229             // Eğer alarmlar aktifse ve giriş basıncı set edilen alt alarm eşik değerinin altında ise ve alarm daha önce gönderilmemişse alarm gönder
00230             // Alarm gönderme işlemi alarm bölgesi değiştiğinde tekrar devreye girer
00231             if (fnode.alarmsEnabled == 1) {
00232 
00233                 if (fnode.inletPressure < (float)fnode.pressureLowThreshold / 10.0f && fnode.pressureLowError == false) {
00234 
00235                     fnode.pressureLowError = true;
00236                     fnode.pressureNormalError = false;
00237                     fnode.pressureHighError = false;
00238 
00239                     // Düşük
00240                     send_alarm(INLET_LOW_PRESSURE, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00241 
00242                     // Eğer giriş basıncı set edilen güvenli bölge içinde ise alarm gönder
00243                 } else if (fnode.inletPressure >= (float)fnode.pressureLowThreshold / 10.0f && fnode.inletPressure <= (float)fnode.pressureHighThreshold / 10.0f && fnode.pressureNormalError == false) {
00244 
00245                     fnode.pressureLowError = false;
00246                     fnode.pressureNormalError = true;
00247                     fnode.pressureHighError = false;
00248 
00249                     // Normal
00250                     send_alarm(INLET_NORMAL_PRESSURE, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00251 
00252                     // Eğer giriş basıncı set edilen üst alarm eşik değerinin üstünde ise alarm gönder
00253                 } else if (fnode.inletPressure > (float)fnode.pressureHighThreshold / 10.0f && fnode.pressureHighError == false) {
00254 
00255                     fnode.pressureLowError = false;
00256                     fnode.pressureNormalError = false;
00257                     fnode.pressureHighError = true;
00258 
00259                     // Yüksek
00260                     send_alarm(INLET_HIGH_PRESSURE, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00261 
00262                 }
00263             }
00264 
00265             // Giriş basıncı set edilen değerin altında ise sulamanın bittiği kabul edilir
00266             // SULAMA DIŞI
00267             if (fnode.inletPressure < (float)fnode.inletPressureSet / 10.0f) {
00268 
00269                 // Giriş basıncı set edilen değerden düşükse önce son kez data gönderilir, sonrasında sulama bitti (filtrasyondan su geçişi durdu) alarmı gönderilir
00270                 if (fnode.irrigation == true) {
00271 
00272                     fnode.irrigation = false;
00273 
00274                     dataTransmitTicker.detach();
00275 
00276                     // Sulama bitince periyodik sayıcıyı durdur ancak counterı sıfırlama (Pause)
00277                     // Sulama başlayınca saymaya devam edecek
00278                     periodicFlushTicker.detach();
00279 
00280                     // Min yıkama aralığını durdur
00281                     minFlushTicker.detach();
00282                     fnode.minFlushCounter = 0;
00283 
00284                     // Sulama bitince sulama sırasında geçen su miktarlarını ve debiyi hesapla
00285                     fnode.WI = fnode.pulseTransmit * fnode.watermeterCoefficient;
00286                     fnode.WIC = fnode.pulse * fnode.watermeterCoefficient;
00287                     fnode.QI = (float)fnode.WI / timer.read();
00288 
00289                     // Sulama dışı değişkenleri sıfırla
00290                     fnode.WD = 0;
00291                     fnode.WDC = 0;
00292                     fnode.QD = 0;
00293 
00294                     // Basınç alarmlarını sıfırla
00295                     fnode.pressureLowError = false;
00296                     fnode.pressureNormalError = false;
00297                     fnode.pressureHighError = false;
00298 
00299                     // Timerı resetle
00300                     timer.reset();
00301 
00302                     // Pals sayaç ISR değişkenlerini sıfırla
00303                     fnode.pulse = 0;
00304                     fnode.pulseTransmit = 0;
00305                     fnode.pulsePressureCheck = 0;
00306 
00307                     // SULAMA BİTTİĞİNDE SON KEZ DATA GÖNDER !!!
00308                     prepare_data();
00309                     if (fnode.autosend == true) {
00310                         send_to_coordinator(fnode.dataBuffer);
00311                     }
00312                     memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00313 
00314                     // SULAMANIN BİTTİĞİNİ BELİRTEN ALARMI GÖNDER !!!
00315                     send_alarm(IRRIGATION_ENDED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00316 
00317                     // Sulama sırasında geçen su miktarını sıfırla
00318                     fnode.WIC = 0;
00319                     fnode.WI = 0;
00320                     fnode.QI = 0;
00321 
00322                     // Veri aktarım aralığını sulama dışı sıklığa ayarla
00323                     dataTransmitTicker.attach(&data_transmit_isr, fnode.dryTransmitInterval * 60);
00324 
00325                     // Sulamanın bittiğini EEPROM'a yaz
00326                     eeprom_write(EEPROM_TYPE, IRRI_STATUS_ADDR, 0);
00327 
00328                 }
00329 
00330                 // Giriş basıncı set değerinin üzerine çıktığında filtrasyon aktive olur. (Kendi başına çalışma koşulu)
00331                 // Bu durumda çıkış basıncının set edilen değere ulaşıp ulaşmadığına bakılır
00332                 //(SULAMA)
00333             } else if (fnode.inletPressure >= (float)fnode.inletPressureSet / 10.0f) {
00334 
00335                 // Giriş basıncı set edilen değerden yüksekse sulama başladı (filtrasyondan su geçişi var) alarmı gönderilir
00336                 if (fnode.irrigation == false) {
00337 
00338                     fnode.irrigation = true;
00339 
00340                     dataTransmitTicker.detach();
00341 
00342                     fnode.WDC = fnode.pulse * fnode.watermeterCoefficient;
00343                     fnode.WD = fnode.pulseTransmit * fnode.watermeterCoefficient;
00344                     fnode.QD = (float)fnode.WD / timer.read();
00345 
00346                     timer.reset();
00347 
00348                     fnode.pulse = 0;
00349                     fnode.pulseTransmit = 0;
00350                     fnode.pulsePressureCheck = 0;
00351 
00352                     fnode.WI = 0;
00353                     fnode.WIC = 0;
00354                     fnode.QI = 0;
00355 
00356                     // Basınç alarmlarını sıfırla
00357                     fnode.pressureLowError = false;
00358                     fnode.pressureNormalError = false;
00359                     fnode.pressureHighError = false;
00360 
00361                     // Veri aktarım aralığını sulama sıklığına ayarla
00362                     dataTransmitTicker.attach(&data_transmit_isr, fnode.irriTransmitInterval * 60);
00363 
00364                     //Sulama başlayınca ilk sulama verisini gönder
00365                     prepare_data();
00366                     if (fnode.autosend == true) {
00367                         send_to_coordinator(fnode.dataBuffer);
00368                     }
00369                     memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00370 
00371                     // Sulama başlayınca sulama başladı alarmını gönder
00372                     send_alarm(IRRIGATION_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00373 
00374                     fnode.WD = 0;
00375                     fnode.WDC = 0;
00376                     fnode.QD = 0;
00377 
00378                     // Periyodik yıkama süresini yeniden başlat
00379                     fnode.periodicFirstStartCounter ++;
00380 
00381                     if (fnode.periodicFirstStartCounter == 1) {
00382 
00383                         periodicFlushTicker.attach(&periodic_flush_isr, 1);
00384                         fnode.periodicFlushCounter = 0;
00385 
00386                     } else if (fnode.periodicFirstStartCounter > 1) {
00387 
00388                         fnode.periodicFirstStartCounter = 2;
00389 
00390                         if (fnode.periodicFlushCounter >= fnode.periodicFlushInterval * 60 * 60) {
00391 
00392                             fnode.periodicFlushCounter = 0;
00393                             periodicFlushTicker.attach(&periodic_flush_isr, 1);
00394 
00395                         } else {
00396 
00397                             periodicFlushTicker.attach(&periodic_flush_isr, 1);
00398 
00399                         }
00400                     }
00401 
00402                     // Min yıkama aralığını yeniden başlat
00403                     fnode.minFlushCounter = 0;
00404 
00405                     // Sulamanın başladığını EEPROM'a yaz
00406                     eeprom_write(EEPROM_TYPE, IRRI_STATUS_ADDR, 1);
00407 
00408                 }
00409 
00410                 // Sulama yapılıyorsa ve sayaç mevcutsa geçen su miktarlarını sulama süresince her basınç kontrolü yapıldığında hesapla
00411                 if ((fnode.systemSetup >> 3) & 1) {
00412 
00413                     fnode.WIC = fnode.pulse * fnode.watermeterCoefficient;
00414                     fnode.WI = fnode.pulsePressureCheck * fnode.watermeterCoefficient;
00415                     fnode.QI = (float)fnode.WI / (float)fnode.pressureControlFrequency;
00416 
00417                     fnode.pulsePressureCheck = 0;
00418 
00419                 }
00420 
00421                 // Eğer çıkış basıncı set edilen değere ulaşmışsa DP de kontrol edilir (Çıkış basıncı stabil durumda, DP kontrolü başlayacak). Ancak o an periyodik yıkama veya elle yıkama olmamaması ve ters yıkamanın kapatılmamaış olması ve iki yıkama arasındaki min sürenin geçmiş olması gerekir.
00422                 if ((fnode.outletPressure >= (float)fnode.outletPressureSet / 10.0f) && fnode.flushing == false && fnode.flushEnabled == 1 && fnode.isMinTimePassed == true) {
00423 
00424                     if (fnode.dpControlStarted == false) {
00425 
00426                         fnode.dpControlStarted = true;
00427 
00428                         fnode.globalFlushPhase = 1;
00429                         fnode.currentFlushPhase = 1;
00430                         fnode.globalFlushingFilter = 1;
00431                         fnode.currentFlushingFilter = 1;
00432                         fnode.currentWorkingSlave = 0;
00433 
00434                         send_alarm(DP_CONTROL_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00435 
00436                     }
00437 
00438                     // DP set edilen değerden yüksekse ve hata durumu yoksa ve ters yıkama aktiflenmişse ve o an yıkama yapılmıyorsa ve min bekleme zamanı geçmişse ters yıkamayı başlat
00439                     if (fnode.dpPressure >= (float)(fnode.dpSet / 10.0f) && fnode.checkDp == true && fnode.errorOccured == false && fnode.flushEnabled == 1 && fnode.flushing == false && fnode.isMinTimePassed == true) {
00440 
00441                         // Periyodik yıkama ISR'sini durdur ve sayacı sıfırla
00442                         periodicFlushTicker.detach();
00443                         fnode.periodicFlushCounter = 0;
00444 
00445                         fnode.isMinTimePassed = false;
00446                         fnode.minFlushCounter = 0;
00447 
00448                         fnode.checkDp = false;
00449 
00450                         fnode.flushing = true;
00451                         fnode.flushStarted = true;
00452 
00453                         // Yıkama fazı 1
00454                         fnode.globalFlushPhase = 1;
00455                         fnode.currentFlushPhase = 1;
00456                         fnode.globalFlushingFilter = 1;
00457                         fnode.currentFlushingFilter = 1;
00458                         fnode.currentWorkingSlave = 0;
00459 
00460                         send_alarm(BACKFLUSH_DP_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00461 
00462                     }
00463                 }
00464             }
00465         }
00466 
00467 // YIKAMA FAZLARI
00468         if (fnode.currentFlushPhase == 1 && fnode.flushStarted == true) {
00469 
00470             // Ters yıkama bitirme fazı
00471             if (fnode.globalFlushPhase == fnode.lastFlushPhase) {
00472 
00473                 fnode.flushStarted = false;
00474 
00475                 send_alarm(BAKCFLUSH_ENDED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00476 
00477                 // DP kontrolünü yeniden başlat
00478                 fnode.checkDp = true;
00479                 fnode.flushing = false;
00480                 fnode.dpControlStarted = false;
00481 
00482                 // Yıkama bitti
00483                 // Sulama varsa periyodik sayaç resetlenir ve devam eder
00484                 // Sulama yoksa periyodik sayaç pause moduna alınır
00485 
00486                 if (fnode.irrigation == true) {
00487 
00488                     fnode.periodicFlushCounter = 0;
00489                     periodicFlushTicker.attach(&periodic_flush_isr, 1);
00490 
00491                 } else {
00492 
00493                     periodicFlushTicker.detach();
00494 
00495                 }
00496 
00497                 // Yıkama bittiği için min yıkama süresi sayacını etkinleştir
00498                 fnode.minFlushCounter = 0;
00499                 fnode.isMinTimePassed = false;
00500 
00501                 if (fnode.irrigation == true) {
00502 
00503                     minFlushTicker.attach(&min_flush_interval_isr, 1);
00504 
00505                 } else {
00506 
00507                     minFlushTicker.detach();
00508 
00509                 }
00510 
00511             } else {
00512 
00513                 fnode.flushStarted = false;
00514                 fnode.flowControl = false;
00515 
00516                 // SOLENOIDLER ACIK
00517                 if (open_solenoid(FILTER_MAIN_SOLENOID) == false) {
00518 
00519                     // ALARM
00520                 }
00521 
00522                 if (send_command(fnode.currentWorkingSlave, OPEN_SOLENOID, fnode.currentFlushingFilter) == false) {
00523 
00524                     // SEND ERROR ALARM
00525 
00526                 } else {
00527 
00528                     send_alarm(FILTER_FLUSH_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00529 
00530                 }
00531 
00532                 // Faz 2'yi zamanla
00533                 flushTimer.attach(&flush_phase_isr, (float)fnode.flowControlLatency);
00534             }
00535 
00536 
00537         } else if (fnode.currentFlushPhase == 2 && fnode.flushStarted == true) {
00538 
00539             fnode.flushStarted = false;
00540             fnode.flowControl = true;
00541 
00542             // Faz 3'ü zamanla
00543             flushTimer.attach(&flush_phase_isr, (float)(fnode.flushDuration - fnode.flowControlLatency));
00544 
00545         } else if (fnode.currentFlushPhase == 3 && fnode.flushStarted == true) {
00546 
00547             fnode.flushStarted = false;
00548             fnode.flowControl = false;
00549 
00550             // SOLENOIDLER KAPALI
00551             if (close_solenoid(FILTER_MAIN_SOLENOID) == false) {
00552 
00553                 // ALARM
00554             }
00555 
00556             if (send_command(fnode.currentWorkingSlave, CLOSE_SOLENOID, fnode.currentFlushingFilter) == false) {
00557 
00558                 // SEND ERROR ALARM
00559 
00560             } else {
00561 
00562                 send_alarm(FILTER_FLUSH_ENDED, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00563 
00564             }
00565 
00566             // Faz 4'ü zamanla
00567             flushTimer.attach(&flush_phase_isr, (float)fnode.flowControlLatency);
00568 
00569         } else if (fnode.currentFlushPhase == 4 && fnode.flushStarted == true) {
00570 
00571             fnode.flushStarted = false;
00572             fnode.flowControl = true;
00573 
00574             // Sonraki ya da son fazı zamanla
00575             flushTimer.attach(&flush_phase_isr, (float)(fnode.flushInterval - fnode.flowControlLatency));
00576         }
00577 
00578 
00579 
00580 // AKIŞ SENSÖRÜ KONTROLÜ
00581 // YIKAMA SIRASINDA
00582 // Filtre yıkanırken AKIŞ YOK hatası:
00583         if (fnode.currentFlushPhase == 2 && flowSensor.read() == 0 && fnode.flowControl == true) {
00584 
00585             // Eğer hata olduğunda ters yıkama duracaksa
00586             if (fnode.onErrorStop == 1) {
00587 
00588                 fnode.flowControl = false;
00589 
00590                 // Faz zamanlayıcısını kapat
00591                 flushTimer.detach();
00592 
00593                 fnode.errorOccured = true;
00594                 fnode.flushing = false;
00595 
00596                 // SOLENOIDLER KAPALI
00597                 if (close_solenoid(FILTER_MAIN_SOLENOID) == false) {
00598 
00599                     // ALARM
00600                 }
00601 
00602 
00603                 if (send_command(fnode.currentWorkingSlave, CLOSE_SOLENOID, fnode.currentFlushingFilter) == false) {
00604 
00605 
00606                 } else {
00607 
00608                     send_alarm(NO_FLOW_DURING_FLUSH, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00609 
00610                 }
00611 
00612                 fnode.globalFlushPhase = 0;
00613                 fnode.currentFlushPhase = 0;
00614                 fnode.globalFlushingFilter = 0;
00615                 fnode.currentFlushingFilter = 0;
00616                 fnode.currentWorkingSlave = 0;
00617 
00618                 // Yıkama bittiği için periyodik yıkama sayacını aktifleştir.
00619                 fnode.periodicFlushCounter = 0;
00620                 periodicFlushTicker.attach(&periodic_flush_isr, 1);
00621 
00622             } else {
00623 
00624                 fnode.flowControl = false;
00625 
00626                 // Filtre yıkaması sırasında akış yok hatası
00627                 send_alarm(NO_FLOW_DURING_FLUSH, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00628 
00629             }
00630 
00631 
00632 //----------------------------------------------------------------------------//
00633             // YIKAMA SONRASINDA
00634             // Filtre yıkaması arasında AKIŞ VAR hatası:
00635         } else if (fnode.currentFlushPhase == 4 && flowSensor.read() == 1 && fnode.flowControl == true) {
00636 
00637             // Eğer hata olduğunda ters yıkama duracaksa
00638             if (fnode.onErrorStop == 1) {
00639 
00640                 fnode.flowControl = false;
00641 
00642                 // Faz zamanlayıcısını kapat
00643                 flushTimer.detach();
00644 
00645                 fnode.errorOccured = true;
00646                 fnode.flushing = false;
00647 
00648                 // 1. ve ana solenoid Faz 4'de kapatıldığı için kapatmaya gerek yok.
00649 
00650                 send_alarm(FLOW_DURING_FLUSH, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00651 
00652                 fnode.globalFlushPhase = 0;
00653                 fnode.currentFlushPhase = 0;
00654                 fnode.globalFlushingFilter = 0;
00655                 fnode.currentFlushingFilter = 0;
00656                 fnode.currentWorkingSlave = 0;
00657 
00658                 // Yıkama bittiği için periyodik yıkama sayacını aktifleştir.
00659                 fnode.periodicFlushCounter = 0;
00660                 periodicFlushTicker.attach(&periodic_flush_isr, 1);
00661 
00662             } else {
00663 
00664                 fnode.flowControl = false;
00665 
00666                 // Filtre yıkaması arasında akış var hatası
00667                 send_alarm(FLOW_DURING_FLUSH, fnode.globalFlushingFilter, fnode.currentWorkingSlave);
00668 
00669             }
00670         }
00671 
00672 
00673         // WSN Komutlarının İşlenmesi
00674         if (fnode.rfInterruptComplete == true) {
00675 
00676             // FENABLE
00677             if (strncmp (fnode.rfBuffer, fenable_command, 7) == 0) {
00678 
00679                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00680 
00681                 fnode.rfInterruptComplete = false;
00682                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00683 
00684                 process_command(FENABLE);
00685 
00686                 // FDISABLE
00687             } else if (strncmp (fnode.rfBuffer, fdisable_command, 8) == 0) {
00688 
00689                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00690 
00691                 fnode.rfInterruptComplete = false;
00692                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00693 
00694                 process_command(FDISABLE);
00695 
00696                 // FSETSYS
00697             } else if (strncmp (fnode.rfBuffer, fsetsys_command, 7) == 0) {
00698 
00699                 sscanf (fnode.rfBuffer,"%s%hhd%hhd%hhd%hhd%hd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hhd%hd%hhd", fnode.str, &fnode.systemSetup, &fnode.autosendStatus, &fnode.irriTransmitInterval, &fnode.dryTransmitInterval, &fnode.watermeterCoefficient, &fnode.pMax, &fnode.pressureSensorType, &fnode.dpSet, &fnode.pressureControlFrequency, &fnode.flushDuration, &fnode.flushInterval, &fnode.flowControlLatency, &fnode.flushEnabled, &fnode.pressureSensorPosition, &fnode.onErrorStop, &fnode.pressureLowThreshold, &fnode.pressureHighThreshold, &fnode.alarmsEnabled, &fnode.dpThreshold, &fnode.inletPressureSet, &fnode.outletPressureSet, &fnode.periodicFlushInterval, &fnode.minFlushInterval, &fnode.filterNumber);
00700                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00701                 memset (fnode.str, 0, sizeof(fnode.str));
00702 
00703                 fnode.rfInterruptComplete = false;
00704                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00705 
00706                 process_command(FSETSYS);
00707 
00708                 // FGETCFG
00709             } else if (strncmp(fnode.rfBuffer, fgetcfg_command, 7) == 0) {
00710 
00711                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00712 
00713                 fnode.rfInterruptComplete = false;
00714                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00715 
00716                 process_command(FGETCFG);
00717 
00718                 // FREAD
00719             } else if (strncmp(fnode.rfBuffer, fread_command, 5) == 0) {
00720 
00721                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00722 
00723                 fnode.rfInterruptComplete = false;
00724                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00725 
00726                 process_command(FREAD);
00727 
00728                 // FFIX
00729             } else if (strncmp(fnode.rfBuffer, ffix_command, 4) == 0) {
00730 
00731                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00732 
00733                 fnode.rfInterruptComplete = false;
00734                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00735 
00736                 process_command(FFIX);
00737 
00738                 // FTEST
00739             } else if (strncmp(fnode.rfBuffer, ftest_command, 5) == 0) {
00740                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00741 
00742                 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FTESTOK\"}");
00743                 send_to_coordinator(fnode.dataBuffer);
00744                 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00745 
00746                 fnode.rfInterruptComplete = false;
00747                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00748 
00749                 // FRESET komutu
00750             } else if (strncmp(fnode.rfBuffer, freset_command, 6) == 0) {
00751                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00752 
00753                 fnode.rfInterruptComplete = false;
00754                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00755 
00756                 if (fnode.irrigation == true) {
00757 
00758                     eeprom_write(EEPROM_TYPE, IRRI_STATUS_ADDR, 1);
00759 
00760                 } else {
00761 
00762                     eeprom_write(EEPROM_TYPE, IRRI_STATUS_ADDR, 0);
00763 
00764                 }
00765 
00766                 if (fnode.autosend == true) {
00767 
00768                     eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, 1);
00769 
00770                 } else {
00771 
00772                     eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, 0);
00773 
00774                 }
00775 
00776                 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FRESETOK\"}");
00777                 send_to_coordinator(fnode.dataBuffer);
00778                 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00779 
00780                 wait(1);
00781                 NVIC_SystemReset();
00782 
00783                 // FCLEAR
00784             } else if (strncmp(fnode.rfBuffer, fclear_command, 6) == 0) {
00785 
00786                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00787 
00788                 bool eepromOk = true;
00789 
00790                 for (uint16_t i = 0; i < 60; i++) {
00791 
00792                     eeprom_write(EEPROM_TYPE, i, 0xFF);
00793 
00794                 }
00795 
00796                 for (uint16_t i = 0; i < 60; i++) {
00797 
00798                     if (eeprom_read(EEPROM_TYPE, i) != 0xFF) {
00799 
00800                         eepromOk = false;
00801 
00802                     }
00803                 }
00804 
00805                 if (eepromOk == true) {
00806 
00807                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FCLEAROK\"}");
00808 
00809                 } else {
00810 
00811                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FCLEARERR\"}");
00812 
00813                 }
00814 
00815                 send_to_coordinator(fnode.dataBuffer);
00816                 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00817 
00818                 fnode.rfInterruptComplete = false;
00819                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00820 
00821                 // FGETSTATUS
00822             } else if (strncmp(fnode.rfBuffer, fgetstatus_command, 10) == 0) {
00823 
00824                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00825 
00826                 fnode.rfInterruptComplete = false;
00827                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00828 
00829                 process_command(FGETSTATUS);
00830 
00831                 // FFGETSTAT
00832             } else if (strncmp(fnode.rfBuffer, ffgetstat_command, 9) == 0) {
00833 
00834                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00835 
00836                 fnode.rfInterruptComplete = false;
00837                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00838 
00839                 process_command(FFGETSTAT);
00840 
00841                 // FGETFSTATUS
00842             } else if (strncmp(fnode.rfBuffer, fgetfstatus_command, 11) == 0) {
00843 
00844                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00845 
00846                 fnode.rfInterruptComplete = false;
00847                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00848 
00849                 process_command(FGETFSTATUS);
00850 
00851                 // FLUSHNOW
00852             } else if (strncmp(fnode.rfBuffer, fflushnow_command, 9) == 0) {
00853 
00854                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00855 
00856                 fnode.rfInterruptComplete = false;
00857                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00858 
00859                 process_command(FLUSHNOW);
00860 
00861                 // FRTON
00862             } else if (strncmp(fnode.rfBuffer, frton_command, 5) == 0) {
00863 
00864                 if(fnode.rtActive == false) {
00865 
00866                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00867                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FRTONOK\"}");
00868                     send_to_coordinator(fnode.dataBuffer);
00869                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00870 
00871                     fnode.rfInterruptComplete = false;
00872                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00873 
00874                     fnode.rtCounter = 0;
00875                     fnode.rtActive = true;
00876 
00877                     fnode.rtPulseFirst = fnode.pulse;
00878 
00879                     rtDataTransmitTicker.attach(&rt_data_transmit_isr, RT_DATA_TRANSMIT_INTERVAL);
00880 
00881                 } else {
00882 
00883                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00884                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FRTONERROR\"}");
00885                     send_to_coordinator(fnode.dataBuffer);
00886                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00887 
00888                     fnode.rfInterruptComplete = false;
00889                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00890 
00891                 }
00892 
00893                 // FRTOFF
00894             } else if (strncmp(fnode.rfBuffer, frtoff_command, 6) == 0) {
00895 
00896                 if (fnode.rtActive == true) {
00897 
00898                     rtDataTransmitTicker.detach();
00899 
00900                     fnode.rtCounter = 0;
00901                     fnode.rtActive = false;
00902 
00903                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00904                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FRTOFFOK\"}");
00905                     send_to_coordinator(fnode.dataBuffer);
00906                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00907 
00908                     fnode.rfInterruptComplete = false;
00909                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00910 
00911                 } else {
00912 
00913                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00914                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"FRTOFFERROR\"}");
00915                     send_to_coordinator(fnode.dataBuffer);
00916                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00917 
00918                     fnode.rfInterruptComplete = false;
00919                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00920 
00921                 }
00922 
00923                 // GETFRTSTATUS
00924             } else if (strncmp(fnode.rfBuffer, getfrtstatus_command, 12) == 0) {
00925 
00926                 if (fnode.rtActive == true) {
00927 
00928                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00929                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"GETFRTSTATUS\",STAT:\"ACTIVE\"}");
00930                     send_to_coordinator(fnode.dataBuffer);
00931                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00932 
00933                     fnode.rfInterruptComplete = false;
00934                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00935 
00936                 } else {
00937 
00938                     memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00939                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"GETFRTSTATUS\",STAT:\"PASSIVE\"}");
00940                     send_to_coordinator(fnode.dataBuffer);
00941                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00942 
00943                     fnode.rfInterruptComplete = false;
00944                     rf.attach(&rf_rx_isr, Serial::RxIrq);
00945 
00946                 }
00947 
00948                 // SELTESTON
00949             } else if (strncmp(fnode.rfBuffer, selteston_command, 9) == 0) {
00950 
00951                 sscanf (fnode.rfBuffer,"%s%hhd%hhd", fnode.str, &fnode.testid, &fnode.testFilterNo);
00952                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00953                 memset (fnode.str, 0, sizeof(fnode.str));
00954 
00955                 if (send_command(fnode.testid, TEST_OPEN_SOLENOID, fnode.testFilterNo) == true) {
00956 
00957                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"SELTESTONOK\"}");
00958                     send_to_coordinator(fnode.dataBuffer);
00959                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00960 
00961                 } else {
00962 
00963                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"SELTESTONERROR\"}");
00964                     send_to_coordinator(fnode.dataBuffer);
00965                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00966                 }
00967 
00968                 fnode.rfInterruptComplete = false;
00969                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00970 
00971                 // SELTESTOFF
00972             } else if (strncmp(fnode.rfBuffer, seltestoff_command, 10) == 0) {
00973 
00974                 sscanf (fnode.rfBuffer,"%s%hhd%hhd", fnode.str, &fnode.testid, &fnode.testFilterNo);
00975                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00976                 memset (fnode.str, 0, sizeof(fnode.str));
00977 
00978                 if (send_command(fnode.testid, TEST_CLOSE_SOLENOID, fnode.testFilterNo) == true) {
00979 
00980                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"SELTESTOFFOK\"}");
00981                     send_to_coordinator(fnode.dataBuffer);
00982                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00983 
00984                 } else {
00985 
00986                     sprintf(fnode.dataBuffer, "%s", "{CMD:\"SELTESTOFFERROR\"}");
00987                     send_to_coordinator(fnode.dataBuffer);
00988                     memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
00989                 }
00990 
00991                 fnode.rfInterruptComplete = false;
00992                 rf.attach(&rf_rx_isr, Serial::RxIrq);
00993 
00994                 // TANIMSIZ KOMUT
00995             } else {
00996 
00997                 memset (fnode.rfBuffer, 0, sizeof(fnode.rfBuffer));
00998 
00999                 sprintf(fnode.dataBuffer, "%s", "{CMD:\"UNKNOWN COMMAND\"}");
01000                 send_to_coordinator(fnode.dataBuffer);
01001                 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer));
01002 
01003                 fnode.rfInterruptComplete = false;
01004                 rf.attach(&rf_rx_isr, Serial::RxIrq);
01005             }
01006         }
01007     }
01008 }