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.cc
- browse files at revision 64
- compare with another revision
- download diff
- download tarball
- view history from revision 64
- Committer: Tim Marston
- Date: 2012-03-09 23:42:20 UTC
- Revision ID: tim@ed.am-20120309234220-xr1vxzve0o5n2oss
added support for eclipse project and converted to a manual Makefile
- files added:
- arduino.mk
- test/fan-test/Makefile
- test/phantom-button-presses
- test/phantom-button-presses/Makefile
- files removed:
- src/util/Bounce.cpp
- files renamed:
- src/propeller-clock.ino => src/propeller-clock.cc
- files modified:
- .bzrignore
- test/led-test/Makefile
added
removed
src/propeller-clock.cc
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
1
2
/*
2
3
* propeller-clock.ino
3
4
*
74
75
75
76
******************************************************************************/
76
77
77
78
#include <Bounce.h>
79
#include <DS1307.h>
80
#include <Wire.h>
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"
84
#include "Arduino.h"
81
85
82
86
//_____________________________________________________________________________
83
87
// data
98
102
static unsigned long segment_step_sub_step = 0;
99
103
static unsigned long segment_step_sub = 0;
100
104
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 )
105
// the button
106
static Button button( 3 );
107
108
// major mode
109
static int major_mode = 0;
110
111
#define MAX_MAJOR_MODES 5
112
113
// major modes
114
static MajorMode *major_modes[ MAX_MAJOR_MODES ] = { 0 };
116
115
117
116
//_____________________________________________________________________________
118
117
// code
119
118
120
119
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;
120
// perform button events
121
void doButtonEvents()
122
{
123
// loop through pending events
124
while( int event = button.get_event() )
125
{
126
switch( event )
127
{
128
case 1:
129
// short press
130
major_modes[ major_mode ]->press();
131
break;
132
133
case 2:
134
// long press
135
major_modes[ major_mode ]->long_press();
136
break;
137
138
case 3:
139
// looooong press (change major mode)
140
do {
141
if( ++major_mode >= MAX_MAJOR_MODES )
142
major_mode = 0;
143
} while( major_modes[ major_mode ] == NULL );
144
major_modes[ major_mode ]->activate();
145
break;
146
158
147
}
159
148
}
160
149
}
161
150
162
151
163
// draw a segment for the test display
164
void drawNextSegment_test( bool reset )
165
{
166
// keep track of segment
167
static unsigned int segment = 0;
168
if( reset ) segment = 0;
169
segment++;
170
171
// turn on inside and outside LEDs
172
digitalWrite( 4, HIGH );
173
digitalWrite( 13, HIGH );
174
175
// display segment number in binary across in the inside LEDs,
176
// with the LED on pin 12 showing the least-significant bit
177
for( int a = 0; a < 8; a++ )
178
digitalWrite( 12 - a, ( ( segment >> a ) & 1 )? HIGH : LOW );
179
}
180
181
182
// draw a segment for the time display
183
void drawNextSegment_time( bool reset )
184
{
185
static unsigned int second = 0;
186
static unsigned int segment = 0;
187
188
// handle display reset
189
if( reset ) {
190
second = 0;
191
segment = 0;
192
}
193
194
// what needs to be drawn?
195
bool draw_tick = !segment && second % 5 == 0;
196
bool draw_second = !segment && second == time_seconds;
197
bool draw_minute = !segment && second == time_minutes;
198
bool draw_hour = !segment && second == time_hours;
199
200
// set the LEDs
201
digitalWrite( 13, HIGH );
202
digitalWrite( 12, draw_tick || draw_minute );
203
for( int a = 10; a <= 11; a++ )
204
digitalWrite( a, draw_minute || draw_second );
205
for( int a = 4; a <= 9; a++ )
206
digitalWrite( 10, draw_minute | draw_second || draw_hour );
207
208
// inc position
209
if( ++segment >= NUM_SECOND_SEGMENTS ) {
210
segment = 0;
211
second++;
212
}
213
}
214
215
216
152
// draw a display segment
217
153
void drawNextSegment( bool reset )
218
154
{
219
static int draw_mode = 0;
220
221
// handle mode switch requests
222
if( reset && inc_draw_mode ) {
223
inc_draw_mode = false;
224
draw_mode++;
225
if( draw_mode >= 2 )
226
draw_mode = 0;
227
}
228
229
// draw the segment
230
switch( draw_mode ) {
231
case 0: drawNextSegment_test( reset ); break;
232
case 1: drawNextSegment_time( reset ); break;
233
}
155
// keep track of segment
156
#if CLOCK_FORWARD
157
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
158
if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
159
#else
160
static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
162
#endif
163
164
// draw
165
Drawer &drawer = major_modes[ major_mode ]->get_drawer();
166
if( reset ) drawer.draw_reset();
167
drawer.draw( segment );
168
169
#if CLOCK_FORWARD
170
if( ++segment >= NUM_SEGMENTS ) segment = 0;
171
#else
172
if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
173
#endif
234
174
}
235
175
236
176
257
197
258
198
// wait until it is time to draw the next segment or a new pulse has
259
199
// occurred
260
void waitTillNextSegment( bool reset )
200
void waitTillEndOfSegment( bool reset )
261
201
{
262
202
static unsigned long end_time = 0;
263
203
308
248
309
249
// set up mode-switch button on pin 3
310
250
pinMode( 3, INPUT );
311
312
// get the time from the real-time clock
313
int rtc_data[ 7 ];
314
RTC.get( rtc_data, true );
315
time_hours = rtc_data[ DS1307_HR ];
316
time_minutes = rtc_data[ DS1307_MIN ];
317
time_seconds = rtc_data[ DS1307_SEC ];
318
319
// serial comms
320
Serial.begin( 9600 );
251
digitalWrite( 3, HIGH );
252
static int event_times[] = { 5, 500, 4000, 0 };
253
button.set_event_times( event_times );
254
255
// set up major modes
256
static SwitcherMajorMode switcher_major_mode;
257
int mode = 0;
258
major_modes[ mode++ ] = &switcher_major_mode;
259
major_modes[ 0 ]->activate();
321
260
}
322
261
323
262
327
266
// if there has been a new pulse, we'll be resetting the display
328
267
bool reset = new_pulse_at? true : false;
329
268
269
// update button
270
button.update();
271
330
272
// only do this stuff at the start of a display cycle, to ensure
331
273
// that no state changes mid-display
332
274
if( reset )
333
275
{
334
// check buttons
335
checkButtons();
276
// calculate segment times
277
calculateSegmentTimes();
336
278
337
279
// keep track of time
338
trackTime();
280
Time &time = Time::get_instance();
281
time.update();
282
283
// perform button events
284
doButtonEvents();
339
285
}
340
286
341
287
// draw this segment
342
288
drawNextSegment( reset );
343
289
344
// do we need to recalculate segment times?
345
if( reset )
346
calculateSegmentTimes();
347
348
290
// wait till it's time to draw the next segment
349
waitTillNextSegment( reset );
291
waitTillEndOfSegment( reset );
350
292
}
Loggerhead is a web-based interface for Bazaar branches
Version: 1.18.2, Revision: 480