/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 01:31:17 UTC
  • Revision ID: tim@ed.am-20120225013117-53ed8yahoreoms76
updated software to include drawing abstraction infrastructure

Show diffs side-by-side

added added

removed removed

src/propeller-clock.ino
75
75
 
76
76
******************************************************************************/
77
77
 
 
78
 
 
79
#include <button.h>
78
80
#include "config.h"
79
 
#include "display.h"
80
 
#include "button.h"
81
81
#include "time.h"
82
 
#include "switcher_major_mode.h"
 
82
#include "mode_switcher.h"
83
83
#include "drawer.h"
84
84
 
85
85
//_____________________________________________________________________________
101
101
static unsigned long segment_step_sub_step = 0;
102
102
static unsigned long segment_step_sub = 0;
103
103
 
104
 
// the button
 
104
// flag to indicate that the drawing mode should be cycled to the next one
 
105
static bool inc_draw_mode = false;
 
106
 
 
107
// a bounce-managed button
105
108
static Button button( 3 );
106
109
 
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 };
114
 
 
115
110
//_____________________________________________________________________________
116
111
//                                                                         code
117
112
 
118
113
 
119
 
// perform button events
120
 
void doButtonEvents()
 
114
// check for button presses
 
115
void checkButtons()
121
116
{
122
 
        // loop through pending events
123
 
        while( int event = button.get_event() )
124
 
        {
125
 
                switch( event )
126
 
                {
127
 
                case 1:
128
 
                        // short press
129
 
                        major_modes[ major_mode ]->press();
130
 
                        break;
131
 
 
132
 
                case 2:
133
 
                        // long press
134
 
                        major_modes[ major_mode ]->long_press();
135
 
                        break;
136
 
 
137
 
                case 3:
138
 
                        // 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();
144
 
                        break;
145
 
 
146
 
                }
 
117
        // update buttons
 
118
        int event = button.update();
 
119
 
 
120
        // handle any events
 
121
        switch( event ) {
 
122
        case 1:
 
123
                inc_draw_mode = true;
 
124
                break;
147
125
        }
148
126
}
149
127
 
150
128
 
 
129
// turn an led on/off
 
130
void ledOn( int num, bool on )
 
131
{
 
132
        if( num < 0 || num > 9 ) return;
 
133
 
 
134
        // convert to pin no.
 
135
        num += 4;
 
136
 
 
137
        // pin 4 needs to be inverted (it's driving a PNP)
 
138
        if( num == 4 ) on = !on;
 
139
 
 
140
        digitalWrite( num, on? HIGH : LOW );
 
141
}
 
142
 
 
143
 
151
144
// draw a display segment
152
145
void drawNextSegment( bool reset )
153
146
{
 
147
        static ModeSwitcher mode_switcher;
 
148
        static bool init = false;
 
149
 
 
150
        if( !init ) {
 
151
                init = true;
 
152
                mode_switcher.activate();
 
153
        }
 
154
 
154
155
        // keep track of segment
155
156
#if CLOCK_FORWARD
156
157
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
161
162
#endif
162
163
 
163
164
        // draw
164
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
 
165
        Drawer &drawer = mode_switcher.get_drawer();
165
166
        if( reset ) drawer.draw_reset();
166
167
        drawer.draw( segment );
167
168
 
196
197
 
197
198
// wait until it is time to draw the next segment or a new pulse has
198
199
// occurred
199
 
void waitTillEndOfSegment( bool reset )
 
200
void waitTillNextSegment( bool reset )
200
201
{
201
202
        static unsigned long end_time = 0;
202
203
 
248
249
        // set up mode-switch button on pin 3
249
250
        pinMode( 3, INPUT );
250
251
        digitalWrite( 3, HIGH );
251
 
        static int event_times[] = { 5, 1000, 4000, 0 };
252
 
        button.set_event_times( event_times );
 
252
        button.add_event_at( 5, 1 );
 
253
        button.add_event_at( 1000, 2 );
 
254
        button.add_event_at( 4000, 3 );
253
255
 
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();
 
256
        // serial comms
 
257
        Serial.begin( 9600 );
259
258
}
260
259
 
261
260
 
265
264
        // if there has been a new pulse, we'll be resetting the display
266
265
        bool reset = new_pulse_at? true : false;
267
266
 
268
 
        // update button
269
 
        button.update();
270
 
 
271
267
        // only do this stuff at the start of a display cycle, to ensure
272
268
        // that no state changes mid-display
273
269
        if( reset )
274
270
        {
275
 
                // calculate segment times
276
 
                calculateSegmentTimes();
 
271
                // check buttons
 
272
                checkButtons();
277
273
 
278
274
                // keep track of time
279
275
                Time &time = Time::get_instance();
280
276
                time.update();
281
 
 
282
 
                // perform button events
283
 
                doButtonEvents();
284
277
        }
285
278
 
286
279
        // draw this segment
287
280
        drawNextSegment( reset );
288
281
 
 
282
        // do we need to recalculate segment times?
 
283
        if( reset )
 
284
                calculateSegmentTimes();
 
285
 
289
286
        // wait till it's time to draw the next segment
290
 
        waitTillEndOfSegment( reset );
 
287
        waitTillNextSegment( reset );
291
288
}