/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-10 21:25:33 UTC
  • Revision ID: edam@waxworlds.org-20120210212533-fwi9b0isyr8my2lu
updated arduino.mk

Show diffs side-by-side

added added

removed removed

Lines of Context:
75
75
 
76
76
******************************************************************************/
77
77
 
78
 
#include "button.h"
79
 
#include "config.h"
80
 
#include "time.h"
81
 
#include "mode_switcher.h"
82
 
#include "drawer.h"
 
78
 
 
79
#include <Bounce.h>
 
80
#include <DS1307.h>
 
81
#include <Wire.h>
83
82
 
84
83
//_____________________________________________________________________________
85
84
//                                                                         data
100
99
static unsigned long segment_step_sub_step = 0;
101
100
static unsigned long segment_step_sub = 0;
102
101
 
103
 
// the button
104
 
static Button button( 3 );
105
 
 
106
 
// major mode
107
 
static int major_mode = 0;
108
 
 
109
 
// major modes
110
 
static std::vector< MajorMode * > major_modes;
 
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 )
111
117
 
112
118
//_____________________________________________________________________________
113
119
//                                                                         code
117
123
void checkButtons()
118
124
{
119
125
        // update buttons
120
 
        int event = button.update();
121
 
 
122
 
        // handle any events
123
 
        switch( event ) {
124
 
        case 1:
125
 
                major_modes[ major_mode ]->short_press();
126
 
                break;
127
 
        case 2:
128
 
                major_modes[ major_mode ]->long_press();
129
 
                break;
130
 
        case 3:
131
 
                if( ++major_mode >= major_modes.size() )
132
 
                        major_mode = 0;
133
 
                major_modes[ major_mode ]->activate();
134
 
                break;
 
126
        button.update();
 
127
 
 
128
        // notice button presses
 
129
        if( button.risingEdge() )
 
130
                inc_draw_mode = true;
 
131
}
 
132
 
 
133
 
 
134
// keep track of time
 
135
void trackTime()
 
136
{
 
137
        // previous time and any carried-over milliseconds
 
138
        static unsigned long last_time = millis();
 
139
        static unsigned long carry = 0;
 
140
 
 
141
        // how many milliseonds have elapsed since we last checked?
 
142
        unsigned long next_time = millis();
 
143
        unsigned long delta = next_time - last_time + carry;
 
144
 
 
145
        // update the previous time and carried-over milliseconds
 
146
        last_time = next_time;
 
147
        carry = delta % 1000;
 
148
 
 
149
        // add the seconds that have passed to the time
 
150
        time_seconds += delta / 1000;
 
151
        while( time_seconds >= 60 ) {
 
152
                time_seconds -= 60;
 
153
                time_minutes++;
 
154
                if( time_minutes >= 60 ) {
 
155
                        time_minutes -= 60;
 
156
                        time_hours++;
 
157
                        if( time_hours >= 24 )
 
158
                                time_hours -= 24;
 
159
                }
 
160
        }
 
161
}
 
162
 
 
163
 
 
164
// turn an led on/off
 
165
void ledOn( int num, bool on )
 
166
{
 
167
        if( num < 0 || num > 9 ) return;
 
168
 
 
169
        // convert to pin no.
 
170
        num += 4;
 
171
 
 
172
        // pin 4 needs to be inverted (it's driving a PNP)
 
173
        // NOTE: PIN 4 TEMPORARILY DISABLED
 
174
        if( num == 4 ) on = true; //!on
 
175
 
 
176
        digitalWrite( num, on? HIGH : LOW );
 
177
}
 
178
 
 
179
 
 
180
// draw a segment for the test display
 
181
void drawNextSegment_test( bool reset )
 
182
{
 
183
        // keep track of segment
 
184
        static unsigned int segment = 0;
 
185
        if( reset ) segment = 0;
 
186
        segment++;
 
187
 
 
188
        // turn on inside and outside LEDs
 
189
        ledOn( 0, true );
 
190
        ledOn( 9, true );
 
191
 
 
192
        // display segment number in binary across in the inside LEDs,
 
193
        // with the LED on pin 12 showing the least-significant bit
 
194
        for( int a = 0; a < 8; a++ )
 
195
                ledOn( 8 - a, ( segment >> a ) & 1 );
 
196
}
 
197
 
 
198
 
 
199
// draw a segment for the time display
 
200
void drawNextSegment_time( bool reset )
 
201
{
 
202
        static int second = 0;
 
203
        static int segment = 0;
 
204
 
 
205
        // handle display reset
 
206
        if( reset ) {
 
207
                second = 0;
 
208
                segment = 0;
 
209
        }
 
210
 
 
211
        // what needs to be drawn?
 
212
        bool draw_tick = !segment && second % 5 == 0;
 
213
        bool draw_second = !segment && second == time_seconds;
 
214
        bool draw_minute = !segment && second == time_minutes;
 
215
        bool draw_hour = !segment && second == time_hours;
 
216
 
 
217
        // set the LEDs
 
218
        ledOn( 9, true );
 
219
        ledOn( 8, draw_tick || draw_minute );
 
220
        for( int a = 6; a <= 7; a++ )
 
221
                ledOn( a, draw_minute || draw_second );
 
222
        for( int a = 0; a <= 5; a++ )
 
223
                ledOn( a, draw_minute || draw_second || draw_hour );
 
224
 
 
225
        // inc position
 
226
        if( ++segment >= NUM_SECOND_SEGMENTS ) {
 
227
                segment = 0;
 
228
                second++;
135
229
        }
136
230
}
137
231
 
139
233
// draw a display segment
140
234
void drawNextSegment( bool reset )
141
235
{
142
 
        // keep track of segment
143
 
#if CLOCK_FORWARD
144
 
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
145
 
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
146
 
#else
147
 
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
148
 
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
149
 
#endif
150
 
 
151
 
        // draw
152
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
153
 
        if( reset ) drawer.draw_reset();
154
 
        drawer.draw( segment );
155
 
 
156
 
#if CLOCK_FORWARD
157
 
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
158
 
#else
159
 
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
160
 
#endif
 
236
        static int draw_mode = 0;
 
237
 
 
238
        // handle mode switch requests
 
239
        if( reset && inc_draw_mode ) {
 
240
                inc_draw_mode = false;
 
241
                draw_mode++;
 
242
                if( draw_mode >= 2 )
 
243
                        draw_mode = 0;
 
244
        }
 
245
 
 
246
        // draw the segment
 
247
        switch( draw_mode ) {
 
248
        case 0: drawNextSegment_test( reset ); break;
 
249
        case 1: drawNextSegment_time( reset ); break;
 
250
        }
161
251
}
162
252
 
163
253
 
236
326
        // set up mode-switch button on pin 3
237
327
        pinMode( 3, INPUT );
238
328
        digitalWrite( 3, HIGH );
239
 
        button.add_event_at( 5, 1 );
240
 
        button.add_event_at( 1000, 2 );
241
 
        button.add_event_at( 4000, 3 );
 
329
 
 
330
        // get the time from the real-time clock
 
331
        int rtc_data[ 7 ];
 
332
        RTC.get( rtc_data, true );
 
333
        time_hours = rtc_data[ DS1307_HR ];
 
334
        time_minutes = rtc_data[ DS1307_MIN ];
 
335
        time_seconds = rtc_data[ DS1307_SEC ];
242
336
 
243
337
        // serial comms
244
338
        Serial.begin( 9600 );
245
 
 
246
 
        // set up major modes
247
 
        static ModeSwitcher mode_switcher;
248
 
        major_modes.push_back( &mode_switcher );
249
 
        major_modes[ 0 ]->activate();
250
339
}
251
340
 
252
341
 
264
353
                checkButtons();
265
354
 
266
355
                // keep track of time
267
 
                Time &time = Time::get_instance();
268
 
                time.update();
 
356
                trackTime();
269
357
        }
270
358
 
271
359
        // draw this segment