BAB V KESIMPULAN DAN SARAN
5.2 Saran
Saran untuk pengembangan Sistem Sinkronisasi Jam Digital Nirkabel adalah sebagai berikut:
1. Melakukan pengujian dengan variabel jarak pada modul transceiver yang akan digunakan.
2. Pembuatan algoritma pemrograman yang lebih baik, sehingga sistem dapat menangani kesalahan saat data waktu pada subsistem slave tidak diterima oleh subsistem master.
77
[1-37]
DAFTAR PUSTAKA
[1] Tim Penyusun, 2008, Kamus Bahasa Indonesia, Pusat Bahasa Departemen Pendidikan Nasional, Jakarta.
[2] Mumford, B., 2002, The Eureka Clock and how to improve it, http://www.bmumford.com/clocks/eureka/eureka.html, diakses 15 Februari 2011. [3] ---, 2007, Intel® ICH Family Real Time Clock (RTC) Accuracy and
Considerations under Test Conditions, Intel.
[4] Ariyanto, E., Yulianto, F. A., dan Brotohars, T., 2010, Sinkronisasi Jam Digital, http://www.ittelkom.ac.id/soppii/index.php, diakses 23 September 2010.
[5] ---, 2008, Datasheet nRF24L01, Nordic Semiconductor.
[6] Hainan, L., dan Zhiqiang, L., 2009, Design Wireless Data Transmission System for Small Hydropower Stations Based on nRF24L01, ICISE 2009 First International Conference on Information Science and Engineering, hal. 4008-4010.
[7] Idris, R., dan Sasmita, P. E., 2008, Perancangan dan Pembuatan Jam Digital Tersinkronisasi secara Otomatis, Program Studi D3 Teknik Elektro, Institut Teknologi Sepuluh Nopember.
[8] Syamsi, M. N., 2005, Penampil Jamak Jam Digital Berbasis Mikrokontroller AT89C2051 Menggunakan Komunikasi Serial, Program Studi Teknik Elektro, Universitas Sanata Dharma.
[9] Palungkun, E. S. F. W., 2009, Jam dan Alarm Sekolah Berbasis Mikrokontroler ATMEGA 16, Program Studi Teknik Elektro, Universitas Sanata Dharma.
[10] Sukaridhoto, S., 2007, Implementasi Sinkronisasi Adzan Masjid, Politeknik Elektronika Negeri Surabaya, Institut Teknologi Sepuluh Nopember.
[11] Padkipsky, M. A., 1982, A Perspective on The Arpanet Reference Model, http://tools.ietf.org/html/rfc871, diakses 2 Oktober 2010.
[12] Martinec, M., 2000, Time with Focus on NTP and Slovenia, http://www.ntp.org/, diakses 2 Oktober 2010.
[13] Mellis, D. A., 2008, Arduino Duemilanove,
http://arduino.cc/en/Main/ArduinoBoardDuemilanove, diakses 5 Oktober 2010. [14] Hidayatullah, S., dan Pirngadi, H., 2009, Rancang Bangun Counter Product Logger
(CP Logger) Menggunakan Sensor Infrared Berbasis Internet, Jurusan Teknik Elektro, Institut Teknologi Sepuluh Nopember.
[15] ---, 2009, Datasheet ATmega48PA/88PA/168PA/328P, Atmel.
[16] Sanandra, R., 2009, Perancangan Stand Alone RFID Reader untuk Aplikasi Sistem Keamanan Pintu, Jurusan Teknik Elektro, Universitas Komputer Indonesia.
[17] ---, 2010, AVR042: AVR Hardware Design Considerations, Atmel. [18] ---, 2008, Datasheet DS1307, Dallas Semiconductor.
[19] Pasaribu, T., 2010, Perancangan Software Jam Digital dengan Sistem Kalender Berbasis Mikrokontroller DS1307, Program Studi Diploma III Fisika Instrumentasi, Universitas Sumatera Utara.
[20] Yuansheng, L., 2010, Analysis of the Maximal Transmission Rate Based on NRF24L01 Chip System, Information Engineering and Computer Science (ICIECS), 2010 2nd International Conference on, hal. 1-3.
[21] Kumar, V., Sonavane, S. S., dan Patil, B. P., 2009, Designing Ultra Low Power Wireless Sensor Network with TCP/IP link, Adaptive Science & Technology, 2009. ICAST 2009. 2nd International Conference on, hal. 86 - 91.
[22] Zhoua, Y., Yuana, Y., Gaob, J., Yanga, L., Zhangb, F., Zhub, G., dan Gaob, X., 2010, An Implanted Closed-loop Chip System for Heart Rate Control: System Design and Effects in Conscious Rats, Journal of Biomedical Research, vol. 24, hal. 107-114.
[23] Gilb, J. P. K., 2005, The IEEE Wireless Dictionary, Standards Information Network IEEE Press, New York - USA.
[24] Chang, D. C., 2009, Least Squares/Maximum Likelihood Methods for the Decision-Aided GFSK Receiver, IEEE SIGNAL PROCESSING LETTERS, vol. 16, no. 6, hal. 517-520.
[25] Gast, M., 2005, 802.11® Wireless Networks: The Definitive Guide, Second Edition, O'Reilly Media, Inc., California.
[26] Agung, I. G. A. P. R., dan Suryawan, K. A., 2007, Perancangan dan Realisasi Penghitung Frekuensi Detak Jantung Berbasis Mikrokontroler AT89S52, Majalah Ilmiah Teknologi Elektro Universitas Udayana, vol. 6, no. 2, hal. 13-19.
[27] ---, 2007, Datasheet LCD LMB162AFC, Shenzhen Topway Technology Co., Ltd.
[28] GrahaTunasMuda, 2011, Character LCD 16x2 Blue Topway,
http://grahatm.blogspot.com/2011/01/character-lcd-16x2-blue-topway.html, diakses Februari 2011.
[29] ---, 2004, Datasheet 74HC595; 74HCT595, Philips Semiconductor. [30] Octovhiana, K. D., 2003, Cepat Mahir Visual Basic 6,
http://ilmukomputer.org/2008/11/25/cepat-mahir-visual-basic-6/, diakses Februari 2011.
[31] ---, 2011, What is Unix time?, http://unixtime.info/, diakses September 2011. [32] ---, 2010, Transceiver nRF24L01+ Module with Chip Antenna,
http://www.sparkfun.com/datasheets/Wireless/Nordic/nRF24L01-Chip-v11.pdf, diakses Maret 2011.
[33] ---, 2003, A733 PNP Epitaxial Silicon Transistor, Elite Enterprises. [34] Rijmenants, D., 2004, [Time Synchronizer],
http://www.planet-source-code.com/vb/scripts/ShowZip.asp?lngWId=1&lngCodeId=56177&strZipAccessCo de=tp%2F%5B561771710, diakses Oktober 2010.
[35] [email protected], tanggal 5 Juli 2011.
[36] PuslitKIM-LIPI, 2006, Network Time Protocol (NTP), http://ntp.kim.lipi.go.id/, diakses September 2011.
[37] ---, 2001, APPLICATION NOTE 58 Crystal Considerations with Dallas Real-Time Clocks (RTCs), MAXIM.
79
L.1 Rangkaian Elektronik
L
TABEL
Tabel 1 Pengamatan pada ruang tertutup metode penskalaan
Slave 1 Slave 2
Se l i si h* Se l i si h*
Slave 1 Slave 2 Slave 1 Slave 2 (de ti k) (de ti k)
10 : 50 : 28 10 : 59 : 0 U315393140 V315393140 11 : 1 : 14 U315393273 -1 11 : 2 : 14 U315393333 -1 11 : 3 : 0 U315393380 V315393380 11 : 5 : 14 U315393513 -1 11 : 6 : 15 U315393573 -2 11 : 7 : 0 U315393620 V315393620 11 : 9 : 14 U315393753 -1 11 : 10 : 14 U315393813 -1 11 : 11 : 0 U315393860 V315393860 11 : 13 : 14 U315393993 -1 11 : 14 : 14 U315394053 -1 11 : 15 : 0 U315394100 V315394100 11 : 17 : 15 U315394233 -2 11 : 18 : 15 U315394293 -2 11 : 19 : 0 U315394340 V315394340 11 : 21 : 14 U315394473 -1 11 : 22 : 14 U315394533 -1
Lokasi p engambilan data: Jl.Kanigoro 224, Pomahan, M aguwoharjo, Sleman, Yogy akarta. Subsistem master
diletakkan di ruang y ang bersebelahan dengan subsistem slave 1 dan slave 2. M etode Pengamatan : Penskalaan
waktu mulai pengambilan data
Kondisi ruangan: Ruang tertutup
jarak subsistem master dengan subsistem slave 1 : + 1 meter jarak subsistem master dengan subsistem slave 2 : + 1,5 meter
Timeline (Master)
Master
Kirim Data (ke) Terima Data (dari)
Denah Lokasi Pengamatan:
subsistem slave 1 dan slave 2 diletakkan p ada ruang y ang sama
Tabel 2 Pengamatan pada ruang terbuka metode penskalaan
Slave 1 Slave 2
Se l i si h* Se l i si h*
Slave 1 Slave 2 Slave 1 Slave 2 (de ti k) (de ti k) 12 : 24 : 2 12 : 29 : 0 U315398540 V315398540 12 : 30 : 21 V315398618 -3 12 : 31 : 15 U315398673 -2 12 : 32 : 15 U315398733 -2 12 : 32 : 21 V315398738 -3 12 : 33 : 0 U315398780 V315398780 12 : 37 : 0 U315399020 V315399020 12 : 40 : 16 U315399213 -3 12 : 40 : 20 V315399218 -2 12 : 41 : 0 U315399260 U315399260 12 : 43 : 14 U315399393 -1 12 : 44 : 14 U315399453 -1 12 : 45 : 0 U315399501 V315399501 12 : 48 : 14 U315399693 -1 12 : 49 : 0 U315399740 V315399740 12 : 51 : 15 U315399873 -2 12 : 52 : 15 U315399933 -2
Ket: *: Selisih adalah waktu antara subsistem master dan subsistem slave Kondisi ruangan: Ruang terbuka (LOS) jarak + 10 meter
Timeline (Master)
Master
Kirim Data (ke) Terima Data (dari)
Lokasi pengambilan data: Jl.Kanigoro 224, Pomahan, M aguwoharjo, Sleman, Yogyakarta.
Tabel 3 Pengamatan pada ruang terbuka metode penskalaan dengan jendela terbuka
Slave 1 Slave 2
Se l i si h* Se l i si h*
Slave 1 Slave 2 Slave 1 Slave 2 (de ti k) (de ti k) 17 : 31 : 45 17 : 32 : 0 U314639120 V314639120 17 : 34 : 20 V314639258 -2 17 : 35 : 20 V314639318 -2 17 : 36 : 0 U314639360 V314639360 17 : 39 : 14 U314639553 -1 17 : 40 : 0 U314639600 V314639600 17 : 42 : 14 U314639733 -1 17 : 43 : 14 U314639793 -1 17 : 44 : 0 U314639840 V314639840 17 : 46 : 17 U314639973 -3 17 : 47 : 17 U314640033 -3 17 : 48 : 1 U314640081 V314640081 17 : 50 : 14 U314640213 -1 17 : 51 : 14 U314640273 -1
Ket: *: Selisih adalah waktu antara subsistem master dan subsistem slave
waktu mulai pengambilan data
Timeline (Master)
Master
Kirim Data (ke) Terima Data (dari) Lokasi pengambilan data: Ruang Tugas Akhir
Library Arduino diunduh dari
1. Time.h, TimeAlarms.h, DS1307RTC.h diunduh di http://www.arduino.cc/playground/Code/Time
2. Mirf.h, nRF24L01.h, MirfHardwareSpiDriver.h diunduh di www.arduino.cc/playground/InterfacingWithHardware/Nrf24L01 3. EEPROM.h, LiquidCrystal.h, SPI.h sudah
Urutan Lampiran pada Source Code adalah sebagai berikut: 1. Program Arduino untuk subsistem master
2. Program Arduino untuk subsistem slave 1 3. Program Arduino untuk subsistem slave 2 4. Program GUI (Form wireLessClockSync.frm) 5. Program GUI (Module modMain.bas)
6. Program GUI (Module RS232.bas)
1 /*
2 ###################################################################### ###
3 ### Many Thanks To:
4 ### ARDUINO TEAM
5 # <Time.h>, <TimeAlarms.h>, <DS1307RTC.h> : Michael Margolis [Mem]
6 # <Mirf.h>, <MirfHardwareSpiDriver.h> : Aaron Shrimpton [Aaronds]
7 # <nRF24L01.h> : Stefan Engelke
8 ###################################################################### ###
9 * FINAL PROJECT : SINKRONISASI JAM DIGITAL NIRKABEL
10 [WIRELESS SYNCHRONISATION on DIGITAL CLOCK]
11 * AUTHOR : NUGROHO BUDI WICAKSONO
12 * LAST MODIFIED : SEPT, 12 2011
13 * PROGRAM NAME : WiSyncMaster.pde
14 * BOARD : UNO
15 * IDE VERSION : ALPHA (022)
16 * HARDWARE REQ. : RTC DS1307, nRF24L01+, LCD 17 ###################################################################### ### 18 */ 19 #include <Time.h> 20 #include <TimeAlarms.h> 21 #include <Wire.h> 22 #include <DS1307RTC.h> 23 #include <EEPROM.h> 24 #include <LiquidCrystal.h> 25 #include <SPI.h> 26 #include <Mirf.h> 27 #include <nRF24L01.h> 28 #include <MirfHardwareSpiDriver.h> 29 #include "stdlib.h" 30 LiquidCrystal lcd(7, 8, 2, 3, 4, 5); 31 //variables for RTC Function
32 #define TIME_MSG_LEN 11
33 #define TIME_HEADER 'T'
34 //variables for Interval Alarm Function
35 #define DATA_INTERVAL 25
36 #define INT_SLAVE 'I'
37 //variables for Exact Time Alarm Function
38 #define DATA_EXACT1 25 // ROOM 1
39 #define EXACT_SLAVE1 'A' // ROOM 1
40 #define DATA_EXACT2 25 // ROOM 2
41 #define EXACT_SLAVE2 'B' // ROOM 2
42 //variable for Testing
43 #define OTHERS 'O'
44 //===========end============
45 //internal mode Alarm for ROOM 1
46 byte hourStart1 = 0; 47 byte minuteStart1 = 0; 48 byte hourStop1 = 0;
49 byte minuteStop1 = 0; 50 byte hourInterval1 = 0; 51 byte minuteInterval1 = 0;
52 unsigned long s1intTime; //slave 1 interval calculation
53 //internal mode Alarm for ROOM 2
54 byte hourStart2 = 0; 55 byte minuteStart2 = 0; 56 byte hourStop2 = 0; 57 byte minuteStop2 = 0; 58 byte hourInterval2 = 0; 59 byte minuteInterval2 = 0;
60 unsigned long s2intTime; //slave 2 interval calculation
61 //=================================================
62 //exactTime mode Alarm for ROOM 1
63 byte exactHour1Slave1 = 0; //HOUR EXACTtime 1 ROOM 1
64 byte exactMinute1Slave1 = 0; //MINUTE EXACTtime 1 ROOM 1
65 byte exactHour2Slave1 = 0; //HOUR EXACTtime 2 ROOM 1
66 byte exactMinute2Slave1 = 0; //MINUTE EXACTtime 2 ROOM 1
67 byte exactHour3Slave1 = 0; //HOUR EXACTtime 3 ROOM 1
68 byte exactMinute3Slave1 = 0; //MINUTE EXACTtime 3 ROOM 1
69 byte exactHour4Slave1 = 0; //HOUR EXACTtime 4 ROOM 1
70 byte exactMinute4Slave1 = 0; //MINUTE EXACTtime 4 ROOM 1
71 byte exactHour5Slave1 = 0; //HOUR EXACTtime 5 ROOM 1
72 byte exactMinute5Slave1 = 0; //MINUTE EXACTtime 5 ROOM 1
73 byte exactHour6Slave1 = 0; //HOUR EXACTtime 6 ROOM 1
74 byte exactMinute6Slave1 = 0; //MINUTE EXACTtime 6 ROOM 1
75 //===========end===========
76 //exactTime mode Alarm for ROOM 2
77 byte exactHour1Slave2 = 0; //HOUR EXACTtime 1 ROOM 2
78 byte exactMinute1Slave2 = 0; //MINUTE EXACTtime 1 ROOM 2
79 byte exactHour2Slave2 = 0; //HOUR EXACTtime 2 ROOM 2
80 byte exactMinute2Slave2 = 0; //MINUTE EXACTtime 2 ROOM 2
81 byte exactHour3Slave2 = 0; //HOUR EXACTtime 3 ROOM 2
82 byte exactMinute3Slave2 = 0; //MINUTE EXACTtime 3 ROOM 2
83 byte exactHour4Slave2 = 0; //HOUR EXACTtime 4 ROOM 2
84 byte exactMinute4Slave2 = 0; //MINUTE EXACTtime 4 ROOM 2
85 byte exactHour5Slave2 = 0; //HOUR EXACTtime 5 ROOM 2
86 byte exactMinute5Slave2 = 0; //MINUTE EXACTtime 5 ROOM 2
87 byte exactHour6Slave2 = 0; //HOUR EXACTtime 6 ROOM 2
88 byte exactMinute6Slave2 = 0; //MINUTE EXACTtime 6 ROOM 2
89 //===========end===========
90 //variables for EEPROMread
91 int address = 200; 92 byte value;
93 //===========end===========
94 //variables for MiRF
95 int count, txORrx; //slave 1
96 char dataSend[11]; //slave 1
97 char dataRecieve[11]; //slave 1
98 byte positive1; //slave 1
100
101 unsigned long substract1; //slave 1
102 unsigned long substract2; //slave 2
103 //===========end===========
104 //==================================================== ALARM ID ====================================================
105 AlarmID_t intervalStart1, intervalStop1, intervalTimer1; //ID for interval Slave 1
106 AlarmID_t intervalStart2, intervalStop2, intervalTimer2; //ID for interval Slave 2
107 AlarmID_t slave1Time1, slave1Time2, slave1Time3, slave1Time4, slave1Time5, slave1Time6; //ID for exacted Time Slave 1
108 AlarmID_t slave2Time1, slave2Time2, slave2Time3, slave2Time4, slave2Time5, slave2Time6; //ID for exacted Time Slave 2
109 AlarmID_t startCount60, everyHourAlarm; //alarm to Sending RTC time to Slave
110 //=======================================================end========== ==============================================
111
112 //==================================================================== ================ SETUP SETUP SETUP SETUP SETUP
113 void setup(){ 114 Serial.begin(9600); 115 lcd.begin(16,2); 116 setSyncProvider(RTC.get); 117 setSyncInterval(600); 118 if(timeStatus()!= timeSet)
119 lcd.println("Can't sync RTC! "); 120 else
121 lcd.println(" Can sync RTC! "); 122 delay(600);
123 //====== Alarm inialisation. INTERVAL MODE ALARM
124 byte h1Start = EEPROM.read (200); //hourEEPROM ==>1//START HOUR
125 byte m1Start = EEPROM.read (201); //minuteEEPROM ==>1//START MINUTE
126 byte h1Stop = EEPROM.read (202); //hourEEPROM ==>1//STOP HOUR
127 byte m1Stop = EEPROM.read (203); //minuteEEPROM ==>1//STOP MINUTE
128 byte h1Int = EEPROM.read (204); //hourEEPROM ==>1//INTERVAL HOUR
129 byte m1Int = EEPROM.read (205); //minuteEEPROM ==>1//INTERVAL MINUTE
130 byte h2Start = EEPROM.read (206); //hourEEPROM ==>2//START HOUR
131 byte m2Start = EEPROM.read (207); //minuteEEPROM ==>2//START MINUTE
132 byte h2Stop = EEPROM.read (208); //hourEEPROM ==>2//STOP HOUR
133 byte m2Stop = EEPROM.read (209); //minuteEEPROM ==>2//STOP MINUTE
134 byte h2Int = EEPROM.read (210); //hourEEPROM ==>2//INTERVAL HOUR
135 byte m2Int = EEPROM.read (211); //minuteEEPROM ==>2//INTERVAL MINUTE
136 //ROOM 1
137 intervalStart1 = Alarm.alarmRepeat(h1Start, m1Start, 3, enableAlarm1); //==start alarm mode interval room 1
138 intervalStop1 = Alarm.alarmRepeat(h1Stop, m1Stop, 30, disableAlarm1); //==stop alarm mode interval room 1
139 s1intTime = m1Int + (h1Int * 60);
140 intervalTimer1 = Alarm.timerRepeat( s1intTime * SECS_PER_MIN, doRingAlarm1 );
141 Alarm.disable(intervalTimer1); 142 //ROOM 2
143 intervalStart2 = Alarm.alarmRepeat(h2Start, m2Start, 8, enableAlarm2); //==start alarm mode interval room 2
144 intervalStop2 = Alarm.alarmRepeat(h2Stop, m2Stop, 30, disableAlarm2); //==stop alarm mode interval room 2
145 s2intTime = m2Int + (h2Int * 60);
146 intervalTimer2 = Alarm.timerRepeat( s2intTime * SECS_PER_MIN, doRingAlarm2 );
147 Alarm.disable(intervalTimer2); 148
149 //====== Alarm inialisation. EXACTTIME MODE ALARM
150 //ROOM 1
151 byte h1Slave1 = EEPROM.read (171); //hourEEPROM ==> HOUR 1 SLAVE 1
152 byte m1Slave1 = EEPROM.read (172); //minuteEEPROM ==> MINUTE 1 SLAVE 1
153 byte h2Slave1 = EEPROM.read (173); //hourEEPROM ==> HOUR 2 SLAVE 1
154 byte m2Slave1 = EEPROM.read (174); //minuteEEPROM ==> MINUTE 2 SLAVE 1
155 byte h3Slave1 = EEPROM.read (175); //hourEEPROM ==> HOUR 3 SLAVE 1
156 byte m3Slave1 = EEPROM.read (176); //minuteEEPROM ==> MINUTE 3 SLAVE 1
157 byte h4Slave1 = EEPROM.read (177); //hourEEPROM ==> HOUR 4 SLAVE 1
158 byte m4Slave1 = EEPROM.read (178); //minuteEEPROM ==> MINUTE 4 SLAVE 1
159 byte h5Slave1 = EEPROM.read (179); //hourEEPROM ==> HOUR 5 SLAVE 1
160 byte m5Slave1 = EEPROM.read (180); //minuteEEPROM ==> MINUTE 5 SLAVE 1
161 byte h6Slave1 = EEPROM.read (181); //hourEEPROM ==> HOUR 6 SLAVE 1
162 byte m6Slave1 = EEPROM.read (182); //minuteEEPROM ==> MINUTE 6 SLAVE 1
163 slave1Time1 = Alarm.alarmRepeat(h1Slave1, m1Slave1, 3, doRingAlarm1);
164 slave1Time2 = Alarm.alarmRepeat(h2Slave1, m2Slave1, 3, doRingAlarm1);
165 slave1Time3 = Alarm.alarmRepeat(h3Slave1, m3Slave1, 3, doRingAlarm1);
166 slave1Time4 = Alarm.alarmRepeat(h4Slave1, m4Slave1, 3, doRingAlarm1);
167 slave1Time5 = Alarm.alarmRepeat(h5Slave1, m5Slave1, 3, doRingAlarm1);
168 slave1Time6 = Alarm.alarmRepeat(h6Slave1, m6Slave1, 3, doRingAlarm1);
169
170 //ROOM 2
171 byte h1Slave2 = EEPROM.read (183); //hourEEPROM ==> HOUR 1 SLAVE 2
172 byte m1Slave2 = EEPROM.read (184); //minuteEEPROM ==> MINUTE 1 SLAVE 2
173 byte h2Slave2 = EEPROM.read (185); //hourEEPROM ==> HOUR 2 SLAVE 2
174 byte m2Slave2 = EEPROM.read (186); //minuteEEPROM ==> MINUTE 2 SLAVE 2
175 byte h3Slave2 = EEPROM.read (187); //hourEEPROM ==> HOUR 3 SLAVE 2
176 byte m3Slave2 = EEPROM.read (188); //minuteEEPROM ==> MINUTE 3 SLAVE 2
177 byte h4Slave2 = EEPROM.read (189); //hourEEPROM ==> HOUR 4 SLAVE 2
178 byte m4Slave2 = EEPROM.read (190); //minuteEEPROM ==> MINUTE 4 SLAVE 2
179 byte h5Slave2 = EEPROM.read (191); //hourEEPROM ==> HOUR 5 SLAVE 2
180 byte m5Slave2 = EEPROM.read (192); //minuteEEPROM ==> MINUTE 5 SLAVE 2
181 byte h6Slave2 = EEPROM.read (193); //hourEEPROM ==> HOUR 6 SLAVE 2
182 byte m6Slave2 = EEPROM.read (194); //minuteEEPROM ==> MINUTE 6 SLAVE 2
183 slave2Time1 = Alarm.alarmRepeat(h1Slave2, m1Slave2, 8, doRingAlarm2);
184 slave2Time2 = Alarm.alarmRepeat(h2Slave2, m2Slave2, 8, doRingAlarm2);
185 slave2Time3 = Alarm.alarmRepeat(h3Slave2, m3Slave2, 8, doRingAlarm2);
186 slave2Time4 = Alarm.alarmRepeat(h4Slave2, m4Slave2, 8, doRingAlarm2);
187 slave2Time5 = Alarm.alarmRepeat(h5Slave2, m5Slave2, 8, doRingAlarm2);
188 slave2Time6 = Alarm.alarmRepeat(h6Slave2, m6Slave2, 8, doRingAlarm2);
189
190 //disabling alarm for slave 1 mode Interval
191 if (h1Start == 65 && m1Start == 65){ 192 Alarm.disable(intervalStart1); 193 Alarm.disable(intervalStop1);
194 Serial.println ("INT Slave 1 disabled"); 195 }
196 //disabling alarm for slave 2mode Interval
197 if (h2Start == 65 && m2Start == 65){ 198 Alarm.disable(intervalStart2); 199 Alarm.disable(intervalStop2);
200 Serial.println ("INT Slave 2 disabled"); 201 }
202 //disabling alarm for slave 1 mode ExactTime =============================
203 if (h1Slave1 == 65 && m1Slave1 == 65){//alarm 1 slave 1
204 Alarm.disable(slave1Time1);
205 Serial.println ("JT Slave 1 ID 1 disabled"); 206 }
207 if (h2Slave1 == 65 && m2Slave1 == 65){//alarm 2 slave 1
208 Alarm.disable(slave1Time2);
209 Serial.println ("JT Slave 1 ID 2 disabled"); 210 }
211 if (h3Slave1 == 65 && m3Slave1 == 65){//alarm 3 slave 1
212 Alarm.disable(slave1Time3);
213 Serial.println ("JT Slave 1 ID 3 disabled"); 214 }
215 if (h4Slave1 == 65 && m4Slave1 == 65){//alarm 4 slave 1
216 Alarm.disable(slave1Time4);
217 Serial.println ("JT Slave 1 ID 4 disabled"); 218 }
219 if (h5Slave1 == 65 && m5Slave1 == 65){//alarm 5 slave 1
220 Alarm.disable(slave1Time5);
221 Serial.println ("JT Slave 1 ID 5 disabled"); 222 }
223 if (h6Slave1 == 65 && m6Slave1 == 65){//alarm 6 slave 1
224 Alarm.disable(slave1Time6);
225 Serial.println ("JT Slave 1 ID 6 disabled"); 226 }
227 //disabling alarm for slave 2 mode ExactTime =============================
228 if (h1Slave2 == 65 && m1Slave2 == 65){//alarm 1 slave 2
229 Alarm.disable(slave2Time1);
230 Serial.println ("JT Slave 2 ID 1 disabled"); 231 }
232 if (h2Slave2 == 65 && m2Slave2 == 65){//alarm 2 slave 2
233 Alarm.disable(slave2Time2);
234 Serial.println ("JT Slave 2 ID 2 disabled"); 235 }
236 if (h3Slave2 == 65 && m3Slave2 == 65){//alarm 3 slave 2
237 Alarm.disable(slave2Time3);
238 Serial.println ("JT Slave 2 ID 3 disabled"); 239 }
240 if (h4Slave2 == 65 && m4Slave2 == 65){//alarm 4 slave 2
241 Alarm.disable(slave2Time4);
243 }
244 if (h5Slave2 == 65 && m5Slave2 == 65){//alarm 5 slave 2
245 Alarm.disable(slave2Time5);
246 Serial.println ("JT Slave 2 ID 5 disabled"); 247 }
248 if (h6Slave2 == 65 && m6Slave2 == 65){//alarm 6 slave 2
249 Alarm.disable(slave2Time6);
250 Serial.println ("JT Slave 2 ID 6 disabled"); 251 }
252
253 time_t curr_time = now();
254 int everyHour = hour(curr_time); 255 everyHour += 1; //should be
uncommented!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
256 // int everyMinute = minute(curr_time); // unused,just for testing
257 // everyMinute = everyMinute + 1; // unused,just for testing
258 startCount60 = Alarm.alarmOnce(everyHour, 00, 10, enableEveryHour ); // should be Alarm.alarmOnce(everyHour, 00, 00,
enableEveryHour, for testing : everyHour, everyMinute, 00, enableEveryHour)
259 everyHourAlarm = Alarm.timerRepeat( 60 * SECS_PER_MIN, sendDataToSlave); // should be repeat every 60 minutes!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
260 Alarm.disable(everyHourAlarm); 261
262 pinMode(9, OUTPUT); 263 digitalWrite(9,HIGH); 264
265 Serial.print(hour()); 266 Serial.print(":"); 267 Serial.print(minute()); 268 Serial.print(":");
269 Serial.println(second()); 270 lcd.clear();
271 digitalWrite(9, HIGH); //Alarm Inisialitation
272
//================================================================== ====== SETTING THE MiRF
273 Mirf.cePin = 6; //CE pin Setup
274 Mirf.csnPin = 10; //CSN pin Setup
275 Mirf.spi = &MirfHardwareSpi; 276 Mirf.init();
277 Mirf.setRADDR((byte *)"mast1"); 278 Mirf.payload = 11;
279 Mirf.channel = 110; 280 Mirf.config(); 281
== end SETTING THE MiRF
282 // Serial.println("Beginning ... ");
283 checkAlarm(); //check the Alarms, please..dont delete this line,this line just to check the alarms
284 Serial.println("Setup is DONE"); 285 positive1 = 2;
286 positive2 = 2;
287 pinMode(A1, INPUT); //inisialisastion of SEND BUTTON
288 }//setup
289
290 //==================================================================== ===================== LOOP LOOP LOOP LOOP LOOP
291 void loop(){
292 masterMiRFlooping(); 293 Alarm.delay(0);
294 if(Serial.available()) 295 {
296 char header = Serial.read(); 297 if (header == TIME_HEADER) 298 processSyncMessage();
299 else if (header == INT_SLAVE) 300 Interval();
301 else if (header == EXACT_SLAVE1) 302 exactTimeSlave1();
303 else if (header == EXACT_SLAVE2) 304 exactTimeSlave2();
305 else if (header == OTHERS) 306 BlinkBlink();
307 }
308 // checkAlarm(); //check the Alarms, please..dont delete this line,this line just to check the alarms
309 masterMiRFlooping(); 310 digitalClockDisplay(); 311 masterMiRFlooping(); 312 showLine2(); 313 delay(1000); 314 masterMiRFlooping();
315 manualSEND(); //new feature
316 // checkAlarmValue(); //like setup again
317 }//loop
318 void manualSEND(){
319 int BUTTON = digitalRead(A1); 320 if (BUTTON == LOW){ 321 sendDataToSlave(); 322 } 323 else{ 324 } 325 }//manualSEND
326 /*============================= receive serial data from VB =============================*/
==========================//
328 void processSyncMessage(){ 329 time_t pctime = 0;
330 while (Serial.available() > TIME_MSG_LEN); 331 for(int i=0; i < TIME_MSG_LEN -1; i++) 332 {
333 char c = Serial.read(); 334 if( c >= '0' && c <= '9'){ 335 pctime = (10 * pctime) + (c - '0'); 336 } 337 } 338 time_t t = pctime; 339 RTC.set(t); 340 setTime(t); 341 }//processSyncMessage 342
343 /*==================== CHECKing DATA from SLAVE =================*/
344 //=================================================================
345 void masterMiRFlooping(){ 346 dataRecieve[Mirf.payload]; 347 //Receive from master
348 if(!Mirf.isSending() && Mirf.dataReady()){ 349 Serial.print("MASTER GOT PACKET : "); 350 Mirf.getData((byte *) dataRecieve);
351 if (count == 0 && dataRecieve[0] == 'U'){ //RTC data from SLAVE 1 = U
352 time_t slave1Time = 0; 353 dataRecieve[0] = '1'; 354 count = 1;
355 for (count = 1; count < 11; count++) { 356 char c = dataRecieve[count];
357 Serial.print(c); 358 if( c >= '0' && c <= '9'){ 359 slave1Time = (10 * slave1Time) + (c - '0'); 360 } 361 } 362 slave1Time = slave1Time + 1000000000;
363 Serial.print ("||| this is SLAVE 1 unixTime : "); 364 Serial.print (slave1Time);
365 Serial.println (""); 366
367 unsigned long slave1RecTime = slave1Time; 368 unsigned long masterRecTime = now(); 369 unsigned long resultRecTime;
370
371 if (masterRecTime > slave1RecTime){
372 resultRecTime = masterRecTime - slave1RecTime; 373 substract1 = resultRecTime;
374 positive1 = 0; 375 }
377 resultRecTime = slave1RecTime - masterRecTime; 378 substract1 = resultRecTime;
379 positive1 = 1; 380 }
381 else if (masterRecTime = slave1RecTime){ 382 resultRecTime = 0;
383 substract1 = 0; 384 positive1 = 2; 385 }
386 count = 0;
387 Serial.print ("this is the substraction result : "); 388 Serial.print (substract1);
389 Serial.println("");
390 Serial.println ("RTC's TIME Slave 1 has been calculated"); 391 Serial.println("");
392 bip(); 393 }
394 else if (count == 0 && dataRecieve[0] == 'V'){ //data from SLAVE 2, header = 'V'
395 time_t slave2Time = 0; 396 dataRecieve[0] = '1'; 397 count = 1;
398 for (count = 1; count < 11; count++) { 399 char c = dataRecieve[count];
400 Serial.print(c); 401 if( c >= '0' && c <= '9'){ 402 slave2Time = (10 * slave2Time) + (c - '0'); 403 } 404 } 405 slave2Time = slave2Time + 1000000000;
406 Serial.print ("||| this is SLAVE 2 unixTime : "); 407 Serial.print (slave2Time);
408 Serial.println (""); 409
410 unsigned long slave2RecTime = slave2Time; 411 unsigned long masterRecTime = now(); 412 unsigned long resultRecTime;
413
414 if (masterRecTime > slave2RecTime){
415 resultRecTime = masterRecTime - slave2RecTime; 416 substract2 = resultRecTime;
417 positive2 = 0; 418 }
419 else if (masterRecTime < slave2RecTime){
420 resultRecTime = slave2RecTime - masterRecTime; 421 substract2 = resultRecTime;
422 positive2 = 1; 423 }
424 else if (masterRecTime = slave2RecTime){ 425 resultRecTime = 0;
427 positive2 = 2; 428 }
429 count = 0;
430 Serial.print ("this is the substraction result : "); 431 Serial.print (substract2);
432 Serial.println("");
433 Serial.println ("RTC's TIME Slave 2 has been calculated"); 434 Serial.println(""); 435 bip(); 436 } 437 } 438 count = 0; 439 }//masterMiRFlooping 440
441 /*==================== START, STOP and RINGing the ALARMS for ROOM 1 =================*/
442 //==================================================================== ==================
443 void enableAlarm1(){
444 Alarm.enable(intervalTimer1); 445 Serial.print(now());
446 Serial.println(" || ===intStart 1==="); 447 Serial.println(""); 448 lcd.setCursor(0,1); 449 lcd.print("===intStart 1==="); 450 delay(2000); 451 lcd.clear(); 452 }//enableAlarm1 453 void disableAlarm1(){ 454 Serial.print(now());
455 Serial.println("====intEnd 1===="); 456 Serial.println("");
457 Alarm.disable(intervalTimer1); 458 lcd.setCursor(0,1); 459 lcd.print("====intEnd 1===="); 460 delay(2000); 461 lcd.clear(); 462 }//disableAlarm1 463 464 void doRingAlarm1(){ 465 count = 0;
466 //Transmit data to Slave
467 Mirf.setTADDR((byte *)"slav1"); //should be slav1
468 delay(5);
469 unsigned long dataNow = 1111111111; // example data length for now()=//1312841340
470 ltoa(dataNow, dataSend, 10); 471 if (count == 0){
472 dataSend[0] = 'A'; 473 count = 1;
475 Serial.print(dataSend[count]); 476 }
477 Mirf.send((byte *) dataSend); 478 Serial.println(now());
479 Serial.println("SLAVE 1's Alarm has been SET"); 480 Serial.println("");
481 count = 0; 482 }
483 }//doRingAlarm1
484 /*==================== START, STOP and RINGing the ALARMS for ROOM 2 =================*/
485 //==================================================================== ==================
486 void enableAlarm2(){ 487 Serial.print(now());
488 Serial.println(" || ===intStart 2==="); 489 Serial.println("");
490 Alarm.enable(intervalTimer2); 491 lcd.setCursor(0,1); 492 lcd.print("===intStart 2==="); 493 delay(2000); 494 lcd.clear(); 495 }//enableAlarm2 496 497 void disableAlarm2(){ 498 Serial.print(now());
499 Serial.println(" || ===intEnd 2==="); 500 Serial.println("");
501 Alarm.disable(intervalTimer2); 502 lcd.setCursor(0,1); 503 lcd.print("====intEnd 2===="); 504 delay(2000); 505 lcd.clear(); 506 }//disableAlarm2 507 508 void doRingAlarm2(){ 509 count = 0;
510 //Transmit data to Slave
511 Mirf.setTADDR((byte *)"slav2"); //should be slav1
512 delay(5);
513 unsigned long dataNow = 1111111111; // example data length for now()=//1312841340
514 ltoa(dataNow, dataSend, 10); 515 if (count == 0){
516 dataSend[0] = 'B'; 517 count = 1;
518 for (count = 1; count < 11; count++) { 519 Serial.print(dataSend[count]);
520 }
521 Mirf.send((byte *) dataSend); 522 Serial.println(now());
523 Serial.println("SLAVE 2's Alarm has been SET"); 524 Serial.println(""); 525 count = 0; 526 } 527 }//doRingAlarm2 528
529 /*==================== ENABLING 60 MINUTES ALARM to SEND DATA to SLAVE =================*/
530 //==================================================================== ==================
531 void enableEveryHour(){
532 Serial.println("Enable successfully"); 533 Alarm.enable(everyHourAlarm);
534 }//enableEveryHour
535
536 void sendDataToSlave(){//Read RTC time data and send it to slave
537 //Transmit data to Slave1
538 count = 0;
539 Mirf.setTADDR((byte *)"slav1");//should be slav1
540 delay(5);
541 Serial.println(" ");
542 unsigned long dataNow1 = now(); 543 ltoa(dataNow1, dataSend, 10); 544 if (count == 0){
545 dataSend[0] = 'U'; //for testing replaced to 'V', it should be 'U'
546 count = 1;
547 for (count = 1; count < 11; count++) { 548 Serial.print(dataSend[count]);
549 }
550 Mirf.send((byte *) & dataSend);
551 Serial.println("||| FinishedSending RTC time to SLAVE 1"); 552 Serial.println("");
553 }
554 count = 0; 555 delay(100);
556 Mirf.setTADDR((byte *)"slav2");//should be slav2
557 delay(5);
558 Serial.println(" ");
559 unsigned long dataNow2 = now(); 560 ltoa(dataNow2, dataSend, 10); 561 if (count == 0){
562 dataSend[0] = 'V'; //SLAVE 2 HEADER
563 count = 1;
564 for (count = 1; count < 11; count++) { 565 Serial.print(dataSend[count]);
566 }
567 Mirf.send((byte *) & dataSend);
568 Serial.println("||| FinishedSending RTC time to SLAVE 2"); 569 Serial.println("");
570 }
572 }//sendDataToSlave
573
574 /*========================== Reading EEPROM value ========================*/
575 void EEPROMread(){
576 value = EEPROM.read(address); 577 Serial.print(address);
578 Serial.print("\t");
579 Serial.print(value, DEC); 580 Serial.println(); 581 address = address + 1; 582 if (address == 212) 583 address = 200; 584 delay(10); 585 }//EEPROMread 586 587 void showLine2(){
588 // line 2 for slave 1
589 lcd.setCursor(0,1); 590 lcd.print("S1:"); 591 lcd.setCursor(3,1); 592 if (positive1 == 0) 593 lcd.print("-"); 594 else if (positive1 == 1) 595 lcd.print("+"); 596 else if (positive1 == 2) 597 lcd.print(" "); 598 if (substract1 < 10){ 599 lcd.setCursor(4,1); 600 lcd.print('0'); 601 lcd.setCursor(5,1); 602 lcd.print(substract1); 603 } 604 else if (substract1 == 0){ 605 lcd.setCursor(4,1); 606 lcd.print('00'); 607 }
608 else if (substract1 >= 10 && substract1 <= 60){ 609 lcd.setCursor(4,1);
610 lcd.print(substract1); 611 }
612 else if (substract1 > 60){ // cannot calling sendDataToSlave Function, 613 lcd.setCursor(3,1); 614 lcd.print(" "); 615 lcd.setCursor(4,1); 616 lcd.print("FF"); 617 count = 0;
618 Mirf.setTADDR((byte *)"slav1");//should be slav1
619 delay(5);
621 unsigned long dataNow = now(); 622 ltoa(dataNow, dataSend, 10); 623 if (count == 0){
624 dataSend[0] = 'U'; //for testing replaced to 'V', it should be 'U'
625 count = 1;
626 for (count = 1; count < 11; count++) { 627 Serial.print(dataSend[count]);
628 }
629 Mirf.send((byte *) & dataSend);
630 substract1 = 0;//==============>IMPORTANT LINE, without this the sistem unstable..substract still > 60.
631 Serial.println(substract1);
632 Serial.println("FinishedSending RTC time to SLAVE 1---"); 633 } 634 count = 0; 635 } 636 lcd.setCursor(6,1); 637 lcd.print("s");
638 // line 2 for slave 2
639 lcd.setCursor(8,1); 640 lcd.print("S2:"); 641 lcd.setCursor(11,1); 642 if (positive2 == 0) 643 lcd.print("-"); 644 else if (positive2 == 1) 645 lcd.print("+"); 646 else if (positive2 == 2) 647 lcd.print(" "); 648 if (substract1 < 10){ 649 lcd.setCursor(12,1); 650 lcd.print('0'); 651 lcd.setCursor(13,1); 652 lcd.print(substract2); 653 } 654 else if (substract2 == 0){ 655 lcd.setCursor(13,1); 656 lcd.print('00'); 657 }
658 else if (substract2 >= 10 && substract2 <= 60){ 659 lcd.setCursor(12,1);
660 lcd.print(substract2); 661 }
662 else if (substract2 > 60){ // cannot calling sendDataToSlave Function, 663 lcd.setCursor(12,1); 664 lcd.print(" "); 665 lcd.setCursor(13,1); 666 lcd.print("FF"); 667 count = 0;
668 Mirf.setTADDR((byte *)"slav2");//should be slav2
669 delay(5);
670 Serial.println(" ");
671 unsigned long dataNow = now(); 672 ltoa(dataNow, dataSend, 10); 673 if (count == 0){
674 dataSend[0] = 'V'; //for testing replaced to 'V', it should be 'U'
675 count = 1;
676 for (count = 1; count < 11; count++) { 677 Serial.print(dataSend[count]);
678 }
679 Mirf.send((byte *) & dataSend);
680 substract2 = 0;//==============>IMPORTANT LINE, without this the sistem unstable..substract still > 60.
681 Serial.println(substract2);
682 Serial.println("FinishedSending RTC time to SLAVE 1---"); 683 } 684 count = 0; 685 } 686 lcd.setCursor(14,1); 687 lcd.print("s"); 688 }//showLine2 689 690 691 void digitalClockDisplay(){ 692 time_t t = now(); 693 lcd.setCursor(0,0); 694 lcd.print("Time"); 695 printTimeDigits(hour(t)); 696 printTimeDigits(minute(t)); 697 printTimeDigits(second(t)); 698 }//digitalClockDisplay 699
700 void printTimeDigits(int timeDigits){ 701 lcd.print(":");
702 if(timeDigits < 10) lcd.print("0"); 703 lcd.print(timeDigits);
704 }//printTimeDigits
705
706 void printDayDigits(int dayDigits){ 707 lcd.print("/");
708 if(dayDigits < 10) lcd.print("0"); 709 lcd.print(dayDigits);
710 }//printDayDigits
711
712 /*====================receive Serial data from Visual Basic====================*/
713 //==================================================================== ================ EXACT TIME MODE ALARM SLAVE 1
714 void exactTimeSlave1(){
715 while (Serial.available() < 24); 716 {
717 char setString[DATA_EXACT1]; 718 int index = 0;
719 for (int i = 0; i < DATA_EXACT1 - 1; i++) 720 {
721 char d = Serial.read();
722 setString[index++] = d - '0'; 723 }
724 int count = index; 725 int element = 0;
726 for( index = 0; index < count; index += 2) 727 {
728 byte val = setString[index] * 10 + setString[index+1]; 729 switch (element++){
730 //===========ALARM EXACTTIME MODE ROOM 1===========
731 case 0:
732 exactHour1Slave1 = val; 733 if (exactHour1Slave1 == 0) 734 EEPROM.write(171, 0);
735 EEPROM.write(171, exactHour1Slave1); 736 break;
737 case 1:
738 exactMinute1Slave1 = val; 739 if (exactMinute1Slave1 == 0) 740 EEPROM.write(172, 0);
741 EEPROM.write(172, exactMinute1Slave1); 742 break;
743 case 2:
744 exactHour2Slave1 = val; 745 if (exactHour2Slave1 == 0) 746 EEPROM.write(173, 0);
747 EEPROM.write(173, exactHour2Slave1); 748 break;
749 case 3:
750 exactMinute2Slave1 = val; 751 if (exactMinute2Slave1 == 0) 752 EEPROM.write(174, 0);
753 EEPROM.write(174, exactMinute2Slave1); 754 break;
755 case 4:
756 exactHour3Slave1 = val; 757 if (exactHour3Slave1 == 0) 758 EEPROM.write(175, 0);
759 EEPROM.write(175, exactHour3Slave1); 760 break;
761 case 5:
762 exactMinute3Slave1 = val; 763 if (exactMinute3Slave1 == 0) 764 EEPROM.write(176, 0);
765 EEPROM.write(176, exactMinute3Slave1); 766 break; 767 case 6: 768 exactHour4Slave1 = val; 769 if (exactHour4Slave1 == 0) 770 EEPROM.write(177, 0);
771 EEPROM.write(177, exactHour4Slave1); 772 break;
773 case 7:
774 exactMinute4Slave1 = val; 775 if (exactMinute4Slave1 == 0) 776 EEPROM.write(178, 0);
777 EEPROM.write(178, exactMinute4Slave1); 778 break;
779 case 8:
780 exactHour5Slave1 = val; 781 if (exactHour5Slave1 == 0) 782 EEPROM.write(179, 0);
783 EEPROM.write(179, exactHour5Slave1); 784 break;
785 case 9:
786 exactMinute5Slave1 = val; 787 if (exactMinute5Slave1 == 0) 788 EEPROM.write(180, 0);
789 EEPROM.write(180, exactMinute5Slave1); 790 break;
791 case 10:
792 exactHour6Slave1 = val; 793 if (exactHour6Slave1 == 0) 794 EEPROM.write(181, 0);
795 EEPROM.write(181, exactHour6Slave1); 796 break;
797 case 11:
798 exactMinute6Slave1 = val; 799 if (exactMinute6Slave1 == 0) 800 EEPROM.write(182, 0);
801 EEPROM.write(182, exactMinute6Slave1); 802 break; 803 } 804 } 805 } 806 }//exactTimeSlave1 807 //==================================================================== ================ EXACT TIME MODE ALARM SLAVE 2
808 void exactTimeSlave2(){
809 while (Serial.available() < 24); 810 {
811 char setString[DATA_EXACT2]; 812 int index = 0;
813 for (int i = 0; i < DATA_EXACT2 - 1; i++) 814 {
815 char d = Serial.read();
816 setString[index++] = d - '0'; 817 }
818 int count = index; 819 int element = 0;
820 for( index = 0; index < count; index += 2) 821 {
822 byte val = setString[index] * 10 + setString[index+1]; 823 switch (element++){
824 //===========ALARM EXACTTIME MODE ROOM 2===========