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.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 "button.h"
80
#include "time.h"
81
#include "Arduino.h"
82
#include "analogue_clock.h"
83
#include "digital_clock.h"
84
#include "test_pattern.h"
78
79
#include <Bounce.h>
80
#include <DS1307.h>
81
#include <Wire.h>
85
82
86
83
//_____________________________________________________________________________
87
84
// data
88
85
86
89
87
// when non-zero, the time (in microseconds) of a new fan pulse that
90
88
// has just occurred, which means that segment drawing needs to be
91
89
// restarted
92
static unsigned long _new_pulse_at = 0;
90
static unsigned long new_pulse_at = 0;
93
91
94
92
// the time (in microseconds) when the last fan pulse occurred
95
static unsigned long _last_pulse_at = 0;
93
static unsigned long last_pulse_at = 0;
96
94
97
95
// duration (in microseconds) that a segment should be displayed
98
static unsigned long _segment_step = 0;
96
static unsigned long segment_step = 0;
99
97
100
98
// remainder after divisor and a tally of the remainders for each segment
101
static unsigned long _segment_step_sub_step = 0;
102
static unsigned long _segment_step_sub = 0;
103
104
// the button
105
static Button _button( 3 );
106
107
// modes
108
static int _major_mode = 0;
109
static int _minor_mode = 0;
110
111
#define MAIN_MODE_IDX 0
112
113
#define ANALOGUE_CLOCK_IDX 0
114
#define DIGITAL_CLOCK_IDX 1
115
#define TEST_PATTERN_IDX 2
99
static unsigned long segment_step_sub_step = 0;
100
static unsigned long segment_step_sub = 0;
101
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 )
116
123
117
124
//_____________________________________________________________________________
118
125
// code
119
126
120
127
121
// activate the current minor mode
122
void activate_minor_mode()
128
// check for button presses
129
void checkButtons()
123
130
{
124
switch( _minor_mode ) {
125
case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
126
}
131
// update buttons
132
button.update();
133
134
// notice button presses
135
if( button.risingEdge() )
136
inc_draw_mode = true;
127
137
}
128
138
129
// perform button events
130
void do_button_events()
139
140
// keep track of time
141
void trackTime()
131
142
{
132
// loop through pending events
133
while( int event = _button.get_event() )
134
{
135
switch( event )
136
{
137
case 1:
138
// short press
139
switch( _major_mode ) {
140
case MAIN_MODE_IDX:
141
switch( _minor_mode ) {
142
case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;
143
case DIGITAL_CLOCK_IDX: digital_clock_press(); break;
144
}
145
break;
146
}
147
break;
148
149
case 2:
150
// long press
151
switch( _major_mode ) {
152
case MAIN_MODE_IDX:
153
if( ++_minor_mode >= 3 )
154
_minor_mode = 0;
155
switch( _minor_mode ) {
156
case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
157
}
158
break;
159
}
160
break;
161
162
case 3:
163
// looooong press (change major mode)
164
if( ++_major_mode > 0 )
165
_major_mode = 0;
166
switch( _major_mode ) {
167
case MAIN_MODE_IDX: _minor_mode = 0; break;
168
}
169
activate_minor_mode();
170
break;
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;
171
165
}
172
166
}
173
167
}
174
168
175
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
176
223
// draw a display segment
177
void draw_next_segment( bool reset )
224
void drawNextSegment( bool reset )
178
225
{
226
static int draw_mode = 0;
227
179
228
// keep track of segment
180
229
#if CLOCK_FORWARD
181
230
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
185
234
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
186
235
#endif
187
236
188
// draw
189
switch( _major_mode ) {
190
case MAIN_MODE_IDX:
191
switch( _minor_mode ) {
192
case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;
193
case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;
194
case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;
195
}
196
break;
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;
197
249
}
198
250
199
251
#if CLOCK_FORWARD
205
257
206
258
207
259
// calculate time constants when a new pulse has occurred
208
void calculate_segment_times()
260
void calculateSegmentTimes()
209
261
{
210
262
// check for overflows, and only recalculate times if there isn't
211
263
// one (if there is, we'll just go with the last pulse's times)
212
if( _new_pulse_at > _last_pulse_at )
264
if( new_pulse_at > last_pulse_at )
213
265
{
214
266
// new segment stepping times
215
unsigned long delta = _new_pulse_at - _last_pulse_at;
216
_segment_step = delta / NUM_SEGMENTS;
217
_segment_step_sub = 0;
218
_segment_step_sub_step = delta % NUM_SEGMENTS;
267
unsigned long delta = new_pulse_at - last_pulse_at;
268
segment_step = delta / NUM_SEGMENTS;
269
segment_step_sub = 0;
270
segment_step_sub_step = delta % NUM_SEGMENTS;
219
271
}
220
272
221
273
// now we have dealt with this pulse, save the pulse time and
222
274
// clear new_pulse_at, ready for the next pulse
223
_last_pulse_at = _new_pulse_at;
224
_new_pulse_at = 0;
275
last_pulse_at = new_pulse_at;
276
new_pulse_at = 0;
225
277
}
226
278
227
279
228
280
// wait until it is time to draw the next segment or a new pulse has
229
281
// occurred
230
void wait_till_end_of_segment( bool reset )
282
void waitTillNextSegment( bool reset )
231
283
{
232
284
static unsigned long end_time = 0;
233
285
234
286
// handle reset
235
287
if( reset )
236
end_time = _last_pulse_at;
288
end_time = last_pulse_at;
237
289
238
290
// work out the time that this segment should be displayed until
239
end_time += _segment_step;
240
_segment_step_sub += _segment_step_sub_step;
241
if( _segment_step_sub >= NUM_SEGMENTS ) {
242
_segment_step_sub -= NUM_SEGMENTS;
291
end_time += segment_step;
292
segment_step_sub += segment_step_sub_step;
293
if( segment_step_sub >= NUM_SEGMENTS ) {
294
segment_step_sub -= NUM_SEGMENTS;
243
295
end_time++;
244
296
}
245
297
246
298
// wait
247
while( micros() < end_time && !_new_pulse_at );
299
while( micros() < end_time && !new_pulse_at );
248
300
}
249
301
250
302
251
303
// ISR to handle the pulses from the fan's tachiometer
252
void fan_pulse_handler()
304
void fanPulseHandler()
253
305
{
254
306
// the fan actually sends two pulses per revolution. These pulses
255
307
// may not be exactly evenly distributed around the rotation, so
260
312
if( !ignore )
261
313
{
262
314
// set a new pulse time
263
_new_pulse_at = micros();
315
new_pulse_at = micros();
264
316
}
265
317
}
266
318
269
321
void setup()
270
322
{
271
323
// set up an interrupt handler on pin 2 to nitice fan pulses
272
attachInterrupt( 0, fan_pulse_handler, RISING );
324
attachInterrupt( 0, fanPulseHandler, RISING );
273
325
digitalWrite( 2, HIGH );
274
326
275
327
// set up output pins (4 to 13) for the led array
279
331
// set up mode-switch button on pin 3
280
332
pinMode( 3, INPUT );
281
333
digitalWrite( 3, HIGH );
282
static int event_times[] = { 5, 500, 4000, 0 };
283
_button.set_event_times( event_times );
284
285
// get time from RTC
286
Time::init();
287
288
// activate the minor mode
289
switch( _major_mode ) {
290
case MAIN_MODE_IDX: activate_minor_mode(); break;
291
}
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 );
292
344
}
293
345
294
346
296
348
void loop()
297
349
{
298
350
// if there has been a new pulse, we'll be resetting the display
299
bool reset = _new_pulse_at? true : false;
300
301
// update button
302
_button.update();
351
bool reset = new_pulse_at? true : false;
303
352
304
353
// only do this stuff at the start of a display cycle, to ensure
305
354
// that no state changes mid-display
306
355
if( reset )
307
356
{
308
// calculate segment times
309
calculate_segment_times();
357
// check buttons
358
checkButtons();
310
359
311
360
// keep track of time
312
Time::update();
313
314
// perform button events
315
do_button_events();
361
trackTime();
316
362
}
317
363
318
364
// draw this segment
319
draw_next_segment( reset );
365
drawNextSegment( reset );
366
367
// do we need to recalculate segment times?
368
if( reset )
369
calculateSegmentTimes();
320
370
321
371
// wait till it's time to draw the next segment
322
wait_till_end_of_segment( reset );
372
waitTillNextSegment( reset );
323
373
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0