/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 13:04:29 UTC
  • Revision ID: tim@ed.am-20120310130429-310w5ejo968mc6mo
cleaned-up notes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* -*- mode: c++; compile-command: "make"; -*- */
 
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
2
/*
3
3
 * propeller-clock.ino
4
4
 *
79
79
#include "button.h"
80
80
#include "time.h"
81
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"
 
82
#include "analogue_clock.h"
 
83
#include "digital_clock.h"
 
84
#include "test_pattern.h"
91
85
 
92
86
//_____________________________________________________________________________
93
87
//                                                                         data
110
104
// the button
111
105
static Button _button( 3 );
112
106
 
113
 
// major modes
114
 
static MajorMode *_modes[ 3 ];
115
 
 
116
 
// current major mode
117
 
static int _mode = 0;
 
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
118
116
 
119
117
//_____________________________________________________________________________
120
118
//                                                                         code
121
119
 
 
120
 
 
121
// activate the current minor mode
 
122
void activate_minor_mode()
 
123
{
 
124
        switch( _minor_mode ) {
 
125
        case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;
 
126
        case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
 
127
        }
 
128
}
 
129
 
122
130
// perform button events
123
131
void do_button_events()
124
132
{
129
137
                {
130
138
                case 1:
131
139
                        // short press
132
 
                        _modes[ _mode ]->press();
 
140
                        switch( _major_mode ) {
 
141
                        case MAIN_MODE_IDX:
 
142
                                switch( _minor_mode ) {
 
143
                                case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;
 
144
                                case DIGITAL_CLOCK_IDX: digital_clock_press(); break;
 
145
                                }
 
146
                                break;
 
147
                        }
133
148
                        break;
 
149
 
134
150
                case 2:
135
151
                        // long press
136
 
                        _modes[ _mode ]->long_press();
 
152
                        switch( _major_mode ) {
 
153
                        case MAIN_MODE_IDX:
 
154
                                if( ++_minor_mode >= 3 )
 
155
                                        _minor_mode = 0;
 
156
                                switch( _minor_mode ) {
 
157
                                case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;
 
158
                                }
 
159
                                break;
 
160
                        }
137
161
                        break;
 
162
 
138
163
                case 3:
139
164
                        // looooong press (change major mode)
140
 
                        _modes[ _mode ]->deactivate();
141
 
                        if( !_modes[ ++_mode ] ) _mode = 0;
142
 
                        _modes[ _mode ]->activate();
 
165
                        if( ++_major_mode > 0 )
 
166
                                _major_mode = 0;
 
167
                        switch( _major_mode ) {
 
168
                        case MAIN_MODE_IDX: _minor_mode = 0; break;
 
169
                        }
 
170
                        activate_minor_mode();
143
171
                        break;
144
172
                }
145
173
        }
158
186
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
159
187
#endif
160
188
 
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();
 
189
        // frame reset
 
190
        if( reset ) {
 
191
                switch( _major_mode ) {
 
192
                case MAIN_MODE_IDX:
 
193
                        switch( _minor_mode ) {
 
194
                        case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;
 
195
                        case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;
 
196
                        }
 
197
                        break;
 
198
                }
170
199
        }
171
200
 
172
201
        // draw
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();
 
202
        switch( _major_mode ) {
 
203
        case MAIN_MODE_IDX:
 
204
                switch( _minor_mode ) {
 
205
                case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;
 
206
                case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;
 
207
                case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;
 
208
                }
 
209
                break;
 
210
        }
180
211
 
181
212
#if CLOCK_FORWARD
182
213
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
230
261
}
231
262
 
232
263
 
233
 
// ISR to handle the pulses from the fan's tachometer
 
264
// ISR to handle the pulses from the fan's tachiometer
234
265
void fan_pulse_handler()
235
266
{
236
267
        // the fan actually sends two pulses per revolution. These pulses
250
281
// main setup
251
282
void setup()
252
283
{
253
 
        // set up an interrupt handler on pin 2 to notice fan pulses
 
284
        // set up an interrupt handler on pin 2 to nitice fan pulses
254
285
        attachInterrupt( 0, fan_pulse_handler, RISING );
255
286
        digitalWrite( 2, HIGH );
256
287
  
267
298
        // initialise RTC
268
299
        Time::init();
269
300
 
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;
279
 
 
280
 
        // add major modes
281
 
        int mode = 0;
282
 
        _modes[ mode++ ] = &switcher;
283
 
        _modes[ mode++ ] = &settings;
284
 
        _modes[ mode ] = 0;
285
 
 
286
 
        // activate the current major mode
287
 
        _modes[ _mode ]->activate();
 
301
        // activate the minor mode
 
302
        switch( _major_mode ) {
 
303
        case MAIN_MODE_IDX: activate_minor_mode(); break;
 
304
        }
288
305
}
289
306
 
290
307