事件紀錄電路 ARDUINO NANO & PROMINI

antlu

最近做了兩個事件紀錄電路,一個是紀錄10組觸發時間隨時可以讀取發生時間,動作是 使用 DS1302 RTC 隨時監控時間,一但 中斷觸發就紀錄當時的時間,這樣可以紀錄小貓侵入的時間,搭配錄影機就方便調影片來追蹤!! 另一個則搭配 SD卡片 把發生的時間紀錄在SD卡上,先前做了個電壓紀錄器,於是把他整合進來,也就是可以紀錄每隔 5秒 10秒 30秒 300秒 1800秒的三組外部輸入電壓數值,也可以紀錄外部觸發 中斷0 中斷1 時候的時間與電壓,這方便紀錄何時繼電器動作時候的三組電壓... 第二個因為搭配SD卡存資料,程式太大所以沒辦法做到讀取 SD卡記憶體的內容,SD卡的資料必須搭配電腦和讀卡機以 EXCEL 檔案讀取...提供大家參考..

第一台的外觀和線路 使用 ARDUINO PRO-MINI
按鍵一事件時間讀取增加,第二按鍵 事件時間讀取減少..
線路圖


PCB




外觀








第二台的外觀和線路 使用 ARDUINO NANO
外觀














線路




輸入部分




第一台程式 (使用 DS1302 RTC  LCM使用74595+LCM2402 ARDUINO PRO-MINI)

1. // USE 74595 LCM ARDUINO PROMINI Interrupt
   
2. // key in low active interrupt BECKHOFF MODULE HIGH ACTIVE
   
3. //used BECKOFF PLC INPUT MODULE LOW OUT 2020.01.23
   
4. #include <DS1302.h>
   
5. 
   
6. volatile boolean int0Flag = 0;
   
7. volatile boolean int1Flag = 0;
   
8. volatile byte evn0_count = 0;
   
9. volatile byte evn1_count = 0;
   
10. //Define 74HC595 Connections with arduio
    
11. const int Dsply_Latch=13; //LCM----74595 pin 12 black
    
12. const int Dsply_Data=12;  //LCM----74595 pin 14 green
    
13. const int Dsply_Clock=11; //LCM----74595 pin 11 blue
    
14. const int RTC_CLK=6;//
    
15. const int RTC_DAT=7;//
    
16. const int RTC_RST=8;//
    
17. const int EVN_1=2;//interrupt 0
    
18. const int EVN_2=3;//interrupt 1
    
19. const int ReadKey1 =4;//^ key
    
20. const int ReadKey2 =5;//v key
    
21. volatile byte EVN_1flag =0;
    
22. volatile byte EVN_2flag =0;
    
23. String date_bf0[]={"1","2","3","4","5","6","7","8","9","10"};//it is String not char ..
    
24. String time_bf0[]={"a","b","c","d","e","f","g","h","i","j"};
    
25. String date_bf1[]={"1","2","3","4","5","6","7","8","9","10"};//it is String not char ..
    
26. String time_bf1[]={"a","b","c","d","e","f","g","h","i","j"};
    
27. int bf0;
    
28. int bf1;
    
29. byte i =0;
    
30. byte j =0;
    
31. byte dspDatacount;
    
32. boolean dspupdate_flag = true;
    
33. // const int Led=13;//Led on off
    
34. void LCDinit(void);
    
35. void LCDSendByte(char d,char RS);
    
36. void LCDPrint(char Line,char string[40]);//--
    
37. DS1302 rtc(RTC_RST,RTC_DAT,RTC_CLK);
    
38. char EVN_Array[3];
    
39. char D[24];
    
40. char A[20];
    
41. void setup() {
    
42.   Serial.begin(9600);
    
43.   delay(500);
    
44.   pinMode(EVN_1,INPUT ); // INPUT_PULLUP
    
45.   pinMode(EVN_2, INPUT); //   
    
46.   pinMode(ReadKey1, INPUT_PULLUP); //
    
47.   pinMode(ReadKey2, INPUT_PULLUP); //
    
48.   attachInterrupt(0,EVN_1_ISR,RISING); // set an interrupt on PinA
    
49.   attachInterrupt(1,EVN_2_ISR,RISING); // set an interrupt on PinB
    
50.   pinMode(Dsply_Data, OUTPUT);
    
51.   pinMode(Dsply_Clock, OUTPUT);
    
52.   pinMode(Dsply_Latch, OUTPUT);  
    
53.   DS1302 rtc(RTC_RST,RTC_DAT,RTC_CLK);
    
54.   rtc.halt(false);
    
55.   
    
56.   //取消寫入保護，設定日期時要這行
    
57. rtc.writeProtect(false);  
    
58. 
    
59. // 以下是設定時間的方法，在電池用完之前，只要設定一次就行了
    
60. // rtc.setTime(23, 7, 0);     // 設定時間 時，分，秒 (24hr format)
    
61. 
    
62. //  rtc.setDate(22, 1, 2020);   // 設定日期 日，月，年
    
63. LCDinit();
    
64. LCDclean();
    
65. LCDPrint(0,"     Event Record V1");
    
66. LCDPrint(1,"          2020.01.17");
    
67. }
    
68. 
    
69. void loop() {
    
70.    while(1)
    
71.    {
    
72. 
    
73. 
    
74. //  Serial.println("end of program");
    
75.    //---------start program ---------------
    
76.    if(int0Flag == true)
    
77.    {
    
78.    
    
79.     evn0_count ++;   
    
80.     if (evn0_count >10){evn0_count =0;}
    
81.     Serial.print("evn0_count =");
    
82.     Serial.println(evn0_count);
    
83.     date_bf0[evn0_count] = rtc.getDateStr();
    
84.     time_bf0[evn0_count] = rtc.getTimeStr();   
    
85.      dspupdate_flag = true;
    
86.       LCDPrintString(0,1,"                      ");  
    
87.      readData2Dsply(evn0_count);
    
88.     String evn_count_str = String(evn0_count);
    
89.      evn_count_str.toCharArray(EVN_Array,3);     
    
90. //     LCDPrintString(0,1,"        int0 count      ");
    
91.      
    
92.     LCDPrintString(0,1,EVN_Array);
    
93.       LCDWriteChar(0,23,'@');
    
94.      delay(100);
    
95.      int0Flag = false;   
    
96.    }
    
97. 
    
98.    if(int1Flag == true)
    
99.    {   
    
100.     evn1_count ++;
     
101.     int1Flag = false;
     
102.         if (evn1_count >10){evn1_count =0;}
     
103.     Serial.print("evn1_count =");
     
104.     Serial.println(evn1_count);
     
105.     date_bf1[evn1_count] = rtc.getDateStr();
     
106.     time_bf1[evn1_count] = rtc.getTimeStr();
     
107.     dspupdate_flag = true;  
     
108.      LCDPrintString(1,1,"                      ");
     
109.     readData2Dsply(evn1_count+10);
     
110.      String evn_count_str = String(evn1_count);
     
111.      evn_count_str.toCharArray(EVN_Array,3);     
     
112.   
     
113. 
     
114.      LCDPrintString(1,1,EVN_Array);
     
115.      LCDWriteChar(1,23,'@');
     
116.      delay(100);
     
117.     int1Flag = false;   
     
118.    }
     
119. 
     
120.    //read key in sw
     
121.    readSW();// const int ReadKey1 =4;//^ key const int ReadKey2 =5;//v key
     
122.    if( dspupdate_flag == true)
     
123.    {  
     
124.    dspData();//display readKey
     
125.      // 日期
     
126.   Serial.print(rtc.getDateStr());
     
127.   Serial.print(" -- ");
     
128. 
     
129.   // 時間
     
130.   Serial.println(rtc.getTimeStr());
     
131.   Serial.println();
     
132.    }
     
133.   }
     
134. }
     
135. 
     
136. //=============================================================
     
137. //             Send Data or Command to LCD
     
138. //=============================================================
     
139. void LCDSendByte(char d,char RS)
     
140. {
     
141.   char dH,dL,temp;
     
142.   //Keep Data on upper nybble
     
143.   dH = d & 0xF0;         //Get MSB
     
144.   dL = d & 0x0F;
     
145.   dL = d << 4;           //Get LSB
     
146. //Send MSB with E=clock  
     
147.   temp=0;
     
148.   temp=dH | RS | 0x02;  //MSB With RS+E bit
     
149.   ShiftData(temp);
     
150. //Send MSB with E=0
     
151.   temp=0;
     
152.   temp=dH | RS;  //MSB With RS bit
     
153.   ShiftData(temp);
     
154. //Send LSB with E=clock
     
155.   temp=0;
     
156.   temp=dL | RS | 0x02;  //MSB With RS+E bit
     
157.   ShiftData(temp);
     
158. //Send LSB with E=0
     
159.   temp=0;
     
160.   temp=dL | RS;  //MSB With RS bit
     
161.   ShiftData(temp);  
     
162. }
     
163. //=============================================
     
164. void ShiftData(char temp)
     
165. {
     
166.   int i;
     
167.   for(i=0;i<8;i++)      
     
168.   {
     
169.     if((temp & 0x80)==0x80)    //Send 1-bit to shift register
     
170.     {digitalWrite(Dsply_Data,HIGH);}
     
171.     else
     
172.     {digitalWrite(Dsply_Data,LOW);}         
     
173.     digitalWrite(Dsply_Clock,LOW);
     
174.     digitalWrite(Dsply_Clock,HIGH);
     
175.     temp=temp<<1;
     
176.   }
     
177.   //Latch the data
     
178.   digitalWrite(Dsply_Latch,LOW);
     
179.   delay(1);
     
180.   digitalWrite(Dsply_Latch,HIGH);        
     
181. }
     
182. //=================================================================
     
183. //           LCD Display Initialization Function
     
184. //=================================================================
     
185. void LCDinit()
     
186. {
     
187.   int count;
     
188.   char t[]={0x43,0x03,0x03,0x02,0x28,0x01,0x0C,0x06,0x02,0x02};   
     
189.       for (count = 0; count <= 9; count++)
     
190.       {
     
191.         LCDSendByte(t[count],0);    //Command RS=0
     
192.       }
     
193. }
     
194. //=================================================================
     
195. //        Display Line on LCD at desired location Function
     
196. //=================================================================
     
197. void LCDPrint(char Line,char string[40])//--------------------------------------
     
198. {
     
199. int len,count;
     
200. if(Line==0) {
     
201.    LCDSendByte(0x80,0);    //Command RS=0 Move Cursor to Home   
     
202. }
     
203. else {
     
204.    LCDSendByte(0xC0,0);    //Command RS=0 Move Cursor to Second Line LCDSendByte(0xC0,0);
     
205. }
     
206.         len = strlen(string);
     
207.     for (count=0;count<len;count++)
     
208.   {
     
209.      LCDSendByte(string[count],1);  //Data RS=1
     
210.   }
     
211. }
     
212. //=================================================================
     
213. void LCDclean(void)
     
214. {
     
215.   LCDSendByte(0x01,0);
     
216. }
     
217. void LCDCurserMove(int y,int x)
     
218. {
     
219. // LCDSendByte((a*4+16),0);//a=1 shift right
     
220. if (y == 0)
     
221.        {   
     
222.        LCDSendByte(0x80 + x,0);
     
223.        }   
     
224. else
     
225.        {   
     
226.        LCDSendByte(0xC0 + x,0);   
     
227.        }      
     
228. LCDSendByte(0x0b,0);   
     
229. }
     
230. 
     
231. void LCDPrintString(int x,int y, char string[])
     
232. {  
     
233.   int count, len;  
     
234. // summ = x;
     
235. if (x == 0)
     
236.        {  
     
237.          LCDSendByte(0x80+y ,0);
     
238.        }
     
239. else
     
240.        {
     
241.        LCDSendByte(0xC0+y,0);  
     
242.        }      
     
243.      len = strlen(string);
     
244.     for (count=0;count<len;count++)
     
245.   {
     
246.      LCDSendByte(string[count],1);  //Data RS=1
     
247.   }
     
248. }
     
249. 
     
250. 
     
251. void LCDWriteChar(int x,int y,char Data)
     
252. {
     
253. 
     
254. if (x == 0)
     
255.        {   
     
256.        LCDSendByte(0x80 + y,0);
     
257.        }   
     
258. else
     
259.        {   
     
260.        LCDSendByte(0xC0 + y,0);   
     
261.        }      
     
262. LCDSendByte(Data,1);   
     
263. }
     
264. 
     
265. void LCDhome(void)
     
266. {
     
267.   LCDSendByte(0x02,0);
     
268. }
     
269. 
     
270. void LCDDisp(void)
     
271. {
     
272.    LCDSendByte(0x0f,0);
     
273. }
     
274. 
     
275. void EVN_1_ISR()//interruput 0
     
276. {
     
277. int0Flag = true;  
     
278. }
     
279. 
     
280. void EVN_2_ISR()//interrupt 1
     
281. {
     
282. int1Flag = true;  
     
283. }
     
284. 
     
285. void readSW(void)
     
286. {
     
287. //const int ReadKey1 =4;//^ key
     
288. //const int ReadKey2 =5;//v key
     
289.   if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2))) //key 1 pressed++
     
290.   {
     
291.     delay(200);
     
292.   if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2)))   
     
293. //    if(!digitalRead(ReadKey1))
     
294.     {
     
295.       if(dspDatacount >19){dspDatacount=0;}
     
296.       dspDatacount++;//display record
     
297.       
     
298.       Serial.print("dspDatacount = ");
     
299.       Serial.println(dspDatacount);
     
300.        dspupdate_flag = true;  
     
301.        readData2Dsply(dspDatacount);
     
302.        LCDWriteChar(0,23,'R');
     
303.        LCDWriteChar(1,23,'R');
     
304.     }
     
305.   }
     
306.   if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2))) //key 2 pressed--
     
307.   {
     
308.     delay(100);
     
309.    if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2)))   
     
310.    // if(!digitalRead(ReadKey2))
     
311.     {     
     
312.       if(dspDatacount !=0){dspDatacount--;}
     
313.    //   Serial.print("dspDatacount = ");
     
314.    //   Serial.println(dspDatacount);  
     
315.        dspupdate_flag = true;
     
316.        readData2Dsply(dspDatacount);  
     
317.         
     
318.     }
     
319.   }
     
320.    if((!digitalRead(ReadKey1))&&(!digitalRead(ReadKey2))) //key 1 & 2 pressed
     
321.   {
     
322.     delay(500);
     
323.     if((!digitalRead(ReadKey1))&&(!digitalRead(ReadKey2)))
     
324.     {     
     
325. 
     
326.         for(byte i=0;i<10;i++)
     
327.         {  
     
328.          time_bf0[i]="";   
     
329.          time_bf1[i]="";
     
330.         }      
     
331.         evn0_count = 0;
     
332.         evn1_count = 0;
     
333.         dspDatacount = 0;
     
334. //      Serial.print("dspDatacount = ");
     
335. //      Serial.println(dspDatacount);  
     
336.       dspupdate_flag = true;
     
337.       
     
338.     }
     
339.   }
     
340.   
     
341. }
     
342. 
     
343. void dspData(void)//display readKey
     
344. {
     
345. //     Serial.println("LCD display *** ");
     
346. //      Serial.print("evn0 display = ");
     
347. //     Serial.println(evn0_count);  
     
348. //     Serial.print("evn1 display = ");
     
349. //     Serial.println(evn1_count);  
     
350.        dspupdate_flag = false;  
     
351. }
     
352. 
     
353. void readData2Dsply(byte rcount)
     
354. {
     
355.   LCDWriteChar(0,0,'A');
     
356.   LCDWriteChar(1,0,'B');
     
357. 
     
358.   if(rcount<10)
     
359.   {
     
360. //   Serial.print("Read event count = ");
     
361. //   Serial.println(rcount);
     
362. //  Serial.println("Read event date&time = ");
     
363. //  Serial.print(date_bf0[rcount]);
     
364. //  Serial.print(" ");
     
365. //  Serial.println(time_bf0[rcount]);
     
366.   String rcount_str = String(rcount);
     
367.   rcount_str.toCharArray(EVN_Array,3);     
     
368.   LCDPrintString(0,1,EVN_Array);
     
369.    date_bf0[rcount].toCharArray(D,11);
     
370.    LCDPrintString(0,3,D);
     
371.    time_bf0[rcount].toCharArray(D,10);
     
372.    LCDPrintString(0,14,D);
     
373.   }
     
374.   if(rcount ==10)
     
375.   {
     
376.     LCDWriteChar(0,2,' ');
     
377.     LCDWriteChar(0,22,' ');
     
378.   }
     
379.   if((rcount >10) && (rcount<=19))
     
380.   {
     
381. //  Serial.print("Read event count = ");
     
382. //  Serial.println(rcount);
     
383.    rcount=rcount-10;
     
384. //  Serial.println("Read event date&time = ");
     
385. //  Serial.print(date_bf1[rcount]);
     
386. //  Serial.print(" ** ");
     
387. //  Serial.println(time_bf1[rcount]);
     
388.   String rcount_str = String(rcount);
     
389.   rcount_str.toCharArray(EVN_Array,3);     
     
390.   LCDPrintString(1,1,EVN_Array);  
     
391.    date_bf1[rcount].toCharArray(D,11);
     
392.    LCDPrintString(1,3,D);
     
393.    time_bf1[rcount].toCharArray(D,10);
     
394.    LCDPrintString(1,14,D);  
     
395.   }
     
396. }

複製代碼

第二台的程式
說明: 使用 I2C 介面的 DS1307 RTC 和 LCM2004  和 ARDUINO NANO  
按鍵一開始/停止紀錄SD ,第二按鍵 選擇時間間隔 5秒...10秒..

1. /* FILE NAME datalog20200127eventV2
   
2. *  20200201 增加了選擇內部計時的功能 兩個按鍵 按鍵一 開始與停止 按鍵二 內部時間間隔選擇
   
3. 5秒 10秒 30秒 60秒 300秒 1800秒 選擇之後 按下開始 就開始計時與紀錄.
   
4. 
   
5. 起始動作 顯示時間而以,螢幕顯示 STOP ,此時並沒有啟動開檔動作(SD CARD) 內部自定 60秒,
   
6. 一但按下START/STOP 按鍵時開始開檔啟動紀錄,這時候就不在建立新檔案,若再按一次 START/STOP 鍵
   
7. 只會做停止計時動作與檔案 SD.FLASH動作,在  任何狀況下可以選擇時間間隔.
   
8. */
   
9. 
   
10. #include <SPI.h>
    
11. #include <SD.h>
    
12. #include <Wire.h>
    
13. #include "RTClib.h"
    
14. #include <LiquidCrystal_I2C.h> //20200127
    
15. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
    
16. 
    
17. #define ECHO_TO_SERIAL   1 // echo data to serial port
    
18. #define WAIT_TO_START    0 // Wait for serial input in setup()
    
19. 
    
20. 
    
21. // The analog pins that connect to the sensors
    
22. #define whitePortPin 0           // analog 0 40V white port adjustable 5 10 40V range
    
23. #define redPortPin 1                // analog 1 5V red port fix 5V range
    
24. #define yellowPortPin 2          // analog 2 20V yellow port fix 20V range 2017.01.01
    
25. #define BANDGAPREF 14            // special indicator that we want to measure the bandgap
    
26. 
    
27. #define aref_voltage 5.0         // we tie 3.3V to ARef and measure it with a multimeter!2017.01.01 change from 3.3 to 5.0V
    
28. #define bandgap_voltage 1.1      // this is not super guaranteed but its not -too- off
    
29. 
    
30. RTC_DS1307 RTC; // define the Real Time Clock object
    
31. const int chipSelect = 10;
    
32. // the logging file
    
33. File logfile;
    
34. 
    
35. void error(char *str)
    
36. {
    
37.   Serial.print(F("error: "));
    
38.   Serial.println(str);
    
39.   lcd.setCursor(1,0);
    
40.   lcd.print("err ");
    
41.   lcd.print(str);
    
42.   while(1);
    
43. }
    
44. //------------20200129-----------------
    
45. byte count = 0;
    
46. volatile boolean int0Flag = 0;
    
47. volatile boolean int1Flag = 0;
    
48. volatile byte evn0_count = 0;
    
49. volatile byte evn1_count = 0;
    
50. const byte EVN_1=2;//interrupt 0
    
51. const byte EVN_2=3;//interrupt 1
    
52. const byte ReadKey1 =4;// START/STOP key
    
53. const byte ReadKey2 =5;// time interval select defalt 60s ,5,10,30,60,300,1800.
    
54. boolean Start_Stop_flag = false;// true is Start,false is Stop
    
55. const int Time_period[6] ={60,5,10,30,300,1800};
    
56. byte Time_periord_count = 0;
    
57. long startTime = 0;//time delay counter 1000ms
    
58. int down_count_sec =0;
    
59. int time_record_count=0;
    
60. boolean onesec = false;
    
61. boolean delayFlag =false;
    
62. boolean dsp_flag = false;
    
63. //------------end--------------
    
64. void setup(void)
    
65. {
    
66.   Serial.begin(9600);
    
67.   Serial.println();
    
68.   pinMode(EVN_1,INPUT ); // INPUT_PULLUP
    
69.   pinMode(EVN_2, INPUT); //   
    
70.   pinMode(ReadKey1, INPUT_PULLUP); // 開始/停止(存檔SD)
    
71.   pinMode(ReadKey2, INPUT_PULLUP); // 選擇間隔秒數
    
72.   attachInterrupt(0,EVN_1_ISR,RISING); // set an interrupt on PinA
    
73.   attachInterrupt(1,EVN_2_ISR,RISING); // set an interrupt on PinB
    
74.   lcd.begin (20,4);  // initialize the lcd
    
75.   lcd.backlight();//To Power ON the back light
    
76. 
    
77.   //--------20200201--------------------
    
78.   //initial  一開始先進入停止模式一但啟動再做SD卡存取
    
79.   while( !Start_Stop_flag)
    
80.   {
    
81.      if(Start_Stop_flag == false)
    
82.       {
    
83.       lcd.setCursor(1,2);
    
84.       lcd.print("STOP ");
    
85.       }
    
86.    if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2))) //key 1 pressed++
    
87.   {
    
88.     delay(200);
    
89.   if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2)))   
    
90. 
    
91.     {
    
92.       Start_Stop_flag = (!Start_Stop_flag);
    
93.       if(Start_Stop_flag == true)
    
94.       {
    
95.         lcd.setCursor(1,2);
    
96.         lcd.print("START");
    
97.         down_count_sec = Time_period[Time_periord_count];//start count
    
98.       }
    
99.       if(Start_Stop_flag == false)
    
100.       {
     
101.         //logfile.flush();
     
102.       }
     
103.     }
     
104.   }
     
105.      if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2))) //key 2 pressed--
     
106.   {
     
107.     delay(100);
     
108.    if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2)))   
     
109.     {  
     
110.        Time_periord_count++;         
     
111.       if(Time_periord_count >5){Time_periord_count =0;}
     
112.      lcd.setCursor(2,3);
     
113.      lcd.print("Time period:      ");
     
114.      lcd.setCursor(14,3);
     
115.      lcd.print(Time_period[Time_periord_count]);
     
116.      Serial.print("Time period: ");
     
117.      Serial.println(Time_period[Time_periord_count]);
     
118.     }
     
119.   }
     
120.   }
     
121.   //-----------20200201  END------------
     
122. #if WAIT_TO_START
     
123.   Serial.println("Type any character to start");
     
124.   while (!Serial.available());
     
125. #endif //WAIT_TO_START
     
126. 
     
127.   // initialize the SD card
     
128.   Serial.print(F("Initializing SD card..."));
     
129.   lcd.setCursor(1,0);
     
130.   lcd.print("init SD ..");
     
131.   // make sure that the default chip select pin is set to
     
132.   // output, even if you don't use it:
     
133.   pinMode(chipSelect, OUTPUT);
     
134.   
     
135.   // see if the card is present and can be initialized:
     
136.   if (!SD.begin(chipSelect)) {
     
137.     error("NO Card or NG");
     
138.   }
     
139.   Serial.println(F("card initialized."));
     
140.   
     
141.   // create a new file
     
142.   char filename[] = "Antlog00.CSV";
     
143.   for (uint8_t i = 0; i < 100; i++) {
     
144.     filename[6] = i/10 + '0';
     
145.     filename[7] = i%10 + '0';
     
146.     if (! SD.exists(filename)) {
     
147.       // only open a new file if it doesn't exist
     
148.       logfile = SD.open(filename, FILE_WRITE);
     
149.       break;  // leave the loop!
     
150.     }
     
151.   }
     
152.   
     
153.   if (! logfile) {
     
154.       error("couldnt create file");
     
155.      }
     
156.   
     
157.   Serial.print(F("Logging to: "));
     
158.   Serial.println(filename);
     
159. 
     
160.   // connect to RTC
     
161.   Wire.begin();  
     
162.   if (!RTC.begin()) {
     
163.     logfile.println("RTC failed");
     
164. #if ECHO_TO_SERIAL
     
165.     Serial.println("RTC failed");
     
166. #endif  //ECHO_TO_SERIAL
     
167.   }
     
168.   
     
169. 
     
170.   logfile.println("millis,stamp,datetime,whitePort,redPort,yellowPort,countNo.");   
     
171. #if ECHO_TO_SERIAL
     
172.   Serial.println("millis,stamp,datetime,whitePort,redPort,yellowPort,countNo.");
     
173. #endif //ECHO_TO_SERIAL
     
174. 
     
175.   // If you want to set the aref to something other than 5v
     
176. //  analogReference(EXTERNAL);
     
177. analogReference(DEFAULT);
     
178.   if (! RTC.isrunning()) {
     
179.   RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
     
180. }
     
181. }
     
182. 
     
183. 
     
184. void loop(void)
     
185. {
     
186.   while(1){
     
187.   DateTime now;
     
188. 
     
189.   readSW();//read START/STOP key and TIME_period select   
     
190. 
     
191.    if(int0Flag == true)
     
192.      {
     
193.       lcd.clear();
     
194.         if (int0Flag ==true){ evn0_count ++; }   
     
195.         Serial.print(F("evn0_count ="));
     
196.         Serial.println(evn0_count);
     
197.         now = RTC.now();
     
198.         lcd.setCursor(0, 2);
     
199.         lcd.print("A");
     
200.         lcd.print(now.day());
     
201.         lcd.print('/');
     
202.         lcd.print(now.month());
     
203.         lcd.print('/');
     
204.         lcd.print(now.year());
     
205.         lcd.setCursor(10, 2);//position,line
     
206.         lcd.print(" ");
     
207.         lcd.print(now.hour());
     
208.         lcd.print(':');
     
209.         lcd.print(now.minute());
     
210.         lcd.print(':');
     
211.         lcd.print(now.second());
     
212.         lcd.print(" ");            
     
213.         lcd.setCursor(1,3);
     
214.         lcd.print("A ");
     
215.         lcd.print(evn0_count);
     
216.         lcd.setCursor(10,3);
     
217.         lcd.print("B ");
     
218.         lcd.print(evn1_count);  
     
219. 
     
220.         uint32_t m = millis();
     
221.         logfile.print(m);           // milliseconds since start
     
222.         logfile.print(", ");   
     
223. #if ECHO_TO_SERIAL
     
224.   Serial.print(m);         // milliseconds since start
     
225.   Serial.print(", ");  
     
226. #endif
     
227. 
     
228.         now = RTC.now();
     
229.         logfile.print(now.unixtime()); // seconds since 1/1/1970
     
230.         logfile.print(", ");
     
231.         logfile.print('"');
     
232.         logfile.print(now.year(), DEC);
     
233.         logfile.print("/");
     
234.         logfile.print(now.month(), DEC);
     
235.         logfile.print("/");
     
236.         logfile.print(now.day(), DEC);
     
237.         logfile.print(" ");
     
238.         logfile.print(now.hour(), DEC);
     
239.         logfile.print(":");
     
240.         logfile.print(now.minute(), DEC);
     
241.         logfile.print(":");
     
242.         logfile.print(now.second(), DEC);
     
243.         logfile.print('"');
     
244. #if ECHO_TO_SERIAL
     
245.   Serial.print(now.unixtime()); // seconds since 1/1/1970
     
246.   Serial.print(", ");
     
247.   Serial.print('"');
     
248.   Serial.print(now.year(), DEC);
     
249.   Serial.print("/");
     
250.   Serial.print(now.month(), DEC);
     
251.   Serial.print("/");
     
252.   Serial.print(now.day(), DEC);
     
253.   Serial.print(" ");
     
254.   Serial.print(now.hour(), DEC);
     
255.   Serial.print(":");
     
256.   Serial.print(now.minute(), DEC);
     
257.   Serial.print(":");
     
258.   Serial.print(now.second(), DEC);
     
259.   Serial.print('"');
     
260. #endif //ECHO_TO_SERIAL
     
261. 
     
262.         analogRead(whitePortPin);
     
263.         delay(10);
     
264.         int whitePortReading = analogRead(whitePortPin);
     
265.         analogRead(redPortPin);
     
266.         delay(10);
     
267.         int redPortReading = analogRead(redPortPin);   
     
268.         analogRead(yellowPortPin); //2017
     
269.         delay(10);                 //2017
     
270.         int yellowPortReading = analogRead(yellowPortPin);  //2017
     
271. 
     
272.         float whiteVoltage = whitePortReading * aref_voltage * 8 / 1024;//2017
     
273.         float redVoltage = redPortReading * aref_voltage / 1024;//2017
     
274.         float yellowVoltage = yellowPortReading * aref_voltage * 4 / 1024;//2017
     
275.         logfile.print(", ");   
     
276.         logfile.print(whiteVoltage);//2017
     
277.         logfile.print(", ");   
     
278.         logfile.print(redVoltage);//2017
     
279.         logfile.print(", ");   
     
280.         logfile.print(yellowVoltage);//2017
     
281.   
     
282. #if ECHO_TO_SERIAL
     
283.   Serial.print(", ");   
     
284.   Serial.print(whiteVoltage);//2017
     
285.   Serial.print(", ");   
     
286.   Serial.print(redVoltage);//2017
     
287.   Serial.print(", ");   
     
288.   Serial.print(yellowVoltage);//2017
     
289. #endif //ECHO_TO_SERIAL
     
290. 
     
291.   // Log the estimated 'VCC' voltage by measuring the internal 1.1v ref
     
292.         analogRead(BANDGAPREF);
     
293.         delay(10);
     
294.         int refReading = analogRead(BANDGAPREF);
     
295.         float supplyvoltage = (bandgap_voltage * 1024) / refReading;
     
296.   
     
297.         logfile.print(", ");
     
298.   if(int0Flag ==true)
     
299.   {
     
300.     logfile.print(evn0_count);
     
301.     logfile.print(",A ");  
     
302.     int0Flag = false;
     
303.   }
     
304. 
     
305. #if ECHO_TO_SERIAL
     
306.   Serial.print(", ");   
     
307.   Serial.print(evn0_count);
     
308. #endif // ECHO_TO_SERIAL
     
309.     logfile.println();
     
310. #if ECHO_TO_SERIAL
     
311.   Serial.println();
     
312. #endif // ECHO_TO_SERIAL
     
313. 
     
314.   count++;
     
315.   }
     
316. //--------------interrupt 1----------------------
     
317.   
     
318. // int0 or int1 when interrupt triggered then evn0_count & evn1_count ++ 5count save file
     
319.   if(int1Flag == true)
     
320.      {
     
321.       lcd.clear();
     
322.         if (int1Flag ==true){ evn1_count ++; }   
     
323. 
     
324.         Serial.print(F("evn1_count ="));
     
325.         Serial.println(evn1_count);
     
326.         now = RTC.now();
     
327.         lcd.setCursor(0, 2);
     
328.         lcd.print("B");
     
329.         lcd.print(now.day());
     
330.         lcd.print('/');
     
331.         lcd.print(now.month());
     
332.         lcd.print('/');
     
333.         lcd.print(now.year());
     
334.         lcd.setCursor(10, 2);//position,line
     
335.         lcd.print(" ");
     
336.         lcd.print(now.hour());
     
337.         lcd.print(':');
     
338.         lcd.print(now.minute());
     
339.         lcd.print(':');
     
340.         lcd.print(now.second());
     
341.         lcd.print(" ");
     
342.       
     
343.         lcd.setCursor(1,3);
     
344.         lcd.print("A ");
     
345.         lcd.print(evn0_count);
     
346.         lcd.setCursor(10,3);
     
347.         lcd.print("B ");
     
348.         lcd.print(evn1_count);  
     
349.    // log milliseconds since starting
     
350.         uint32_t m = millis();
     
351.         logfile.print(m);           // milliseconds since start
     
352.         logfile.print(", ");   
     
353. #if ECHO_TO_SERIAL
     
354.   Serial.print(m);         // milliseconds since start
     
355.   Serial.print(", ");  
     
356. #endif
     
357. 
     
358.   // fetch the time
     
359.         now = RTC.now();
     
360.         logfile.print(now.unixtime()); // seconds since 1/1/1970
     
361.         logfile.print(", ");
     
362.         logfile.print('"');
     
363.         logfile.print(now.year(), DEC);
     
364.         logfile.print("/");
     
365.         logfile.print(now.month(), DEC);
     
366.         logfile.print("/");
     
367.         logfile.print(now.day(), DEC);
     
368.         logfile.print(" ");
     
369.         logfile.print(now.hour(), DEC);
     
370.         logfile.print(":");
     
371.         logfile.print(now.minute(), DEC);
     
372.         logfile.print(":");
     
373.         logfile.print(now.second(), DEC);
     
374.         logfile.print('"');
     
375. #if ECHO_TO_SERIAL
     
376.   Serial.print(now.unixtime()); // seconds since 1/1/1970
     
377.   Serial.print(", ");
     
378.   Serial.print('"');
     
379.   Serial.print(now.year(), DEC);
     
380.   Serial.print("/");
     
381.   Serial.print(now.month(), DEC);
     
382.   Serial.print("/");
     
383.   Serial.print(now.day(), DEC);
     
384.   Serial.print(" ");
     
385.   Serial.print(now.hour(), DEC);
     
386.   Serial.print(":");
     
387.   Serial.print(now.minute(), DEC);
     
388.   Serial.print(":");
     
389.   Serial.print(now.second(), DEC);
     
390.   Serial.print('"');
     
391. #endif //ECHO_TO_SERIAL
     
392. 
     
393.         analogRead(whitePortPin);
     
394.         delay(10);
     
395.         int whitePortReading = analogRead(whitePortPin);
     
396.         analogRead(redPortPin);
     
397.         delay(10);
     
398.         int redPortReading = analogRead(redPortPin);   
     
399.         analogRead(yellowPortPin); //2017
     
400.         delay(10);                 //2017
     
401.         int yellowPortReading = analogRead(yellowPortPin);  //2017
     
402.   
     
403. // converting that reading to voltage, for 3.3v arduino use 3.3, for 5.0, use 5.0
     
404. // float voltage = redPortReading * aref_voltage / 1024;  
     
405. // float temperatureC = (voltage - 0.5) * 100 ;
     
406. // float temperatureF = (temperatureC * 9 / 5) + 32;
     
407.         float whiteVoltage = whitePortReading * aref_voltage * 8 / 1024;//2017
     
408.         float redVoltage = redPortReading * aref_voltage / 1024;//2017
     
409.         float yellowVoltage = yellowPortReading * aref_voltage * 4 / 1024;//2017
     
410.         logfile.print(", ");   
     
411.         logfile.print(whiteVoltage);//2017
     
412.         logfile.print(", ");   
     
413.         logfile.print(redVoltage);//2017
     
414.         logfile.print(", ");   
     
415.         logfile.print(yellowVoltage);//2017
     
416.   
     
417. #if ECHO_TO_SERIAL
     
418.   Serial.print(", ");   
     
419.   Serial.print(whiteVoltage);//2017
     
420.   Serial.print(", ");   
     
421.   Serial.print(redVoltage);//2017
     
422.   Serial.print(", ");   
     
423.   Serial.print(yellowVoltage);//2017
     
424. #endif //ECHO_TO_SERIAL
     
425. 
     
426.   // Log the estimated 'VCC' voltage by measuring the internal 1.1v ref
     
427.         analogRead(BANDGAPREF);
     
428.         delay(10);
     
429.         int refReading = analogRead(BANDGAPREF);
     
430.         float supplyvoltage = (bandgap_voltage * 1024) / refReading;   
     
431.         logfile.print(", ");
     
432. 
     
433.    if(int1Flag ==true)
     
434.     {
     
435.      logfile.print(evn1_count);
     
436.      logfile.print(",B ");  
     
437.      int1Flag = false;
     
438.     }
     
439. #if ECHO_TO_SERIAL
     
440.   Serial.print(", ");   
     
441.   Serial.print(evn0_count);
     
442.   
     
443. #endif // ECHO_TO_SERIAL
     
444.     logfile.println();
     
445. #if ECHO_TO_SERIAL
     
446.   Serial.println();
     
447. #endif // ECHO_TO_SERIAL
     
448. 
     
449.   count++;
     
450.   }
     
451. //--------------end interrupt1----------------------------
     
452. //----20200201--time delay -1s -----------
     
453. if(Start_Stop_flag == true)
     
454. {
     
455.   if(millis()-startTime>1000)//1s 1 time
     
456.    {
     
457.     down_count_sec--;
     
458.     onesec = true;
     
459.     startTime = millis();
     
460.    }
     
461. // Serial.println("START status");
     
462. if(down_count_sec == 0)
     
463. {
     
464.           uint32_t m = millis();
     
465.         logfile.print(m);           // milliseconds since start
     
466.         logfile.print(", ");  
     
467.            now = RTC.now();
     
468.         logfile.print(now.unixtime()); // seconds since 1/1/1970
     
469.         logfile.print(", ");
     
470.         logfile.print('"');
     
471.         logfile.print(now.year(), DEC);
     
472.         logfile.print("/");
     
473.         logfile.print(now.month(), DEC);
     
474.         logfile.print("/");
     
475.         logfile.print(now.day(), DEC);
     
476.         logfile.print(" ");
     
477.         logfile.print(now.hour(), DEC);
     
478.         logfile.print(":");
     
479.         logfile.print(now.minute(), DEC);
     
480.         logfile.print(":");
     
481.         logfile.print(now.second(), DEC);
     
482.         logfile.print('"');
     
483. #if ECHO_TO_SERIAL
     
484.   Serial.print(now.unixtime()); // seconds since 1/1/1970
     
485.   Serial.print(", ");
     
486.   Serial.print('"');
     
487.   Serial.print(now.year(), DEC);
     
488.   Serial.print("/");
     
489.   Serial.print(now.month(), DEC);
     
490.   Serial.print("/");
     
491.   Serial.print(now.day(), DEC);
     
492.   Serial.print(" ");
     
493.   Serial.print(now.hour(), DEC);
     
494.   Serial.print(":");
     
495.   Serial.print(now.minute(), DEC);
     
496.   Serial.print(":");
     
497.   Serial.print(now.second(), DEC);
     
498.   Serial.print('"');
     
499. #endif //ECHO_TO_SERIAL
     
500. 
     
501.         analogRead(whitePortPin);
     
502.         delay(10);
     
503.         int whitePortReading = analogRead(whitePortPin);
     
504. //          Serial.print (F("whitePortPin "));
     
505. //            Serial.println(whitePortPin);
     
506. //         Serial.print (F("whitePortReading "));
     
507.         
     
508. //        Serial.println(whitePortReading);
     
509.         analogRead(redPortPin);
     
510.         delay(10);
     
511.         int redPortReading = analogRead(redPortPin);   
     
512.         analogRead(yellowPortPin); //2017
     
513.         delay(10);                 //2017
     
514.         int yellowPortReading = analogRead(yellowPortPin);  //2017
     
515. 
     
516.         float whiteVoltage = whitePortReading * aref_voltage * 8 / 1024;//2017
     
517.         float redVoltage = redPortReading * aref_voltage / 1024;//2017
     
518.         float yellowVoltage = yellowPortReading * aref_voltage * 4 / 1024;//2017
     
519.         logfile.print(", ");   
     
520.         logfile.print(whiteVoltage);//2017
     
521.         logfile.print(", ");   
     
522.         logfile.print(redVoltage);//2017
     
523.         logfile.print(", ");   
     
524.         logfile.print(yellowVoltage);//2017
     
525.         logfile.print(", ");
     
526.         logfile.print(time_record_count);
     
527.         logfile.print(",T ");  
     
528.         logfile.println();
     
529. 
     
530.   
     
531.     logfile.flush(); //????? 是否需要?
     
532. #if ECHO_TO_SERIAL
     
533.   Serial.print(", ");   
     
534.   Serial.print(whiteVoltage);//2017
     
535.   Serial.print(", ");   
     
536.   Serial.print(redVoltage);//2017
     
537.   Serial.print(", ");   
     
538.   Serial.print(yellowVoltage);//2017
     
539. #endif //ECHO_TO_SERIAL
     
540.     down_count_sec= Time_period[Time_periord_count];//reset timer counter
     
541.     Serial.println("down count complete status");
     
542.     time_record_count++;
     
543.     lcd.setCursor(16,1);
     
544.     lcd.print(time_record_count);
     
545. }
     
546. }
     
547. 
     
548. //-----20200201   end ------------
     
549.   
     
550.   if(count ==5)//per 5 time save 1 time to SD card
     
551.     {
     
552.        logfile.flush();
     
553.        count = 0;
     
554.     }
     
555. 
     
556. if(onesec ==true)//1S update once
     
557. {
     
558.   onesec = false;
     
559.    now = RTC.now();
     
560.     lcd.setCursor(0, 1);//position,line
     
561.     lcd.print("TIME");
     
562.     lcd.print(" ");
     
563.     lcd.print(now.hour());
     
564.     lcd.print(':');
     
565.     lcd.print(now.minute());
     
566.     lcd.print(':');
     
567.     lcd.print(now.second());
     
568.     lcd.print(" ");
     
569.     lcd.setCursor(0, 0);
     
570.     lcd.print("DATE");
     
571.     lcd.print(" ");
     
572.     lcd.print(now.day());
     
573.     lcd.print('/');
     
574.     lcd.print(now.month());
     
575.     lcd.print('/');
     
576.     lcd.print(now.year());
     
577. }
     
578. }
     
579. }
     
580. 
     
581. 
     
582. void EVN_1_ISR()//interruput 0
     
583. {
     
584. int0Flag = true;  
     
585. }
     
586. 
     
587. void EVN_2_ISR()//interrupt 1
     
588. {
     
589. int1Flag = true;  
     
590. }
     
591. 
     
592.   //--------20200201--------------------
     
593. void readSW(void)
     
594. {
     
595.     if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2))) //start/stop key
     
596.   {
     
597.     delay(200);
     
598.   if((!digitalRead(ReadKey1))&&(digitalRead(ReadKey2)))   
     
599. 
     
600.     {
     
601.      
     
602.       Start_Stop_flag = (!Start_Stop_flag);
     
603.       dsp_flag= true;
     
604.     }
     
605.   }
     
606.      if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2))) //key 2 pressed--
     
607.   {
     
608.     delay(100);
     
609.    if((digitalRead(ReadKey1))&&(!digitalRead(ReadKey2)))   
     
610.     {  
     
611.        Time_periord_count++;
     
612.          
     
613.       if(Time_periord_count >5){Time_periord_count =0;}
     
614. 
     
615.      dsp_flag= true;
     
616.      down_count_sec= Time_period[Time_periord_count];//reset timer counter
     
617.      Serial.print(F("Time period: "));
     
618.      Serial.println(Time_period[Time_periord_count]);   
     
619.     }
     
620.   }
     
621. 
     
622. if(dsp_flag== true)
     
623. {
     
624.     lcd.clear();
     
625.         lcd.setCursor(0,2);
     
626. 
     
627.       if(Start_Stop_flag == false)
     
628.         {
     
629.          lcd.setCursor(1,2);         
     
630.          lcd.print("STOP");
     
631.         }
     
632. 
     
633.       else
     
634.        {      
     
635.          lcd.print("START");
     
636.         }   
     
637.      lcd.setCursor(1,3);
     
638.      lcd.print(" Time period:      ");
     
639.      lcd.setCursor(14,3);
     
640.      lcd.print(Time_period[Time_periord_count]);
     
641.   dsp_flag = false;  
     
642. }  
     
643.   }
     
644. 
     
645.   //-----------20200201  END------------

複製代碼

spirit.twn

大師作品先收藏，再慢慢拜讀

antlu

spirit.twn 發表於 2020-2-7 04:32 AM
大師作品先收藏，再慢慢拜讀

您謬讚了!! 這只是新年期間的玩具而已!!

jason680

請教一下....

從硬體電路看起來
LCD 是4bits模式
程式用1bits
是否有什麼原因...

antlu

jason680 發表於 2020-2-7 04:39 PM
請教一下....

從硬體電路看起來

為了節省用腳 LCD 有兩個接法,第一個是使用 74HC595 把信號分成三個 DATA CLOCK LATCH 這是我以前寫的,手頭上有一堆 2402 總共腳位 DS1302 CLK DAT RST ,第二個是使用 I2C 的接法 SCLK 和 SDA 兩條線,因為 DS1307 RTC 也使用 I2C 介面,程式是別人寫的,使用 SD卡需要 SCK MISO MOSI CS 接腳,中斷 使用 INT0 INT1 按鍵兩隻腳. 雖然 ARDUINO 很方便,使用相同的MCU 但是不同的板子 UNO PROMINI NANO 接腳不同,PRO-MINI 沒有A4 A5 接線出來,所以無法做 I2C 連接, 程式下載需要外接 USB-RS232/TTL ...

jason680

antlu 發表於 2020-2-7 07:02 PM
為了節省用腳 LCD 有兩個接法,第一個是使用 74HC595 把信號分成三個 DATA CLOCK LATCH 這是我以前寫的,手 ...

看明白了,謝謝...
1. 是好幾塊板子
2. ARDUINO 只有畫出connector連接器
3. 控制LCM 中間經過74595
  serial input, parallel output 串入並出 可以節省腳位,要花時間移位...
4. RTC DS1302 走I2C界面
5. 兩個INT 有光耦合隔離
6. 其他
  按鍵(INC,DEC)跟LED 指示燈...
  SD卡再研究...

antlu

jason680 發表於 2020-2-8 01:52 PM
看明白了,謝謝...
1. 是好幾塊板子
2. ARDUINO 只有畫出connector連接器

RTC DS1302 不是走I2C  DS1307才是走I2C , 藍色的LCM 2004 用 I2C  .黃色的LCM 2402 用 74HC595 做的!!