To get this branch, use:
bzr branch
http://bzr.ed.am/elec/propeller-clock
« back to all changes in this revision
Viewing changes to src/propeller-clock.ino
- browse files at revision 54
- compare with another revision
- download diff
- download tarball
- view history from revision 54
- Committer: edam
- Date: 2012-02-23 20:18:22 UTC
- Revision ID: edam@waxworlds.org-20120223201822-dno5n4fwvd35izq9
changed 12-tick to a double tick, added CLOCK_SHIFT to align face and fixed hour-hand
- files added:
- src/util/Bounce.cpp
- files removed:
- src/analogue_clock_mode.cc
- files renamed:
- src/propeller-clock.cc => src/propeller-clock.ino
- files modified:
- .bzrignore
- src/Makefile
added
removed
src/propeller-clock.ino
75
75
76
76
******************************************************************************/
77
77
78
#include "config.h"
79
#include "display.h"
80
#include "button.h"
81
#include "time.h"
82
#include "switcher_major_mode.h"
83
#include "drawer.h"
84
#include "Arduino.h"
78
79
#include <Bounce.h>
80
#include <DS1307.h>
81
#include <Wire.h>
85
82
86
83
//_____________________________________________________________________________
87
84
// data
102
99
static unsigned long segment_step_sub_step = 0;
103
100
static unsigned long segment_step_sub = 0;
104
101
105
// the button
106
static Button button( 3 );
107
108
// major mode
109
static int major_mode = 0;
110
111
#define MAX_MAJOR_MODES 5
112
113
// major modes
114
static MajorMode *major_modes[ MAX_MAJOR_MODES ] = { 0 };
102
// flag to indicate that the drawing mode should be cycled to the next one
103
static bool inc_draw_mode = false;
104
105
// a bounce-managed button
106
static Bounce button( 3, 50 );
107
108
// the time
109
static int time_hours = 0;
110
static int time_minutes = 0;
111
static int time_seconds = 0;
112
113
// number of segments in a full display (rotation) is 60 (one per
114
// second) times the desired number of sub-divisions of a second
115
#define NUM_SECOND_SEGMENTS 5
116
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
117
118
// clock draw direction
119
#define CLOCK_FORWARD 0
120
121
// rotate display (in segments)
122
#define CLOCK_SHIFT ( 58 * NUM_SECOND_SEGMENTS - 1 )
115
123
116
124
//_____________________________________________________________________________
117
125
// code
118
126
119
127
120
// perform button events
121
void doButtonEvents()
122
{
123
// loop through pending events
124
while( int event = button.get_event() )
125
{
126
switch( event )
127
{
128
case 1:
129
// short press
130
major_modes[ major_mode ]->press();
131
break;
132
133
case 2:
134
// long press
135
major_modes[ major_mode ]->long_press();
136
break;
137
138
case 3:
139
// looooong press (change major mode)
140
do {
141
if( ++major_mode >= MAX_MAJOR_MODES )
142
major_mode = 0;
143
} while( major_modes[ major_mode ] == NULL );
144
major_modes[ major_mode ]->activate();
145
break;
146
128
// check for button presses
129
void checkButtons()
130
{
131
// update buttons
132
button.update();
133
134
// notice button presses
135
if( button.risingEdge() )
136
inc_draw_mode = true;
137
}
138
139
140
// keep track of time
141
void trackTime()
142
{
143
// previous time and any carried-over milliseconds
144
static unsigned long last_time = millis();
145
static unsigned long carry = 0;
146
147
// how many milliseonds have elapsed since we last checked?
148
unsigned long next_time = millis();
149
unsigned long delta = next_time - last_time + carry;
150
151
// update the previous time and carried-over milliseconds
152
last_time = next_time;
153
carry = delta % 1000;
154
155
// add the seconds that have passed to the time
156
time_seconds += delta / 1000;
157
while( time_seconds >= 60 ) {
158
time_seconds -= 60;
159
time_minutes++;
160
if( time_minutes >= 60 ) {
161
time_minutes -= 60;
162
time_hours++;
163
if( time_hours >= 24 )
164
time_hours -= 24;
147
165
}
148
166
}
149
167
}
150
168
151
169
170
// turn an led on/off
171
void ledOn( int num, bool on )
172
{
173
if( num < 0 || num > 9 ) return;
174
175
// convert to pin no.
176
num += 4;
177
178
// pin 4 needs to be inverted (it's driving a PNP)
179
if( num == 4 ) on = !on;
180
181
digitalWrite( num, on? HIGH : LOW );
182
}
183
184
185
// draw a segment for the test display
186
void drawNextSegment_test( int segment )
187
{
188
// turn on outside LEDs
189
ledOn( 9, true );
190
191
// display segment number in binary across in the inside LEDs,
192
// with the LED on pin 12 showing the least-significant bit
193
for( int a = 0; a < 9; a++ )
194
ledOn( 8 - a, ( segment >> a ) & 1 );
195
}
196
197
198
// draw a segment for the time display
199
void drawNextSegment_time( int segment )
200
{
201
int second = segment / NUM_SECOND_SEGMENTS;
202
int second_segment = segment % NUM_SECOND_SEGMENTS;
203
204
// what needs to be drawn?
205
bool draw_tick = ( !second_segment && second % 5 == 0 && second ) ||
206
( second == 0 && second_segment == 1 ) ||
207
( second == 59 && second_segment == NUM_SECOND_SEGMENTS - 1 );
208
bool draw_second = !second_segment && second == time_seconds;
209
bool draw_minute = !second_segment && second == time_minutes;
210
bool draw_hour = segment == time_hours * 5 * NUM_SECOND_SEGMENTS +
211
( 5 * NUM_SECOND_SEGMENTS * time_minutes / 60 );
212
213
// set the LEDs
214
ledOn( 9, true );
215
ledOn( 8, draw_tick || draw_second );
216
for( int a = 6; a <= 7; a++ )
217
ledOn( a, draw_minute || draw_second );
218
for( int a = 0; a <= 5; a++ )
219
ledOn( a, draw_minute || draw_second || draw_hour );
220
}
221
222
152
223
// draw a display segment
153
224
void drawNextSegment( bool reset )
154
225
{
226
static int draw_mode = 0;
227
155
228
// keep track of segment
156
229
#if CLOCK_FORWARD
157
230
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
161
234
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
162
235
#endif
163
236
164
// draw
165
Drawer &drawer = major_modes[ major_mode ]->get_drawer();
166
if( reset ) drawer.draw_reset();
167
drawer.draw( segment );
237
// handle mode switch requests
238
if( reset && inc_draw_mode ) {
239
inc_draw_mode = false;
240
draw_mode++;
241
if( draw_mode >= 2 )
242
draw_mode = 0;
243
}
244
245
// draw the segment
246
switch( draw_mode ) {
247
case 0: drawNextSegment_test( segment ); break;
248
case 1: drawNextSegment_time( segment ); break;
249
}
168
250
169
251
#if CLOCK_FORWARD
170
252
if( ++segment >= NUM_SEGMENTS ) segment = 0;
197
279
198
280
// wait until it is time to draw the next segment or a new pulse has
199
281
// occurred
200
void waitTillEndOfSegment( bool reset )
282
void waitTillNextSegment( bool reset )
201
283
{
202
284
static unsigned long end_time = 0;
203
285
249
331
// set up mode-switch button on pin 3
250
332
pinMode( 3, INPUT );
251
333
digitalWrite( 3, HIGH );
252
static int event_times[] = { 5, 500, 4000, 0 };
253
button.set_event_times( event_times );
254
255
// set up major modes
256
static SwitcherMajorMode switcher_major_mode;
257
int mode = 0;
258
major_modes[ mode++ ] = &switcher_major_mode;
259
major_modes[ 0 ]->activate();
334
335
// get the time from the real-time clock
336
int rtc_data[ 7 ];
337
RTC.get( rtc_data, true );
338
time_hours = rtc_data[ DS1307_HR ];
339
time_minutes = rtc_data[ DS1307_MIN ];
340
time_seconds = rtc_data[ DS1307_SEC ];
341
342
// serial comms
343
Serial.begin( 9600 );
260
344
}
261
345
262
346
266
350
// if there has been a new pulse, we'll be resetting the display
267
351
bool reset = new_pulse_at? true : false;
268
352
269
// update button
270
button.update();
271
272
353
// only do this stuff at the start of a display cycle, to ensure
273
354
// that no state changes mid-display
274
355
if( reset )
275
356
{
276
// calculate segment times
277
calculateSegmentTimes();
357
// check buttons
358
checkButtons();
278
359
279
360
// keep track of time
280
Time &time = Time::get_instance();
281
time.update();
282
283
// perform button events
284
doButtonEvents();
361
trackTime();
285
362
}
286
363
287
364
// draw this segment
288
365
drawNextSegment( reset );
289
366
367
// do we need to recalculate segment times?
368
if( reset )
369
calculateSegmentTimes();
370
290
371
// wait till it's time to draw the next segment
291
waitTillEndOfSegment( reset );
372
waitTillNextSegment( reset );
292
373
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0