/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-23 00:26:32 UTC
  • Revision ID: edam@waxworlds.org-20120223002632-kkwrdwijfmv45f0j
conrtol segment number from one place and reverse the order the segments are drawn (backwards clock!)

Show diffs side-by-side

added added

removed removed

Lines of Context:
75
75
 
76
76
******************************************************************************/
77
77
 
78
 
#include "config.h"
79
 
#include "display.h"
80
 
#include "button.h"
81
 
#include "time.h"
82
 
#include "switcher_major_mode.h"
83
 
#include "drawer.h"
84
 
#include "Arduino.h"
 
78
 
 
79
#include <Bounce.h>
 
80
#include <DS1307.h>
 
81
#include <Wire.h>
85
82
 
86
83
//_____________________________________________________________________________
87
84
//                                                                         data
102
99
static unsigned long segment_step_sub_step = 0;
103
100
static unsigned long segment_step_sub = 0;
104
101
 
105
 
// the button
106
 
static Button button( 3 );
107
 
 
108
 
// major mode
109
 
static int major_mode = 0;
110
 
 
111
 
#define MAX_MAJOR_MODES 5
112
 
 
113
 
// major modes
114
 
static MajorMode *major_modes[ MAX_MAJOR_MODES ] = { 0 };
 
102
// flag to indicate that the drawing mode should be cycled to the next one
 
103
static bool inc_draw_mode = false;
 
104
 
 
105
// a bounce-managed button
 
106
static Bounce button( 3, 50 );
 
107
 
 
108
// the time
 
109
static int time_hours = 0;
 
110
static int time_minutes = 0;
 
111
static int time_seconds = 0;
 
112
 
 
113
// number of segments in a full display (rotation) is 60 (one per
 
114
// second) times the desired number of sub-divisions of a second
 
115
#define NUM_SECOND_SEGMENTS 5
 
116
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
 
117
 
 
118
// clock direction
 
119
#define CLOCK_FORWARD 0
115
120
 
116
121
//_____________________________________________________________________________
117
122
//                                                                         code
118
123
 
119
124
 
120
 
// perform button events
121
 
void doButtonEvents()
122
 
{
123
 
        // loop through pending events
124
 
        while( int event = button.get_event() )
125
 
        {
126
 
                switch( event )
127
 
                {
128
 
                case 1:
129
 
                        // short press
130
 
                        major_modes[ major_mode ]->press();
131
 
                        break;
132
 
 
133
 
                case 2:
134
 
                        // long press
135
 
                        major_modes[ major_mode ]->long_press();
136
 
                        break;
137
 
 
138
 
                case 3:
139
 
                        // looooong press (change major mode)
140
 
                        do {
141
 
                                if( ++major_mode >= MAX_MAJOR_MODES )
142
 
                                        major_mode = 0;
143
 
                        } while( major_modes[ major_mode ] == NULL );
144
 
                        major_modes[ major_mode ]->activate();
145
 
                        break;
146
 
 
 
125
// check for button presses
 
126
void checkButtons()
 
127
{
 
128
        // update buttons
 
129
        button.update();
 
130
 
 
131
        // notice button presses
 
132
        if( button.risingEdge() )
 
133
                inc_draw_mode = true;
 
134
}
 
135
 
 
136
 
 
137
// keep track of time
 
138
void trackTime()
 
139
{
 
140
        // previous time and any carried-over milliseconds
 
141
        static unsigned long last_time = millis();
 
142
        static unsigned long carry = 0;
 
143
 
 
144
        // how many milliseonds have elapsed since we last checked?
 
145
        unsigned long next_time = millis();
 
146
        unsigned long delta = next_time - last_time + carry;
 
147
 
 
148
        // update the previous time and carried-over milliseconds
 
149
        last_time = next_time;
 
150
        carry = delta % 1000;
 
151
 
 
152
        // add the seconds that have passed to the time
 
153
        time_seconds += delta / 1000;
 
154
        while( time_seconds >= 60 ) {
 
155
                time_seconds -= 60;
 
156
                time_minutes++;
 
157
                if( time_minutes >= 60 ) {
 
158
                        time_minutes -= 60;
 
159
                        time_hours++;
 
160
                        if( time_hours >= 24 )
 
161
                                time_hours -= 24;
147
162
                }
148
163
        }
149
164
}
150
165
 
151
166
 
 
167
// turn an led on/off
 
168
void ledOn( int num, bool on )
 
169
{
 
170
        if( num < 0 || num > 9 ) return;
 
171
 
 
172
        // convert to pin no.
 
173
        num += 4;
 
174
 
 
175
        // pin 4 needs to be inverted (it's driving a PNP)
 
176
        // NOTE: PIN 4 TEMPORARILY DISABLED
 
177
//      if( num == 4 ) on = true;
 
178
if( num == 4 ) on = !on;
 
179
 
 
180
        digitalWrite( num, on? HIGH : LOW );
 
181
}
 
182
 
 
183
 
 
184
// draw a segment for the test display
 
185
void drawNextSegment_test( int segment )
 
186
{
 
187
        // turn on inside and outside LEDs
 
188
        ledOn( 9, true );
 
189
 
 
190
        // display segment number in binary across in the inside LEDs,
 
191
        // with the LED on pin 12 showing the least-significant bit
 
192
        for( int a = 0; a < 9; a++ )
 
193
                ledOn( 8 - a, ( segment >> a ) & 1 );
 
194
}
 
195
 
 
196
 
 
197
// draw a segment for the time display
 
198
void drawNextSegment_time( int segment )
 
199
{
 
200
        int second = segment / NUM_SECOND_SEGMENTS;
 
201
        int second_segment = segment % NUM_SECOND_SEGMENTS;
 
202
 
 
203
        // what needs to be drawn?
 
204
        bool draw_tick = !second_segment && second % 5 == 0;
 
205
        bool draw_second = !second_segment && second == time_seconds;
 
206
        bool draw_minute = !second_segment && second == time_minutes;
 
207
        bool draw_hour = !second_segment && second == time_hours;
 
208
 
 
209
        // set the LEDs
 
210
        ledOn( 9, true );
 
211
        ledOn( 8, draw_tick || draw_minute );
 
212
        for( int a = 6; a <= 7; a++ )
 
213
                ledOn( a, draw_minute || draw_second );
 
214
        for( int a = 0; a <= 5; a++ )
 
215
                ledOn( a, draw_minute || draw_second || draw_hour );
 
216
}
 
217
 
 
218
 
152
219
// draw a display segment
153
220
void drawNextSegment( bool reset )
154
221
{
 
222
        static int draw_mode = 0;
 
223
 
155
224
        // keep track of segment
156
225
#if CLOCK_FORWARD
157
 
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
158
 
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
 
226
        static int segment = 0;
 
227
        if( reset ) segment = 0;
159
228
#else
160
 
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
 
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
 
229
        static int segment = NUM_SEGMENTS - 1;
 
230
        if( reset ) segment = NUM_SEGMENTS - 1;
162
231
#endif
163
232
 
164
 
        // draw
165
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
166
 
        if( reset ) drawer.draw_reset();
167
 
        drawer.draw( segment );
 
233
        // handle mode switch requests
 
234
        if( reset && inc_draw_mode ) {
 
235
                inc_draw_mode = false;
 
236
                draw_mode++;
 
237
                if( draw_mode >= 2 )
 
238
                        draw_mode = 0;
 
239
        }
 
240
 
 
241
        // draw the segment
 
242
        switch( draw_mode ) {
 
243
        case 0: drawNextSegment_test( segment ); break;
 
244
        case 1: drawNextSegment_time( segment ); break;
 
245
        }
168
246
 
169
247
#if CLOCK_FORWARD
170
 
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
 
248
        segment++;
171
249
#else
172
 
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
 
250
        segment--;
173
251
#endif
174
252
}
175
253
 
197
275
 
198
276
// wait until it is time to draw the next segment or a new pulse has
199
277
// occurred
200
 
void waitTillEndOfSegment( bool reset )
 
278
void waitTillNextSegment( bool reset )
201
279
{
202
280
        static unsigned long end_time = 0;
203
281
 
249
327
        // set up mode-switch button on pin 3
250
328
        pinMode( 3, INPUT );
251
329
        digitalWrite( 3, HIGH );
252
 
        static int event_times[] = { 5, 500, 4000, 0 };
253
 
        button.set_event_times( event_times );
254
 
 
255
 
        // set up major modes
256
 
        static SwitcherMajorMode switcher_major_mode;
257
 
        int mode = 0;
258
 
        major_modes[ mode++ ] = &switcher_major_mode;
259
 
        major_modes[ 0 ]->activate();
 
330
 
 
331
        // get the time from the real-time clock
 
332
        int rtc_data[ 7 ];
 
333
        RTC.get( rtc_data, true );
 
334
        time_hours = rtc_data[ DS1307_HR ];
 
335
        time_minutes = rtc_data[ DS1307_MIN ];
 
336
        time_seconds = rtc_data[ DS1307_SEC ];
 
337
 
 
338
        // serial comms
 
339
        Serial.begin( 9600 );
260
340
}
261
341
 
262
342
 
266
346
        // if there has been a new pulse, we'll be resetting the display
267
347
        bool reset = new_pulse_at? true : false;
268
348
 
269
 
        // update button
270
 
        button.update();
271
 
 
272
349
        // only do this stuff at the start of a display cycle, to ensure
273
350
        // that no state changes mid-display
274
351
        if( reset )
275
352
        {
276
 
                // calculate segment times
277
 
                calculateSegmentTimes();
 
353
                // check buttons
 
354
                checkButtons();
278
355
 
279
356
                // keep track of time
280
 
                Time &time = Time::get_instance();
281
 
                time.update();
282
 
 
283
 
                // perform button events
284
 
                doButtonEvents();
 
357
                trackTime();
285
358
        }
286
359
 
287
360
        // draw this segment
288
361
        drawNextSegment( reset );
289
362
 
 
363
        // do we need to recalculate segment times?
 
364
        if( reset )
 
365
                calculateSegmentTimes();
 
366
 
290
367
        // wait till it's time to draw the next segment
291
 
        waitTillEndOfSegment( reset );
 
368
        waitTillNextSegment( reset );
292
369
}