/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-05-18 14:55:12 UTC
  • Revision ID: tim@ed.am-20120518145512-4dg4ble01d47a8z5
moved rount Time a bit, and passed _button to SettingsMajorMode so that it can
come in and out of send_interim mode

Show diffs side-by-side

added added

removed removed

src/propeller-clock.cc
1
 
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
 
1
/* -*- mode: c++; compile-command: "make"; -*- */
2
2
/*
3
3
 * propeller-clock.ino
4
4
 *
28
28
 
29
29
 * a PC fan is wired up to a 12V power supply
30
30
 
31
 
 * the fan's SENSE (tachiometer) pin connected to pin 2 on the
32
 
   arduino.
 
31
 * the fan's SENSE (tachometer) pin connected to pin 2 on the
 
32
   Arduino.
33
33
 
34
 
 * the pins 4 to 13 on the arduino should directly drive an LED (the
 
34
 * the pins 4 to 13 on the Arduino should directly drive an LED (the
35
35
   LED on pin 4 is in the centre of the clock face and the LED on pin
36
36
   13 is at the outside.
37
37
 
38
38
 * if a longer hand (and a larger clock face) is desired, pin 4 can be
39
39
   used to indirectly drive a transistor which in turn drives several
40
 
   LEDs that turn on anf off in unison in the centre of the clock.
 
40
   LEDs that turn on and off in unison in the centre of the clock.
41
41
 
42
42
 * a button should be attached to pin 3 that grounds it when pressed.
43
43
 
44
 
 * A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
 
44
 * A DS1307 remote clock is connected via I2C on analogue pins 4 and 5.
45
45
 
46
46
Implementation details:
47
47
 
50
50
 * the timing of the drawing of the clock face is recalculated with
51
51
   every rotation of the propeller.
52
52
    
53
 
 * a PC fan actually sends 2 tachiometer pulses per revolution, so the
 
53
 * a PC fan actually sends 2 tachometer pulses per revolution, so the
54
54
   software skips every other one. This means that the clock may
55
55
   appear upside-down if started with the propeller in the wrong
56
 
   position. You will need to experiment to dicsover the position that
 
56
   position. You will need to experiment to discover the position that
57
57
   the propeller must be in when starting the clock.
58
58
    
59
59
Usage instructions:
76
76
******************************************************************************/
77
77
 
78
78
#include "config.h"
79
 
#include "display.h"
80
79
#include "button.h"
81
80
#include "time.h"
82
 
#include "switcher_major_mode.h"
83
 
#include "drawer.h"
 
81
#include "Arduino.h"
 
82
#include "modes/switcher_major_mode.h"
 
83
#include "modes/settings_major_mode.h"
 
84
#include "modes/analogue_clock_mode.h"
 
85
#include "modes/digital_clock_mode.h"
 
86
#include "modes/info_mode.h"
 
87
#include "modes/test_pattern_mode.h"
 
88
#include "text.h"
 
89
#include "text_renderer.h"
 
90
#include "common.h"
84
91
 
85
92
//_____________________________________________________________________________
86
93
//                                                                         data
87
94
 
88
 
 
89
95
// when non-zero, the time (in microseconds) of a new fan pulse that
90
96
// has just occurred, which means that segment drawing needs to be
91
97
// restarted
92
 
static unsigned long new_pulse_at = 0;
 
98
static unsigned long _new_pulse_at = 0;
93
99
 
94
100
// the time (in microseconds) when the last fan pulse occurred
95
 
static unsigned long last_pulse_at = 0;
 
101
static unsigned long _last_pulse_at = 0;
96
102
 
97
103
// duration (in microseconds) that a segment should be displayed
98
 
static unsigned long segment_step = 0;
 
104
static unsigned long _segment_step = 0;
99
105
 
100
106
// 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;
 
107
static unsigned long _segment_step_sub_step = 0;
 
108
static unsigned long _segment_step_sub = 0;
103
109
 
104
110
// the button
105
 
static Button button( 3 );
106
 
 
107
 
// major mode
108
 
static int major_mode = 0;
109
 
 
110
 
#define MAX_MAJOR_MODES 5
 
111
static Button _button( 3 );
111
112
 
112
113
// major modes
113
 
static MajorMode *major_modes[ MAX_MAJOR_MODES ] = { 0 };
 
114
static MajorMode *_modes[ 3 ];
 
115
 
 
116
// current major mode
 
117
static int _mode = 0;
114
118
 
115
119
//_____________________________________________________________________________
116
120
//                                                                         code
117
121
 
118
 
 
119
122
// perform button events
120
 
void doButtonEvents()
 
123
void do_button_events()
121
124
{
122
125
        // loop through pending events
123
 
        while( int event = button.get_event() )
 
126
        while( int event = _button.get_event() )
124
127
        {
125
128
                switch( event )
126
129
                {
127
130
                case 1:
128
131
                        // short press
129
 
                        major_modes[ major_mode ]->press();
 
132
                        _modes[ _mode ]->press();
130
133
                        break;
131
 
 
132
134
                case 2:
133
135
                        // long press
134
 
                        major_modes[ major_mode ]->long_press();
 
136
                        _modes[ _mode ]->long_press();
135
137
                        break;
136
 
 
137
138
                case 3:
138
139
                        // looooong press (change major 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();
 
140
                        _modes[ _mode ]->deactivate();
 
141
                        if( !_modes[ ++_mode ] ) _mode = 0;
 
142
                        _modes[ _mode ]->activate();
144
143
                        break;
145
 
 
146
144
                }
147
145
        }
148
146
}
149
147
 
150
148
 
151
149
// draw a display segment
152
 
void drawNextSegment( bool reset )
 
150
void draw_next_segment( bool reset )
153
151
{
154
152
        // keep track of segment
155
153
#if CLOCK_FORWARD
160
158
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
159
#endif
162
160
 
 
161
        // reset the text renderer's buffer
 
162
        TextRenderer::reset_buffer();
 
163
 
 
164
        if( reset )
 
165
        {
 
166
                _modes[ _mode ]->draw_reset();
 
167
 
 
168
                // tell the text services we're starting a new frame
 
169
                Text::draw_reset();
 
170
        }
 
171
 
163
172
        // draw
164
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
165
 
        if( reset ) drawer.draw_reset();
166
 
        drawer.draw( segment );
 
173
        _modes[ _mode ]->draw( segment );
 
174
 
 
175
        // TODO: remove this hack
 
176
        Text::post_draw();
 
177
 
 
178
        // draw text rednerer's buffer
 
179
        TextRenderer::output_buffer();
167
180
 
168
181
#if CLOCK_FORWARD
169
182
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
174
187
 
175
188
 
176
189
// calculate time constants when a new pulse has occurred
177
 
void calculateSegmentTimes()
 
190
void calculate_segment_times()
178
191
{
179
192
        // check for overflows, and only recalculate times if there isn't
180
193
        // one (if there is, we'll just go with the last pulse's times)
181
 
        if( new_pulse_at > last_pulse_at )
 
194
        if( _new_pulse_at > _last_pulse_at )
182
195
        {
183
196
                // new segment stepping times
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;
 
197
                unsigned long delta = _new_pulse_at - _last_pulse_at;
 
198
                _segment_step = delta / NUM_SEGMENTS;
 
199
                _segment_step_sub = 0;
 
200
                _segment_step_sub_step = delta % NUM_SEGMENTS;
188
201
        }
189
202
 
190
203
        // now we have dealt with this pulse, save the pulse time and
191
204
        // clear new_pulse_at, ready for the next pulse
192
 
        last_pulse_at = new_pulse_at;
193
 
        new_pulse_at = 0;
 
205
        _last_pulse_at = _new_pulse_at;
 
206
        _new_pulse_at = 0;
194
207
}
195
208
 
196
209
 
197
210
// wait until it is time to draw the next segment or a new pulse has
198
211
// occurred
199
 
void waitTillEndOfSegment( bool reset )
 
212
void wait_till_end_of_segment( bool reset )
200
213
{
201
214
        static unsigned long end_time = 0;
202
215
 
203
216
        // handle reset
204
217
        if( reset )
205
 
                end_time = last_pulse_at;
 
218
                end_time = _last_pulse_at;
206
219
 
207
220
        // work out the time that this segment should be displayed until
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;
 
221
        end_time += _segment_step;
 
222
        _segment_step_sub += _segment_step_sub_step;
 
223
        if( _segment_step_sub >= NUM_SEGMENTS ) {
 
224
                _segment_step_sub -= NUM_SEGMENTS;
212
225
                end_time++;
213
226
        }
214
227
 
215
228
        // wait
216
 
        while( micros() < end_time && !new_pulse_at );
 
229
        while( micros() < end_time && !_new_pulse_at );
217
230
}
218
231
 
219
232
 
220
 
// ISR to handle the pulses from the fan's tachiometer
221
 
void fanPulseHandler()
 
233
// ISR to handle the pulses from the fan's tachometer
 
234
void fan_pulse_handler()
222
235
{
223
236
        // the fan actually sends two pulses per revolution. These pulses
224
237
        // may not be exactly evenly distributed around the rotation, so
229
242
        if( !ignore )
230
243
        {
231
244
                // set a new pulse time
232
 
                new_pulse_at = micros();
 
245
                _new_pulse_at = micros();
233
246
        }
234
247
}
235
248
 
237
250
// main setup
238
251
void setup()
239
252
{
240
 
        // set up an interrupt handler on pin 2 to nitice fan pulses
241
 
        attachInterrupt( 0, fanPulseHandler, RISING );
 
253
        // set up an interrupt handler on pin 2 to notice fan pulses
 
254
        attachInterrupt( 0, fan_pulse_handler, RISING );
242
255
        digitalWrite( 2, HIGH );
243
256
  
244
257
        // set up output pins (4 to 13) for the led array
248
261
        // set up mode-switch button on pin 3
249
262
        pinMode( 3, INPUT );
250
263
        digitalWrite( 3, HIGH );
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;
 
264
        static int event_times[] = { 5, 500, 4000, 0 };
 
265
        _button.set_event_times( event_times );
 
266
 
 
267
        // initialise RTC
 
268
//      Time::load_time();
 
269
 
 
270
        // init text renderer
 
271
        TextRenderer::init();
 
272
 
 
273
        // reset text
 
274
        Text::reset();
 
275
        leds_off();
 
276
 
 
277
        static SwitcherMajorMode switcher;
 
278
        static SettingsMajorMode settings( _button );
 
279
 
 
280
        // add major modes
256
281
        int mode = 0;
257
 
        major_modes[ mode++ ] = &switcher_major_mode;
258
 
        major_modes[ 0 ]->activate();
 
282
        _modes[ mode++ ] = &switcher;
 
283
        _modes[ mode++ ] = &settings;
 
284
        _modes[ mode ] = 0;
 
285
 
 
286
        // activate the current major mode
 
287
        _modes[ _mode ]->activate();
259
288
}
260
289
 
261
290
 
263
292
void loop()
264
293
{
265
294
        // if there has been a new pulse, we'll be resetting the display
266
 
        bool reset = new_pulse_at? true : false;
 
295
        bool reset = _new_pulse_at? true : false;
267
296
 
268
297
        // update button
269
 
        button.update();
 
298
        _button.update();
270
299
 
271
300
        // only do this stuff at the start of a display cycle, to ensure
272
301
        // that no state changes mid-display
273
302
        if( reset )
274
303
        {
275
304
                // calculate segment times
276
 
                calculateSegmentTimes();
 
305
                calculate_segment_times();
277
306
 
278
307
                // keep track of time
279
 
                Time &time = Time::get_instance();
280
 
                time.update();
 
308
                Time::update();
281
309
 
282
310
                // perform button events
283
 
                doButtonEvents();
 
311
                do_button_events();
284
312
        }
285
313
 
286
314
        // draw this segment
287
 
        drawNextSegment( reset );
 
315
        draw_next_segment( reset );
288
316
 
289
317
        // wait till it's time to draw the next segment
290
 
        waitTillEndOfSegment( reset );
 
318
        wait_till_end_of_segment( reset );
291
319
}