/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-25 14:54:33 UTC
  • Revision ID: edam@waxworlds.org-20120225145433-kih8qs45x05cum46
removed Bounce library and updated/fixed new code

Show diffs side-by-side

added added

removed removed

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