开源下的丑丑蓝牙小表

diyreon

    在开源的网站下看到一个蓝牙小表，自己也去捣鼓一下：
放在桌面上的样子（面板是早上早餐卡免费送的，奇丑，勿喷.......）


拉了个橡皮筋绑在手里{:soso_e106:}





绝对不是土豪，专职吊打屌丝一名。
用到东西有：pro mini  ,HC-06蓝牙，DDS1306 OLED显示屏，一堆小线
：连线，热硅胶不可缺少的粘合物，奔着资源短缺就地利用见啥用啥的原则


基本的线接好之后，就这个挫样{:soso_e113:}

先装载APP,说到APP就难搞了，要安卓4.3以上才可以，让我等4.2的用户情何以堪，为了能顺利安装，把烂手机怒刷成4.4，结果APP装上了，手机的基本电话功给丧失了{:soso_e136:}.......


通过蓝牙控制可以操作手表的三种模式，模拟、数字、还有混合的
加个小电池，上电看看效果：


拉起橡皮筋（手表有误差.....别看肉包{:soso_e120:}）



在这基础上还可以添加其他的功能，例如温湿度啊，GPS啊等等，有待开发，好了，在这里谢谢原著，感谢开源，自己DIY了一把，玩了一下。贴出我稍微改动的代码：把显示模块改成了SPI模式

1. /*
   
2.     RetroWatch Arduino is a part of open source smart watch project.
   
3.     Copyright (C) 2014  Suh Young Bae
   
4. 
   
5.     This program is free software: you can redistribute it and/or modify
   
6.     it under the terms of the GNU General Public License as published by
   
7.     the Free Software Foundation, either version 3 of the License, or
   
8.     (at your option) any later version.
   
9. 
   
10.     This program is distributed in the hope that it will be useful,
    
11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    
12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
13.     GNU General Public License for more details.
    
14. 
    
15.     You should have received a copy of the GNU General Public License
    
16.     along with this program.  If not, see [http://www.gnu.org/licenses/].
    
17. */
    
18. /*
    
19. Retro Watch Arduino v1.0
    
20. 
    
21.   Get the latest version, android host app at
    
22.   ------> https://github.com/godstale/retrowatch
    
23.   ------> or http://www.hardcopyworld.com
    
24. 
    
25. Written by Suh Young Bae ([email][email protected][/email])
    
26. All text above, and the first splash screen(Adafruit) must be included in any redistribution
    
27. */
    
28. 
    
29. #include <avr/pgmspace.h>
    
30. #include <Wire.h>
    
31. #include <SoftwareSerial.h>
    
32. #include <Adafruit_GFX.h>
    
33. #include <Adafruit_SSD1306.h>
    
34. #include <math.h>
    
35. #include "bitmap.h"
    
36. #include <SPI.h>
    
37. 
    
38. ///////////////////////////////////////////////////////////////////
    
39. //----- OLED instance
    
40. #define OLED_MOSI   9
    
41. #define OLED_CLK   10
    
42. #define OLED_DC    11
    
43. #define OLED_CS    12
    
44. #define OLED_RESET 13
    
45. Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
    
46. 
    
47. #if (SSD1306_LCDHEIGHT != 64)
    
48. #error("Height incorrect, please fix Adafruit_SSD1306.h!");
    
49. #endif
    
50. ///////////////////////////////////////////////////////////////////
    
51. 
    
52. ///////////////////////////////////////////////////////////////////
    
53. //----- BT instance
    
54. SoftwareSerial BTSerial(2, 3); //Connect HC-06, RX, TX
    
55. ///////////////////////////////////////////////////////////////////
    
56. 
    
57. //----- Bluetooth transaction parsing
    
58. #define TR_MODE_IDLE 1
    
59. #define TR_MODE_WAIT_CMD 11
    
60. #define TR_MODE_WAIT_MESSAGE 101
    
61. #define TR_MODE_WAIT_TIME 111
    
62. #define TR_MODE_WAIT_ID 121
    
63. #define TR_MODE_WAIT_COMPLETE 201
    
64. 
    
65. #define TRANSACTION_START_BYTE 0xfc
    
66. #define TRANSACTION_END_BYTE 0xfd
    
67. 
    
68. #define CMD_TYPE_NONE 0x00
    
69. #define CMD_TYPE_RESET_EMERGENCY_OBJ 0x05
    
70. #define CMD_TYPE_RESET_NORMAL_OBJ 0x02
    
71. #define CMD_TYPE_RESET_USER_MESSAGE 0x03
    
72. 
    
73. #define CMD_TYPE_ADD_EMERGENCY_OBJ 0x11
    
74. #define CMD_TYPE_ADD_NORMAL_OBJ 0x12
    
75. #define CMD_TYPE_ADD_USER_MESSAGE 0x13
    
76. 
    
77. #define CMD_TYPE_DELETE_EMERGENCY_OBJ 0x21
    
78. #define CMD_TYPE_DELETE_NORMAL_OBJ 0x22
    
79. #define CMD_TYPE_DELETE_USER_MESSAGE 0x23
    
80. 
    
81. #define CMD_TYPE_SET_TIME 0x31
    
82. #define CMD_TYPE_REQUEST_MOVEMENT_HISTORY 0x32
    
83. #define CMD_TYPE_SET_CLOCK_STYLE 0x33
    
84. #define CMD_TYPE_SET_INDICATOR 0x34
    
85. 
    
86. #define CMD_TYPE_PING 0x51
    
87. #define CMD_TYPE_AWAKE 0x52
    
88. #define CMD_TYPE_SLEEP 0x53
    
89. #define CMD_TYPE_REBOOT 0x54
    
90. 
    
91. byte TRANSACTION_POINTER = TR_MODE_IDLE;
    
92. byte TR_COMMAND = CMD_TYPE_NONE;
    
93. 
    
94. //----- Message item buffer
    
95. #define MSG_COUNT_MAX 7
    
96. #define MSG_BUFFER_MAX 19
    
97. unsigned char msgBuffer[MSG_COUNT_MAX][MSG_BUFFER_MAX];
    
98. char msgParsingLine = 0;
    
99. char msgParsingChar = 0;
    
100. char msgCurDisp = 0;
     
101. 
     
102. //----- Emergency item buffer
     
103. #define EMG_COUNT_MAX 3
     
104. #define EMG_BUFFER_MAX 19
     
105. char emgBuffer[EMG_COUNT_MAX][EMG_BUFFER_MAX];
     
106. char emgParsingLine = 0;
     
107. char emgParsingChar = 0;
     
108. char emgCurDisp = 0;
     
109. 
     
110. //----- Time
     
111. #define UPDATE_TIME_INTERVAL 60000
     
112. byte iMonth = 1;
     
113. byte iDay = 1;
     
114. byte iWeek = 1;    // 1: SUN, MON, TUE, WED, THU, FRI,SAT
     
115. byte iAmPm = 0;    // 0:AM, 1:PM
     
116. byte iHour = 0;
     
117. byte iMinutes = 0;
     
118. byte iSecond = 0;
     
119. 
     
120. #define TIME_BUFFER_MAX 6
     
121. char timeParsingIndex = 0;
     
122. char timeBuffer[6] = {-1, -1, -1, -1, -1, -1};
     
123. PROGMEM const char* weekString[] = {"", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
     
124. PROGMEM const char* ampmString[] = {"AM", "PM"};
     
125. 
     
126. //----- Display features
     
127. #define DISPLAY_MODE_START_UP 0
     
128. #define DISPLAY_MODE_CLOCK 1
     
129. #define DISPLAY_MODE_EMERGENCY_MSG 2
     
130. #define DISPLAY_MODE_NORMAL_MSG 3
     
131. #define DISPLAY_MODE_IDLE 11
     
132. byte displayMode = DISPLAY_MODE_START_UP;
     
133. 
     
134. #define CLOCK_STYLE_SIMPLE_ANALOG  0x01
     
135. #define CLOCK_STYLE_SIMPLE_DIGIT  0x02
     
136. #define CLOCK_STYLE_SIMPLE_MIX  0x03
     
137. byte clockStyle = CLOCK_STYLE_SIMPLE_MIX;
     
138. 
     
139. #define INDICATOR_ENABLE 0x01
     
140. boolean updateIndicator = true;
     
141. 
     
142. byte centerX = 64;
     
143. byte centerY = 32;
     
144. byte iRadius = 28;
     
145. 
     
146. #define IDLE_DISP_INTERVAL 60000
     
147. #define CLOCK_DISP_INTERVAL 60000
     
148. #define EMERGENCY_DISP_INTERVAL 5000
     
149. #define MESSAGE_DISP_INTERVAL 3000
     
150. unsigned long prevClockTime = 0;
     
151. unsigned long prevDisplayTime = 0;
     
152. 
     
153. unsigned long next_display_interval = 0;
     
154. unsigned long mode_change_timer = 0;
     
155. #define CLOCK_DISPLAY_TIME 300000
     
156. #define EMER_DISPLAY_TIME 10000
     
157. #define MSG_DISPLAY_TIME 5000
     
158. 
     
159. //----- Button control
     
160. int buttonPin = 5;
     
161. boolean isClicked = false;
     
162. 
     
163. 
     
164. 
     
165. void setup()   {
     
166.   //Serial.begin(9600);    // Do not enable serial. This makes serious problem because of shortage of RAM.
     
167.   pinMode(buttonPin, INPUT);  // Defines button pin
     
168.   
     
169.   init_emg_array();
     
170.   init_msg_array();
     
171.   
     
172.   //----- by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
     
173.   display.begin(SSD1306_SWITCHCAPVCC);  // initialize with the I2C addr 0x3D (for the 128x64)
     
174.   display.display();    // show splashscreen
     
175.   delay(1000);
     
176.   drawStartUp();    // Show RetroWatch Logo
     
177.   centerX = display.width() / 2;
     
178.   centerY = display.height() / 2;
     
179.   iRadius = centerY - 2;
     
180. 
     
181.   BTSerial.begin(9600);  // set the data rate for the BT port
     
182. }
     
183. 
     
184. 
     
185. void loop()
     
186. {
     
187.   boolean isReceived = false;
     
188.   unsigned long current_time = 0;
     
189.   
     
190.   // Get button input
     
191.   if(digitalRead(buttonPin) == LOW) isClicked = LOW;
     
192.   
     
193.   // Receive data from remote and parse
     
194.   isReceived = receiveBluetoothData();
     
195.   
     
196.   // Update clock time
     
197.   current_time = millis();
     
198.   updateTime(current_time);
     
199.   
     
200.   // Display routine
     
201.   onDraw(current_time);
     
202.   
     
203.   // If data doesn't arrive, wait for a while to save battery
     
204.   if(!isReceived)
     
205.     delay(300);
     
206. }
     
207. 
     
208. 
     
209. 
     
210. 
     
211. ///////////////////////////////////
     
212. //----- Utils
     
213. ///////////////////////////////////
     
214. void init_msg_array() {
     
215.   for(int i=0; i<MSG_COUNT_MAX; i++) {
     
216.     for(int j=0; j<MSG_BUFFER_MAX; j++) {
     
217.       msgBuffer[i][j] = 0x00;
     
218.     }
     
219.   }
     
220.   msgParsingLine = 0;
     
221.   msgParsingChar = 0;    // First 2 byte is management byte
     
222.   msgCurDisp = 0;
     
223. }
     
224. 
     
225. void init_emg_array() {
     
226.   for(int i=0; i<EMG_COUNT_MAX; i++) {
     
227.     for(int j=0; j<EMG_BUFFER_MAX; j++) {
     
228.       emgBuffer[i][j] = 0x00;
     
229.     }
     
230.   }
     
231.   emgParsingLine = 0;
     
232.   emgParsingChar = 0;    // First 2 byte is management byte
     
233.   emgCurDisp = 0;
     
234. }
     
235. 
     
236. ///////////////////////////////////
     
237. //----- Time functions
     
238. ///////////////////////////////////
     
239. void setTimeValue() {
     
240.   iMonth = timeBuffer[0];
     
241.   iDay = timeBuffer[1];
     
242.   iWeek = timeBuffer[2];    // 1: SUN, MON, TUE, WED, THU, FRI,SAT
     
243.   iAmPm = timeBuffer[3];    // 0:AM, 1:PM
     
244.   iHour = timeBuffer[4];
     
245.   iMinutes = timeBuffer[5];
     
246. }
     
247. 
     
248. void updateTime(unsigned long current_time) {
     
249.   if(iMinutes >= 0) {
     
250.     if(current_time - prevClockTime > UPDATE_TIME_INTERVAL) {
     
251.       // Increase time
     
252.       iMinutes++;
     
253.       if(iMinutes >= 60) {
     
254.         iMinutes = 0;
     
255.         iHour++;
     
256.         if(iHour > 12) {
     
257.           iHour = 1;
     
258.           (iAmPm == 0) ? iAmPm=1 : iAmPm=0;
     
259.           if(iAmPm == 0) {
     
260.             iWeek++;
     
261.             if(iWeek > 7)
     
262.               iWeek = 1;
     
263.             iDay++;
     
264.             if(iDay > 30)  // Yes. day is not exact.
     
265.               iDay = 1;
     
266.           }
     
267.         }
     
268.       }
     
269.       prevClockTime = current_time;
     
270.     }
     
271.   }
     
272.   else {
     
273.     displayMode = DISPLAY_MODE_START_UP;
     
274.   }
     
275. }
     
276. 
     
277. ///////////////////////////////////
     
278. //----- BT, Data parsing functions
     
279. ///////////////////////////////////
     
280. 
     
281. // Parsing packet according to current mode
     
282. boolean receiveBluetoothData() {
     
283.   int isTransactionEnded = false;
     
284.   while(!isTransactionEnded) {
     
285.     if(BTSerial.available()) {
     
286.       byte c = BTSerial.read();
     
287.       
     
288.       if(c == 0xFF && TRANSACTION_POINTER != TR_MODE_WAIT_MESSAGE) return false;
     
289.       
     
290.       if(TRANSACTION_POINTER == TR_MODE_IDLE) {
     
291.         parseStartSignal(c);
     
292.       }
     
293.       else if(TRANSACTION_POINTER == TR_MODE_WAIT_CMD) {
     
294.         parseCommand(c);
     
295.       }
     
296.       else if(TRANSACTION_POINTER == TR_MODE_WAIT_MESSAGE) {
     
297.         parseMessage(c);
     
298.       }
     
299.       else if(TRANSACTION_POINTER == TR_MODE_WAIT_TIME) {
     
300.         parseTime(c);
     
301.       }
     
302.       else if(TRANSACTION_POINTER == TR_MODE_WAIT_ID) {
     
303.         parseId(c);
     
304.       }
     
305.       else if(TRANSACTION_POINTER == TR_MODE_WAIT_COMPLETE) {
     
306.         isTransactionEnded = parseEndSignal(c);
     
307.       }
     
308.       
     
309.     }  // End of if(BTSerial.available())
     
310.     else {
     
311.       isTransactionEnded = true;
     
312.     }
     
313.   }  // End of while()
     
314.   return true;
     
315. }  // End of receiveBluetoothData()
     
316. 
     
317. void parseStartSignal(byte c) {
     
318.   //drawLogChar(c);
     
319.   if(c == TRANSACTION_START_BYTE) {
     
320.     TRANSACTION_POINTER = TR_MODE_WAIT_CMD;
     
321.     TR_COMMAND = CMD_TYPE_NONE;
     
322.   }
     
323. }
     
324. 
     
325. void parseCommand(byte c) {
     
326.   if(c == CMD_TYPE_RESET_EMERGENCY_OBJ || c == CMD_TYPE_RESET_NORMAL_OBJ || c == CMD_TYPE_RESET_USER_MESSAGE) {
     
327.     TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
328.     TR_COMMAND = c;
     
329.     processTransaction();
     
330.   }
     
331.   else if(c == CMD_TYPE_ADD_EMERGENCY_OBJ || c == CMD_TYPE_ADD_NORMAL_OBJ || c == CMD_TYPE_ADD_USER_MESSAGE) {
     
332.     TRANSACTION_POINTER = TR_MODE_WAIT_MESSAGE;
     
333.     TR_COMMAND = c;
     
334.     if(c == CMD_TYPE_ADD_EMERGENCY_OBJ) {
     
335.       emgParsingChar = 0;
     
336.       if(emgParsingLine >= MSG_COUNT_MAX || emgParsingLine < 0)
     
337.         emgParsingLine = 0;
     
338.     }
     
339.     else if(c == CMD_TYPE_ADD_NORMAL_OBJ) {
     
340.       msgParsingChar = 0;
     
341.       if(msgParsingLine >= MSG_COUNT_MAX || msgParsingLine < 0)
     
342.         msgParsingLine = 0;
     
343.     }
     
344.   }
     
345.   else if(c == CMD_TYPE_DELETE_EMERGENCY_OBJ || c == CMD_TYPE_DELETE_NORMAL_OBJ || c == CMD_TYPE_DELETE_USER_MESSAGE) {
     
346.     TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
347.     TR_COMMAND = c;
     
348.   }
     
349.   else if(c == CMD_TYPE_SET_TIME) {
     
350.     TRANSACTION_POINTER = TR_MODE_WAIT_TIME;
     
351.     TR_COMMAND = c;
     
352.   }
     
353.   else if(c == CMD_TYPE_SET_CLOCK_STYLE || c == CMD_TYPE_SET_INDICATOR) {
     
354.     TRANSACTION_POINTER = TR_MODE_WAIT_ID;
     
355.     TR_COMMAND = c;
     
356.   }
     
357.   else {
     
358.     TRANSACTION_POINTER = TR_MODE_IDLE;
     
359.     TR_COMMAND = CMD_TYPE_NONE;
     
360.   }
     
361. }
     
362. 
     
363. void parseMessage(byte c) {
     
364.   if(c == TRANSACTION_END_BYTE) {
     
365.     processTransaction();
     
366.     TRANSACTION_POINTER = TR_MODE_IDLE;
     
367.   }
     
368.   
     
369.   if(TR_COMMAND == CMD_TYPE_ADD_EMERGENCY_OBJ) {
     
370.     if(emgParsingChar < EMG_BUFFER_MAX) {
     
371.       if(emgParsingChar > 1) {
     
372.         emgBuffer[emgParsingLine][emgParsingChar] = c;
     
373.       }
     
374.       emgParsingChar++;
     
375.     }
     
376.     else {
     
377.       TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
378.     }
     
379.   }
     
380.   else if(TR_COMMAND == CMD_TYPE_ADD_NORMAL_OBJ) {
     
381.     if(msgParsingChar < MSG_BUFFER_MAX) {
     
382.       if(msgParsingChar > 1) {
     
383.         msgBuffer[msgParsingLine][msgParsingChar] = c;
     
384.       }
     
385.       msgParsingChar++;
     
386.     }
     
387.     else {
     
388.       TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
389.     }
     
390.   }
     
391.   else if(TR_COMMAND == CMD_TYPE_ADD_USER_MESSAGE) {
     
392.     // Not available yet.
     
393.     TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
394.   }
     
395. }
     
396. 
     
397. void parseTime(byte c) {
     
398.   if(TR_COMMAND == CMD_TYPE_SET_TIME) {
     
399.     if(timeParsingIndex >= 0 && timeParsingIndex < TIME_BUFFER_MAX) {
     
400.       timeBuffer[timeParsingIndex] = (int)c;
     
401.       timeParsingIndex++;
     
402.     }
     
403.     else {
     
404.       processTransaction();
     
405.       TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
406.     }
     
407.   }
     
408. }
     
409. 
     
410. void parseId(byte c) {
     
411.   if(TR_COMMAND == CMD_TYPE_SET_CLOCK_STYLE) {
     
412.     clockStyle = c;
     
413.     processTransaction();
     
414.   }
     
415.   else if(TR_COMMAND == CMD_TYPE_SET_INDICATOR) {
     
416.     if(c == INDICATOR_ENABLE)
     
417.       updateIndicator = true;
     
418.     else
     
419.       updateIndicator = false;
     
420.     processTransaction();
     
421.   }
     
422.   TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
     
423. }
     
424. 
     
425. boolean parseEndSignal(byte c) {
     
426.   if(c == TRANSACTION_END_BYTE) {
     
427.     TRANSACTION_POINTER = TR_MODE_IDLE;
     
428.     return true;
     
429.   }
     
430.   return false;
     
431. }
     
432. 
     
433. void processTransaction() {
     
434.   if(TR_COMMAND == CMD_TYPE_RESET_EMERGENCY_OBJ) {
     
435.     init_emg_array();//init_msg_array();
     
436.   }
     
437.   else if(TR_COMMAND == CMD_TYPE_RESET_NORMAL_OBJ) {
     
438.     init_msg_array();//init_emg_array();
     
439.   }
     
440.   else if(TR_COMMAND == CMD_TYPE_RESET_USER_MESSAGE) {
     
441.     // Not available yet.
     
442.   }
     
443.   else if(TR_COMMAND == CMD_TYPE_ADD_NORMAL_OBJ) {
     
444.     msgBuffer[msgParsingLine][0] = 0x01;
     
445.     msgParsingChar = 0;
     
446.     msgParsingLine++;
     
447.     if(msgParsingLine >= MSG_COUNT_MAX)
     
448.       msgParsingLine = 0;
     
449.     setNextDisplayTime(millis(), 0);  // update screen immediately
     
450.   }
     
451.   else if(TR_COMMAND == CMD_TYPE_ADD_EMERGENCY_OBJ) {
     
452.     emgBuffer[emgParsingLine][0] = 0x01;
     
453.     emgParsingChar = 0;
     
454.     emgParsingLine++;
     
455.     if(emgParsingLine >= EMG_COUNT_MAX)
     
456.       emgParsingLine = 0;
     
457.     startEmergencyMode();
     
458.     setNextDisplayTime(millis(), 2000);
     
459.   }
     
460.   else if(TR_COMMAND == CMD_TYPE_ADD_USER_MESSAGE) {
     
461.   }
     
462.   else if(TR_COMMAND == CMD_TYPE_DELETE_EMERGENCY_OBJ || TR_COMMAND == CMD_TYPE_DELETE_NORMAL_OBJ || TR_COMMAND == CMD_TYPE_DELETE_USER_MESSAGE) {
     
463.     // Not available yet.
     
464.   }
     
465.   else if(TR_COMMAND == CMD_TYPE_SET_TIME) {
     
466.     setTimeValue();
     
467.     timeParsingIndex = 0;
     
468.     setNextDisplayTime(millis(), 0);  // update screen immediately
     
469.   }
     
470.   if(TR_COMMAND == CMD_TYPE_SET_CLOCK_STYLE || CMD_TYPE_SET_INDICATOR) {
     
471.     setNextDisplayTime(millis(), 0);  // update screen immediately
     
472.   }
     
473. }
     
474. 
     
475. ///////////////////////////////////
     
476. //----- Drawing methods
     
477. ///////////////////////////////////
     
478. 
     
479. // Main drawing routine.
     
480. // Every drawing starts here.
     
481. void onDraw(unsigned long currentTime) {
     
482.   if(!isDisplayTime(currentTime))    // Do not re-draw at every tick
     
483.     return;
     
484.   
     
485.   if(displayMode == DISPLAY_MODE_START_UP) {
     
486.     drawStartUp();
     
487.   }
     
488.   else if(displayMode == DISPLAY_MODE_CLOCK) {
     
489.     if(isClicked == LOW) {    // User input received
     
490.       startEmergencyMode();
     
491.       setPageChangeTime(0);    // Change mode with no page-delay
     
492.       setNextDisplayTime(currentTime, 0);    // Do not wait next re-draw time
     
493.     }
     
494.     else {
     
495.       drawClock();
     
496.       
     
497.       if(isPageChangeTime(currentTime)) {  // It's time to go into idle mode
     
498.         startIdleMode();
     
499.         setPageChangeTime(currentTime);  // Set a short delay
     
500.       }
     
501.       setNextDisplayTime(currentTime, CLOCK_DISP_INTERVAL);
     
502.     }
     
503.   }
     
504.   else if(displayMode == DISPLAY_MODE_EMERGENCY_MSG) {
     
505.     if(findNextEmerMessage()) {
     
506.       drawEmergency();
     
507.       emgCurDisp++;
     
508.       if(emgCurDisp >= EMG_COUNT_MAX) {
     
509.         emgCurDisp = 0;
     
510.         startMessageMode();
     
511.       }
     
512.       setNextDisplayTime(currentTime, EMERGENCY_DISP_INTERVAL);
     
513.     }
     
514.     // There's no message left to display. Go to normal message mode.
     
515.     else {
     
516.       startMessageMode();
     
517.       //setPageChangeTime(0);
     
518.       setNextDisplayTime(currentTime, 0);  // with no re-draw interval
     
519.     }
     
520.   }
     
521.   else if(displayMode == DISPLAY_MODE_NORMAL_MSG) {
     
522.     if(findNextNormalMessage()) {
     
523.       drawMessage();
     
524.       msgCurDisp++;
     
525.       if(msgCurDisp >= MSG_COUNT_MAX) {
     
526.         msgCurDisp = 0;
     
527.         startClockMode();
     
528.       }
     
529.       setNextDisplayTime(currentTime, MESSAGE_DISP_INTERVAL);
     
530.     }
     
531.     // There's no message left to display. Go to clock mode.
     
532.     else {
     
533.       startClockMode();
     
534.       setPageChangeTime(currentTime);
     
535.       setNextDisplayTime(currentTime, 0);  // with no re-draw interval
     
536.     }
     
537.   }
     
538.   else if(displayMode == DISPLAY_MODE_IDLE) {
     
539.     if(isClicked == LOW) {    // Wake up watch if there's an user input
     
540.       startClockMode();
     
541.       setPageChangeTime(currentTime);
     
542.       setNextDisplayTime(currentTime, 0);
     
543.     }
     
544.     else {
     
545.       drawIdleClock();
     
546.       setNextDisplayTime(currentTime, IDLE_DISP_INTERVAL);
     
547.     }
     
548.   }
     
549.   else {
     
550.     startClockMode();    // This means there's an error
     
551.   }
     
552.   
     
553.   isClicked = HIGH;
     
554. }  // End of onDraw()
     
555. 
     
556. 
     
557. // To avoid re-draw on every drawing time
     
558. // wait for time interval according to current mode
     
559. // But user input(button) breaks this sleep
     
560. boolean isDisplayTime(unsigned long currentTime) {
     
561.   if(currentTime - prevDisplayTime > next_display_interval) {
     
562.     return true;
     
563.   }
     
564.   if(isClicked == LOW) {
     
565.     delay(500);
     
566.     return true;
     
567.   }
     
568.   return false;
     
569. }
     
570. 
     
571. // Set next re-draw time
     
572. void setNextDisplayTime(unsigned long currentTime, unsigned long nextUpdateTime) {
     
573.   next_display_interval = nextUpdateTime;
     
574.   prevDisplayTime = currentTime;
     
575. }
     
576. 
     
577. // Decide if it's the time to change page(mode)
     
578. boolean isPageChangeTime(unsigned long currentTime) {
     
579.   if(displayMode == DISPLAY_MODE_CLOCK) {
     
580.     if(currentTime - mode_change_timer > CLOCK_DISPLAY_TIME)
     
581.       return true;
     
582.   }
     
583.   return false;
     
584. }
     
585. 
     
586. // Set time interval to next page(mode)
     
587. void setPageChangeTime(unsigned long currentTime) {
     
588.   mode_change_timer = currentTime;
     
589. }
     
590. 
     
591. // Check if available emergency message exists or not
     
592. boolean findNextEmerMessage() {
     
593.   if(emgCurDisp < 0 || emgCurDisp >= EMG_COUNT_MAX) emgCurDisp = 0;
     
594.   while(true) {
     
595.     if(emgBuffer[emgCurDisp][0] == 0x00) {  // 0x00 means disabled
     
596.       emgCurDisp++;
     
597.       if(emgCurDisp >= EMG_COUNT_MAX) {
     
598.         emgCurDisp = 0;
     
599.         return false;
     
600.       }
     
601.     }
     
602.     else {
     
603.       break;
     
604.     }
     
605.   }  // End of while()
     
606.   return true;
     
607. }
     
608. 
     
609. // Check if available normal message exists or not
     
610. boolean findNextNormalMessage() {
     
611.   if(msgCurDisp < 0 || msgCurDisp >= MSG_COUNT_MAX) msgCurDisp = 0;
     
612.   while(true) {
     
613.     if(msgBuffer[msgCurDisp][0] == 0x00) {
     
614.       msgCurDisp++;
     
615.       if(msgCurDisp >= MSG_COUNT_MAX) {
     
616.         msgCurDisp = 0;
     
617.         return false;
     
618.       }
     
619.     }
     
620.     else {
     
621.       break;
     
622.     }
     
623.   }  // End of while()
     
624.   return true;
     
625. }
     
626. 
     
627. // Count all available emergency messages
     
628. int countEmergency() {
     
629.   int count = 0;
     
630.   for(int i=0; i<EMG_COUNT_MAX; i++) {
     
631.     if(emgBuffer[i][0] != 0x00)
     
632.       count++;
     
633.   }
     
634.   return count;
     
635. }
     
636. 
     
637. // Count all available normal messages
     
638. int countMessage() {
     
639.   int count = 0;
     
640.   for(int i=0; i<MSG_COUNT_MAX; i++) {
     
641.     if(msgBuffer[i][0] != 0x00)
     
642.       count++;
     
643.   }
     
644.   return count;
     
645. }
     
646. 
     
647. void startClockMode() {
     
648.   displayMode = DISPLAY_MODE_CLOCK;
     
649. }
     
650. 
     
651. void startEmergencyMode() {
     
652.   displayMode = DISPLAY_MODE_EMERGENCY_MSG;
     
653.   emgCurDisp = 0;
     
654. }
     
655. 
     
656. void startMessageMode() {
     
657.   displayMode = DISPLAY_MODE_NORMAL_MSG;
     
658.   msgCurDisp = 0;
     
659. }
     
660. 
     
661. void startIdleMode() {
     
662.   displayMode = DISPLAY_MODE_IDLE;
     
663. }
     
664. 
     
665. // Draw indicator. Indicator shows count of emergency and normal message
     
666. void drawIndicator() {
     
667.   if(updateIndicator) {
     
668.     int msgCount = countMessage();
     
669.     int emgCount = countEmergency();
     
670.     int drawCount = 1;
     
671.    
     
672.     if(msgCount > 0) {
     
673.       display.drawBitmap(127 - 8, 1, IMG_indicator_msg, 8, 8, WHITE);
     
674.       display.setTextColor(WHITE);
     
675.       display.setTextSize(1);
     
676.       display.setCursor(127 - 15, 1);
     
677.       display.print(msgCount);
     
678.       drawCount++;
     
679.     }
     
680.    
     
681.     if(emgCount > 0) {
     
682.       display.drawBitmap(127 - 8*drawCount - 7*(drawCount-1), 1, IMG_indicator_emg, 8, 8, WHITE);
     
683.       display.setTextColor(WHITE);
     
684.       display.setTextSize(1);
     
685.       display.setCursor(127 - 8*drawCount - 7*drawCount, 1);
     
686.       display.print(emgCount);
     
687.     }
     
688. 
     
689.   }
     
690. }
     
691. 
     
692. // RetroWatch splash screen
     
693. void drawStartUp() {
     
694.   display.clearDisplay();
     
695.   
     
696.   display.drawBitmap(10, 15, IMG_logo_24x24, 24, 24, WHITE);
     
697.   
     
698.   display.setTextSize(2);
     
699.   display.setTextColor(WHITE);
     
700.   display.setCursor(45,12);
     
701.   display.println("Retro");
     
702.   display.setCursor(45,28);
     
703.   display.println("Watch");
     
704.   display.setTextSize(1);
     
705.   display.setCursor(45,45);
     
706.   display.setTextColor(WHITE);
     
707.   display.println("Arduino v1.0");
     
708.   display.display();
     
709.   delay(2000);
     
710.   
     
711.   startClockMode();
     
712. }
     
713. 
     
714. // Draw emergency message page
     
715. void drawEmergency() {
     
716.   int icon_num = 60;
     
717.   display.clearDisplay();
     
718.   
     
719.   if(updateIndicator)
     
720.     drawIndicator();
     
721.   
     
722.   if(emgBuffer[emgCurDisp][2] > -1 && emgBuffer[emgCurDisp][2] < ICON_ARRAY_SIZE)
     
723.     icon_num = (int)(emgBuffer[emgCurDisp][2]);
     
724.   
     
725.   drawIcon(centerX - 8, centerY - 20, icon_num);
     
726.   
     
727.   display.setTextColor(WHITE);
     
728.   display.setTextSize(1);
     
729.   display.setCursor(getCenterAlignedXOfEmg(emgCurDisp), centerY + 10);
     
730.   for(int i=3; i<EMG_BUFFER_MAX; i++) {
     
731.     char curChar = emgBuffer[emgCurDisp][i];
     
732.     if(curChar == 0x00) break;
     
733.     if(curChar >= 0xf0) continue;
     
734.     display.write(curChar);
     
735.   }
     
736. 
     
737.   display.display();
     
738. }
     
739. 
     
740. // Draw normal message page
     
741. void drawMessage() {
     
742.   int icon_num = 0;
     
743.   display.clearDisplay();
     
744.   
     
745.   if(updateIndicator)
     
746.     drawIndicator();
     
747.   
     
748.   if(msgBuffer[msgCurDisp][2] > -1 && msgBuffer[msgCurDisp][2] < ICON_ARRAY_SIZE)
     
749.     icon_num = (int)(msgBuffer[msgCurDisp][2]);
     
750.   
     
751.   drawIcon(centerX - 8, centerY - 20, icon_num);
     
752.   
     
753.   display.setTextColor(WHITE);
     
754.   display.setTextSize(1);
     
755.   display.setCursor(getCenterAlignedXOfMsg(msgCurDisp), centerY + 10);
     
756. //  display.print(msgCurDisp);  // For debug
     
757.   for(int i=3; i<MSG_BUFFER_MAX; i++) {
     
758.     char curChar = msgBuffer[msgCurDisp][i];
     
759.     if(curChar == 0x00) break;
     
760.     if(curChar >= 0xf0) continue;
     
761.     display.write(curChar);
     
762.   }
     
763. 
     
764.   display.display();
     
765. }
     
766. 
     
767. // Draw main clock screen
     
768. // Clock style changes according to user selection
     
769. void drawClock() {
     
770.   display.clearDisplay();
     
771. 
     
772.   if(updateIndicator)
     
773.     drawIndicator();
     
774.   
     
775.   // CLOCK_STYLE_SIMPLE_DIGIT
     
776.   if(clockStyle == CLOCK_STYLE_SIMPLE_DIGIT) {
     
777.     display.setTextSize(2);
     
778.     display.setTextColor(WHITE);
     
779.     display.setCursor(centerX - 34, centerY - 17);
     
780.     display.println((const char*)pgm_read_word(&(weekString[iWeek])));
     
781.     display.setTextSize(2);
     
782.     display.setCursor(centerX + 11, centerY - 17);
     
783.     display.println((const char*)pgm_read_word(&(ampmString[iAmPm])));
     
784. 
     
785.     display.setTextSize(2);
     
786.     display.setCursor(centerX - 29, centerY + 6);
     
787.     if(iHour < 10)
     
788.       display.print("0");
     
789.     display.print(iHour);
     
790.     display.print(":");
     
791.     if(iMinutes < 10)
     
792.       display.print("0");
     
793.     display.println(iMinutes);
     
794.    
     
795.     display.display();
     
796.   }
     
797.   // CLOCK_STYLE_SIMPLE_MIX
     
798.   else if(clockStyle == CLOCK_STYLE_SIMPLE_MIX) {
     
799.     display.drawCircle(centerY, centerY, iRadius - 6, WHITE);
     
800.     showTimePin(centerY, centerY, 0.1, 0.4, iHour*5 + (int)(iMinutes*5/60));
     
801.     showTimePin(centerY, centerY, 0.1, 0.70, iMinutes);
     
802.    
     
803.     display.setTextSize(1);
     
804.     display.setTextColor(WHITE);
     
805.     display.setCursor(centerY*2 + 3, 23);
     
806.     display.println((const char*)pgm_read_word(&(weekString[iWeek])));
     
807.     display.setCursor(centerY*2 + 28, 23);
     
808.     display.println((const char*)pgm_read_word(&(ampmString[iAmPm])));
     
809.    
     
810.     display.setTextSize(2);
     
811.     display.setCursor(centerY*2, 37);
     
812.     if(iHour < 10)
     
813.       display.print("0");
     
814.     display.print(iHour);
     
815.     display.print(":");
     
816.     if(iMinutes < 10)
     
817.       display.print("0");
     
818.     display.println(iMinutes);
     
819.     display.display();
     
820.   }
     
821.   else {
     
822.     // CLOCK_STYLE_SIMPLE_ANALOG.
     
823.     display.drawCircle(centerX, centerY, iRadius, WHITE);
     
824.     showTimePin(centerX, centerY, 0.1, 0.5, iHour*5 + (int)(iMinutes*5/60));
     
825.     showTimePin(centerX, centerY, 0.1, 0.78, iMinutes);
     
826.     // showTimePin(centerX, centerY, 0.1, 0.9, iSecond);
     
827.     display.display();
     
828.    
     
829.     iSecond++;
     
830.     if(iSecond > 60) iSecond = 0;
     
831.   }
     
832. }
     
833. 
     
834. // Draw idle page
     
835. void drawIdleClock() {
     
836.     display.clearDisplay();
     
837. 
     
838.     if(updateIndicator)
     
839.       drawIndicator();
     
840. 
     
841.     display.setTextSize(2);
     
842.     display.setCursor(centerX - 29, centerY - 4);
     
843.     if(iHour < 10)
     
844.       display.print("0");
     
845.     display.print(iHour);
     
846.     display.print(":");
     
847.     if(iMinutes < 10)
     
848.       display.print("0");
     
849.     display.println(iMinutes);
     
850. 
     
851.     display.display();
     
852. }
     
853. 
     
854. // Returns starting point of normal string to display
     
855. int getCenterAlignedXOfMsg(int msgIndex) {
     
856.   int pointX = centerX;
     
857.   for(int i=3; i<MSG_BUFFER_MAX; i++) {
     
858.     char curChar = msgBuffer[msgIndex][i];
     
859.     if(curChar == 0x00) break;
     
860.     if(curChar >= 0xf0) continue;
     
861.     pointX -= 3;
     
862.   }
     
863.   if(pointX < 0) pointX = 0;
     
864.   return pointX;
     
865. }
     
866. 
     
867. // Returns starting point of emergency string to display
     
868. int getCenterAlignedXOfEmg(int emgIndex) {
     
869.   int pointX = centerX;
     
870.   for(int i=3; i<EMG_BUFFER_MAX; i++) {
     
871.     char curChar = emgBuffer[emgIndex][i];
     
872.     if(curChar == 0x00) break;
     
873.     if(curChar >= 0xf0) continue;
     
874.     pointX -= 3;
     
875.   }
     
876.   if(pointX < 0) pointX = 0;
     
877.   return pointX;
     
878. }
     
879. 
     
880. // Calculate clock pin position
     
881. double RAD=3.141592/180;
     
882. double LR = 89.99;
     
883. void showTimePin(int center_x, int center_y, double pl1, double pl2, double pl3) {
     
884.   double x1, x2, y1, y2;
     
885.   x1 = center_x + (iRadius * pl1) * cos((6 * pl3 + LR) * RAD);
     
886.   y1 = center_y + (iRadius * pl1) * sin((6 * pl3 + LR) * RAD);
     
887.   x2 = center_x + (iRadius * pl2) * cos((6 * pl3 - LR) * RAD);
     
888.   y2 = center_y + (iRadius * pl2) * sin((6 * pl3 - LR) * RAD);
     
889.   
     
890.   display.drawLine((int)x1, (int)y1, (int)x2, (int)y2, WHITE);
     
891. }
     
892. 
     
893. // Icon drawing tool
     
894. void drawIcon(int posx, int posy, int icon_num) {
     
895.   if(icon_num < 0 || icon_num >= ICON_ARRAY_SIZE)
     
896.     return;
     
897.    
     
898.   display.drawBitmap(posx, posy, (const unsigned char*)pgm_read_word(&(bitmap_array[icon_num])), 16, 16, WHITE);
     
899. }
     

复制代码

出处的网址http://www.hardcopyworld.com/ngine/aduino/index.php/archives/670

林定祥

穿戴式原型机有意思.

wing

很可爱呢

shihaipeng04

太好玩了，可惜啊，这个时间，第一眼看见的是蘑菇肉包，瞬间就饿的不行了。 楼主的杀伤力太大了

diyreon

shihaipeng04 发表于 2014-7-1 12:19
太好玩了，可惜啊，这个时间，第一眼看见的是蘑菇肉包，瞬间就饿的不行了。 楼主的杀伤力太大了

没有亚克力，早上真功夫路边发传单卡用来就地用的，勿看包子

diyreon

wing 发表于 2014-7-1 12:17
很可爱呢

哈哈

diyreon

林定祥 发表于 2014-7-1 11:54
穿戴式原型机有意思.

只能找到这个卡片做外客了

幻生幻灭

第一眼看见的还以为是蘑菇云。。。

pdfan

显示屏是什么型号？，那个TI的表是什么表？

heiketiguo

以前看过这个，但他用的是I2C，中国的OLED屏用Adafruit库只能用SPI，楼主这个屏在哪买的？

heiketiguo

http://www.instructables.com/id/ ... art-watch/?ALLSTEPS

504835618

编译出错！！！

diyreon

幻生幻灭 发表于 2014-7-1 18:47
第一眼看见的还以为是蘑菇云。。。

包子是亮点

diyreon

pdfan 发表于 2014-7-1 18:52
显示屏是什么型号？，那个TI的表是什么表？

SSD1306  终于有人知道TI的表了，当年参加电赛TI送的

diyreon

heiketiguo 发表于 2014-7-1 21:20
以前看过这个，但他用的是I2C，中国的OLED屏用Adafruit库只能用SPI，楼主这个屏在哪买的？

我做了两个，这个是SPI的屏，把代码修改了一下，今天再买了一个I2C的屏，把温湿度也加上去了
感觉挺好玩的