/elec/propeller-clock

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

  • Committer: edam
  • Date: 2012-02-28 17:11:15 UTC
  • Revision ID: edam@waxworlds.org-20120228171115-j3k91a3v71d3wnc1
cleanu

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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"
81
84
 
82
85
//_____________________________________________________________________________
83
86
//                                                                         data
98
101
static unsigned long segment_step_sub_step = 0;
99
102
static unsigned long segment_step_sub = 0;
100
103
 
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 )
 
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 };
116
114
 
117
115
//_____________________________________________________________________________
118
116
//                                                                         code
119
117
 
120
118
 
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;
 
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
 
158
146
                }
159
147
        }
160
148
}
161
149
 
162
150
 
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
151
// draw a display segment
217
152
void drawNextSegment( bool reset )
218
153
{
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
 
        }
 
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
173
}
235
174
 
236
175
 
257
196
 
258
197
// wait until it is time to draw the next segment or a new pulse has
259
198
// occurred
260
 
void waitTillNextSegment( bool reset )
 
199
void waitTillEndOfSegment( bool reset )
261
200
{
262
201
        static unsigned long end_time = 0;
263
202
 
308
247
 
309
248
        // set up mode-switch button on pin 3
310
249
        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 );
 
250
        digitalWrite( 3, HIGH );
 
251
        static int event_times[] = { 5, 1000, 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();
321
259
}
322
260
 
323
261
 
327
265
        // if there has been a new pulse, we'll be resetting the display
328
266
        bool reset = new_pulse_at? true : false;
329
267
 
 
268
        // update button
 
269
        button.update();
 
270
 
330
271
        // only do this stuff at the start of a display cycle, to ensure
331
272
        // that no state changes mid-display
332
273
        if( reset )
333
274
        {
334
 
                // check buttons
335
 
                checkButtons();
 
275
                // calculate segment times
 
276
                calculateSegmentTimes();
336
277
 
337
278
                // keep track of time
338
 
                trackTime();
 
279
                Time &time = Time::get_instance();
 
280
                time.update();
 
281
 
 
282
                // perform button events
 
283
                doButtonEvents();
339
284
        }
340
285
 
341
286
        // draw this segment
342
287
        drawNextSegment( reset );
343
288
 
344
 
        // do we need to recalculate segment times?
345
 
        if( reset )
346
 
                calculateSegmentTimes();
347
 
 
348
289
        // wait till it's time to draw the next segment
349
 
        waitTillNextSegment( reset );
 
290
        waitTillEndOfSegment( reset );
350
291
}