/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
76
76
******************************************************************************/
77
77
 
78
78
 
79
 
#include <Bounce.h>
80
 
#include <DS1307.h>
81
 
#include <Wire.h>
 
79
#include <button.h>
 
80
#include "config.h"
 
81
#include "time.h"
 
82
#include "mode_switcher.h"
 
83
#include "drawer.h"
82
84
 
83
85
//_____________________________________________________________________________
84
86
//                                                                         data
103
105
static bool inc_draw_mode = false;
104
106
 
105
107
// 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
 
108
static Button button( 3 );
120
109
 
121
110
//_____________________________________________________________________________
122
111
//                                                                         code
126
115
void checkButtons()
127
116
{
128
117
        // update buttons
129
 
        button.update();
 
118
        int event = button.update();
130
119
 
131
 
        // notice button presses
132
 
        if( button.risingEdge() )
 
120
        // handle any events
 
121
        switch( event ) {
 
122
        case 1:
133
123
                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;
162
 
                }
 
124
                break;
163
125
        }
164
126
}
165
127
 
173
135
        num += 4;
174
136
 
175
137
        // 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;
 
138
        if( num == 4 ) on = !on;
179
139
 
180
140
        digitalWrite( num, on? HIGH : LOW );
181
141
}
182
142
 
183
143
 
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
 
 
219
144
// draw a display segment
220
145
void drawNextSegment( bool reset )
221
146
{
222
 
        static int draw_mode = 0;
 
147
        static ModeSwitcher mode_switcher;
 
148
        static bool init = false;
 
149
 
 
150
        if( !init ) {
 
151
                init = true;
 
152
                mode_switcher.activate();
 
153
        }
223
154
 
224
155
        // keep track of segment
225
156
#if CLOCK_FORWARD
226
 
        static int segment = 0;
227
 
        if( reset ) segment = 0;
 
157
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
 
158
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
228
159
#else
229
 
        static int segment = NUM_SEGMENTS - 1;
230
 
        if( reset ) segment = NUM_SEGMENTS - 1;
 
160
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
 
161
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
231
162
#endif
232
163
 
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
 
        }
 
164
        // draw
 
165
        Drawer &drawer = mode_switcher.get_drawer();
 
166
        if( reset ) drawer.draw_reset();
 
167
        drawer.draw( segment );
246
168
 
247
169
#if CLOCK_FORWARD
248
 
        segment++;
 
170
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
249
171
#else
250
 
        segment--;
 
172
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
251
173
#endif
252
174
}
253
175
 
327
249
        // set up mode-switch button on pin 3
328
250
        pinMode( 3, INPUT );
329
251
        digitalWrite( 3, HIGH );
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 ];
 
252
        button.add_event_at( 5, 1 );
 
253
        button.add_event_at( 1000, 2 );
 
254
        button.add_event_at( 4000, 3 );
337
255
 
338
256
        // serial comms
339
257
        Serial.begin( 9600 );
354
272
                checkButtons();
355
273
 
356
274
                // keep track of time
357
 
                trackTime();
 
275
                Time &time = Time::get_instance();
 
276
                time.update();
358
277
        }
359
278
 
360
279
        // draw this segment