/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-09 23:42:20 UTC
  • Revision ID: tim@ed.am-20120309234220-xr1vxzve0o5n2oss
added support for eclipse project and converted to a manual Makefile

Show diffs side-by-side

added added

removed removed

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