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 31
- compare with another revision
- download diff
- download tarball
- view history from revision 31
- Committer: edam
- Date: 2012-01-01 14:05:28 UTC
- Revision ID: edam@waxworlds.org-20120101140528-ldqldo67nil1xf1s
added arduino.mk to the project
- files added:
- src/util/Bounce.cpp
- files removed:
- arduino.mk
- test/fan-test
- test/fan-test/Makefile
- test/led-test
- test/led-test/Makefile
- test/phantom-button-presses
- test/phantom-button-presses/Makefile
- files renamed:
- test/fan-test/fan-test.ino => test/fan-test.pde
- files modified:
- electronics-information
added
removed
src/propeller-clock.ino
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
1
/*
3
2
* propeller-clock.ino
4
3
*
36
35
13 is at the outside.
37
36
38
37
* if a longer hand (and a larger clock face) is desired, pin 4 can be
39
used to indirectly drive a transistor which in turn drives several
40
LEDs that turn on anf off in unison in the centre of the clock.
38
used to indirectly drive (via a MOSFET) multiple LEDs which turn on
39
and off in unison in the centre of the clock.
41
40
42
41
* a button should be attached to pin 3 that grounds it when pressed.
43
42
44
* A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
45
46
43
Implementation details:
47
44
48
* for a schematic, see ../project/propeller-clock.sch.
45
* for a schematic, see project/propeller-clock.sch.
49
46
50
47
* the timing of the drawing of the clock face is recalculated with
51
48
every rotation of the propeller.
70
67
- pressing the button increments the field currently being set
71
68
- pressing and holding the button for a second cycles through the
72
69
fields that can be set
73
- pressing and holding the button for 5 seconds sets the time and
74
exits "time set" mode
70
- press and holding the button for 5 seconds to finish
75
71
76
72
******************************************************************************/
77
73
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"
74
75
#include <Bounce.h>
84
76
85
77
//_____________________________________________________________________________
86
78
// data
101
93
static unsigned long segment_step_sub_step = 0;
102
94
static unsigned long segment_step_sub = 0;
103
95
104
// the button
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 };
96
// flag to indicate that the drawing mode should be cycled to the next one
97
static bool inc_draw_mode = false;
98
99
// a bounce-managed button
100
static Bounce button( 3, 5 );
101
102
// the time
103
static int time_hours = 0;
104
static int time_minutes = 0;
105
static int time_seconds = 0;
106
107
// number of segments in a full display (rotation) is 60 (one per
108
// second) times the desired number of sub-divisions of a second
109
#define NUM_SECOND_SEGMENTS 5
110
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
114
111
115
112
//_____________________________________________________________________________
116
113
// code
117
114
118
115
119
// perform button events
120
void doButtonEvents()
121
{
122
// loop through pending events
123
while( int event = button.get_event() )
124
{
125
switch( event )
126
{
127
case 1:
128
// short press
129
major_modes[ major_mode ]->press();
130
break;
131
132
case 2:
133
// long press
134
major_modes[ major_mode ]->long_press();
135
break;
136
137
case 3:
138
// looooong press (change major 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();
144
break;
145
116
// check for button presses
117
void checkButtons()
118
{
119
// update buttons
120
button.update();
121
122
// notice button presses
123
if( button.risingEdge() )
124
inc_draw_mode = true;
125
}
126
127
128
// keep track of time
129
void trackTime()
130
{
131
// previous time and any carried-over milliseconds
132
static unsigned long last_time = millis();
133
static unsigned long carry = 0;
134
135
// how many milliseonds have elapsed since we last checked?
136
unsigned long next_time = millis();
137
unsigned long delta = next_time - last_time + carry;
138
139
// update the previous time and carried-over milliseconds
140
last_time = next_time;
141
carry = delta % 1000;
142
143
// add the seconds that have passed to the time
144
time_seconds += delta / 1000;
145
while( time_seconds >= 60 ) {
146
time_seconds -= 60;
147
time_minutes++;
148
if( time_minutes >= 60 ) {
149
time_minutes -= 60;
150
time_hours++;
151
if( time_hours >= 24 )
152
time_hours -= 24;
146
153
}
147
154
}
148
155
}
149
156
150
157
158
// draw a segment for the test display
159
void drawNextSegment_test( bool reset )
160
{
161
// keep track of segment
162
static unsigned int segment = 0;
163
if( reset ) segment = 0;
164
segment++;
165
166
// turn on inside and outside LEDs
167
digitalWrite( 4, HIGH );
168
digitalWrite( 13, HIGH );
169
170
// display segment number in binary across in the inside LEDs,
171
// with the LED on pin 12 showing the least-significant bit
172
for( int a = 0; a < 8; a++ )
173
digitalWrite( 12 - a, ( ( segment >> a ) & 1 )? HIGH : LOW );
174
}
175
176
177
// draw a segment for the time display
178
void drawNextSegment_time( bool reset )
179
{
180
static unsigned int second = 0;
181
static unsigned int segment = 0;
182
183
// handle display reset
184
if( reset ) {
185
second = 0;
186
segment = 0;
187
}
188
189
// what needs to be drawn?
190
bool draw_tick = !segment && second % 5 == 0;
191
bool draw_second = !segment && second == time_seconds;
192
bool draw_minute = !segment && second == time_minutes;
193
bool draw_hour = !segment && second == time_hours;
194
195
// set the LEDs
196
digitalWrite( 13, HIGH );
197
digitalWrite( 12, draw_tick || draw_minute );
198
for( int a = 10; a <= 11; a++ )
199
digitalWrite( a, draw_minute || draw_second );
200
for( int a = 4; a <= 9; a++ )
201
digitalWrite( 10, draw_minute | draw_second || draw_hour );
202
203
// inc position
204
if( ++segment >= NUM_SECOND_SEGMENTS ) {
205
segment = 0;
206
second++;
207
}
208
}
209
210
151
211
// draw a display segment
152
212
void drawNextSegment( bool reset )
153
213
{
154
// keep track of segment
155
#if CLOCK_FORWARD
156
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
157
if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
158
#else
159
static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
160
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
#endif
162
163
// draw
164
Drawer &drawer = major_modes[ major_mode ]->get_drawer();
165
if( reset ) drawer.draw_reset();
166
drawer.draw( segment );
167
168
#if CLOCK_FORWARD
169
if( ++segment >= NUM_SEGMENTS ) segment = 0;
170
#else
171
if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
172
#endif
214
static int draw_mode = 0;
215
216
// handle mode switch requests
217
if( reset && inc_draw_mode ) {
218
inc_draw_mode = false;
219
draw_mode++;
220
if( draw_mode >= 2 )
221
draw_mode = 0;
222
}
223
224
// draw the segment
225
switch( draw_mode ) {
226
case 0: drawNextSegment_test( reset ); break;
227
case 1: drawNextSegment_time( reset ); break;
228
}
173
229
}
174
230
175
231
196
252
197
253
// wait until it is time to draw the next segment or a new pulse has
198
254
// occurred
199
void waitTillEndOfSegment( bool reset )
255
void waitTillNextSegment( bool reset )
200
256
{
201
257
static unsigned long end_time = 0;
202
258
247
303
248
304
// set up mode-switch button on pin 3
249
305
pinMode( 3, INPUT );
250
digitalWrite( 3, HIGH );
251
static int event_times[] = { 5, 500, 4000, 0 };
252
button.set_event_times( event_times );
253
306
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();
307
// serial comms
308
Serial.begin( 9600 );
259
309
}
260
310
261
311
265
315
// if there has been a new pulse, we'll be resetting the display
266
316
bool reset = new_pulse_at? true : false;
267
317
268
// update button
269
button.update();
270
271
318
// only do this stuff at the start of a display cycle, to ensure
272
319
// that no state changes mid-display
273
320
if( reset )
274
321
{
275
// calculate segment times
276
calculateSegmentTimes();
322
// check buttons
323
checkButtons();
277
324
278
325
// keep track of time
279
Time &time = Time::get_instance();
280
time.update();
281
282
// perform button events
283
doButtonEvents();
326
trackTime();
284
327
}
285
328
286
329
// draw this segment
287
330
drawNextSegment( reset );
288
331
332
// do we need to recalculate segment times?
333
if( reset )
334
calculateSegmentTimes();
335
289
336
// wait till it's time to draw the next segment
290
waitTillEndOfSegment( reset );
337
waitTillNextSegment( reset );
291
338
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0