/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-23 20:18:22 UTC
  • Revision ID: edam@waxworlds.org-20120223201822-dno5n4fwvd35izq9
changed 12-tick to a double tick, added CLOCK_SHIFT to align face and fixed hour-hand

Show diffs side-by-side

added added

removed removed

Lines of Context:
75
75
 
76
76
******************************************************************************/
77
77
 
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"
 
78
 
 
79
#include <Bounce.h>
 
80
#include <DS1307.h>
 
81
#include <Wire.h>
85
82
 
86
83
//_____________________________________________________________________________
87
84
//                                                                         data
88
85
 
 
86
 
89
87
// when non-zero, the time (in microseconds) of a new fan pulse that
90
88
// has just occurred, which means that segment drawing needs to be
91
89
// restarted
92
 
static unsigned long _new_pulse_at = 0;
 
90
static unsigned long new_pulse_at = 0;
93
91
 
94
92
// the time (in microseconds) when the last fan pulse occurred
95
 
static unsigned long _last_pulse_at = 0;
 
93
static unsigned long last_pulse_at = 0;
96
94
 
97
95
// duration (in microseconds) that a segment should be displayed
98
 
static unsigned long _segment_step = 0;
 
96
static unsigned long segment_step = 0;
99
97
 
100
98
// remainder after divisor and a tally of the remainders for each segment
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
 
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 draw direction
 
119
#define CLOCK_FORWARD 0
 
120
 
 
121
// rotate display (in segments)
 
122
#define CLOCK_SHIFT ( 58 * NUM_SECOND_SEGMENTS - 1 )
116
123
 
117
124
//_____________________________________________________________________________
118
125
//                                                                         code
119
126
 
120
127
 
121
 
// activate the current minor mode
122
 
void activate_minor_mode()
 
128
// check for button presses
 
129
void checkButtons()
123
130
{
124
 
        switch( _minor_mode ) {
125
 
        case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
126
 
        }
 
131
        // update buttons
 
132
        button.update();
 
133
 
 
134
        // notice button presses
 
135
        if( button.risingEdge() )
 
136
                inc_draw_mode = true;
127
137
}
128
138
 
129
 
// perform button events
130
 
void do_button_events()
 
139
 
 
140
// keep track of time
 
141
void trackTime()
131
142
{
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;
 
143
        // previous time and any carried-over milliseconds
 
144
        static unsigned long last_time = millis();
 
145
        static unsigned long carry = 0;
 
146
 
 
147
        // how many milliseonds have elapsed since we last checked?
 
148
        unsigned long next_time = millis();
 
149
        unsigned long delta = next_time - last_time + carry;
 
150
 
 
151
        // update the previous time and carried-over milliseconds
 
152
        last_time = next_time;
 
153
        carry = delta % 1000;
 
154
 
 
155
        // add the seconds that have passed to the time
 
156
        time_seconds += delta / 1000;
 
157
        while( time_seconds >= 60 ) {
 
158
                time_seconds -= 60;
 
159
                time_minutes++;
 
160
                if( time_minutes >= 60 ) {
 
161
                        time_minutes -= 60;
 
162
                        time_hours++;
 
163
                        if( time_hours >= 24 )
 
164
                                time_hours -= 24;
171
165
                }
172
166
        }
173
167
}
174
168
 
175
169
 
 
170
// turn an led on/off
 
171
void ledOn( int num, bool on )
 
172
{
 
173
        if( num < 0 || num > 9 ) return;
 
174
 
 
175
        // convert to pin no.
 
176
        num += 4;
 
177
 
 
178
        // pin 4 needs to be inverted (it's driving a PNP)
 
179
        if( num == 4 ) on = !on;
 
180
 
 
181
        digitalWrite( num, on? HIGH : LOW );
 
182
}
 
183
 
 
184
 
 
185
// draw a segment for the test display
 
186
void drawNextSegment_test( int segment )
 
187
{
 
188
        // turn on outside LEDs
 
189
        ledOn( 9, true );
 
190
 
 
191
        // display segment number in binary across in the inside LEDs,
 
192
        // with the LED on pin 12 showing the least-significant bit
 
193
        for( int a = 0; a < 9; a++ )
 
194
                ledOn( 8 - a, ( segment >> a ) & 1 );
 
195
}
 
196
 
 
197
 
 
198
// draw a segment for the time display
 
199
void drawNextSegment_time( int segment )
 
200
{
 
201
        int second = segment / NUM_SECOND_SEGMENTS;
 
202
        int second_segment = segment % NUM_SECOND_SEGMENTS;
 
203
 
 
204
        // what needs to be drawn?
 
205
        bool draw_tick = ( !second_segment && second % 5 == 0 && second ) ||
 
206
                ( second == 0 && second_segment == 1 ) ||
 
207
                ( second == 59 && second_segment == NUM_SECOND_SEGMENTS - 1 );
 
208
        bool draw_second = !second_segment && second == time_seconds;
 
209
        bool draw_minute = !second_segment && second == time_minutes;
 
210
        bool draw_hour = segment == time_hours * 5 * NUM_SECOND_SEGMENTS +
 
211
                ( 5 * NUM_SECOND_SEGMENTS * time_minutes / 60 );
 
212
 
 
213
        // set the LEDs
 
214
        ledOn( 9, true );
 
215
        ledOn( 8, draw_tick || draw_second );
 
216
        for( int a = 6; a <= 7; a++ )
 
217
                ledOn( a, draw_minute || draw_second );
 
218
        for( int a = 0; a <= 5; a++ )
 
219
                ledOn( a, draw_minute || draw_second || draw_hour );
 
220
}
 
221
 
 
222
 
176
223
// draw a display segment
177
 
void draw_next_segment( bool reset )
 
224
void drawNextSegment( bool reset )
178
225
{
 
226
        static int draw_mode = 0;
 
227
 
179
228
        // keep track of segment
180
229
#if CLOCK_FORWARD
181
230
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
185
234
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
186
235
#endif
187
236
 
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;
 
237
        // handle mode switch requests
 
238
        if( reset && inc_draw_mode ) {
 
239
                inc_draw_mode = false;
 
240
                draw_mode++;
 
241
                if( draw_mode >= 2 )
 
242
                        draw_mode = 0;
 
243
        }
 
244
 
 
245
        // draw the segment
 
246
        switch( draw_mode ) {
 
247
        case 0: drawNextSegment_test( segment ); break;
 
248
        case 1: drawNextSegment_time( segment ); break;
197
249
        }
198
250
 
199
251
#if CLOCK_FORWARD
205
257
 
206
258
 
207
259
// calculate time constants when a new pulse has occurred
208
 
void calculate_segment_times()
 
260
void calculateSegmentTimes()
209
261
{
210
262
        // check for overflows, and only recalculate times if there isn't
211
263
        // one (if there is, we'll just go with the last pulse's times)
212
 
        if( _new_pulse_at > _last_pulse_at )
 
264
        if( new_pulse_at > last_pulse_at )
213
265
        {
214
266
                // new segment stepping times
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
                unsigned long delta = new_pulse_at - last_pulse_at;
 
268
                segment_step = delta / NUM_SEGMENTS;
 
269
                segment_step_sub = 0;
 
270
                segment_step_sub_step = delta % NUM_SEGMENTS;
219
271
        }
220
272
 
221
273
        // now we have dealt with this pulse, save the pulse time and
222
274
        // clear new_pulse_at, ready for the next pulse
223
 
        _last_pulse_at = _new_pulse_at;
224
 
        _new_pulse_at = 0;
 
275
        last_pulse_at = new_pulse_at;
 
276
        new_pulse_at = 0;
225
277
}
226
278
 
227
279
 
228
280
// wait until it is time to draw the next segment or a new pulse has
229
281
// occurred
230
 
void wait_till_end_of_segment( bool reset )
 
282
void waitTillNextSegment( bool reset )
231
283
{
232
284
        static unsigned long end_time = 0;
233
285
 
234
286
        // handle reset
235
287
        if( reset )
236
 
                end_time = _last_pulse_at;
 
288
                end_time = last_pulse_at;
237
289
 
238
290
        // work out the time that this segment should be displayed until
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
        end_time += segment_step;
 
292
        segment_step_sub += segment_step_sub_step;
 
293
        if( segment_step_sub >= NUM_SEGMENTS ) {
 
294
                segment_step_sub -= NUM_SEGMENTS;
243
295
                end_time++;
244
296
        }
245
297
 
246
298
        // wait
247
 
        while( micros() < end_time && !_new_pulse_at );
 
299
        while( micros() < end_time && !new_pulse_at );
248
300
}
249
301
 
250
302
 
251
303
// ISR to handle the pulses from the fan's tachiometer
252
 
void fan_pulse_handler()
 
304
void fanPulseHandler()
253
305
{
254
306
        // the fan actually sends two pulses per revolution. These pulses
255
307
        // may not be exactly evenly distributed around the rotation, so
260
312
        if( !ignore )
261
313
        {
262
314
                // set a new pulse time
263
 
                _new_pulse_at = micros();
 
315
                new_pulse_at = micros();
264
316
        }
265
317
}
266
318
 
269
321
void setup()
270
322
{
271
323
        // set up an interrupt handler on pin 2 to nitice fan pulses
272
 
        attachInterrupt( 0, fan_pulse_handler, RISING );
 
324
        attachInterrupt( 0, fanPulseHandler, RISING );
273
325
        digitalWrite( 2, HIGH );
274
326
  
275
327
        // set up output pins (4 to 13) for the led array
279
331
        // set up mode-switch button on pin 3
280
332
        pinMode( 3, INPUT );
281
333
        digitalWrite( 3, HIGH );
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
 
        }
 
334
 
 
335
        // get the time from the real-time clock
 
336
        int rtc_data[ 7 ];
 
337
        RTC.get( rtc_data, true );
 
338
        time_hours = rtc_data[ DS1307_HR ];
 
339
        time_minutes = rtc_data[ DS1307_MIN ];
 
340
        time_seconds = rtc_data[ DS1307_SEC ];
 
341
 
 
342
        // serial comms
 
343
        Serial.begin( 9600 );
292
344
}
293
345
 
294
346
 
296
348
void loop()
297
349
{
298
350
        // if there has been a new pulse, we'll be resetting the display
299
 
        bool reset = _new_pulse_at? true : false;
300
 
 
301
 
        // update button
302
 
        _button.update();
 
351
        bool reset = new_pulse_at? true : false;
303
352
 
304
353
        // only do this stuff at the start of a display cycle, to ensure
305
354
        // that no state changes mid-display
306
355
        if( reset )
307
356
        {
308
 
                // calculate segment times
309
 
                calculate_segment_times();
 
357
                // check buttons
 
358
                checkButtons();
310
359
 
311
360
                // keep track of time
312
 
                Time::update();
313
 
 
314
 
                // perform button events
315
 
                do_button_events();
 
361
                trackTime();
316
362
        }
317
363
 
318
364
        // draw this segment
319
 
        draw_next_segment( reset );
 
365
        drawNextSegment( reset );
 
366
 
 
367
        // do we need to recalculate segment times?
 
368
        if( reset )
 
369
                calculateSegmentTimes();
320
370
 
321
371
        // wait till it's time to draw the next segment
322
 
        wait_till_end_of_segment( reset );
 
372
        waitTillNextSegment( reset );
323
373
}