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 63
- compare with another revision
- download diff
- download tarball
- view history from revision 63
- Committer: edam
- Date: 2012-03-03 10:06:31 UTC
- Revision ID: edam@waxworlds.org-20120303100631-ae3idks1703vdm05
widenned clock hands, tweaked scales, got top & bottom text modes working
- files added:
- src/drawer.cc
- files removed:
- test/rtc-test
- test/rtc-test/util
- files renamed:
- src/analogue_clock.cc => src/analogue_clock_mode.cc
- src/analogue_clock.h => src/analogue_clock_mode.h
- src/digital_clock.cc => src/digital_clock_mode.cc
- src/digital_clock.h => src/digital_clock_mode.h
- src/common.cc => src/display.cc
- src/common.h => src/display.h
- src/propeller-clock.cc => src/propeller-clock.ino
- src/test_pattern.cc => src/test_mode.cc
- src/test_pattern.h => src/test_mode.h
- files modified:
- .bzrignore
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:
76
76
******************************************************************************/
77
77
78
78
#include "config.h"
79
#include "display.h"
79
80
#include "button.h"
80
81
#include "time.h"
81
#include "Arduino.h"
82
#include "analogue_clock.h"
83
#include "digital_clock.h"
84
#include "test_pattern.h"
82
#include "switcher_major_mode.h"
83
#include "drawer.h"
85
84
86
85
//_____________________________________________________________________________
87
86
// data
88
87
88
89
89
// when non-zero, the time (in microseconds) of a new fan pulse that
90
90
// has just occurred, which means that segment drawing needs to be
91
91
// restarted
92
static unsigned long _new_pulse_at = 0;
92
static unsigned long new_pulse_at = 0;
93
93
94
94
// the time (in microseconds) when the last fan pulse occurred
95
static unsigned long _last_pulse_at = 0;
95
static unsigned long last_pulse_at = 0;
96
96
97
97
// duration (in microseconds) that a segment should be displayed
98
static unsigned long _segment_step = 0;
98
static unsigned long segment_step = 0;
99
99
100
100
// 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;
101
static unsigned long segment_step_sub_step = 0;
102
static unsigned long segment_step_sub = 0;
103
103
104
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
105
static Button button( 3 );
106
107
// major mode
108
static int major_mode = 0;
109
110
#define MAX_MAJOR_MODES 5
111
112
// major modes
113
static MajorMode *major_modes[ MAX_MAJOR_MODES ] = { 0 };
116
114
117
115
//_____________________________________________________________________________
118
116
// code
119
117
120
118
121
// activate the current minor mode
122
void activate_minor_mode()
123
{
124
switch( _minor_mode ) {
125
case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;
126
case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
127
}
128
}
129
130
119
// perform button events
131
void do_button_events()
120
void doButtonEvents()
132
121
{
133
122
// loop through pending events
134
while( int event = _button.get_event() )
123
while( int event = button.get_event() )
135
124
{
136
125
switch( event )
137
126
{
138
127
case 1:
139
128
// short press
140
switch( _major_mode ) {
141
case MAIN_MODE_IDX:
142
switch( _minor_mode ) {
143
case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;
144
case DIGITAL_CLOCK_IDX: digital_clock_press(); break;
145
}
146
break;
147
}
129
major_modes[ major_mode ]->press();
148
130
break;
149
131
150
132
case 2:
151
133
// long press
152
switch( _major_mode ) {
153
case MAIN_MODE_IDX:
154
if( ++_minor_mode >= 3 )
155
_minor_mode = 0;
156
switch( _minor_mode ) {
157
case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
158
}
159
break;
160
}
134
major_modes[ major_mode ]->long_press();
161
135
break;
162
136
163
137
case 3:
164
138
// looooong press (change major mode)
165
if( ++_major_mode > 0 )
166
_major_mode = 0;
167
switch( _major_mode ) {
168
case MAIN_MODE_IDX: _minor_mode = 0; break;
169
}
170
activate_minor_mode();
139
do {
140
if( ++major_mode >= MAX_MAJOR_MODES )
141
major_mode = 0;
142
} while( major_modes[ major_mode ] == NULL );
143
major_modes[ major_mode ]->activate();
171
144
break;
145
172
146
}
173
147
}
174
148
}
175
149
176
150
177
151
// draw a display segment
178
void draw_next_segment( bool reset )
152
void drawNextSegment( bool reset )
179
153
{
180
154
// keep track of segment
181
155
#if CLOCK_FORWARD
186
160
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
187
161
#endif
188
162
189
// frame reset
190
if( reset ) {
191
switch( _major_mode ) {
192
case MAIN_MODE_IDX:
193
switch( _minor_mode ) {
194
case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;
195
case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;
196
}
197
break;
198
}
199
}
200
201
163
// draw
202
switch( _major_mode ) {
203
case MAIN_MODE_IDX:
204
switch( _minor_mode ) {
205
case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;
206
case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;
207
case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;
208
}
209
break;
210
}
164
Drawer &drawer = major_modes[ major_mode ]->get_drawer();
165
if( reset ) drawer.draw_reset();
166
drawer.draw( segment );
211
167
212
168
#if CLOCK_FORWARD
213
169
if( ++segment >= NUM_SEGMENTS ) segment = 0;
218
174
219
175
220
176
// calculate time constants when a new pulse has occurred
221
void calculate_segment_times()
177
void calculateSegmentTimes()
222
178
{
223
179
// check for overflows, and only recalculate times if there isn't
224
180
// one (if there is, we'll just go with the last pulse's times)
225
if( _new_pulse_at > _last_pulse_at )
181
if( new_pulse_at > last_pulse_at )
226
182
{
227
183
// new segment stepping times
228
unsigned long delta = _new_pulse_at - _last_pulse_at;
229
_segment_step = delta / NUM_SEGMENTS;
230
_segment_step_sub = 0;
231
_segment_step_sub_step = delta % NUM_SEGMENTS;
184
unsigned long delta = new_pulse_at - last_pulse_at;
185
segment_step = delta / NUM_SEGMENTS;
186
segment_step_sub = 0;
187
segment_step_sub_step = delta % NUM_SEGMENTS;
232
188
}
233
189
234
190
// now we have dealt with this pulse, save the pulse time and
235
191
// clear new_pulse_at, ready for the next pulse
236
_last_pulse_at = _new_pulse_at;
237
_new_pulse_at = 0;
192
last_pulse_at = new_pulse_at;
193
new_pulse_at = 0;
238
194
}
239
195
240
196
241
197
// wait until it is time to draw the next segment or a new pulse has
242
198
// occurred
243
void wait_till_end_of_segment( bool reset )
199
void waitTillEndOfSegment( bool reset )
244
200
{
245
201
static unsigned long end_time = 0;
246
202
247
203
// handle reset
248
204
if( reset )
249
end_time = _last_pulse_at;
205
end_time = last_pulse_at;
250
206
251
207
// work out the time that this segment should be displayed until
252
end_time += _segment_step;
253
_segment_step_sub += _segment_step_sub_step;
254
if( _segment_step_sub >= NUM_SEGMENTS ) {
255
_segment_step_sub -= NUM_SEGMENTS;
208
end_time += segment_step;
209
segment_step_sub += segment_step_sub_step;
210
if( segment_step_sub >= NUM_SEGMENTS ) {
211
segment_step_sub -= NUM_SEGMENTS;
256
212
end_time++;
257
213
}
258
214
259
215
// wait
260
while( micros() < end_time && !_new_pulse_at );
216
while( micros() < end_time && !new_pulse_at );
261
217
}
262
218
263
219
264
220
// ISR to handle the pulses from the fan's tachiometer
265
void fan_pulse_handler()
221
void fanPulseHandler()
266
222
{
267
223
// the fan actually sends two pulses per revolution. These pulses
268
224
// may not be exactly evenly distributed around the rotation, so
273
229
if( !ignore )
274
230
{
275
231
// set a new pulse time
276
_new_pulse_at = micros();
232
new_pulse_at = micros();
277
233
}
278
234
}
279
235
282
238
void setup()
283
239
{
284
240
// set up an interrupt handler on pin 2 to nitice fan pulses
285
attachInterrupt( 0, fan_pulse_handler, RISING );
241
attachInterrupt( 0, fanPulseHandler, RISING );
286
242
digitalWrite( 2, HIGH );
287
243
288
244
// set up output pins (4 to 13) for the led array
293
249
pinMode( 3, INPUT );
294
250
digitalWrite( 3, HIGH );
295
251
static int event_times[] = { 5, 500, 4000, 0 };
296
_button.set_event_times( event_times );
297
298
// initialise RTC
299
Time::init();
300
301
// activate the minor mode
302
switch( _major_mode ) {
303
case MAIN_MODE_IDX: activate_minor_mode(); break;
304
}
252
button.set_event_times( event_times );
253
254
// set up major modes
255
static SwitcherMajorMode switcher_major_mode;
256
int mode = 0;
257
major_modes[ mode++ ] = &switcher_major_mode;
258
major_modes[ 0 ]->activate();
305
259
}
306
260
307
261
309
263
void loop()
310
264
{
311
265
// if there has been a new pulse, we'll be resetting the display
312
bool reset = _new_pulse_at? true : false;
266
bool reset = new_pulse_at? true : false;
313
267
314
268
// update button
315
_button.update();
269
button.update();
316
270
317
271
// only do this stuff at the start of a display cycle, to ensure
318
272
// that no state changes mid-display
319
273
if( reset )
320
274
{
321
275
// calculate segment times
322
calculate_segment_times();
276
calculateSegmentTimes();
323
277
324
278
// keep track of time
325
Time::update();
279
Time &time = Time::get_instance();
280
time.update();
326
281
327
282
// perform button events
328
do_button_events();
283
doButtonEvents();
329
284
}
330
285
331
286
// draw this segment
332
draw_next_segment( reset );
287
drawNextSegment( reset );
333
288
334
289
// wait till it's time to draw the next segment
335
wait_till_end_of_segment( reset );
290
waitTillEndOfSegment( reset );
336
291
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0