/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-01-14 17:31:34 UTC
  • Revision ID: edam@waxworlds.org-20120114173134-5zoqjn0upzpb4ufa
added led-test subproject

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/propeller-clock.ino
1
 
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
1
/*
3
2
 * propeller-clock.ino
4
3
 *
103
102
static bool inc_draw_mode = false;
104
103
 
105
104
// a bounce-managed button
106
 
static Bounce button( 3, 50 );
 
105
static Bounce button( 3, 5 );
107
106
 
108
107
// the time
109
108
static int time_hours = 0;
115
114
#define NUM_SECOND_SEGMENTS 5
116
115
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
117
116
 
118
 
// clock direction
119
 
#define CLOCK_FORWARD 0
120
 
 
121
117
//_____________________________________________________________________________
122
118
//                                                                         code
123
119
 
164
160
}
165
161
 
166
162
 
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
163
// draw a segment for the test display
185
 
void drawNextSegment_test( int segment )
 
164
void drawNextSegment_test( bool reset )
186
165
{
 
166
        // keep track of segment
 
167
        static unsigned int segment = 0;
 
168
        if( reset ) segment = 0;
 
169
        segment++;
 
170
 
187
171
        // turn on inside and outside LEDs
188
 
        ledOn( 9, true );
 
172
        digitalWrite( 4, HIGH );
 
173
        digitalWrite( 13, HIGH );
189
174
 
190
175
        // display segment number in binary across in the inside LEDs,
191
176
        // 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 );
 
177
        for( int a = 0; a < 8; a++ )
 
178
                digitalWrite( 12 - a, ( ( segment >> a ) & 1 )? HIGH : LOW );
194
179
}
195
180
 
196
181
 
197
182
// draw a segment for the time display
198
 
void drawNextSegment_time( int segment )
 
183
void drawNextSegment_time( bool reset )
199
184
{
200
 
        int second = segment / NUM_SECOND_SEGMENTS;
201
 
        int second_segment = segment % NUM_SECOND_SEGMENTS;
 
185
        static unsigned int second = 0;
 
186
        static unsigned int segment = 0;
 
187
 
 
188
        // handle display reset
 
189
        if( reset ) {
 
190
                second = 0;
 
191
                segment = 0;
 
192
        }
202
193
 
203
194
        // 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;
 
195
        bool draw_tick = !segment && second % 5 == 0;
 
196
        bool draw_second = !segment && second == time_seconds;
 
197
        bool draw_minute = !segment && second == time_minutes;
 
198
        bool draw_hour = !segment && second == time_hours;
208
199
 
209
200
        // 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 );
 
201
        digitalWrite( 13, HIGH );
 
202
        digitalWrite( 12, draw_tick || draw_minute );
 
203
        for( int a = 10; a <= 11; a++ )
 
204
                digitalWrite( a, draw_minute || draw_second );
 
205
        for( int a = 4; a <= 9; a++ )
 
206
                digitalWrite( 10, draw_minute | draw_second || draw_hour );
 
207
 
 
208
        // inc position
 
209
        if( ++segment >= NUM_SECOND_SEGMENTS ) {
 
210
                segment = 0;
 
211
                second++;
 
212
        }
216
213
}
217
214
 
218
215
 
221
218
{
222
219
        static int draw_mode = 0;
223
220
 
224
 
        // keep track of segment
225
 
#if CLOCK_FORWARD
226
 
        static int segment = 0;
227
 
        if( reset ) segment = 0;
228
 
#else
229
 
        static int segment = NUM_SEGMENTS - 1;
230
 
        if( reset ) segment = NUM_SEGMENTS - 1;
231
 
#endif
232
 
 
233
221
        // handle mode switch requests
234
222
        if( reset && inc_draw_mode ) {
235
223
                inc_draw_mode = false;
240
228
 
241
229
        // draw the segment
242
230
        switch( draw_mode ) {
243
 
        case 0: drawNextSegment_test( segment ); break;
244
 
        case 1: drawNextSegment_time( segment ); break;
 
231
        case 0: drawNextSegment_test( reset ); break;
 
232
        case 1: drawNextSegment_time( reset ); break;
245
233
        }
246
 
 
247
 
#if CLOCK_FORWARD
248
 
        segment++;
249
 
#else
250
 
        segment--;
251
 
#endif
252
234
}
253
235
 
254
236
 
326
308
 
327
309
        // set up mode-switch button on pin 3
328
310
        pinMode( 3, INPUT );
329
 
        digitalWrite( 3, HIGH );
330
311
 
331
312
        // get the time from the real-time clock
332
313
        int rtc_data[ 7 ];