DEVINT_SOURCE
1
Dependencies: mbed
Embed:
(wiki syntax)
Show/hide line numbers
function.h
00001 #ifndef FUNCTION_H 00002 #define FUNCTION_H 00003 00004 /* 00005 **************************************************************************** 00006 **************************************************************************** 00007 ** DEVINT BİLİŞİM YAZILIM DONANIM TİC. LTD. ŞTİ. TARAFINDAN GELİŞTİRİLMİŞTİR 00008 ** İzmir / TÜRKİYE 00009 ** 00010 ** Copyright (C) 2015 00011 **************************************************************************** 00012 **************************************************************************** 00013 *************************************************************** K A M B O ** 00014 */ 00015 00016 // FONKSIYON PROTOTİPLERİ 00017 void configure_eeprom_default_values(void); 00018 //****************************************************************************** 00019 00020 void init_node(void); 00021 //****************************************************************************** 00022 00023 float read_pressure_dp(void); 00024 //****************************************************************************** 00025 00026 float read_pressure(void); 00027 //****************************************************************************** 00028 00029 void prepare_data(void); 00030 //****************************************************************************** 00031 00032 void prepare_data_fread(void); 00033 //****************************************************************************** 00034 00035 void send_to_coordinator(char* char_array); 00036 //****************************************************************************** 00037 00038 void process_command(uint8_t cmmnd); 00039 //****************************************************************************** 00040 00041 void data_transmit_isr(void); 00042 //****************************************************************************** 00043 00044 void rf_rx_isr(void); 00045 //****************************************************************************** 00046 00047 void master_rx_isr(void); 00048 //****************************************************************************** 00049 00050 bool open_solenoid(uint8_t filter_no); 00051 //****************************************************************************** 00052 00053 bool close_solenoid(uint8_t filter_no); 00054 //****************************************************************************** 00055 00056 float map(float x, float in_min, float in_max, float out_min, float out_max); 00057 //****************************************************************************** 00058 00059 void watermeter_isr(void); 00060 //****************************************************************************** 00061 00062 void flowrate_isr(void); 00063 //****************************************************************************** 00064 00065 void flush_phase_isr(void); 00066 //****************************************************************************** 00067 00068 void pressure_check_isr(void); 00069 //****************************************************************************** 00070 00071 bool check_and_close_valves(void); 00072 //****************************************************************************** 00073 00074 void periodic_flush_isr(void); 00075 //****************************************************************************** 00076 00077 void min_flush_interval_isr(void); 00078 //****************************************************************************** 00079 00080 void rt_data_transmit_isr(void); 00081 //****************************************************************************** 00082 00083 void send_alarm(uint8_t _alarmID, uint16_t _filterID, uint8_t _slaveID); 00084 //****************************************************************************** 00085 00086 bool send_command(uint8_t _slaveid, uint8_t _command, uint8_t _filterid); 00087 //****************************************************************************** 00088 00089 // FONKSIYONLAR 00090 float map(float x, float in_min, float in_max, float out_min, float out_max) 00091 { 00092 return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; 00093 } 00094 00095 // 00096 bool check_and_close_valves() 00097 { 00098 bool check = false; 00099 00100 for (uint8_t _slaveID = 0; _slaveID <= fnode.totalSlaveNumber - 1; _slaveID++) { 00101 00102 for (uint8_t _filterNo = 0; _filterNo < 5; _filterNo ++) { 00103 00104 if (send_command(_slaveID, CLOSE_SOLENOID, _filterNo)) { 00105 00106 check = true; 00107 wait_ms(500); 00108 00109 } else { 00110 00111 check = false; 00112 00113 } 00114 00115 if (check == false) { 00116 break; 00117 } 00118 } 00119 00120 if (check == false) { 00121 break; 00122 } 00123 } 00124 00125 return check; 00126 } 00127 00128 bool open_solenoid(uint8_t _filter_no) 00129 { 00130 bool _success = false; 00131 00132 switch (_filter_no) { 00133 00134 case FILTER_1_SOLENOID: { // OUT1 00135 00136 // İleri 00137 fnode.filterByte_2 &= ~(1 << 6); // Bit 6 = 0 00138 fnode.filterByte_1 = fnode.filterByte_1; 00139 00140 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00141 00142 _success = true; 00143 00144 // H-köprüsünü aç ve uyandır 00145 fnode.filterByte_2 &= ~(1 << 5); // Bit 5 = 0 00146 fnode.filterByte_2 &= ~(1 << 4); // Bit 4 = 0 00147 fnode.filterByte_1 = fnode.filterByte_1; 00148 00149 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00150 00151 wait_ms(250); 00152 00153 _success = true; 00154 00155 // Uyut ve H-köprüsünü kapat 00156 fnode.filterByte_2 |= 1 << 4; // Bit 4 = 1 00157 fnode.filterByte_2 |= 1 << 5; // Bit 5 = 1 00158 fnode.filterByte_1 = fnode.filterByte_1; 00159 00160 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00161 00162 _success = true; 00163 00164 } else { 00165 00166 _success = false; 00167 00168 } 00169 00170 } else { 00171 00172 _success = false; 00173 00174 } 00175 00176 } else { 00177 00178 _success = false; 00179 00180 } 00181 } 00182 break; 00183 00184 case FILTER_2_SOLENOID: { // OUT2 00185 00186 // İleri 00187 fnode.filterByte_2 &= ~(1 << 3); // Bit 3 = 0 00188 fnode.filterByte_1 = fnode.filterByte_1; 00189 00190 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00191 00192 _success = true; 00193 00194 // H-köprüsünü aç ve uyandır 00195 fnode.filterByte_2 &= ~(1 << 2); // Bit 2 = 0 00196 fnode.filterByte_2 &= ~(1 << 1); // Bit 1 = 0 00197 fnode.filterByte_1 = fnode.filterByte_1; 00198 00199 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00200 00201 wait_ms(250); 00202 00203 _success = true; 00204 00205 // Uyut ve H-köprüsünü kapat 00206 fnode.filterByte_2 |= 1 << 1; // Bit 1 is 1 00207 fnode.filterByte_2 |= 1 << 2; // Bit 2 is 1 00208 fnode.filterByte_1 = fnode.filterByte_1; 00209 00210 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00211 00212 _success = true; 00213 00214 } else { 00215 00216 _success = false; 00217 00218 } 00219 00220 00221 } else { 00222 00223 _success = false; 00224 00225 } 00226 00227 } else { 00228 00229 _success = false; 00230 00231 } 00232 } 00233 break; 00234 00235 case FILTER_3_SOLENOID: { // OUT3 00236 00237 // İleri 00238 fnode.filterByte_2 &= ~(1 << 0); // Bit 0 = 0 00239 fnode.filterByte_1 = fnode.filterByte_1; 00240 00241 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00242 00243 _success = true; 00244 00245 // H-köprüsünü aç ve uyandır 00246 fnode.filterByte_1 &= ~(1 << 7); // Bit 7 = 0 00247 fnode.filterByte_1 &= ~(1 << 6); // Bit 6 = 0 00248 fnode.filterByte_2 = fnode.filterByte_2; 00249 00250 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00251 00252 wait_ms(250); 00253 00254 _success = true; 00255 00256 // Uyut ve H-köprüsünü kapat 00257 fnode.filterByte_1 |= 1 << 6; // Bit 6 = 1 00258 fnode.filterByte_1 |= 1 << 7; // Bit 7 = 1 00259 fnode.filterByte_2 = fnode.filterByte_2; 00260 00261 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00262 00263 _success = true; 00264 00265 } else { 00266 00267 _success = false; 00268 00269 } 00270 00271 } else { 00272 00273 _success = false; 00274 00275 } 00276 00277 } else { 00278 00279 _success = false; 00280 00281 } 00282 } 00283 break; 00284 00285 case FILTER_4_SOLENOID: { // OUT4 00286 00287 // İleri 00288 fnode.filterByte_1 &= ~(1 << 5); // Bit 5 = 0 00289 fnode.filterByte_2 = fnode.filterByte_2; 00290 00291 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00292 00293 _success = true; 00294 00295 // H-köprüsünü aç ve uyandır 00296 fnode.filterByte_1 &= ~(1 << 4); // Bit 4 = 0 00297 fnode.filterByte_1 &= ~(1 << 3); // Bit 3 = 0 00298 fnode.filterByte_2 = fnode.filterByte_2; 00299 00300 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00301 00302 wait_ms(250); 00303 00304 _success = true; 00305 00306 // Uyut ve H-köprüsünü kapat 00307 fnode.filterByte_1 |= 1 << 3; // Bit 3 = 1 00308 fnode.filterByte_1 |= 1 << 4; // Bit 4 = 0 00309 fnode.filterByte_2 = fnode.filterByte_2; 00310 00311 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00312 00313 _success = true; 00314 00315 } else { 00316 00317 _success = false; 00318 00319 } 00320 00321 } else { 00322 00323 _success = false; 00324 00325 } 00326 00327 } else { 00328 00329 _success = false; 00330 00331 } 00332 } 00333 break; 00334 00335 case FILTER_MAIN_SOLENOID: { // OUT5 00336 00337 // İleri 00338 fnode.filterByte_1 &= ~(1 << 2); // Bit 2 = 0 00339 fnode.filterByte_2 = fnode.filterByte_2; 00340 00341 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00342 00343 _success = true; 00344 00345 // H-köprüsünü aç ve uyandır 00346 fnode.filterByte_1 &= ~(1 << 1); // Bit 1 = 0 00347 fnode.filterByte_1 &= ~(1 << 0); // Bit 0 = 0 00348 fnode.filterByte_2 = fnode.filterByte_2; 00349 00350 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00351 00352 wait_ms(250); 00353 00354 _success = true; 00355 00356 // Uyut ve H-köprüsünü kapat 00357 fnode.filterByte_1 |= 1 << 0; // Bit 0 = 1 00358 fnode.filterByte_1 |= 1 << 1; // Bit 1 = 0 00359 fnode.filterByte_2 = fnode.filterByte_2; 00360 00361 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00362 00363 _success = true; 00364 00365 } else { 00366 00367 _success = false; 00368 00369 } 00370 00371 } else { 00372 00373 _success = false; 00374 00375 } 00376 00377 } else { 00378 00379 _success = false; 00380 00381 } 00382 } 00383 break; 00384 } 00385 00386 return _success; 00387 } 00388 00389 // 00390 bool close_solenoid(uint8_t _filter_no) 00391 { 00392 bool _success = false; 00393 00394 switch (_filter_no) { 00395 00396 case FILTER_1_SOLENOID: { // OUT1 00397 00398 // Geri 00399 fnode.filterByte_2 |= 1 << 6; // Bit 6 = 1 00400 fnode.filterByte_1 = fnode.filterByte_1; 00401 00402 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00403 00404 _success = true; 00405 00406 // H-köprüsünü aç ve uyandır 00407 fnode.filterByte_2 &= ~(1 << 5); // Bit 5 = 0 00408 fnode.filterByte_2 &= ~(1 << 4); // Bit 4 = 0 00409 fnode.filterByte_1 = fnode.filterByte_1; 00410 00411 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00412 00413 wait_ms(250); 00414 00415 _success = true; 00416 00417 // Uyut ve H-köprüsünü kapat 00418 fnode.filterByte_2 |= 1 << 4; // Bit 4 = 1 00419 fnode.filterByte_2 |= 1 << 5; // Bit 5 = 1 00420 fnode.filterByte_1 = fnode.filterByte_1; 00421 00422 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00423 00424 _success = true; 00425 00426 } else { 00427 00428 _success = false; 00429 00430 } 00431 00432 } else { 00433 00434 _success = false; 00435 00436 } 00437 00438 00439 } else { 00440 00441 _success = false; 00442 00443 } 00444 } 00445 break; 00446 00447 case FILTER_2_SOLENOID: { // OUT2 00448 00449 // Geri 00450 fnode.filterByte_2 |= 1 << 3; // Bit 3 = 1 00451 fnode.filterByte_1 = fnode.filterByte_1; 00452 00453 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00454 00455 _success = true; 00456 00457 // H-köprüsünü aç ve uyandır 00458 fnode.filterByte_2 &= ~(1 << 2); // Bit 2 = 0 00459 fnode.filterByte_2 &= ~(1 << 1); // Bit 1 = 0 00460 fnode.filterByte_1 = fnode.filterByte_1; 00461 00462 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00463 00464 wait_ms(250); 00465 00466 _success = true; 00467 00468 // Uyut ve H-köprüsünü kapat 00469 fnode.filterByte_2 |= 1 << 1; // Bit 1 = 1 00470 fnode.filterByte_2 |= 1 << 2; // Bit 2 = 1 00471 fnode.filterByte_1 = fnode.filterByte_1; 00472 00473 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00474 00475 _success = true; 00476 00477 } else { 00478 00479 _success = false; 00480 00481 } 00482 00483 } else { 00484 00485 _success = false; 00486 00487 } 00488 00489 } else { 00490 00491 _success = false; 00492 00493 } 00494 } 00495 break; 00496 00497 case FILTER_3_SOLENOID: { // OUT3 00498 00499 // Geri 00500 fnode.filterByte_2 |= 1 << 0; // Bit 0 = 1 00501 fnode.filterByte_1 = fnode.filterByte_1; 00502 00503 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00504 00505 _success = true; 00506 00507 // H-köprüsünü aç ve uyandır 00508 fnode.filterByte_1 &= ~(1 << 7); // Bit 7 = 0 00509 fnode.filterByte_1 &= ~(1 << 6); // Bit 6 = 0 00510 fnode.filterByte_2 = fnode.filterByte_2; 00511 00512 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00513 00514 wait_ms(250); 00515 00516 _success = true; 00517 00518 // Uyut ve H-köprüsünü kapat 00519 fnode.filterByte_1 |= 1 << 6; // Bit 6 = 1 00520 fnode.filterByte_1 |= 1 << 7; // Bit 7 = 1 00521 fnode.filterByte_2 = fnode.filterByte_2; 00522 00523 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00524 00525 _success = true; 00526 00527 } else { 00528 00529 _success = false; 00530 00531 } 00532 00533 } else { 00534 00535 _success = false; 00536 00537 } 00538 00539 } else { 00540 00541 _success = false; 00542 00543 } 00544 } 00545 break; 00546 00547 case FILTER_4_SOLENOID: { // OUT4 00548 00549 // Geri 00550 fnode.filterByte_1 |= 1 << 5; // Bit 5 = 1 00551 fnode.filterByte_2 = fnode.filterByte_2; 00552 00553 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00554 00555 _success = true; 00556 00557 // H-köprüsünü aç ve uyandır 00558 fnode.filterByte_1 &= ~(1 << 4); // Bit 4 = 0 00559 fnode.filterByte_1 &= ~(1 << 3); // Bit 3 = 0 00560 fnode.filterByte_2 = fnode.filterByte_2; 00561 00562 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00563 00564 wait_ms(250); 00565 00566 _success = true; 00567 00568 // Uyut ve H-köprüsünü kapat 00569 fnode.filterByte_1 |= 1 << 3; // Bit 3 = 1 00570 fnode.filterByte_1 |= 1 << 4; // Bit 4 = 0 00571 fnode.filterByte_2 = fnode.filterByte_2; 00572 00573 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00574 00575 _success = true; 00576 00577 } else { 00578 00579 _success = false; 00580 00581 } 00582 00583 } else { 00584 00585 _success = false; 00586 00587 } 00588 00589 } else { 00590 00591 _success = false; 00592 00593 } 00594 } 00595 break; 00596 00597 case FILTER_MAIN_SOLENOID: { // OUT5 00598 00599 // Geri 00600 fnode.filterByte_1 |= 1 << 2; // Bit 2 = 1 00601 fnode.filterByte_2 = fnode.filterByte_2; 00602 00603 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00604 00605 _success = true; 00606 00607 // H-köprüsünü aç ve uyandır 00608 fnode.filterByte_1 &= ~(1 << 1); // Bit 1 = 0 00609 fnode.filterByte_1 &= ~(1 << 0); // Bit 0 = 0 00610 fnode.filterByte_2 = fnode.filterByte_2; 00611 00612 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00613 00614 wait_ms(250); 00615 00616 _success = true; 00617 00618 // Uyut ve H-köprüsünü kapat 00619 fnode.filterByte_1 |= 1 << 0; // Bit 0 = 1 00620 fnode.filterByte_1 |= 1 << 1; // Bit 1 = 0 00621 fnode.filterByte_2 = fnode.filterByte_2; 00622 00623 if (io_send(fnode.filterByte_1, fnode.filterByte_2) == true) { 00624 00625 _success = true; 00626 00627 } else { 00628 00629 _success = false; 00630 00631 } 00632 00633 } else { 00634 00635 _success = false; 00636 00637 } 00638 00639 } else { 00640 00641 _success = false; 00642 00643 } 00644 } 00645 break; 00646 } 00647 00648 return _success; 00649 } 00650 00651 // 00652 void configure_eeprom_default_values() 00653 { 00654 if (eeprom_read(EEPROM_TYPE, DEFAULT_CONFIG_ADDR) != 35) { 00655 00656 for (uint8_t i = 0; i < 99; i++) { 00657 00658 eeprom_write(EEPROM_TYPE, i, 0xFF); 00659 00660 } 00661 00662 eeprom_write(EEPROM_TYPE, DEFAULT_CONFIG_ADDR, 35); 00663 00664 eeprom_write(EEPROM_TYPE, SYSTEM_SETUP_ADDR, SYSTEM_SETUP_DEFAULT); 00665 eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, AUTOSEND_STATUS_DEFAULT); 00666 eeprom_write(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR, IRRI_TRANSMIT_INTERVAL_DEFAULT); 00667 eeprom_write(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR, DRY_TRANSMIT_INTERVAL_DEFAULT); 00668 eeprom_write(EEPROM_TYPE, WATERMETER_COEFF_ADDR_1, WATERMETER_COEFF_DEFAULT >> 8); 00669 eeprom_write(EEPROM_TYPE, WATERMETER_COEFF_ADDR_2, WATERMETER_COEFF_DEFAULT & 0xFF); 00670 eeprom_write(EEPROM_TYPE, PMAX_ADDR, PMAX_DEFAULT); 00671 eeprom_write(EEPROM_TYPE, PRESSURE_SENSOR_ADDR, PRESSURE_SENSOR_DEFAULT); 00672 eeprom_write(EEPROM_TYPE, DP_ADDR, DP_DEFAULT); 00673 eeprom_write(EEPROM_TYPE, PRESSURE_CONTROL_FREQUENCY_ADDR, PRESSURE_CONTROL_FREQUENCY_DEFAULT); 00674 eeprom_write(EEPROM_TYPE, FLUSH_DURATION_ADDR, FLUSH_DURATION_DEFAULT); 00675 eeprom_write(EEPROM_TYPE, FLUSH_INTERVAL_ADDR, FLUSH_INTERVAL_DEFAULT); 00676 eeprom_write(EEPROM_TYPE, FLOW_CONTROL_LATENCY_ADDR, FLOW_CONTROL_LATENCY_DEFAULT); 00677 eeprom_write(EEPROM_TYPE, FLUSH_ENABLE_ADDR, FLUSH_ENABLE_DEFAULT); 00678 eeprom_write(EEPROM_TYPE, PR_SENSOR_POSITION_ADDR, PR_SENSOR_POSITION_DEFAULT); 00679 eeprom_write(EEPROM_TYPE, BACKFLUSH_STOP_ADDR, BACKFLUSH_STOP_DEFAULT); 00680 eeprom_write(EEPROM_TYPE, INLET_PRS_LOW_TRS_ADDR, INLET_PRS_LOW_TRS_DEFAULT); 00681 eeprom_write(EEPROM_TYPE, INLET_PRS_HIGH_TRS_ADDR, INLET_PRS_HIGH_TRS_DEFAULT); 00682 eeprom_write(EEPROM_TYPE, ALARMS_ENABLE_ADDR, ALARMS_ENABLE_DEFAULT); 00683 eeprom_write(EEPROM_TYPE, DP_HIGH_TRS_ADDR, DP_HIGH_TRS_DEFAULT); 00684 eeprom_write(EEPROM_TYPE, INLET_PRS_SET_ADDR, INLET_PRS_SET_DEFAULT); 00685 eeprom_write(EEPROM_TYPE, OUTLET_PRS_SET_FOR_DP_ADDR, OUTLET_PRS_SET_FOR_DP_DEFAULT); 00686 eeprom_write(EEPROM_TYPE, PERIODIC_FLUSH_ADDR, PERIODIC_FLUSH_DEFAULT); 00687 eeprom_write(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_1, MIN_FLUSH_INTERVAL_DEFAULT >> 8); 00688 eeprom_write(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_2, MIN_FLUSH_INTERVAL_DEFAULT & 0xFF); 00689 eeprom_write(EEPROM_TYPE, FILTER_NUMBER_ADDR, FILTER_NUMBER_DEFAULT); 00690 } 00691 } 00692 00693 // 00694 void init_node() 00695 { 00696 // EEPROM'dan sistem ayarlarını oku 00697 fnode.systemSetup = eeprom_read(EEPROM_TYPE, SYSTEM_SETUP_ADDR); 00698 00699 // Filtre sayısını hesapla 00700 fnode.filterNumber = eeprom_read(EEPROM_TYPE, FILTER_NUMBER_ADDR); 00701 fnode.lastFlushPhase = ((uint16_t)fnode.filterNumber * 4) + 1; 00702 00703 // Sayaç mevcuts ISR'yi aktifle 00704 if ((fnode.systemSetup >> 3) & 1 == 1) { 00705 00706 watermeterInterrupt.rise(&watermeter_isr); 00707 00708 } 00709 00710 // EEPROM'dan sulama sırasında veri gönderim sıklığını oku 00711 fnode.irriTransmitInterval = eeprom_read(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR); 00712 00713 // EEPROM'dan sulama dışında veri gönderim sıklığını oku 00714 fnode.dryTransmitInterval = eeprom_read(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR); 00715 00716 // EEPROM'dan otomatik veri gönderimini oku 00717 if (eeprom_read(EEPROM_TYPE, AUTOSEND_STATUS_ADDR) == 1) { 00718 00719 fnode.autosend = true; 00720 00721 } else { 00722 00723 fnode.autosend = false; 00724 00725 } 00726 00727 if (eeprom_read(EEPROM_TYPE, IRRI_STATUS_ADDR) == 1) { 00728 00729 fnode.irrigation = true; 00730 00731 dataTransmitTicker.attach(&data_transmit_isr, fnode.irriTransmitInterval * 60); 00732 00733 timer.reset(); 00734 timer.start(); 00735 00736 } else { 00737 00738 fnode.irrigation = false; 00739 00740 dataTransmitTicker.attach(&data_transmit_isr, fnode.dryTransmitInterval * 60); 00741 00742 timer.reset(); 00743 timer.start(); 00744 00745 } 00746 00747 // EEPROM'dan sayaç katsayısını oku 00748 fnode.watermeterCoefficient = (eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_1) << 8) + eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_2); 00749 00750 // EEPROM'dan basınç sensörünün okuyabileceği maksimum basıncı oku 00751 fnode.pMax = eeprom_read(EEPROM_TYPE, PMAX_ADDR); 00752 00753 // EEPROM'dan basınç sensörü tipini oku (4-20 mA veya 0-3.3v) 00754 fnode.pressureSensorType = eeprom_read(EEPROM_TYPE, PRESSURE_SENSOR_ADDR); 00755 00756 // EEPROM'dan DP set değerini oku 00757 fnode.dpSet = eeprom_read(EEPROM_TYPE, DP_ADDR); 00758 00759 // EEPROM'dan basınç kontrol sıklığını oku 00760 fnode.pressureControlFrequency = eeprom_read(EEPROM_TYPE, PRESSURE_CONTROL_FREQUENCY_ADDR); 00761 00762 // EEPROM'dan 1 filtre yıkama süresini oku 00763 fnode.flushDuration = eeprom_read(EEPROM_TYPE, FLUSH_DURATION_ADDR); 00764 00765 // EEPROM'dan 2 filtre yıkaması arasındaki bekleme süresini oku 00766 fnode.flushInterval = eeprom_read(EEPROM_TYPE, FLUSH_INTERVAL_ADDR); 00767 00768 // EEPROM'dan akış kontrolü gecikme süresini oku (Akış kontrolü filtre yıkaması başladıktan ya da bittikten kaç saniye sonra yapılacak?) 00769 fnode.flowControlLatency = eeprom_read(EEPROM_TYPE, FLOW_CONTROL_LATENCY_ADDR); 00770 00771 // EEPROM'dan ters yıkama kontrolü aktif ya da pasif durumunu oku 00772 if (eeprom_read(EEPROM_TYPE, FLUSH_ENABLE_ADDR) == 1) { 00773 00774 fnode.flushEnabled = 1; 00775 00776 } else { 00777 00778 fnode.flushEnabled = 0; 00779 00780 } 00781 00782 // EEPROM'dan basınç sensörünün yerleştirme noktasını oku (Filtre öncesi ya da sonrası) 00783 fnode.pressureSensorPosition = eeprom_read(EEPROM_TYPE, PR_SENSOR_POSITION_ADDR); 00784 00785 // EEPROM'dan hata durumunda ters yıkamanın durdurulup durdurulmayacağını oku 00786 if (eeprom_read(EEPROM_TYPE, BACKFLUSH_STOP_ADDR) == 0) { 00787 00788 fnode.onErrorStop = 0; 00789 00790 } else { 00791 00792 fnode.onErrorStop = 1; 00793 00794 } 00795 00796 fnode.pressureLowThreshold = eeprom_read(EEPROM_TYPE, INLET_PRS_LOW_TRS_ADDR); 00797 fnode.pressureHighThreshold = eeprom_read(EEPROM_TYPE, INLET_PRS_HIGH_TRS_ADDR); 00798 00799 // Timer ve tickerları başlat 00800 // Basınç sürekli kontrol edilecek 00801 pressureCheckTicker.attach(&pressure_check_isr, fnode.pressureControlFrequency); 00802 00803 // EEPROM'dan alarmların açık/kapalı durumunu oku 00804 if (eeprom_read(EEPROM_TYPE, ALARMS_ENABLE_ADDR) == 0) { 00805 00806 fnode.alarmsEnabled = 0; 00807 00808 } else { 00809 00810 fnode.alarmsEnabled = 1; 00811 00812 } 00813 00814 // EEPROM'dan DP alarmı eşik değerini oku 00815 // Yıkama sırasında DP bu değerin üstüne çıkarsa alarm gönderilir 00816 // Bazı durumlarda DP düşmeyebilir !!! 00817 fnode.dpThreshold = eeprom_read(EEPROM_TYPE, DP_HIGH_TRS_ADDR); 00818 00819 // EEPROM'dan sulamanın başladığının anlaşılacağı giriş basıncı set değerini oku 00820 fnode.inletPressureSet = eeprom_read(EEPROM_TYPE, INLET_PRS_SET_ADDR); 00821 00822 // EEPROM'dan DP kontrolünün başlayacağı filtrasyon çıkış basıncı set değerini oku 00823 fnode.outletPressureSet = eeprom_read(EEPROM_TYPE, OUTLET_PRS_SET_FOR_DP_ADDR); 00824 00825 // periodicFlushInterval değeri 0 ise periyodik yıkama yapılmaz 00826 fnode.periodicFlushInterval = eeprom_read(EEPROM_TYPE, PERIODIC_FLUSH_ADDR); 00827 00828 if (fnode.periodicFlushInterval == 0) { 00829 00830 fnode.periodicFlushEnabled = false; 00831 periodicFlushTicker.detach(); 00832 fnode.periodicFlushCounter = 0; 00833 00834 } else { 00835 00836 fnode.periodicFlushEnabled = true; 00837 fnode.periodicFlushCounter = 0; 00838 00839 // Periodic flush isr works every 1 second to increase periodicCounter by 1 00840 // If periodicCounter value >= peridicFlushInterval * 3600 00841 // Example: 00842 // Periodic flush interval is 6 hours 00843 // Periodic counter counts every 1 seconds by ISR 00844 // In 1 hour there is 3600 seconds..... In 6 hours 6 * 3600 = 21600 seconds 00845 00846 if (fnode.irrigation == true) { 00847 00848 periodicFlushTicker.attach(&periodic_flush_isr, 1); // ISR set every 1 second 00849 00850 } else { 00851 00852 periodicFlushTicker.detach(); 00853 00854 } 00855 } 00856 00857 // minFlushInterval değeri 0'dan farklı ise DP yıkamaları min süre beklenerek yapılır 00858 c23_a = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_1); 00859 c23_b = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_2); 00860 fnode.minFlushInterval = (c23_a << 8) + c23_b; 00861 00862 if (fnode.minFlushInterval == 0) { 00863 00864 fnode.minFlushEnabled = false; 00865 00866 } else { 00867 00868 fnode.minFlushEnabled = true; 00869 } 00870 00871 if (fnode.filterNumber % 4 == 0) { 00872 00873 fnode.totalSlaveNumber = fnode.filterNumber / 4; 00874 00875 } else { 00876 00877 fnode.totalSlaveNumber = (fnode.filterNumber / 4) + 1; 00878 } 00879 } 00880 00881 // 00882 float read_pressure_dp() 00883 { 00884 // Analog kanal okumasının RMS (Root Mean Square) hesaplaması 00885 memset(rmsStore, 0, sizeof(rmsStore)); 00886 totalSampling = 0.0; 00887 tempValue = 0.0; 00888 tdp = 0.0; 00889 00890 for (uint8_t b = 0; b < RMS_SAMPLING_NUMBER; b++) { 00891 00892 tempValue = dpSensor.read(); 00893 rmsStore[b] = tempValue * tempValue; 00894 totalSampling = totalSampling + rmsStore[b]; 00895 00896 } 00897 00898 tdp = (sqrt ((float)((totalSampling / RMS_SAMPLING_NUMBER)))) * 4096.0f; 00899 // 00900 00901 // Fark basınç hesaplaması, BAR, -4 ile +4 bar arası 00902 // DP + 4 = ((Sensor okuması - 409.6) / 409.6) ==> Honeywell sensor katalog sadeleştirilmiş denklem 00903 tdpResult = ((tdp-409.6f)/409.6f) - 4.0f; 00904 00905 if (tdpResult < 0) { 00906 00907 tdpResult = 0; 00908 00909 } 00910 00911 tdpResult = floor(tdpResult * 10) / 10; 00912 00913 return tdpResult; 00914 } 00915 00916 // 00917 float read_pressure() 00918 { 00919 // Analog kanal okumasının RMS (Root Mean Square) hesaplaması 00920 memset(rmsStore, 0, sizeof(rmsStore)); 00921 totalSampling = 0; 00922 tempValue = 0; 00923 tp = 0; 00924 00925 for (uint8_t b = 0; b < RMS_SAMPLING_NUMBER; b++) { 00926 00927 tempValue = pressureSensor.read(); 00928 rmsStore[b] = tempValue * tempValue; 00929 totalSampling = totalSampling + rmsStore[b]; 00930 00931 } 00932 00933 tp = (sqrt ((float)((totalSampling / RMS_SAMPLING_NUMBER)))) * 4096.0f; 00934 // 00935 00936 if (fnode.pressureSensorType == 0) { 00937 00938 // Ham analog verisinden basınç hesaplaması, BAR 00939 // Honeywell Truw Stability sensörlerine özel, PSI, 3.3v, map'lenmemiş 00940 tp = ((tp - 409.6f) / (3276.8f / (float)fnode.pMax)) * 0.0689476f; // 0.0689 is for psi to bar conversion; 00941 00942 } else { 00943 00944 // Ham analog verisinden basınç hesaplaması, BAR 00945 // 4-20 mA sensöre özel, BAR 00946 // 4 mA = 480 mV = 595.8 RAW 00947 // 20 mA = 2400 mV = 2978.9 RAW 00948 tp = map (tp, 595.8f, 2978.9f, 0.0f, (float)fnode.pMax); 00949 00950 } 00951 00952 if (tp < 0) { 00953 00954 tp = 0; 00955 00956 } 00957 00958 tp = floor(tp * 10) / 10; 00959 00960 return tp; 00961 } 00962 00963 void prepare_data_fread() 00964 { 00965 memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 00966 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 00967 00968 // Filtrasyon JSON headırını yaz 00969 sprintf(fnode.temporaryBuffer, "%s", json[0]); 00970 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 00971 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 00972 00973 // Eğer basınç sensörü varsa 00974 if (fnode.systemSetup & (1 << 1)) { 00975 00976 // Basınç sensörü varken DP sensörü de mevcutsa hem giriş hem çıkış basıncını yaz 00977 if (fnode.systemSetup & (1 << 1)) { 00978 00979 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%.1f%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], fnode.outletPressure, ','); 00980 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 00981 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 00982 00983 // Basınç sensörü varken DP sensörü yoksa basınç sensörünün pozisyonuna göre giriş veya çıkış basıncını yaz 00984 } else { 00985 00986 // Basınç sensörü girişte ise giriş basıncını yaz, çıkış basıncı NULL olsun 00987 if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 0) { 00988 00989 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%s%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], "null", ','); 00990 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 00991 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 00992 00993 // Basınç sensörü çıkışta ise çıkış basıncını yaz, giriş basıncı NULL olsun 00994 } else if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 1) { 00995 00996 sprintf(fnode.temporaryBuffer, "%s%s%c%s%.1f%c", jsonHeader[0], "null", ',', jsonHeader[1], fnode.outletPressure, ','); 00997 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 00998 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 00999 01000 } 01001 } 01002 01003 // Basınç sensörü yoksa giriş ve çıkış basınç değerleri NULL olsun 01004 } else { 01005 01006 sprintf(fnode.temporaryBuffer, "%s%s%c%s%s%c", jsonHeader[0], "null", ',', jsonHeader[1], "null", ','); 01007 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01008 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01009 } 01010 01011 // Eğer DP sensörü varsa DP verisini ekle 01012 if (fnode.systemSetup & (1 << 1)) { 01013 01014 sprintf(fnode.temporaryBuffer, "%s%.1f%c", jsonHeader[2], fnode.dpPressure, ','); 01015 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01016 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01017 01018 // DP sensörü yoksa DP verisi NULL olsun 01019 } else { 01020 01021 sprintf(fnode.temporaryBuffer, "%s%s%c", jsonHeader[2], "null", ','); 01022 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01023 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01024 01025 } 01026 01027 // Eğer sayaç mevcutsa su hacmi ve debi verilerini ekle 01028 // İki veri gönderimi arasındaki su hacmi ve debi verisini burada hesapla 01029 if (fnode.systemSetup & (1 << 3)) { 01030 01031 sprintf(fnode.temporaryBuffer, "%s%llu%c%s%llu%c%s%.1f%c%s%llu%c%s%llu%c%s%.1f", jsonHeader[3], fnode.rWI, ',', jsonHeader[4], fnode.rWIC, ',', jsonHeader[5], fnode.rQI, ',', jsonHeader[6], fnode.rWD, ',', jsonHeader[7], fnode.rWDC, ',', jsonHeader[8], fnode.rQD); 01032 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01033 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01034 01035 01036 } else { 01037 01038 sprintf(fnode.temporaryBuffer, "%s%s%c%s%s%c%s%s%c%s%s%c%s%s%c%s%s", jsonHeader[3], "null", ',', jsonHeader[4], "null", ',', jsonHeader[5], "null", ',', jsonHeader[6], "null", ',', jsonHeader[7], "null", ',', jsonHeader[8], "null"); 01039 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01040 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01041 01042 } 01043 01044 // Sulama durumu 01045 if (fnode.irrigation == true) { 01046 01047 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"IRR\""); 01048 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01049 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01050 01051 } else { 01052 01053 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"DRY\""); 01054 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01055 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01056 01057 } 01058 01059 // Yıkama durumu 01060 if (fnode.flushing == true) { 01061 01062 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:1"); 01063 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01064 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01065 01066 } else { 01067 01068 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:0"); 01069 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01070 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01071 01072 } 01073 01074 sprintf(fnode.temporaryBuffer, "%s", "},RT:1}"); 01075 01076 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01077 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01078 } 01079 01080 01081 // 01082 void prepare_data() 01083 { 01084 memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01085 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01086 01087 // Filtrasyon JSON headırını yaz 01088 sprintf(fnode.temporaryBuffer, "%s", json[0]); 01089 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01090 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01091 01092 // Eğer basınç sensörü varsa 01093 if (fnode.systemSetup & (1 << 1)) { 01094 01095 // Basınç sensörü varken DP sensörü de mevcutsa hem giriş hem çıkış basıncını yaz 01096 if (fnode.systemSetup & (1 << 0)) { 01097 01098 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%.1f%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], fnode.outletPressure, ','); 01099 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01100 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01101 01102 // Basınç sensörü varken DP sensörü yoksa basınç sensörünün pozisyonuna göre giriş veya çıkış basıncını yaz 01103 } else { 01104 01105 // Basınç sensörü girişte ise giriş basıncını yaz, çıkış basıncı NULL olsun 01106 if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 0) { 01107 01108 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%s%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], "null", ','); 01109 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01110 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01111 01112 // Basınç sensörü çıkışta ise çıkış basıncını yaz, giriş basıncı NULL olsun 01113 } else if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 1) { 01114 01115 sprintf(fnode.temporaryBuffer, "%s%s%c%s%.1f%c", jsonHeader[0], "null", ',', jsonHeader[1], fnode.outletPressure, ','); 01116 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01117 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01118 01119 } 01120 } 01121 01122 // Basınç sensörü yoksa giriş ve çıkış basınç değerleri NULL olsun 01123 } else { 01124 01125 sprintf(fnode.temporaryBuffer, "%s%s%c%s%s%c", jsonHeader[0], "null", ',', jsonHeader[1], "null", ','); 01126 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01127 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01128 } 01129 01130 // Eğer DP sensörü varsa DP verisini ekle 01131 if (fnode.systemSetup & (1 << 0)) { 01132 01133 sprintf(fnode.temporaryBuffer, "%s%.1f%c", jsonHeader[2], fnode.dpPressure, ','); 01134 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01135 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01136 01137 // DP sensörü yoksa DP verisi NULL olsun 01138 } else { 01139 01140 sprintf(fnode.temporaryBuffer, "%s%s%c", jsonHeader[2], "null", ','); 01141 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01142 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01143 01144 } 01145 01146 // Eğer sayaç mevcutsa su hacmi ve debi verilerini ekle 01147 // İki veri gönderimi arasındaki su hacmi ve debi verisini burada hesapla 01148 if (fnode.systemSetup & (1 << 3)) { 01149 01150 sprintf(fnode.temporaryBuffer, "%s%llu%c%s%llu%c%s%.1f%c%s%llu%c%s%llu%c%s%.1f", jsonHeader[3], fnode.WI, ',', jsonHeader[4], fnode.WIC, ',', jsonHeader[5], fnode.QI, ',', jsonHeader[6], fnode.WD, ',', jsonHeader[7], fnode.WDC, ',', jsonHeader[8], fnode.QD); 01151 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01152 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01153 01154 01155 } else { 01156 01157 sprintf(fnode.temporaryBuffer, "%s%s%c%s%s%c%s%s%c%s%s%c%s%s%c%s%s", jsonHeader[3], "null", ',', jsonHeader[4], "null", ',', jsonHeader[5], "null", ',', jsonHeader[6], "null", ',', jsonHeader[7], "null", ',', jsonHeader[8], "null"); 01158 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01159 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01160 01161 } 01162 01163 // Sulama durumu 01164 if (fnode.irrigation == true) { 01165 01166 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"IRR\""); 01167 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01168 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01169 01170 } else { 01171 01172 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"DRY\""); 01173 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01174 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01175 01176 } 01177 01178 // Yıkama durumu 01179 if (fnode.flushing == true) { 01180 01181 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:1"); 01182 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01183 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01184 01185 } else { 01186 01187 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:0"); 01188 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01189 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01190 01191 } 01192 01193 sprintf(fnode.temporaryBuffer, "%s", "}}"); 01194 01195 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01196 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01197 } 01198 01199 // 01200 void send_to_coordinator(char* char_array) 01201 { 01202 rf.putc(COORD_ADDR_1); 01203 rf.putc(COORD_ADDR_2); 01204 rf.putc(EQUAL); 01205 rf.puts(char_array); 01206 rf.putc(CR); 01207 wait_ms(50); 01208 } 01209 01210 // 01211 void process_command(uint8_t cmnd) 01212 { 01213 switch(cmnd) { 01214 01215 case FENABLE: { 01216 01217 // Eğer ters yıkama zaten akitflenmişse hata mesajı gönder 01218 if (eeprom_read(EEPROM_TYPE, FLUSH_ENABLE_ADDR) == 1) { 01219 01220 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FENABLEERR\"}"); 01221 send_to_coordinator(fnode.dataBuffer); 01222 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01223 01224 // Ters yıkamayı devre dışı bırak 01225 } else { 01226 01227 // Yıkamanın devreye alındığını EEPROM'a yaz 01228 eeprom_write(EEPROM_TYPE, FLUSH_ENABLE_ADDR, 1); 01229 01230 fnode.flushEnabled = 1; 01231 01232 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FENABLEOK\"}"); 01233 send_to_coordinator(fnode.dataBuffer); 01234 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01235 01236 } 01237 } 01238 break; 01239 01240 case FDISABLE: { 01241 01242 // Eğer ters yıkama zaten akitflenmişse hata mesajı gönder 01243 if (eeprom_read(EEPROM_TYPE, FLUSH_ENABLE_ADDR) == 0) { 01244 01245 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FDISABLEERR\"}"); 01246 send_to_coordinator(fnode.dataBuffer); 01247 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01248 01249 // Ters yıkamayı devre dışı bırak 01250 } else { 01251 01252 // Yıkamanın devre dışı kaldığını EEPROM'a yaz 01253 eeprom_write(EEPROM_TYPE, FLUSH_ENABLE_ADDR, 0); 01254 01255 fnode.flushEnabled = 0; 01256 01257 /* 01258 // Yıkama zamanlayıcısını kapat 01259 flushTimer.detach(); 01260 01261 // Yıkama fazını sıfırla 01262 fnode.flushPhase = 0; 01263 01264 // Solenoid vanaları kontrol et ve kapat 01265 check_and_close_valves(); 01266 */ 01267 01268 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FDISABLEOK\"}"); 01269 send_to_coordinator(fnode.dataBuffer); 01270 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01271 01272 } 01273 } 01274 break; 01275 01276 case FSETSYS: { 01277 01278 // Sistem ayarları 01279 eeprom_write(EEPROM_TYPE, SYSTEM_SETUP_ADDR, fnode.systemSetup); 01280 01281 // Otomatik veri aktarımı 01282 eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, fnode.autosendStatus); 01283 01284 // Yeni set edilecek veri aktarım aralıkları eskisinden farklıysa zamanlayıcıları yeni ayarla başlat 01285 // Eski ile yeni aktarım aralıkları aynı ise değişiklik yapma (Alt satırlarda) 01286 irriTrsIntOld = eeprom_read(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR); 01287 eeprom_write(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR, fnode.irriTransmitInterval); 01288 01289 dryTrsIntOld = eeprom_read(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR); 01290 eeprom_write(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR, fnode.dryTransmitInterval); 01291 01292 // Sayaç katsayısı 01293 eeprom_write(EEPROM_TYPE, WATERMETER_COEFF_ADDR_1, fnode.watermeterCoefficient >> 8); 01294 eeprom_write(EEPROM_TYPE, WATERMETER_COEFF_ADDR_2, fnode.watermeterCoefficient & 0xFF); 01295 01296 // Basınç sensörü maksimum basıncı 01297 eeprom_write(EEPROM_TYPE, PMAX_ADDR, fnode.pMax); 01298 01299 // Basınç sensörü tipi 01300 eeprom_write(EEPROM_TYPE, PRESSURE_SENSOR_ADDR, fnode.pressureSensorType); 01301 01302 // DP set 01303 eeprom_write(EEPROM_TYPE, DP_ADDR, fnode.dpSet); 01304 01305 // Basınç kontrol sıklığı 01306 eeprom_write(EEPROM_TYPE, PRESSURE_CONTROL_FREQUENCY_ADDR, fnode.pressureControlFrequency); 01307 01308 // 1 filtre yıkama süresi 01309 eeprom_write(EEPROM_TYPE, FLUSH_DURATION_ADDR, fnode.flushDuration); 01310 01311 // Yıkama aralığı 01312 eeprom_write(EEPROM_TYPE, FLUSH_INTERVAL_ADDR, fnode.flushInterval); 01313 01314 // Akış kontrol gecikmesi 01315 eeprom_write(EEPROM_TYPE, FLOW_CONTROL_LATENCY_ADDR, fnode.flowControlLatency); 01316 01317 // Ters yıkama devrede/devrede değil 01318 eeprom_write(EEPROM_TYPE, FLUSH_ENABLE_ADDR, fnode.flushEnabled); 01319 01320 // Basınç sensörü pozisyonu 01321 eeprom_write(EEPROM_TYPE, PR_SENSOR_POSITION_ADDR, fnode.pressureSensorPosition); 01322 01323 // Hata durumunda ters yıkamayı durdur/durdurma 01324 eeprom_write(EEPROM_TYPE, BACKFLUSH_STOP_ADDR, fnode.onErrorStop); 01325 01326 // Giriş basıncı alarm alt sınır eşik 01327 eeprom_write(EEPROM_TYPE, INLET_PRS_LOW_TRS_ADDR, fnode.pressureLowThreshold); 01328 01329 // Giriş basıncı alarm üst sınır eşik 01330 eeprom_write(EEPROM_TYPE, INLET_PRS_HIGH_TRS_ADDR, fnode.pressureHighThreshold); 01331 01332 // Alarmlar devrede 01333 eeprom_write(EEPROM_TYPE, ALARMS_ENABLE_ADDR, fnode.alarmsEnabled); 01334 01335 // DP alarm eşik değeri 01336 eeprom_write(EEPROM_TYPE, DP_HIGH_TRS_ADDR, fnode.dpThreshold); 01337 01338 eeprom_write(EEPROM_TYPE, INLET_PRS_SET_ADDR, fnode.inletPressureSet); 01339 01340 eeprom_write(EEPROM_TYPE, OUTLET_PRS_SET_FOR_DP_ADDR, fnode.outletPressureSet); 01341 01342 eeprom_write(EEPROM_TYPE, PERIODIC_FLUSH_ADDR, fnode.periodicFlushInterval); 01343 01344 eeprom_write(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_1, fnode.minFlushInterval >> 8); 01345 eeprom_write(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_2, fnode.minFlushInterval & 0xFF); 01346 01347 eeprom_write(EEPROM_TYPE, FILTER_NUMBER_ADDR, fnode.filterNumber); 01348 01349 01350 // Check written SSETSYS values on EEPROM 01351 c1 = eeprom_read(EEPROM_TYPE, SYSTEM_SETUP_ADDR); 01352 c2 = eeprom_read(EEPROM_TYPE, AUTOSEND_STATUS_ADDR); 01353 c3 = eeprom_read(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR); 01354 c4 = eeprom_read(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR); 01355 c5_a = eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_1); 01356 c5_b = eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_2); 01357 c5 = (c5_a << 8) + c5_b; 01358 c6 = eeprom_read(EEPROM_TYPE, PMAX_ADDR); 01359 c7 = eeprom_read(EEPROM_TYPE, PRESSURE_SENSOR_ADDR); 01360 c8 = eeprom_read(EEPROM_TYPE, DP_ADDR); 01361 c9 = eeprom_read(EEPROM_TYPE, PRESSURE_CONTROL_FREQUENCY_ADDR); 01362 c10 = eeprom_read(EEPROM_TYPE, FLUSH_DURATION_ADDR); 01363 c11 = eeprom_read(EEPROM_TYPE, FLUSH_INTERVAL_ADDR); 01364 c12 = eeprom_read(EEPROM_TYPE, FLOW_CONTROL_LATENCY_ADDR); 01365 c13 = eeprom_read(EEPROM_TYPE, FLUSH_ENABLE_ADDR); 01366 c14 = eeprom_read(EEPROM_TYPE, PR_SENSOR_POSITION_ADDR); 01367 c15 = eeprom_read(EEPROM_TYPE, BACKFLUSH_STOP_ADDR); 01368 c16 = eeprom_read(EEPROM_TYPE, INLET_PRS_LOW_TRS_ADDR); 01369 c17 = eeprom_read(EEPROM_TYPE, INLET_PRS_HIGH_TRS_ADDR); 01370 c18 = eeprom_read(EEPROM_TYPE, ALARMS_ENABLE_ADDR); 01371 c19 = eeprom_read(EEPROM_TYPE, DP_HIGH_TRS_ADDR); 01372 c20 = eeprom_read(EEPROM_TYPE, INLET_PRS_SET_ADDR); 01373 c21 = eeprom_read(EEPROM_TYPE, OUTLET_PRS_SET_FOR_DP_ADDR); 01374 c22 = eeprom_read(EEPROM_TYPE, PERIODIC_FLUSH_ADDR); 01375 c23_a = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_1); 01376 c23_b = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_2); 01377 c23 = (c23_a << 8) + c23_b; 01378 c24 = eeprom_read(EEPROM_TYPE, FILTER_NUMBER_ADDR); 01379 01380 // Kaydedilen değerler ile gönderilen değerleri karşılaştır 01381 // Aynı ise sunucuya mesaj gönder 01382 if (c1 == fnode.systemSetup && c2 == fnode.autosendStatus && c3 == fnode.irriTransmitInterval && c4 == fnode.dryTransmitInterval && c5 == fnode.watermeterCoefficient && c6 == fnode.pMax && c7 == fnode.pressureSensorType && c8 == fnode.dpSet && c9 == fnode.pressureControlFrequency && c10 == fnode.flushDuration && c11 == fnode.flushInterval && c12 == fnode.flowControlLatency && c13 == fnode.flushEnabled && c14 == fnode.pressureSensorPosition && c15 == fnode.onErrorStop && c16 == fnode.pressureLowThreshold && c17 == fnode.pressureHighThreshold && c18 == fnode.alarmsEnabled && c19 == fnode.dpThreshold && c20 == fnode.inletPressureSet && c21 == fnode.outletPressureSet && c22 == fnode.periodicFlushInterval && c23 == fnode.minFlushInterval && c24 == fnode.filterNumber) { 01383 01384 sprintf(fnode.dataBuffer, "%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%c", "{CMD:\"FSETSYSOK\",C1:", c1, ",C2:", c2, ",C3:", c3, ",C4:", c4, ",C5:", c5, ",C6:", c6, ",C7:", c7, ",C8:", c8, ",C9:", c9, ",C10:", c10, ",C11:", c11, ",C12:", c12, ",C13:", c13, ",C14:", c14, ",C15:", c15, ",C16:", c16, ",C17:", c17, ",C18:", c18, ",C19:", c19, ",C20:", c20, ",C21:", c21, ",C22:", c22, ",C23:", c23, ",C24:", c24, '}'); 01385 send_to_coordinator(fnode.dataBuffer); 01386 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01387 01388 // YENİ SET Değerlerine göre ayarlar 01389 // Filtre sayısı 01390 fnode.filterNumber = c24; 01391 fnode.lastFlushPhase = ((uint16_t)fnode.filterNumber * 4) + 1; 01392 01393 // Sayaç mevcutsa ISR'yi aktifle 01394 if (fnode.systemSetup & (1 << 3)) { 01395 01396 watermeterInterrupt.rise(NULL); 01397 watermeterInterrupt.rise(&watermeter_isr); 01398 01399 } else { 01400 01401 watermeterInterrupt.rise(NULL); 01402 } 01403 01404 if (fnode.autosendStatus == 0) { 01405 01406 fnode.autosend = false; 01407 01408 } else { 01409 01410 fnode.autosend = true; 01411 } 01412 01413 // If irrigation phase and autosend is active and new data transmission interval is different than old one attach data transmission ISR again 01414 if (fnode.irrigation == true && fnode.autosend == true && irriTrsIntOld != fnode.irriTransmitInterval) { 01415 01416 dataTransmitTicker.detach(); 01417 dataTransmitTicker.attach(&data_transmit_isr, fnode.irriTransmitInterval * 60); 01418 01419 // If not irrigation phase and autosend is active and new data transmission interval is different than old one attach data transmission ISR again 01420 } else if (fnode.irrigation == false && fnode.autosend == true && dryTrsIntOld != fnode.dryTransmitInterval) { 01421 01422 dataTransmitTicker.detach(); 01423 dataTransmitTicker.attach(&data_transmit_isr, fnode.dryTransmitInterval * 60); 01424 01425 // If autosend is not active detach data transmission ISR 01426 } else if (fnode.autosend == false) { 01427 01428 dataTransmitTicker.detach(); 01429 01430 } 01431 01432 // periodicFlushInterval değeri 0 ise periyodik yıkama yapılmaz 01433 if (fnode.periodicFlushInterval == 0) { 01434 01435 fnode.periodicFlushEnabled = false; 01436 periodicFlushTicker.detach(); 01437 fnode.periodicFlushCounter = 0; 01438 01439 } else { 01440 01441 fnode.periodicFlushEnabled = true; 01442 fnode.periodicFlushCounter = 0; 01443 01444 // Periodic flush isr works every 1 second to increase periodicCounter by 1 01445 // If periodicCounter value >= peridicFlushInterval * 3600 01446 // Example: 01447 // Periodic flush interval is 6 hours 01448 // Periodic counter counts every 1 seconds by ISR 01449 // In 1 hour there is 3600 seconds..... In 6 hours 6 * 3600 = 21600 seconds 01450 01451 if (fnode.irrigation == true) { 01452 01453 periodicFlushTicker.attach(&periodic_flush_isr, 1); // ISR set every 1 second 01454 01455 } else { 01456 01457 periodicFlushTicker.detach(); 01458 01459 } 01460 } 01461 01462 // minFlushInterval değeri 0'dan farklı ise DP yıkamaları min süre beklenerek yapılır 01463 if (fnode.minFlushInterval == 0) { 01464 01465 fnode.minFlushEnabled = false; 01466 01467 } else { 01468 01469 fnode.minFlushEnabled = true; 01470 } 01471 01472 } else { 01473 01474 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FSETSYSERR\"}"); 01475 send_to_coordinator(fnode.dataBuffer); 01476 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01477 01478 } 01479 } 01480 break; 01481 01482 case FGETCFG: { 01483 01484 // Get configuration from EEPROM 01485 c1 = eeprom_read(EEPROM_TYPE, SYSTEM_SETUP_ADDR); 01486 c2 = eeprom_read(EEPROM_TYPE, AUTOSEND_STATUS_ADDR); 01487 c3 = eeprom_read(EEPROM_TYPE, IRRI_TRANSMIT_INTERVAL_ADDR); 01488 c4 = eeprom_read(EEPROM_TYPE, DRY_TRANSMIT_INTERVAL_ADDR); 01489 c5_a = eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_1); 01490 c5_b = eeprom_read(EEPROM_TYPE, WATERMETER_COEFF_ADDR_2); 01491 c5 = (c5_a << 8) + c5_b; 01492 c6 = eeprom_read(EEPROM_TYPE, PMAX_ADDR); 01493 c7 = eeprom_read(EEPROM_TYPE, PRESSURE_SENSOR_ADDR); 01494 c8 = eeprom_read(EEPROM_TYPE, DP_ADDR); 01495 c9 = eeprom_read(EEPROM_TYPE, PRESSURE_CONTROL_FREQUENCY_ADDR); 01496 c10 = eeprom_read(EEPROM_TYPE, FLUSH_DURATION_ADDR); 01497 c11 = eeprom_read(EEPROM_TYPE, FLUSH_INTERVAL_ADDR); 01498 c12 = eeprom_read(EEPROM_TYPE, FLOW_CONTROL_LATENCY_ADDR); 01499 c13 = eeprom_read(EEPROM_TYPE, FLUSH_ENABLE_ADDR); 01500 c14 = eeprom_read(EEPROM_TYPE, PR_SENSOR_POSITION_ADDR); 01501 c15 = eeprom_read(EEPROM_TYPE, BACKFLUSH_STOP_ADDR); 01502 c16 = eeprom_read(EEPROM_TYPE, INLET_PRS_LOW_TRS_ADDR); 01503 c17 = eeprom_read(EEPROM_TYPE, INLET_PRS_HIGH_TRS_ADDR); 01504 c18 = eeprom_read(EEPROM_TYPE, ALARMS_ENABLE_ADDR); 01505 c19 = eeprom_read(EEPROM_TYPE, DP_HIGH_TRS_ADDR); 01506 c20 = eeprom_read(EEPROM_TYPE, INLET_PRS_SET_ADDR); 01507 c21 = eeprom_read(EEPROM_TYPE, OUTLET_PRS_SET_FOR_DP_ADDR); 01508 c22 = eeprom_read(EEPROM_TYPE, PERIODIC_FLUSH_ADDR); 01509 c23_a = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_1); 01510 c23_b = eeprom_read(EEPROM_TYPE, MIN_FLUSH_INTERVAL_ADDR_2); 01511 c23 = (c23_a << 8) + c23_b; 01512 c24 = eeprom_read(EEPROM_TYPE, FILTER_NUMBER_ADDR); 01513 01514 sprintf(fnode.dataBuffer, "%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%c", "{CMD:\"FGETCFGOK\",C1:", c1, ",C2:", c2, ",C3:", c3, ",C4:", c4, ",C5:", c5, ",C6:", c6, ",C7:", c7, ",C8:", c8, ",C9:", c9, ",C10:", c10, ",C11:", c11, ",C12:", c12, ",C13:", c13, ",C14:", c14, ",C15:", c15, ",C16:", c16, ",C17:", c17, ",C18:", c18, ",C19:", c19, ",C20:", c20, ",C21:", c21, ",C22:", c22, ",C23:", c23, ",C24:", c24, '}'); 01515 send_to_coordinator(fnode.dataBuffer); 01516 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01517 01518 } 01519 break; 01520 01521 case FSTART: { 01522 01523 if (fnode.autosend == false) { 01524 01525 fnode.autosend = true; 01526 01527 if (fnode.irrigation) { 01528 01529 dataTransmitTicker.detach(); 01530 dataTransmitTicker.attach(&data_transmit_isr, fnode.irriTransmitInterval * 60); 01531 01532 } else { 01533 01534 dataTransmitTicker.detach(); 01535 dataTransmitTicker.attach(&data_transmit_isr, fnode.dryTransmitInterval * 60); 01536 01537 } 01538 01539 // Save autosend enable status to EEPROM 01540 eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, 1); 01541 01542 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FSTARTOK\"}"); 01543 send_to_coordinator(fnode.dataBuffer); 01544 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01545 01546 } else { 01547 01548 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FSTARTERR\"}"); 01549 send_to_coordinator(fnode.dataBuffer); 01550 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01551 01552 } 01553 01554 } 01555 break; 01556 01557 01558 case FSTOP: { 01559 01560 if (fnode.autosend == true) { 01561 01562 fnode.autosend = false; 01563 01564 dataTransmitTicker.detach(); 01565 01566 // Save autosend disable status to EEPROM 01567 eeprom_write(EEPROM_TYPE, AUTOSEND_STATUS_ADDR, 0); 01568 01569 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FSTOPOK\"}"); 01570 send_to_coordinator(fnode.dataBuffer); 01571 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01572 01573 } else { 01574 01575 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FSTOPERR\"}"); 01576 send_to_coordinator(fnode.dataBuffer); 01577 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01578 01579 } 01580 } 01581 break; 01582 01583 case FFIX: { 01584 01585 if (fnode.errorOccured == true) { 01586 01587 fnode.errorOccured = false; 01588 01589 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FFIXOK\"}"); 01590 send_to_coordinator(fnode.dataBuffer); 01591 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01592 01593 } else { 01594 01595 sprintf(fnode.dataBuffer, "%s", "{CMD:\"FFIXERR\"}"); 01596 send_to_coordinator(fnode.dataBuffer); 01597 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01598 01599 } 01600 } 01601 break; 01602 01603 case FGETSTATUS: { 01604 01605 //STAT:"IRR" 01606 if (fnode.irrigation == true) { 01607 01608 sprintf(fnode.dataBuffer, "%s", "{STAT:\"IRR\"}"); 01609 send_to_coordinator(fnode.dataBuffer); 01610 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01611 01612 //STAT:"DRY" 01613 } else { 01614 01615 sprintf(fnode.dataBuffer, "%s", "{STAT:\"DRY\"}"); 01616 send_to_coordinator(fnode.dataBuffer); 01617 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01618 01619 } 01620 01621 } 01622 break; 01623 01624 case FGETFSTATUS: { 01625 01626 // Flushing Now 01627 if(fnode.flushing) { 01628 sprintf(fnode.dataBuffer, "%s", "{STAT:\"FLUSHING\"}"); 01629 send_to_coordinator(fnode.dataBuffer); 01630 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01631 01632 } else { 01633 01634 sprintf(fnode.dataBuffer, "%s", "{STAT:\"NOTFLUSHING\"}"); 01635 send_to_coordinator(fnode.dataBuffer); 01636 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01637 01638 } 01639 } 01640 break; 01641 01642 case FFGETSTAT: { 01643 01644 memset(fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01645 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01646 01647 // Filtrasyon JSON headırını yaz 01648 //sprintf(fnode.temporaryBuffer, "%s", json[0]); 01649 sprintf(fnode.temporaryBuffer, "%s", "{STAT:{"); 01650 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01651 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01652 01653 fnode.pressure = read_pressure(); 01654 fnode.dpPressure = read_pressure_dp(); 01655 01656 // 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 01657 // Giriş basıncı = Okunan basınç 01658 // Çıkış basıncı = Okunan basınç - Fark basınç 01659 if (fnode.pressureSensorPosition == 0) { 01660 01661 fnode.inletPressure = fnode.pressure; 01662 fnode.outletPressure = fnode.pressure - fnode.dpPressure; 01663 01664 if (fnode.outletPressure < 0) { 01665 01666 fnode.outletPressure = 0; 01667 01668 } 01669 01670 // 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 01671 // Giriş basıncı = Okunan basınç + Fark basınç 01672 // Çıkış basıncı = Okunan basınç 01673 } else { 01674 01675 fnode.inletPressure = fnode.pressure + fnode.dpPressure; 01676 fnode.outletPressure = fnode.pressure; 01677 01678 } 01679 01680 // Eğer basınç sensörü varsa 01681 if (fnode.systemSetup & (1 << 1)) { 01682 01683 // Basınç sensörü varken DP sensörü de mevcutsa hem giriş hem çıkış basıncını yaz 01684 if (fnode.systemSetup & (1 << 1)) { 01685 01686 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%.1f%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], fnode.outletPressure, ','); 01687 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01688 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01689 01690 // Basınç sensörü varken DP sensörü yoksa basınç sensörünün pozisyonuna göre giriş veya çıkış basıncını yaz 01691 } else { 01692 01693 // Basınç sensörü girişte ise giriş basıncını yaz, çıkış basıncı NULL olsun 01694 if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 0) { 01695 01696 sprintf(fnode.temporaryBuffer, "%s%.1f%c%s%s%c", jsonHeader[0], fnode.inletPressure, ',', jsonHeader[1], "null", ','); 01697 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01698 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01699 01700 // Basınç sensörü çıkışta ise çıkış basıncını yaz, giriş basıncı NULL olsun 01701 } else if (fnode.systemSetup & (1 << 1) && fnode.pressureSensorPosition == 1) { 01702 01703 sprintf(fnode.temporaryBuffer, "%s%s%c%s%.1f%c", jsonHeader[0], "null", ',', jsonHeader[1], fnode.outletPressure, ','); 01704 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01705 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01706 01707 } 01708 } 01709 01710 // Basınç sensörü yoksa giriş ve çıkış basınç değerleri NULL olsun 01711 } else { 01712 01713 sprintf(fnode.temporaryBuffer, "%s%s%c%s%s%c", jsonHeader[0], "null", ',', jsonHeader[1], "null", ','); 01714 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01715 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01716 } 01717 01718 // Eğer DP sensörü varsa DP verisini ekle 01719 if (fnode.systemSetup & (1 << 1)) { 01720 01721 sprintf(fnode.temporaryBuffer, "%s%.1f", jsonHeader[2], fnode.dpPressure); 01722 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01723 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01724 01725 // DP sensörü yoksa DP verisi NULL olsun 01726 } else { 01727 01728 sprintf(fnode.temporaryBuffer, "%s%s", jsonHeader[2], "null"); 01729 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01730 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01731 01732 } 01733 01734 01735 // Sulama durumu 01736 if (fnode.irrigation == true) { 01737 01738 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"IRR\""); 01739 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01740 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01741 01742 } else { 01743 01744 sprintf(fnode.temporaryBuffer, "%s", ",STAT:\"DRY\""); 01745 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01746 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01747 01748 } 01749 01750 // Yıkama durumu 01751 if (fnode.flushing == true) { 01752 01753 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:1"); 01754 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01755 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01756 01757 } else { 01758 01759 sprintf(fnode.temporaryBuffer, "%s", ",FSTAT:0"); 01760 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01761 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01762 01763 } 01764 01765 sprintf(fnode.temporaryBuffer, "%s", "},RT:1}"); 01766 01767 strcat(fnode.dataBuffer, fnode.temporaryBuffer); 01768 memset (fnode.temporaryBuffer, 0, sizeof(fnode.temporaryBuffer)); 01769 01770 send_to_coordinator(fnode.dataBuffer); 01771 memset (fnode.dataBuffer, 0, sizeof(fnode.dataBuffer)); 01772 01773 } 01774 break; 01775 01776 // Elle yıkamayı başlat 01777 case FLUSHNOW: { 01778 01779 // Eğer zaten yıkama varsa 01780 if(fnode.flushing == true) { 01781 01782 send_alarm(ALREADY_FLUSHING, fnode.globalFlushingFilter, fnode.currentWorkingSlave); 01783 01784 // Yıkama yoksa başla 01785 } else if (fnode.flushEnabled == 1 && fnode.errorOccured == false) { 01786 01787 periodicFlushTicker.detach(); 01788 fnode.periodicFlushCounter = 0; 01789 01790 fnode.flushing = true; 01791 fnode.flushStarted = true; 01792 fnode.checkDp = false; 01793 01794 minFlushTicker.detach(); 01795 fnode.minFlushCounter = 0; 01796 fnode.isMinTimePassed = false; 01797 01798 fnode.globalFlushPhase = 1; 01799 fnode.currentFlushPhase = 1; 01800 fnode.globalFlushingFilter = 1; 01801 fnode.currentFlushingFilter = 1; 01802 fnode.currentWorkingSlave = 0; 01803 01804 send_alarm(BACKFLUSH_MANUAL_STARTED, fnode.globalFlushingFilter, fnode.currentWorkingSlave); 01805 01806 } else if (fnode.flushEnabled == 0 && fnode.errorOccured == false) { 01807 01808 send_alarm(FLUSH_DISABLED, fnode.globalFlushingFilter, fnode.currentWorkingSlave); 01809 01810 } 01811 } 01812 break; 01813 } 01814 } 01815 01816 bool send_command(uint8_t _slaveid, uint8_t _command, uint8_t _filterid) 01817 { 01818 bool _ackinit = false; 01819 01820 if (_slaveid == MASTER_ID) { 01821 01822 if (_command == OPEN_SOLENOID || _command == TEST_OPEN_SOLENOID) { 01823 01824 if (open_solenoid(_filterid) == true) { 01825 01826 _ackinit = true; 01827 01828 } 01829 01830 } else if (_command == CLOSE_SOLENOID || _command == TEST_CLOSE_SOLENOID) { 01831 01832 if (close_solenoid(_filterid)) { 01833 01834 _ackinit = true; 01835 01836 } 01837 } 01838 01839 } else { 01840 01841 fnode.masterTxBuffer[0] = MASTER_ID; 01842 fnode.masterTxBuffer[1] = _slaveid; 01843 fnode.masterTxBuffer[2] = _command; 01844 fnode.masterTxBuffer[3] = _filterid; 01845 fnode.masterTxBuffer[4] = 0x0D; 01846 01847 for (uint8_t i = 0; i < sizeof(fnode.masterTxBuffer); i++) { 01848 01849 for (uint8_t j = 0; j < 3; j++) { 01850 01851 if (master.putc(fnode.masterTxBuffer[i]) == fnode.masterTxBuffer[i]) { 01852 01853 _ackinit = true; 01854 01855 } else { 01856 01857 _ackinit = false; 01858 01859 } 01860 01861 if (_ackinit == true) { 01862 01863 break; 01864 01865 } 01866 } 01867 01868 if (_ackinit == false) { 01869 01870 break; 01871 01872 } 01873 } 01874 01875 // Slave'den cevap tamamlanıncaya/gelinceye kadar bekle (ISR ile tamamlanır) 01876 while (fnode.masterInterruptComplete != true) {} 01877 01878 if (fnode.masterInterruptComplete == true) { 01879 01880 if (fnode.masterRxBuffer[0] == _OK_) { 01881 01882 _ackinit = true; 01883 01884 } else { 01885 01886 _ackinit = false; 01887 01888 } 01889 } 01890 01891 01892 memset (fnode.masterRxBuffer, 0, sizeof(fnode.masterRxBuffer)); 01893 master.attach(&master_rx_isr, Serial::RxIrq); 01894 01895 fnode.masterInterruptComplete = false; 01896 } 01897 01898 return _ackinit; 01899 } 01900 01901 // Data aktarım ISR 01902 void data_transmit_isr() 01903 { 01904 fnode.transmitData = true; 01905 } 01906 01907 // RF Rx ISR 01908 void rf_rx_isr() 01909 { 01910 fnode.rfBufferChar = rf.getc(); 01911 01912 if (fnode.rfBufferChar != '\r') { 01913 01914 fnode.rfBuffer[fnode.rfBufferCounter] = fnode.rfBufferChar; 01915 fnode.rfBufferCounter++; 01916 01917 } else if (fnode.rfBufferChar == '\r') { 01918 01919 rf.attach(NULL, Serial::RxIrq); 01920 fnode.rfBufferCounter = 0; 01921 fnode.rfInterruptComplete = true; 01922 } 01923 } 01924 01925 void master_rx_isr() 01926 { 01927 fnode.masterBufferChar = master.getc(); 01928 01929 if (fnode.masterBufferChar != '\r') { 01930 01931 fnode.masterRxBuffer[fnode.masterBufferCounter] = fnode.masterBufferChar; 01932 fnode.masterBufferCounter++; 01933 01934 } else if (fnode.masterBufferChar == '\r') { 01935 01936 master.attach(NULL, Serial::RxIrq); 01937 fnode.masterBufferCounter = 0; 01938 fnode.masterInterruptComplete = true; 01939 } 01940 } 01941 01942 // Sayaç pals ISR 01943 void watermeter_isr() 01944 { 01945 fnode.pulse ++; 01946 fnode.pulseTransmit ++; 01947 fnode.pulsePressureCheck ++; 01948 } 01949 01950 // Yıkama fazı değişim ISR 01951 void flush_phase_isr() 01952 { 01953 fnode.flush_isr = true; 01954 } 01955 01956 // Basınç kontrol ISR 01957 void pressure_check_isr() 01958 { 01959 fnode.checkPressure = true; 01960 } 01961 01962 void periodic_flush_isr() 01963 { 01964 fnode.periodicFlushCounter ++; 01965 } 01966 01967 void min_flush_interval_isr() 01968 { 01969 fnode.minFlushCounter ++; 01970 } 01971 01972 void rt_data_transmit_isr() 01973 { 01974 fnode.transmit_rtData = true; 01975 fnode.rtCounter ++; 01976 } 01977 #endif
Generated on Sat Jul 16 2022 01:21:54 by
1.7.2