/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.cc

  • Committer: Tim Marston
  • Date: 2012-03-10 12:31:16 UTC
  • Revision ID: tim@ed.am-20120310123116-l348p5btgecmdj1q
added realtime clock test

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/propeller-clock.cc
75
75
 
76
76
******************************************************************************/
77
77
 
78
 
 
79
 
#include <Bounce.h>
80
 
#include <DS1307.h>
81
 
#include <Wire.h>
 
78
#include "config.h"
 
79
#include "button.h"
 
80
#include "time.h"
 
81
#include "Arduino.h"
 
82
#include "analogue_clock.h"
 
83
#include "digital_clock.h"
 
84
#include "test_pattern.h"
82
85
 
83
86
//_____________________________________________________________________________
84
87
//                                                                         data
85
88
 
86
 
 
87
89
// when non-zero, the time (in microseconds) of a new fan pulse that
88
90
// has just occurred, which means that segment drawing needs to be
89
91
// restarted
90
 
static unsigned long new_pulse_at = 0;
 
92
static unsigned long _new_pulse_at = 0;
91
93
 
92
94
// the time (in microseconds) when the last fan pulse occurred
93
 
static unsigned long last_pulse_at = 0;
 
95
static unsigned long _last_pulse_at = 0;
94
96
 
95
97
// duration (in microseconds) that a segment should be displayed
96
 
static unsigned long segment_step = 0;
 
98
static unsigned long _segment_step = 0;
97
99
 
98
100
// remainder after divisor and a tally of the remainders for each segment
99
 
static unsigned long segment_step_sub_step = 0;
100
 
static unsigned long segment_step_sub = 0;
101
 
 
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
 
101
static unsigned long _segment_step_sub_step = 0;
 
102
static unsigned long _segment_step_sub = 0;
 
103
 
 
104
// the button
 
105
static Button _button( 3 );
 
106
 
 
107
// modes
 
108
static int _major_mode = 0;
 
109
static int _minor_mode = 0;
 
110
 
 
111
#define MAIN_MODE_IDX 0
 
112
 
 
113
#define ANALOGUE_CLOCK_IDX 0
 
114
#define DIGITAL_CLOCK_IDX 1
 
115
#define TEST_PATTERN_IDX 2
120
116
 
121
117
//_____________________________________________________________________________
122
118
//                                                                         code
123
119
 
124
120
 
125
 
// check for button presses
126
 
void checkButtons()
 
121
// activate the current minor mode
 
122
void activate_minor_mode()
127
123
{
128
 
        // update buttons
129
 
        button.update();
130
 
 
131
 
        // notice button presses
132
 
        if( button.risingEdge() )
133
 
                inc_draw_mode = true;
 
124
        switch( _minor_mode ) {
 
125
        case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
 
126
        }
134
127
}
135
128
 
136
 
 
137
 
// keep track of time
138
 
void trackTime()
 
129
// perform button events
 
130
void do_button_events()
139
131
{
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;
 
132
        // loop through pending events
 
133
        while( int event = _button.get_event() )
 
134
        {
 
135
                switch( event )
 
136
                {
 
137
                case 1:
 
138
                        // short press
 
139
                        switch( _major_mode ) {
 
140
                        case MAIN_MODE_IDX:
 
141
                                switch( _minor_mode ) {
 
142
                                case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;
 
143
                                case DIGITAL_CLOCK_IDX: digital_clock_press(); break;
 
144
                                }
 
145
                                break;
 
146
                        }
 
147
                        break;
 
148
 
 
149
                case 2:
 
150
                        // long press
 
151
                        switch( _major_mode ) {
 
152
                        case MAIN_MODE_IDX:
 
153
                                if( ++_minor_mode >= 3 )
 
154
                                        _minor_mode = 0;
 
155
                                switch( _minor_mode ) {
 
156
                                case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
 
157
                                }
 
158
                                break;
 
159
                        }
 
160
                        break;
 
161
 
 
162
                case 3:
 
163
                        // looooong press (change major mode)
 
164
                        if( ++_major_mode > 0 )
 
165
                                _major_mode = 0;
 
166
                        switch( _major_mode ) {
 
167
                        case MAIN_MODE_IDX: _minor_mode = 0; break;
 
168
                        }
 
169
                        activate_minor_mode();
 
170
                        break;
162
171
                }
163
172
        }
164
173
}
165
174
 
166
175
 
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
 
 
219
176
// draw a display segment
220
 
void drawNextSegment( bool reset )
 
177
void draw_next_segment( bool reset )
221
178
{
222
 
        static int draw_mode = 0;
223
 
 
224
179
        // keep track of segment
225
180
#if CLOCK_FORWARD
226
 
        static int segment = 0;
227
 
        if( reset ) segment = 0;
 
181
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
 
182
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
228
183
#else
229
 
        static int segment = NUM_SEGMENTS - 1;
230
 
        if( reset ) segment = NUM_SEGMENTS - 1;
 
184
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
 
185
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
231
186
#endif
232
187
 
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;
 
188
        // draw
 
189
        switch( _major_mode ) {
 
190
        case MAIN_MODE_IDX:
 
191
                switch( _minor_mode ) {
 
192
                case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;
 
193
                case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;
 
194
                case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;
 
195
                }
 
196
                break;
245
197
        }
246
198
 
247
199
#if CLOCK_FORWARD
248
 
        segment++;
 
200
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
249
201
#else
250
 
        segment--;
 
202
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
251
203
#endif
252
204
}
253
205
 
254
206
 
255
207
// calculate time constants when a new pulse has occurred
256
 
void calculateSegmentTimes()
 
208
void calculate_segment_times()
257
209
{
258
210
        // check for overflows, and only recalculate times if there isn't
259
211
        // one (if there is, we'll just go with the last pulse's times)
260
 
        if( new_pulse_at > last_pulse_at )
 
212
        if( _new_pulse_at > _last_pulse_at )
261
213
        {
262
214
                // new segment stepping times
263
 
                unsigned long delta = new_pulse_at - last_pulse_at;
264
 
                segment_step = delta / NUM_SEGMENTS;
265
 
                segment_step_sub = 0;
266
 
                segment_step_sub_step = delta % NUM_SEGMENTS;
 
215
                unsigned long delta = _new_pulse_at - _last_pulse_at;
 
216
                _segment_step = delta / NUM_SEGMENTS;
 
217
                _segment_step_sub = 0;
 
218
                _segment_step_sub_step = delta % NUM_SEGMENTS;
267
219
        }
268
220
 
269
221
        // now we have dealt with this pulse, save the pulse time and
270
222
        // clear new_pulse_at, ready for the next pulse
271
 
        last_pulse_at = new_pulse_at;
272
 
        new_pulse_at = 0;
 
223
        _last_pulse_at = _new_pulse_at;
 
224
        _new_pulse_at = 0;
273
225
}
274
226
 
275
227
 
276
228
// wait until it is time to draw the next segment or a new pulse has
277
229
// occurred
278
 
void waitTillNextSegment( bool reset )
 
230
void wait_till_end_of_segment( bool reset )
279
231
{
280
232
        static unsigned long end_time = 0;
281
233
 
282
234
        // handle reset
283
235
        if( reset )
284
 
                end_time = last_pulse_at;
 
236
                end_time = _last_pulse_at;
285
237
 
286
238
        // work out the time that this segment should be displayed until
287
 
        end_time += segment_step;
288
 
        segment_step_sub += segment_step_sub_step;
289
 
        if( segment_step_sub >= NUM_SEGMENTS ) {
290
 
                segment_step_sub -= NUM_SEGMENTS;
 
239
        end_time += _segment_step;
 
240
        _segment_step_sub += _segment_step_sub_step;
 
241
        if( _segment_step_sub >= NUM_SEGMENTS ) {
 
242
                _segment_step_sub -= NUM_SEGMENTS;
291
243
                end_time++;
292
244
        }
293
245
 
294
246
        // wait
295
 
        while( micros() < end_time && !new_pulse_at );
 
247
        while( micros() < end_time && !_new_pulse_at );
296
248
}
297
249
 
298
250
 
299
251
// ISR to handle the pulses from the fan's tachiometer
300
 
void fanPulseHandler()
 
252
void fan_pulse_handler()
301
253
{
302
254
        // the fan actually sends two pulses per revolution. These pulses
303
255
        // may not be exactly evenly distributed around the rotation, so
308
260
        if( !ignore )
309
261
        {
310
262
                // set a new pulse time
311
 
                new_pulse_at = micros();
 
263
                _new_pulse_at = micros();
312
264
        }
313
265
}
314
266
 
317
269
void setup()
318
270
{
319
271
        // set up an interrupt handler on pin 2 to nitice fan pulses
320
 
        attachInterrupt( 0, fanPulseHandler, RISING );
 
272
        attachInterrupt( 0, fan_pulse_handler, RISING );
321
273
        digitalWrite( 2, HIGH );
322
274
  
323
275
        // set up output pins (4 to 13) for the led array
327
279
        // set up mode-switch button on pin 3
328
280
        pinMode( 3, INPUT );
329
281
        digitalWrite( 3, HIGH );
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 );
 
282
        static int event_times[] = { 5, 500, 4000, 0 };
 
283
        _button.set_event_times( event_times );
 
284
 
 
285
        // get time from RTC
 
286
        Time::init();
 
287
 
 
288
        // activate the minor mode
 
289
        switch( _major_mode ) {
 
290
        case MAIN_MODE_IDX: activate_minor_mode(); break;
 
291
        }
340
292
}
341
293
 
342
294
 
344
296
void loop()
345
297
{
346
298
        // if there has been a new pulse, we'll be resetting the display
347
 
        bool reset = new_pulse_at? true : false;
 
299
        bool reset = _new_pulse_at? true : false;
 
300
 
 
301
        // update button
 
302
        _button.update();
348
303
 
349
304
        // only do this stuff at the start of a display cycle, to ensure
350
305
        // that no state changes mid-display
351
306
        if( reset )
352
307
        {
353
 
                // check buttons
354
 
                checkButtons();
 
308
                // calculate segment times
 
309
                calculate_segment_times();
355
310
 
356
311
                // keep track of time
357
 
                trackTime();
 
312
                Time::update();
 
313
 
 
314
                // perform button events
 
315
                do_button_events();
358
316
        }
359
317
 
360
318
        // draw this segment
361
 
        drawNextSegment( reset );
362
 
 
363
 
        // do we need to recalculate segment times?
364
 
        if( reset )
365
 
                calculateSegmentTimes();
 
319
        draw_next_segment( reset );
366
320
 
367
321
        // wait till it's time to draw the next segment
368
 
        waitTillNextSegment( reset );
 
322
        wait_till_end_of_segment( reset );
369
323
}