/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.pde

  • Committer: edam
  • Date: 2011-12-02 19:57:43 UTC
  • Revision ID: edam@waxworlds.org-20111202195743-x73t8g3sn3w507ya
completed the scematic

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
22
 */
23
23
 
 
24
/******************************************************************************
 
25
 
 
26
Set up:
 
27
 
 
28
 * a PC fan is wired up to a 12V power supply
 
29
 
 
30
 * the fan's SENSE (tachiometer) pin connected to pin 2 on the
 
31
   arduino.
 
32
 
 
33
 * the pins 4 to 13 on the arduino should directly drive an LED (the
 
34
   LED on pin 4 is in the centre of the clock face and the LED on pin
 
35
   13 is at the outside.
 
36
 
 
37
 * if a longer hand (and a larger clock face) is desired, pin 4 can be
 
38
   used to indirectly drive (via a MOSFET) multiple LEDs which turn on
 
39
   and off in unison in the centre of the clock.
 
40
 
 
41
 * a button should be attached to pin 3 that grounds it when pressed.
 
42
 
 
43
Implementation details:
 
44
 
 
45
 * for a schematic, see project/propeller-clock.sch.
 
46
 
 
47
 * the timing of the drawing of the clock face is recalculated with
 
48
   every rotation of the propeller.
 
49
    
 
50
 * a PC fan actually sends 2 tachiometer pulses per revolution, so the
 
51
   software skips every other one. This means that the clock may
 
52
   appear upside-down if started with the propeller in the wrong
 
53
   position. You will need to experiment to dicsover the position that
 
54
   the propeller must be in when starting the clock.
 
55
    
 
56
Usage instructions:
 
57
 
 
58
 * pressing the button cycles between variations of the current
 
59
   display mode.
 
60
  
 
61
 * pressing and holding the button for a second cycles between display
 
62
   modes (e.g., analogue and digital).
 
63
 
 
64
 * pressing and holding the button for 5 seconds enters "time set"
 
65
   mode. In this mode, the following applies:
 
66
    - the field that is being set flashes
 
67
    - pressing the button increments the field currently being set
 
68
    - pressing and holding the button for a second cycles through the
 
69
      fields that can be set
 
70
    - press and holding the button for 5 seconds to finish
 
71
 
 
72
******************************************************************************/
 
73
 
 
74
 
 
75
#include <Bounce.h>
 
76
 
24
77
//_____________________________________________________________________________
25
78
//                                                                         data
26
79
 
40
93
static unsigned long segment_step_sub_step = 0;
41
94
static unsigned long segment_step_sub = 0;
42
95
 
 
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
 
43
107
// number of segments in a full display (rotation) is 60 (one per
44
108
// second) times the desired number of sub-divisions of a second
45
 
#define NUM_SEGMENTS ( 60 * 5 )
46
 
 
 
109
#define NUM_SECOND_SEGMENTS 5
 
110
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
47
111
 
48
112
//_____________________________________________________________________________
49
113
//                                                                         code
50
114
 
51
115
 
52
 
// ISR to handle the pulses from the fan's tachiometer
53
 
void fanPulseHandler()
54
 
{
55
 
        // the fan actually sends two pulses per revolution. These pulses
56
 
        // may not be exactly evenly distributed around the rotation, so
57
 
        // we can't recalculate times on every pulse. Instead, we ignore
58
 
        // every other pulse so timings are based on a complete rotation.
59
 
        static bool ignore = true;
60
 
        ignore = !ignore;
61
 
        if( !ignore )
62
 
        {
63
 
                // set a new pulse time
64
 
                new_pulse_at = micros();
 
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;
 
153
                }
65
154
        }
66
155
}
67
156
 
68
157
 
69
 
// draw a particular segment
70
 
void drawNextSegment( bool reset )
 
158
// draw a segment for the test display
 
159
void drawNextSegment_test( bool reset )
71
160
{
 
161
        // keep track of segment
72
162
        static unsigned int segment = 0;
73
163
        if( reset ) segment = 0;
74
164
        segment++;
75
165
 
76
 
        for( int a = 0; a < 10; a++ )
77
 
                digitalWrite( a + 4, ( ( segment >> a ) & 1 )? HIGH : LOW );
 
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_minute;
 
193
        bool draw_hour = !segment && second == time_hour;
 
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
 
 
211
// draw a display segment
 
212
void drawNextSegment( bool reset )
 
213
{
 
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
        }
78
229
}
79
230
 
80
231
 
111
262
 
112
263
        // work out the time that this segment should be displayed until
113
264
        end_time += segment_step;
114
 
        semgment_step_sub += semgment_step_sub_step;
115
 
        if( semgment_step_sub >= NUM_SEGMENTS ) {
116
 
                semgment_step_sub -= NUM_SEGMENTS;
 
265
        segment_step_sub += segment_step_sub_step;
 
266
        if( segment_step_sub >= NUM_SEGMENTS ) {
 
267
                segment_step_sub -= NUM_SEGMENTS;
117
268
                end_time++;
118
269
        }
119
270
 
122
273
}
123
274
 
124
275
 
 
276
// ISR to handle the pulses from the fan's tachiometer
 
277
void fanPulseHandler()
 
278
{
 
279
        // the fan actually sends two pulses per revolution. These pulses
 
280
        // may not be exactly evenly distributed around the rotation, so
 
281
        // we can't recalculate times on every pulse. Instead, we ignore
 
282
        // every other pulse so timings are based on a complete rotation.
 
283
        static bool ignore = true;
 
284
        ignore = !ignore;
 
285
        if( !ignore )
 
286
        {
 
287
                // set a new pulse time
 
288
                new_pulse_at = micros();
 
289
        }
 
290
}
 
291
 
 
292
 
125
293
// main setup
126
294
void setup()
127
295
{
133
301
        for( int a = 4; a < 14; a++ )
134
302
                pinMode( a, OUTPUT );
135
303
 
 
304
        // set up mode-switch button on pin 3
 
305
        pinMode( 3, INPUT );
 
306
 
136
307
        // serial comms
137
308
        Serial.begin( 9600 );
138
309
}
144
315
        // if there has been a new pulse, we'll be resetting the display
145
316
        bool reset = new_pulse_at? true : false;
146
317
 
 
318
        // only do this stuff at the start of a display cycle, to ensure
 
319
        // that no state changes mid-display
 
320
        if( reset )
 
321
        {
 
322
                // check buttons
 
323
                checkButtons();
 
324
 
 
325
                // keep track of time
 
326
                trackTime();
 
327
        }
 
328
 
147
329
        // draw this segment
148
330
        drawNextSegment( reset );
149
331