/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-01 14:05:28 UTC
  • Revision ID: edam@waxworlds.org-20120101140528-ldqldo67nil1xf1s
added arduino.mk to the project

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/propeller-clock.ino
1
1
/*
2
 
 * propeller-clock.pde
 
2
 * propeller-clock.ino
3
3
 *
4
 
 * Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
 
4
 * Copyright (C) 2011 Tim Marston <tim@ed.am> and Dan Marston.
5
5
 *
6
6
 * This file is part of propeller-clock (hereafter referred to as "this
7
 
 * program"). See http://ed.am/software/arduino/propeller-clock for more
 
7
 * program"). See http://ed.am/dev/software/arduino/propeller-clock for more
8
8
 * information.
9
9
 *
10
10
 * This program is free software: you can redistribute it and/or modify
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
 
43
 
// display mode
44
 
static
45
 
 
 
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 )
46
111
 
47
112
//_____________________________________________________________________________
48
113
//                                                                         code
49
114
 
50
115
 
51
 
// ISR to handle the pulses from the fan's tachiometer
52
 
void fanPulseHandler()
53
 
{
54
 
        // the fan actually sends two pulses per revolution. These pulses
55
 
        // may not be exactly evenly distributed around the rotation, so
56
 
        // we can't recalculate times on every pulse. Instead, we ignore
57
 
        // every other pulse so timings are based on a complete rotation.
58
 
        static bool ignore = true;
59
 
        ignore = !ignore;
60
 
        if( !ignore )
61
 
        {
62
 
                // set a new pulse time
63
 
                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
                }
64
154
        }
65
155
}
66
156
 
67
157
 
68
 
// draw a particular segment
69
 
void drawNextSegment( bool reset )
 
158
// draw a segment for the test display
 
159
void drawNextSegment_test( bool reset )
70
160
{
 
161
        // keep track of segment
71
162
        static unsigned int segment = 0;
72
163
        if( reset ) segment = 0;
73
164
        segment++;
74
165
 
75
 
        for( int a = 0; a < 10; a++ )
76
 
                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_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
 
 
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
        }
77
229
}
78
230
 
79
231
 
110
262
 
111
263
        // work out the time that this segment should be displayed until
112
264
        end_time += segment_step;
113
 
        semgment_step_sub += semgment_step_sub_step;
114
 
        if( semgment_step_sub >= NUM_SEGMENTS ) {
115
 
                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;
116
268
                end_time++;
117
269
        }
118
270
 
121
273
}
122
274
 
123
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
 
124
293
// main setup
125
294
void setup()
126
295
{
132
301
        for( int a = 4; a < 14; a++ )
133
302
                pinMode( a, OUTPUT );
134
303
 
 
304
        // set up mode-switch button on pin 3
 
305
        pinMode( 3, INPUT );
 
306
 
135
307
        // serial comms
136
308
        Serial.begin( 9600 );
137
309
}
143
315
        // if there has been a new pulse, we'll be resetting the display
144
316
        bool reset = new_pulse_at? true : false;
145
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
 
146
329
        // draw this segment
147
330
        drawNextSegment( reset );
148
331