/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-28 16:50:26 UTC
  • Revision ID: edam@waxworlds.org-20120228165026-pwnwo300xx2e2kg6
removed ulibc, fixed button, added text rendering

Show diffs side-by-side

added added

removed removed

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