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 40
- compare with another revision
- download diff
- download tarball
- view history from revision 40
- Committer: edam
- Date: 2012-01-26 23:54:36 UTC
- Revision ID: edam@waxworlds.org-20120126235436-mlq6e00q6rxqudy2
updated schematic
- files added:
- src/util/Bounce.cpp
- files removed:
- arduino.mk
- test/fan-test/Makefile
- test/phantom-button-presses
- test/phantom-button-presses/Makefile
- files modified:
- electronics-information
- test/led-test/Makefile
added
removed
src/propeller-clock.ino
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
1
/*
3
2
* propeller-clock.ino
4
3
*
75
74
76
75
******************************************************************************/
77
76
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"
77
78
#include <Bounce.h>
79
#include <DS1307.h>
80
#include <Wire.h>
84
81
85
82
//_____________________________________________________________________________
86
83
// data
101
98
static unsigned long segment_step_sub_step = 0;
102
99
static unsigned long segment_step_sub = 0;
103
100
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 };
101
// flag to indicate that the drawing mode should be cycled to the next one
102
static bool inc_draw_mode = false;
103
104
// a bounce-managed button
105
static Bounce button( 3, 5 );
106
107
// the time
108
static int time_hours = 0;
109
static int time_minutes = 0;
110
static int time_seconds = 0;
111
112
// number of segments in a full display (rotation) is 60 (one per
113
// second) times the desired number of sub-divisions of a second
114
#define NUM_SECOND_SEGMENTS 5
115
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
114
116
115
117
//_____________________________________________________________________________
116
118
// code
117
119
118
120
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
121
// check for button presses
122
void checkButtons()
123
{
124
// update buttons
125
button.update();
126
127
// notice button presses
128
if( button.risingEdge() )
129
inc_draw_mode = true;
130
}
131
132
133
// keep track of time
134
void trackTime()
135
{
136
// previous time and any carried-over milliseconds
137
static unsigned long last_time = millis();
138
static unsigned long carry = 0;
139
140
// how many milliseonds have elapsed since we last checked?
141
unsigned long next_time = millis();
142
unsigned long delta = next_time - last_time + carry;
143
144
// update the previous time and carried-over milliseconds
145
last_time = next_time;
146
carry = delta % 1000;
147
148
// add the seconds that have passed to the time
149
time_seconds += delta / 1000;
150
while( time_seconds >= 60 ) {
151
time_seconds -= 60;
152
time_minutes++;
153
if( time_minutes >= 60 ) {
154
time_minutes -= 60;
155
time_hours++;
156
if( time_hours >= 24 )
157
time_hours -= 24;
146
158
}
147
159
}
148
160
}
149
161
150
162
163
// turn an led on/off
164
void ledOn( int num, bool on )
165
{
166
if( num < 0 || num > 9 ) return;
167
168
// convert to pin no.
169
num += 4;
170
171
// pin 4 needs to be inverted (it's driving a PNP)
172
if( num == 4 ) on = !on;
173
174
digitalWrite( num, on? HIGH : LOW );
175
}
176
177
178
// draw a segment for the test display
179
void drawNextSegment_test( bool reset )
180
{
181
// keep track of segment
182
static unsigned int segment = 0;
183
if( reset ) segment = 0;
184
segment++;
185
186
// turn on inside and outside LEDs
187
ledOn( 0, true );
188
ledOn( 9, true );
189
190
// display segment number in binary across in the inside LEDs,
191
// with the LED on pin 12 showing the least-significant bit
192
for( int a = 0; a < 8; a++ )
193
ledOn( 8 - a, ( segment >> a ) & 1 );
194
}
195
196
197
// draw a segment for the time display
198
void drawNextSegment_time( bool reset )
199
{
200
static int second = 0;
201
static int segment = 0;
202
203
// handle display reset
204
if( reset ) {
205
second = 0;
206
segment = 0;
207
}
208
209
// what needs to be drawn?
210
bool draw_tick = !segment && second % 5 == 0;
211
bool draw_second = !segment && second == time_seconds;
212
bool draw_minute = !segment && second == time_minutes;
213
bool draw_hour = !segment && second == time_hours;
214
215
// set the LEDs
216
ledOn( 9, true );
217
ledOn( 8, draw_tick || draw_minute );
218
for( int a = 6; a <= 7; a++ )
219
ledOn( a, draw_minute || draw_second );
220
for( int a = 0; a <= 5; a++ )
221
ledOn( a, draw_minute || draw_second || draw_hour );
222
223
// inc position
224
if( ++segment >= NUM_SECOND_SEGMENTS ) {
225
segment = 0;
226
second++;
227
}
228
}
229
230
151
231
// draw a display segment
152
232
void drawNextSegment( bool reset )
153
233
{
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
234
static int draw_mode = 0;
235
236
// handle mode switch requests
237
if( reset && inc_draw_mode ) {
238
inc_draw_mode = false;
239
draw_mode++;
240
if( draw_mode >= 2 )
241
draw_mode = 0;
242
}
243
244
// draw the segment
245
switch( draw_mode ) {
246
case 0: drawNextSegment_test( reset ); break;
247
case 1: drawNextSegment_time( reset ); break;
248
}
173
249
}
174
250
175
251
196
272
197
273
// wait until it is time to draw the next segment or a new pulse has
198
274
// occurred
199
void waitTillEndOfSegment( bool reset )
275
void waitTillNextSegment( bool reset )
200
276
{
201
277
static unsigned long end_time = 0;
202
278
247
323
248
324
// set up mode-switch button on pin 3
249
325
pinMode( 3, INPUT );
250
digitalWrite( 3, HIGH );
251
static int event_times[] = { 5, 500, 4000, 0 };
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();
326
327
// get the time from the real-time clock
328
int rtc_data[ 7 ];
329
RTC.get( rtc_data, true );
330
time_hours = rtc_data[ DS1307_HR ];
331
time_minutes = rtc_data[ DS1307_MIN ];
332
time_seconds = rtc_data[ DS1307_SEC ];
333
334
// serial comms
335
Serial.begin( 9600 );
259
336
}
260
337
261
338
265
342
// if there has been a new pulse, we'll be resetting the display
266
343
bool reset = new_pulse_at? true : false;
267
344
268
// update button
269
button.update();
270
271
345
// only do this stuff at the start of a display cycle, to ensure
272
346
// that no state changes mid-display
273
347
if( reset )
274
348
{
275
// calculate segment times
276
calculateSegmentTimes();
349
// check buttons
350
checkButtons();
277
351
278
352
// keep track of time
279
Time &time = Time::get_instance();
280
time.update();
281
282
// perform button events
283
doButtonEvents();
353
trackTime();
284
354
}
285
355
286
356
// draw this segment
287
357
drawNextSegment( reset );
288
358
359
// do we need to recalculate segment times?
360
if( reset )
361
calculateSegmentTimes();
362
289
363
// wait till it's time to draw the next segment
290
waitTillEndOfSegment( reset );
364
waitTillNextSegment( reset );
291
365
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0