/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: 2011-12-22 01:27:11 UTC
  • Revision ID: edam@waxworlds.org-20111222012711-s9o130j1506clnxa
updated propeller clock code for arduino-1.0 and fixed a compiler error

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
1
/*
3
2
 * propeller-clock.ino
4
3
 *
5
4
 * Copyright (C) 2011 Tim Marston <tim@ed.am> and Dan Marston.
6
5
 *
7
6
 * This file is part of propeller-clock (hereafter referred to as "this
8
 
 * program"). See http://ed.am/dev/software/arduino/propeller-clock for more
 
7
 * program"). See http://ed.am/software/arduino/propeller-clock for more
9
8
 * information.
10
9
 *
11
10
 * This program is free software: you can redistribute it and/or modify
36
35
   13 is at the outside.
37
36
 
38
37
 * if a longer hand (and a larger clock face) is desired, pin 4 can be
39
 
   used to indirectly drive a transistor which in turn drives several
40
 
   LEDs that turn on anf off in unison in the centre of the clock.
 
38
   used to indirectly drive (via a MOSFET) multiple LEDs which turn on
 
39
   and off in unison in the centre of the clock.
41
40
 
42
41
 * a button should be attached to pin 3 that grounds it when pressed.
43
42
 
44
 
 * A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
45
 
 
46
43
Implementation details:
47
44
 
48
 
 * for a schematic, see ../project/propeller-clock.sch.
 
45
 * for a schematic, see project/propeller-clock.sch.
49
46
 
50
47
 * the timing of the drawing of the clock face is recalculated with
51
48
   every rotation of the propeller.
70
67
    - pressing the button increments the field currently being set
71
68
    - pressing and holding the button for a second cycles through the
72
69
      fields that can be set
73
 
    - pressing and holding the button for 5 seconds sets the time and
74
 
      exits "time set" mode
 
70
    - press and holding the button for 5 seconds to finish
75
71
 
76
72
******************************************************************************/
77
73
 
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"
 
74
 
 
75
#include <Bounce.h>
85
76
 
86
77
//_____________________________________________________________________________
87
78
//                                                                         data
102
93
static unsigned long segment_step_sub_step = 0;
103
94
static unsigned long segment_step_sub = 0;
104
95
 
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 };
 
96
// flag to indicate that the drawing mode should be cycled to the next one
 
97
static bool inc_draw_mode = false;
 
98
 
 
99
// a bounce-managed button
 
100
static Bounce button( 3, 5 );
 
101
 
 
102
// the time
 
103
static int time_hours = 0;
 
104
static int time_minutes = 0;
 
105
static int time_seconds = 0;
 
106
 
 
107
// number of segments in a full display (rotation) is 60 (one per
 
108
// second) times the desired number of sub-divisions of a second
 
109
#define NUM_SECOND_SEGMENTS 5
 
110
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
115
111
 
116
112
//_____________________________________________________________________________
117
113
//                                                                         code
118
114
 
119
115
 
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
 
 
 
116
// check for button presses
 
117
void checkButtons()
 
118
{
 
119
        // update buttons
 
120
        button.update();
 
121
 
 
122
        // notice button presses
 
123
        if( button.risingEdge() )
 
124
                inc_draw_mode = true;
 
125
}
 
126
 
 
127
 
 
128
// keep track of time
 
129
void trackTime()
 
130
{
 
131
        // previous time and any carried-over milliseconds
 
132
        static unsigned long last_time = millis();
 
133
        static unsigned long carry = 0;
 
134
 
 
135
        // how many milliseonds have elapsed since we last checked?
 
136
        unsigned long next_time = millis();
 
137
        unsigned long delta = next_time - last_time + carry;
 
138
 
 
139
        // update the previous time and carried-over milliseconds
 
140
        last_time = next_time;
 
141
        carry = delta % 1000;
 
142
 
 
143
        // add the seconds that have passed to the time
 
144
        time_seconds += delta / 1000;
 
145
        while( time_seconds >= 60 ) {
 
146
                time_seconds -= 60;
 
147
                time_minutes++;
 
148
                if( time_minutes >= 60 ) {
 
149
                        time_minutes -= 60;
 
150
                        time_hours++;
 
151
                        if( time_hours >= 24 )
 
152
                                time_hours -= 24;
147
153
                }
148
154
        }
149
155
}
150
156
 
151
157
 
 
158
// draw a segment for the test display
 
159
void drawNextSegment_test( bool reset )
 
160
{
 
161
        // keep track of segment
 
162
        static unsigned int segment = 0;
 
163
        if( reset ) segment = 0;
 
164
        segment++;
 
165
 
 
166
        // turn on inside and outside LEDs
 
167
        digitalWrite( 4, HIGH );
 
168
        digitalWrite( 13, HIGH );
 
169
 
 
170
        // display segment number in binary across in the inside LEDs,
 
171
        // with the LED on pin 12 showing the least-significant bit
 
172
        for( int a = 0; a < 8; a++ )
 
173
                digitalWrite( 12 - a, ( ( segment >> a ) & 1 )? HIGH : LOW );
 
174
}
 
175
 
 
176
 
 
177
// draw a segment for the time display
 
178
void drawNextSegment_time( bool reset )
 
179
{
 
180
        static unsigned int second = 0;
 
181
        static unsigned int segment = 0;
 
182
 
 
183
        // handle display reset
 
184
        if( reset ) {
 
185
                second = 0;
 
186
                segment = 0;
 
187
        }
 
188
 
 
189
        // what needs to be drawn?
 
190
        bool draw_tick = !segment && second % 5 == 0;
 
191
        bool draw_second = !segment && second == time_seconds;
 
192
        bool draw_minute = !segment && second == time_minutes;
 
193
        bool draw_hour = !segment && second == time_hours;
 
194
 
 
195
        // set the LEDs
 
196
        digitalWrite( 13, HIGH );
 
197
        digitalWrite( 12, draw_tick || draw_minute );
 
198
        for( int a = 10; a <= 11; a++ )
 
199
                digitalWrite( a, draw_minute || draw_second );
 
200
        for( int a = 4; a <= 9; a++ )
 
201
                digitalWrite( 10, draw_minute | draw_second || draw_hour );
 
202
 
 
203
        // inc position
 
204
        if( ++segment >= NUM_SECOND_SEGMENTS ) {
 
205
                segment = 0;
 
206
                second++;
 
207
        }
 
208
}
 
209
 
 
210
 
152
211
// draw a display segment
153
212
void drawNextSegment( bool reset )
154
213
{
155
 
        // keep track of segment
156
 
#if CLOCK_FORWARD
157
 
        static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
158
 
        if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
159
 
#else
160
 
        static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
161
 
        if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
162
 
#endif
163
 
 
164
 
        // draw
165
 
        Drawer &drawer = major_modes[ major_mode ]->get_drawer();
166
 
        if( reset ) drawer.draw_reset();
167
 
        drawer.draw( segment );
168
 
 
169
 
#if CLOCK_FORWARD
170
 
        if( ++segment >= NUM_SEGMENTS ) segment = 0;
171
 
#else
172
 
        if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
173
 
#endif
 
214
        static int draw_mode = 0;
 
215
 
 
216
        // handle mode switch requests
 
217
        if( reset && inc_draw_mode ) {
 
218
                inc_draw_mode = false;
 
219
                draw_mode++;
 
220
                if( draw_mode >= 2 )
 
221
                        draw_mode = 0;
 
222
        }
 
223
 
 
224
        // draw the segment
 
225
        switch( draw_mode ) {
 
226
        case 0: drawNextSegment_test( reset ); break;
 
227
        case 1: drawNextSegment_time( reset ); break;
 
228
        }
174
229
}
175
230
 
176
231
 
197
252
 
198
253
// wait until it is time to draw the next segment or a new pulse has
199
254
// occurred
200
 
void waitTillEndOfSegment( bool reset )
 
255
void waitTillNextSegment( bool reset )
201
256
{
202
257
        static unsigned long end_time = 0;
203
258
 
248
303
 
249
304
        // set up mode-switch button on pin 3
250
305
        pinMode( 3, INPUT );
251
 
        digitalWrite( 3, HIGH );
252
 
        static int event_times[] = { 5, 500, 4000, 0 };
253
 
        button.set_event_times( event_times );
254
306
 
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();
 
307
        // serial comms
 
308
        Serial.begin( 9600 );
260
309
}
261
310
 
262
311
 
266
315
        // if there has been a new pulse, we'll be resetting the display
267
316
        bool reset = new_pulse_at? true : false;
268
317
 
269
 
        // update button
270
 
        button.update();
271
 
 
272
318
        // only do this stuff at the start of a display cycle, to ensure
273
319
        // that no state changes mid-display
274
320
        if( reset )
275
321
        {
276
 
                // calculate segment times
277
 
                calculateSegmentTimes();
 
322
                // check buttons
 
323
                checkButtons();
278
324
 
279
325
                // keep track of time
280
 
                Time &time = Time::get_instance();
281
 
                time.update();
282
 
 
283
 
                // perform button events
284
 
                doButtonEvents();
 
326
                trackTime();
285
327
        }
286
328
 
287
329
        // draw this segment
288
330
        drawNextSegment( reset );
289
331
 
 
332
        // do we need to recalculate segment times?
 
333
        if( reset )
 
334
                calculateSegmentTimes();
 
335
 
290
336
        // wait till it's time to draw the next segment
291
 
        waitTillEndOfSegment( reset );
 
337
        waitTillNextSegment( reset );
292
338
}