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
- test/rtc-test
- test/rtc-test/util
- files renamed:
- src/propeller-clock.cc => src/propeller-clock.ino
- files modified:
- .bzrignore
- src/Makefile
added
removed
src/propeller-clock.ino
28
28
29
29
* a PC fan is wired up to a 12V power supply
30
30
31
* the fan's SENSE (tachometer) pin connected to pin 2 on the
32
Arduino.
31
* the fan's SENSE (tachiometer) pin connected to pin 2 on the
32
arduino.
33
33
34
* the pins 4 to 13 on the Arduino should directly drive an LED (the
34
* the pins 4 to 13 on the arduino should directly drive an LED (the
35
35
LED on pin 4 is in the centre of the clock face and the LED on pin
36
36
13 is at the outside.
37
37
38
38
* if a longer hand (and a larger clock face) is desired, pin 4 can be
39
39
used to indirectly drive a transistor which in turn drives several
40
LEDs that turn on and off in unison in the centre of the clock.
40
LEDs that turn on anf off in unison in the centre of the clock.
41
41
42
42
* a button should be attached to pin 3 that grounds it when pressed.
43
43
44
* A DS1307 remote clock is connected via I2C on analogue pins 4 and 5.
44
* A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
45
45
46
46
Implementation details:
47
47
50
50
* the timing of the drawing of the clock face is recalculated with
51
51
every rotation of the propeller.
52
52
53
* a PC fan actually sends 2 tachometer pulses per revolution, so the
53
* a PC fan actually sends 2 tachiometer pulses per revolution, so the
54
54
software skips every other one. This means that the clock may
55
55
appear upside-down if started with the propeller in the wrong
56
position. You will need to experiment to discover the position that
56
position. You will need to experiment to dicsover the position that
57
57
the propeller must be in when starting the clock.
58
58
59
59
Usage instructions:
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"
85
#include "settings_mode.h"
86
#include "text.h"
87
#include "text_renderer.h"
88
#include "common.h"
78
79
#include <Bounce.h>
80
#include <DS1307.h>
81
#include <Wire.h>
89
82
90
83
//_____________________________________________________________________________
91
84
// data
92
85
86
93
87
// when non-zero, the time (in microseconds) of a new fan pulse that
94
88
// has just occurred, which means that segment drawing needs to be
95
89
// restarted
96
static unsigned long _new_pulse_at = 0;
90
static unsigned long new_pulse_at = 0;
97
91
98
92
// the time (in microseconds) when the last fan pulse occurred
99
static unsigned long _last_pulse_at = 0;
93
static unsigned long last_pulse_at = 0;
100
94
101
95
// duration (in microseconds) that a segment should be displayed
102
static unsigned long _segment_step = 0;
96
static unsigned long segment_step = 0;
103
97
104
98
// remainder after divisor and a tally of the remainders for each segment
105
static unsigned long _segment_step_sub_step = 0;
106
static unsigned long _segment_step_sub = 0;
107
108
// the button
109
static Button _button( 3 );
110
111
// modes
112
static int _major_mode = 0;
113
static int _minor_mode = 0;
114
115
#define MAIN_MODE_IDX 1
116
#define SETTINGS_MODE_IDX 0
117
118
#define ANALOGUE_CLOCK_IDX 0
119
#define DIGITAL_CLOCK_IDX 1
120
#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 )
121
123
122
124
//_____________________________________________________________________________
123
125
// code
124
126
125
127
126
// activate the current minor mode
127
void activate_minor_mode()
128
{
129
// reset text
130
Text::reset();
131
leds_off();
132
133
// give the mode a chance to init
134
switch( _minor_mode ) {
135
case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;
136
case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
137
}
138
}
139
140
141
// activate major mode
142
void activate_major_mode()
143
{
144
// reset text
145
Text::reset();
146
leds_off();
147
148
// reset buttons
149
_button.set_press_mode( _major_mode != SETTINGS_MODE_IDX );
150
151
// give the mode a chance to init
152
switch( _major_mode ) {
153
case MAIN_MODE_IDX: activate_minor_mode(); break;
154
case SETTINGS_MODE_IDX: settings_mode_activate(); break;
155
}
156
}
157
158
159
// perform button events
160
void do_button_events()
161
{
162
// loop through pending events
163
while( int event = _button.get_event() )
164
{
165
switch( event )
166
{
167
case 1:
168
// short press
169
switch( _major_mode ) {
170
case MAIN_MODE_IDX:
171
switch( _minor_mode ) {
172
case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;
173
case DIGITAL_CLOCK_IDX: digital_clock_press(); break;
174
}
175
break;
176
case SETTINGS_MODE_IDX: settings_mode_press(); break;
177
}
178
break;
179
180
case 2:
181
// long press
182
switch( _major_mode ) {
183
case MAIN_MODE_IDX:
184
if( ++_minor_mode >= 3 )
185
_minor_mode = 0;
186
activate_minor_mode();
187
break;
188
case SETTINGS_MODE_IDX: settings_mode_long_press(); break;
189
}
190
break;
191
192
case 3:
193
// looooong press (change major mode)
194
if( ++_major_mode > 1 )
195
_major_mode = 0;
196
activate_major_mode();
197
break;
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;
198
165
}
199
166
}
200
167
}
201
168
202
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
203
223
// draw a display segment
204
void draw_next_segment( bool reset )
224
void drawNextSegment( bool reset )
205
225
{
226
static int draw_mode = 0;
227
206
228
// keep track of segment
207
229
#if CLOCK_FORWARD
208
230
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
212
234
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
213
235
#endif
214
236
215
// reset the text renderer
216
TextRenderer::reset_buffer();
217
218
// frame reset
219
if( reset ) {
220
switch( _major_mode ) {
221
case MAIN_MODE_IDX:
222
switch( _minor_mode ) {
223
case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;
224
case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;
225
}
226
break;
227
case SETTINGS_MODE_IDX: settings_mode_draw_reset(); break;
228
}
229
230
// tell the text services we're starting a new frame
231
Text::draw_reset();
232
}
233
234
// draw
235
switch( _major_mode ) {
236
case MAIN_MODE_IDX:
237
switch( _minor_mode ) {
238
case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;
239
case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;
240
case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;
241
}
242
break;
243
case SETTINGS_MODE_IDX: settings_mode_draw( segment ); break;
244
}
245
246
// draw any text that was rendered
247
TextRenderer::output_buffer();
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
}
248
250
249
251
#if CLOCK_FORWARD
250
252
if( ++segment >= NUM_SEGMENTS ) segment = 0;
255
257
256
258
257
259
// calculate time constants when a new pulse has occurred
258
void calculate_segment_times()
260
void calculateSegmentTimes()
259
261
{
260
262
// check for overflows, and only recalculate times if there isn't
261
263
// one (if there is, we'll just go with the last pulse's times)
262
if( _new_pulse_at > _last_pulse_at )
264
if( new_pulse_at > last_pulse_at )
263
265
{
264
266
// new segment stepping times
265
unsigned long delta = _new_pulse_at - _last_pulse_at;
266
_segment_step = delta / NUM_SEGMENTS;
267
_segment_step_sub = 0;
268
_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;
269
271
}
270
272
271
273
// now we have dealt with this pulse, save the pulse time and
272
274
// clear new_pulse_at, ready for the next pulse
273
_last_pulse_at = _new_pulse_at;
274
_new_pulse_at = 0;
275
last_pulse_at = new_pulse_at;
276
new_pulse_at = 0;
275
277
}
276
278
277
279
278
280
// wait until it is time to draw the next segment or a new pulse has
279
281
// occurred
280
void wait_till_end_of_segment( bool reset )
282
void waitTillNextSegment( bool reset )
281
283
{
282
284
static unsigned long end_time = 0;
283
285
284
286
// handle reset
285
287
if( reset )
286
end_time = _last_pulse_at;
288
end_time = last_pulse_at;
287
289
288
290
// work out the time that this segment should be displayed until
289
end_time += _segment_step;
290
_segment_step_sub += _segment_step_sub_step;
291
if( _segment_step_sub >= NUM_SEGMENTS ) {
292
_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;
293
295
end_time++;
294
296
}
295
297
296
298
// wait
297
while( micros() < end_time && !_new_pulse_at );
299
while( micros() < end_time && !new_pulse_at );
298
300
}
299
301
300
302
301
303
// ISR to handle the pulses from the fan's tachiometer
302
void fan_pulse_handler()
304
void fanPulseHandler()
303
305
{
304
306
// the fan actually sends two pulses per revolution. These pulses
305
307
// may not be exactly evenly distributed around the rotation, so
310
312
if( !ignore )
311
313
{
312
314
// set a new pulse time
313
_new_pulse_at = micros();
315
new_pulse_at = micros();
314
316
}
315
317
}
316
318
319
321
void setup()
320
322
{
321
323
// set up an interrupt handler on pin 2 to nitice fan pulses
322
attachInterrupt( 0, fan_pulse_handler, RISING );
324
attachInterrupt( 0, fanPulseHandler, RISING );
323
325
digitalWrite( 2, HIGH );
324
326
325
327
// set up output pins (4 to 13) for the led array
329
331
// set up mode-switch button on pin 3
330
332
pinMode( 3, INPUT );
331
333
digitalWrite( 3, HIGH );
332
static int event_times[] = { 5, 500, 4000, 0 };
333
_button.set_event_times( event_times );
334
335
// initialise RTC
336
Time::init();
337
338
// init text renderer
339
TextRenderer::init();
340
341
// activate the minor mode
342
activate_major_mode();
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 );
343
344
}
344
345
345
346
347
348
void loop()
348
349
{
349
350
// if there has been a new pulse, we'll be resetting the display
350
bool reset = _new_pulse_at? true : false;
351
352
// update button
353
_button.update();
351
bool reset = new_pulse_at? true : false;
354
352
355
353
// only do this stuff at the start of a display cycle, to ensure
356
354
// that no state changes mid-display
357
355
if( reset )
358
356
{
359
// calculate segment times
360
calculate_segment_times();
357
// check buttons
358
checkButtons();
361
359
362
360
// keep track of time
363
Time::update();
364
365
// perform button events
366
do_button_events();
361
trackTime();
367
362
}
368
363
369
364
// draw this segment
370
draw_next_segment( reset );
365
drawNextSegment( reset );
366
367
// do we need to recalculate segment times?
368
if( reset )
369
calculateSegmentTimes();
371
370
372
371
// wait till it's time to draw the next segment
373
wait_till_end_of_segment( reset );
372
waitTillNextSegment( reset );
374
373
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0