/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
#include "config.h"
78
79
#include "button.h"
79
 
#include "config.h"
80
80
#include "time.h"
81
 
#include "mode_switcher.h"
82
 
#include "drawer.h"
 
81
#include "Arduino.h"
 
82
#include "analogue_clock.h"
 
83
#include "digital_clock.h"
 
84
#include "test_pattern.h"
83
85
 
84
86
//_____________________________________________________________________________
85
87
//                                                                         data
86
88
 
87
 
 
88
89
// when non-zero, the time (in microseconds) of a new fan pulse that
89
90
// has just occurred, which means that segment drawing needs to be
90
91
// restarted
91
 
static unsigned long new_pulse_at = 0;
 
92
static unsigned long _new_pulse_at = 0;
92
93
 
93
94
// the time (in microseconds) when the last fan pulse occurred
94
 
static unsigned long last_pulse_at = 0;
 
95
static unsigned long _last_pulse_at = 0;
95
96
 
96
97
// duration (in microseconds) that a segment should be displayed
97
 
static unsigned long segment_step = 0;
 
98
static unsigned long _segment_step = 0;
98
99
 
99
100
// remainder after divisor and a tally of the remainders for each segment
100
 
static unsigned long segment_step_sub_step = 0;
101
 
static unsigned long segment_step_sub = 0;
 
101
static unsigned long _segment_step_sub_step = 0;
 
102
static unsigned long _segment_step_sub = 0;
102
103
 
103
104
// the button
104
 
static Button button( 3 );
105
 
 
106
 
// major mode
107
 
static int major_mode = 0;
108
 
 
109
 
// major modes
110
 
static std::vector< MajorMode * > major_modes;
 
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
111
116
 
112
117
//_____________________________________________________________________________
113
118
//                                                                         code
114
119
 
115
120
 
116
 
// check for button presses
117
 
void checkButtons()
118
 
{
119
 
        // update buttons
120
 
        int event = button.update();
121
 
 
122
 
        // handle any events
123
 
        switch( event ) {
124
 
        case 1:
125
 
                major_modes[ major_mode ]->short_press();
126
 
                break;
127
 
        case 2:
128
 
                major_modes[ major_mode ]->long_press();
129
 
                break;
130
 
        case 3:
131
 
                if( ++major_mode >= major_modes.size() )
132
 
                        major_mode = 0;
133
 
                major_modes[ major_mode ]->activate();
134
 
                break;
 
121
// activate the current minor mode
 
122
void activate_minor_mode()
 
123
{
 
124
        switch( _minor_mode ) {
 
125
        case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
 
126
        }
 
127
}
 
128
 
 
129
// perform button events
 
130
void do_button_events()
 
131
{
 
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;
 
171
                }
135
172
        }
136
173
}
137
174
 
138
175
 
139
176
// draw a display segment
140
 
void drawNextSegment( bool reset )
 
177
void draw_next_segment( bool reset )
141
178
{
142
179
        // keep track of segment
143
180
#if CLOCK_FORWARD
149
186
#endif
150
187
 
151
188
        // draw
152
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
153
 
        if( reset ) drawer.draw_reset();
154
 
        drawer.draw( segment );
 
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;
 
197
        }
155
198
 
156
199
#if CLOCK_FORWARD
157
200
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
162
205
 
163
206
 
164
207
// calculate time constants when a new pulse has occurred
165
 
void calculateSegmentTimes()
 
208
void calculate_segment_times()
166
209
{
167
210
        // check for overflows, and only recalculate times if there isn't
168
211
        // one (if there is, we'll just go with the last pulse's times)
169
 
        if( new_pulse_at > last_pulse_at )
 
212
        if( _new_pulse_at > _last_pulse_at )
170
213
        {
171
214
                // new segment stepping times
172
 
                unsigned long delta = new_pulse_at - last_pulse_at;
173
 
                segment_step = delta / NUM_SEGMENTS;
174
 
                segment_step_sub = 0;
175
 
                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;
176
219
        }
177
220
 
178
221
        // now we have dealt with this pulse, save the pulse time and
179
222
        // clear new_pulse_at, ready for the next pulse
180
 
        last_pulse_at = new_pulse_at;
181
 
        new_pulse_at = 0;
 
223
        _last_pulse_at = _new_pulse_at;
 
224
        _new_pulse_at = 0;
182
225
}
183
226
 
184
227
 
185
228
// wait until it is time to draw the next segment or a new pulse has
186
229
// occurred
187
 
void waitTillNextSegment( bool reset )
 
230
void wait_till_end_of_segment( bool reset )
188
231
{
189
232
        static unsigned long end_time = 0;
190
233
 
191
234
        // handle reset
192
235
        if( reset )
193
 
                end_time = last_pulse_at;
 
236
                end_time = _last_pulse_at;
194
237
 
195
238
        // work out the time that this segment should be displayed until
196
 
        end_time += segment_step;
197
 
        segment_step_sub += segment_step_sub_step;
198
 
        if( segment_step_sub >= NUM_SEGMENTS ) {
199
 
                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;
200
243
                end_time++;
201
244
        }
202
245
 
203
246
        // wait
204
 
        while( micros() < end_time && !new_pulse_at );
 
247
        while( micros() < end_time && !_new_pulse_at );
205
248
}
206
249
 
207
250
 
208
251
// ISR to handle the pulses from the fan's tachiometer
209
 
void fanPulseHandler()
 
252
void fan_pulse_handler()
210
253
{
211
254
        // the fan actually sends two pulses per revolution. These pulses
212
255
        // may not be exactly evenly distributed around the rotation, so
217
260
        if( !ignore )
218
261
        {
219
262
                // set a new pulse time
220
 
                new_pulse_at = micros();
 
263
                _new_pulse_at = micros();
221
264
        }
222
265
}
223
266
 
226
269
void setup()
227
270
{
228
271
        // set up an interrupt handler on pin 2 to nitice fan pulses
229
 
        attachInterrupt( 0, fanPulseHandler, RISING );
 
272
        attachInterrupt( 0, fan_pulse_handler, RISING );
230
273
        digitalWrite( 2, HIGH );
231
274
  
232
275
        // set up output pins (4 to 13) for the led array
236
279
        // set up mode-switch button on pin 3
237
280
        pinMode( 3, INPUT );
238
281
        digitalWrite( 3, HIGH );
239
 
        button.add_event_at( 5, 1 );
240
 
        button.add_event_at( 1000, 2 );
241
 
        button.add_event_at( 4000, 3 );
242
 
 
243
 
        // serial comms
244
 
        Serial.begin( 9600 );
245
 
 
246
 
        // set up major modes
247
 
        static ModeSwitcher mode_switcher;
248
 
        major_modes.push_back( &mode_switcher );
249
 
        major_modes[ 0 ]->activate();
 
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
        }
250
292
}
251
293
 
252
294
 
254
296
void loop()
255
297
{
256
298
        // if there has been a new pulse, we'll be resetting the display
257
 
        bool reset = new_pulse_at? true : false;
 
299
        bool reset = _new_pulse_at? true : false;
 
300
 
 
301
        // update button
 
302
        _button.update();
258
303
 
259
304
        // only do this stuff at the start of a display cycle, to ensure
260
305
        // that no state changes mid-display
261
306
        if( reset )
262
307
        {
263
 
                // check buttons
264
 
                checkButtons();
 
308
                // calculate segment times
 
309
                calculate_segment_times();
265
310
 
266
311
                // keep track of time
267
 
                Time &time = Time::get_instance();
268
 
                time.update();
 
312
                Time::update();
 
313
 
 
314
                // perform button events
 
315
                do_button_events();
269
316
        }
270
317
 
271
318
        // draw this segment
272
 
        drawNextSegment( reset );
273
 
 
274
 
        // do we need to recalculate segment times?
275
 
        if( reset )
276
 
                calculateSegmentTimes();
 
319
        draw_next_segment( reset );
277
320
 
278
321
        // wait till it's time to draw the next segment
279
 
        waitTillNextSegment( reset );
 
322
        wait_till_end_of_segment( reset );
280
323
}