/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:29:52 UTC
  • Revision ID: tim@ed.am-20120225012952-32q8gg07aovk3qxh
updated arduino.mk

Show diffs side-by-side

added added

removed removed

src/propeller-clock.ino
 
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
1
2
/*
2
3
 * propeller-clock.ino
3
4
 *
102
103
static bool inc_draw_mode = false;
103
104
 
104
105
// a bounce-managed button
105
 
static Bounce button( 3, 5 );
 
106
static Bounce button( 3, 50 );
106
107
 
107
108
// the time
108
109
static int time_hours = 0;
114
115
#define NUM_SECOND_SEGMENTS 5
115
116
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
116
117
 
 
118
// clock draw direction
 
119
#define CLOCK_FORWARD 0
 
120
 
 
121
// rotate display (in segments)
 
122
#define CLOCK_SHIFT ( 58 * NUM_SECOND_SEGMENTS - 1 )
 
123
 
117
124
//_____________________________________________________________________________
118
125
//                                                                         code
119
126
 
176
183
 
177
184
 
178
185
// draw a segment for the test display
179
 
void drawNextSegment_test( bool reset )
 
186
void drawNextSegment_test( int segment )
180
187
{
181
 
        // keep track of segment
182
 
        static unsigned int segment = 0;
183
 
        if( reset ) segment = 0;
184
 
        segment++;
185
 
 
186
 
        // turn on inside and outside LEDs
187
 
        ledOn( 0, true );
 
188
        // turn on outside LEDs
188
189
        ledOn( 9, true );
189
190
 
190
191
        // display segment number in binary across in the inside LEDs,
191
192
        // with the LED on pin 12 showing the least-significant bit
192
 
        for( int a = 0; a < 8; a++ )
 
193
        for( int a = 0; a < 9; a++ )
193
194
                ledOn( 8 - a, ( segment >> a ) & 1 );
194
195
}
195
196
 
196
197
 
197
198
// draw a segment for the time display
198
 
void drawNextSegment_time( bool reset )
 
199
void drawNextSegment_time( int segment )
199
200
{
200
 
        static int second = 0;
201
 
        static int segment = 0;
202
 
 
203
 
        // handle display reset
204
 
        if( reset ) {
205
 
                second = 0;
206
 
                segment = 0;
207
 
        }
 
201
        int second = segment / NUM_SECOND_SEGMENTS;
 
202
        int second_segment = segment % NUM_SECOND_SEGMENTS;
208
203
 
209
204
        // what needs to be drawn?
210
 
        bool draw_tick = !segment && second % 5 == 0;
211
 
        bool draw_second = !segment && second == time_seconds;
212
 
        bool draw_minute = !segment && second == time_minutes;
213
 
        bool draw_hour = !segment && second == time_hours;
 
205
        bool draw_tick = ( !second_segment && second % 5 == 0 && second ) ||
 
206
                ( second == 0 && second_segment == 1 ) ||
 
207
                ( second == 59 && second_segment == NUM_SECOND_SEGMENTS - 1 );
 
208
        bool draw_second = !second_segment && second == time_seconds;
 
209
        bool draw_minute = !second_segment && second == time_minutes;
 
210
        bool draw_hour = segment == time_hours * 5 * NUM_SECOND_SEGMENTS +
 
211
                ( 5 * NUM_SECOND_SEGMENTS * time_minutes / 60 );
214
212
 
215
213
        // set the LEDs
216
214
        ledOn( 9, true );
217
 
        ledOn( 8, draw_tick || draw_minute );
 
215
        ledOn( 8, draw_tick || draw_second );
218
216
        for( int a = 6; a <= 7; a++ )
219
217
                ledOn( a, draw_minute || draw_second );
220
218
        for( int a = 0; a <= 5; a++ )
221
219
                ledOn( a, draw_minute || draw_second || draw_hour );
222
 
 
223
 
        // inc position
224
 
        if( ++segment >= NUM_SECOND_SEGMENTS ) {
225
 
                segment = 0;
226
 
                second++;
227
 
        }
228
220
}
229
221
 
230
222
 
233
225
{
234
226
        static int draw_mode = 0;
235
227
 
 
228
        // keep track of segment
 
229
#if CLOCK_FORWARD
 
230
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
 
231
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
 
232
#else
 
233
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
 
234
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
 
235
#endif
 
236
 
236
237
        // handle mode switch requests
237
238
        if( reset && inc_draw_mode ) {
238
239
                inc_draw_mode = false;
243
244
 
244
245
        // draw the segment
245
246
        switch( draw_mode ) {
246
 
        case 0: drawNextSegment_test( reset ); break;
247
 
        case 1: drawNextSegment_time( reset ); break;
 
247
        case 0: drawNextSegment_test( segment ); break;
 
248
        case 1: drawNextSegment_time( segment ); break;
248
249
        }
 
250
 
 
251
#if CLOCK_FORWARD
 
252
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
 
253
#else
 
254
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
 
255
#endif
249
256
}
250
257
 
251
258
 
323
330
 
324
331
        // set up mode-switch button on pin 3
325
332
        pinMode( 3, INPUT );
 
333
        digitalWrite( 3, HIGH );
326
334
 
327
335
        // get the time from the real-time clock
328
336
        int rtc_data[ 7 ];