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 53
- compare with another revision
- download diff
- download tarball
- view history from revision 53
- Committer: edam
- Date: 2012-02-23 00:26:32 UTC
- Revision ID: edam@waxworlds.org-20120223002632-kkwrdwijfmv45f0j
conrtol segment number from one place and reverse the order the segments are drawn (backwards clock!)
- files added:
- src/util/Bounce.cpp
- files removed:
- src/analogue_clock_mode.cc
- files renamed:
- src/propeller-clock.cc => src/propeller-clock.ino
- files modified:
- .bzrignore
- src/Makefile
added
removed
src/propeller-clock.ino
75
75
76
76
******************************************************************************/
77
77
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"
78
79
#include <Bounce.h>
80
#include <DS1307.h>
81
#include <Wire.h>
85
82
86
83
//_____________________________________________________________________________
87
84
// data
102
99
static unsigned long segment_step_sub_step = 0;
103
100
static unsigned long segment_step_sub = 0;
104
101
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 };
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 direction
119
#define CLOCK_FORWARD 0
115
120
116
121
//_____________________________________________________________________________
117
122
// code
118
123
119
124
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
125
// check for button presses
126
void checkButtons()
127
{
128
// update buttons
129
button.update();
130
131
// notice button presses
132
if( button.risingEdge() )
133
inc_draw_mode = true;
134
}
135
136
137
// keep track of time
138
void trackTime()
139
{
140
// previous time and any carried-over milliseconds
141
static unsigned long last_time = millis();
142
static unsigned long carry = 0;
143
144
// how many milliseonds have elapsed since we last checked?
145
unsigned long next_time = millis();
146
unsigned long delta = next_time - last_time + carry;
147
148
// update the previous time and carried-over milliseconds
149
last_time = next_time;
150
carry = delta % 1000;
151
152
// add the seconds that have passed to the time
153
time_seconds += delta / 1000;
154
while( time_seconds >= 60 ) {
155
time_seconds -= 60;
156
time_minutes++;
157
if( time_minutes >= 60 ) {
158
time_minutes -= 60;
159
time_hours++;
160
if( time_hours >= 24 )
161
time_hours -= 24;
147
162
}
148
163
}
149
164
}
150
165
151
166
167
// turn an led on/off
168
void ledOn( int num, bool on )
169
{
170
if( num < 0 || num > 9 ) return;
171
172
// convert to pin no.
173
num += 4;
174
175
// pin 4 needs to be inverted (it's driving a PNP)
176
// NOTE: PIN 4 TEMPORARILY DISABLED
177
// if( num == 4 ) on = true;
178
if( num == 4 ) on = !on;
179
180
digitalWrite( num, on? HIGH : LOW );
181
}
182
183
184
// draw a segment for the test display
185
void drawNextSegment_test( int segment )
186
{
187
// turn on inside and outside LEDs
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 < 9; a++ )
193
ledOn( 8 - a, ( segment >> a ) & 1 );
194
}
195
196
197
// draw a segment for the time display
198
void drawNextSegment_time( int segment )
199
{
200
int second = segment / NUM_SECOND_SEGMENTS;
201
int second_segment = segment % NUM_SECOND_SEGMENTS;
202
203
// what needs to be drawn?
204
bool draw_tick = !second_segment && second % 5 == 0;
205
bool draw_second = !second_segment && second == time_seconds;
206
bool draw_minute = !second_segment && second == time_minutes;
207
bool draw_hour = !second_segment && second == time_hours;
208
209
// set the LEDs
210
ledOn( 9, true );
211
ledOn( 8, draw_tick || draw_minute );
212
for( int a = 6; a <= 7; a++ )
213
ledOn( a, draw_minute || draw_second );
214
for( int a = 0; a <= 5; a++ )
215
ledOn( a, draw_minute || draw_second || draw_hour );
216
}
217
218
152
219
// draw a display segment
153
220
void drawNextSegment( bool reset )
154
221
{
222
static int draw_mode = 0;
223
155
224
// keep track of segment
156
225
#if CLOCK_FORWARD
157
static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
158
if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
226
static int segment = 0;
227
if( reset ) segment = 0;
159
228
#else
160
static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
229
static int segment = NUM_SEGMENTS - 1;
230
if( reset ) segment = NUM_SEGMENTS - 1;
162
231
#endif
163
232
164
// draw
165
Drawer &drawer = major_modes[ major_mode ]->get_drawer();
166
if( reset ) drawer.draw_reset();
167
drawer.draw( segment );
233
// handle mode switch requests
234
if( reset && inc_draw_mode ) {
235
inc_draw_mode = false;
236
draw_mode++;
237
if( draw_mode >= 2 )
238
draw_mode = 0;
239
}
240
241
// draw the segment
242
switch( draw_mode ) {
243
case 0: drawNextSegment_test( segment ); break;
244
case 1: drawNextSegment_time( segment ); break;
245
}
168
246
169
247
#if CLOCK_FORWARD
170
if( ++segment >= NUM_SEGMENTS ) segment = 0;
248
segment++;
171
249
#else
172
if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
250
segment--;
173
251
#endif
174
252
}
175
253
197
275
198
276
// wait until it is time to draw the next segment or a new pulse has
199
277
// occurred
200
void waitTillEndOfSegment( bool reset )
278
void waitTillNextSegment( bool reset )
201
279
{
202
280
static unsigned long end_time = 0;
203
281
249
327
// set up mode-switch button on pin 3
250
328
pinMode( 3, INPUT );
251
329
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();
330
331
// get the time from the real-time clock
332
int rtc_data[ 7 ];
333
RTC.get( rtc_data, true );
334
time_hours = rtc_data[ DS1307_HR ];
335
time_minutes = rtc_data[ DS1307_MIN ];
336
time_seconds = rtc_data[ DS1307_SEC ];
337
338
// serial comms
339
Serial.begin( 9600 );
260
340
}
261
341
262
342
266
346
// if there has been a new pulse, we'll be resetting the display
267
347
bool reset = new_pulse_at? true : false;
268
348
269
// update button
270
button.update();
271
272
349
// only do this stuff at the start of a display cycle, to ensure
273
350
// that no state changes mid-display
274
351
if( reset )
275
352
{
276
// calculate segment times
277
calculateSegmentTimes();
353
// check buttons
354
checkButtons();
278
355
279
356
// keep track of time
280
Time &time = Time::get_instance();
281
time.update();
282
283
// perform button events
284
doButtonEvents();
357
trackTime();
285
358
}
286
359
287
360
// draw this segment
288
361
drawNextSegment( reset );
289
362
363
// do we need to recalculate segment times?
364
if( reset )
365
calculateSegmentTimes();
366
290
367
// wait till it's time to draw the next segment
291
waitTillEndOfSegment( reset );
368
waitTillNextSegment( reset );
292
369
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0