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

  • Committer: edam
  • Date: 2011-11-17 13:11:02 UTC
  • Revision ID: edam@waxworlds.org-20111117131102-ihs5tz2hynj18h0r
moved schematic and Makefile to propeller-clock dir and updated Makefile for Arduino Pro Mini w/ Atmel 168 board

Show diffs side-by-side

added added

removed removed

1
 
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
2
1
/*
3
 
 * propeller-clock.ino
 
2
 * propeller-clock.pde
4
3
 *
5
 
 * Copyright (C) 2011 Tim Marston <tim@ed.am> and Dan Marston.
 
4
 * Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
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
22
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23
22
 */
24
23
 
25
 
/******************************************************************************
26
 
 
27
 
Set up:
28
 
 
29
 
 * a PC fan is wired up to a 12V power supply
30
 
 
31
 
 * the fan's SENSE (tachiometer) pin connected to pin 2 on the
32
 
   arduino.
33
 
 
34
 
 * the pins 4 to 13 on the arduino should directly drive an LED (the
35
 
   LED on pin 4 is in the centre of the clock face and the LED on pin
36
 
   13 is at the outside.
37
 
 
38
 
 * 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.
41
 
 
42
 
 * a button should be attached to pin 3 that grounds it when pressed.
43
 
 
44
 
 * A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
45
 
 
46
 
Implementation details:
47
 
 
48
 
 * for a schematic, see ../project/propeller-clock.sch.
49
 
 
50
 
 * the timing of the drawing of the clock face is recalculated with
51
 
   every rotation of the propeller.
52
 
    
53
 
 * a PC fan actually sends 2 tachiometer pulses per revolution, so the
54
 
   software skips every other one. This means that the clock may
55
 
   appear upside-down if started with the propeller in the wrong
56
 
   position. You will need to experiment to dicsover the position that
57
 
   the propeller must be in when starting the clock.
58
 
    
59
 
Usage instructions:
60
 
 
61
 
 * pressing the button cycles between variations of the current
62
 
   display mode.
63
 
  
64
 
 * pressing and holding the button for a second cycles between display
65
 
   modes (e.g., analogue and digital).
66
 
 
67
 
 * pressing and holding the button for 5 seconds enters "time set"
68
 
   mode. In this mode, the following applies:
69
 
    - the field that is being set flashes
70
 
    - pressing the button increments the field currently being set
71
 
    - pressing and holding the button for a second cycles through the
72
 
      fields that can be set
73
 
    - pressing and holding the button for 5 seconds sets the time and
74
 
      exits "time set" mode
75
 
 
76
 
******************************************************************************/
77
 
 
78
 
 
79
 
#include <button.h>
80
 
#include "config.h"
81
 
#include "time.h"
82
 
#include "mode_switcher.h"
83
 
#include "drawer.h"
84
 
 
85
24
//_____________________________________________________________________________
86
25
//                                                                         data
87
26
 
101
40
static unsigned long segment_step_sub_step = 0;
102
41
static unsigned long segment_step_sub = 0;
103
42
 
104
 
// flag to indicate that the drawing mode should be cycled to the next one
105
 
static bool inc_draw_mode = false;
 
43
// number of segments in a full display (rotation) is 60 (one per
 
44
// second) times the desired number of sub-divisions of a second
 
45
#define NUM_SEGMENTS ( 60 * 5 )
106
46
 
107
 
// a bounce-managed button
108
 
static Button button( 3 );
109
47
 
110
48
//_____________________________________________________________________________
111
49
//                                                                         code
112
50
 
113
51
 
114
 
// check for button presses
115
 
void checkButtons()
 
52
// ISR to handle the pulses from the fan's tachiometer
 
53
void fanPulseHandler()
116
54
{
117
 
        // update buttons
118
 
        int event = button.update();
119
 
 
120
 
        // handle any events
121
 
        switch( event ) {
122
 
        case 1:
123
 
                inc_draw_mode = true;
124
 
                break;
 
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();
125
65
        }
126
66
}
127
67
 
128
68
 
129
 
// turn an led on/off
130
 
void ledOn( int num, bool on )
131
 
{
132
 
        if( num < 0 || num > 9 ) return;
133
 
 
134
 
        // convert to pin no.
135
 
        num += 4;
136
 
 
137
 
        // pin 4 needs to be inverted (it's driving a PNP)
138
 
        if( num == 4 ) on = !on;
139
 
 
140
 
        digitalWrite( num, on? HIGH : LOW );
141
 
}
142
 
 
143
 
 
144
 
// draw a display segment
 
69
// draw a particular segment
145
70
void drawNextSegment( bool reset )
146
71
{
147
 
        static ModeSwitcher mode_switcher;
148
 
        static bool init = false;
149
 
 
150
 
        if( !init ) {
151
 
                init = true;
152
 
                mode_switcher.activate();
153
 
        }
154
 
 
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 = mode_switcher.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
 
72
        static unsigned int segment = 0;
 
73
        if( reset ) segment = 0;
 
74
        segment++;
 
75
 
 
76
        for( int a = 0; a < 10; a++ )
 
77
                digitalWrite( a + 4, ( ( segment >> a ) & 1 )? HIGH : LOW );
174
78
}
175
79
 
176
80
 
207
111
 
208
112
        // work out the time that this segment should be displayed until
209
113
        end_time += segment_step;
210
 
        segment_step_sub += segment_step_sub_step;
211
 
        if( segment_step_sub >= NUM_SEGMENTS ) {
212
 
                segment_step_sub -= NUM_SEGMENTS;
 
114
        semgment_step_sub += semgment_step_sub_step;
 
115
        if( semgment_step_sub >= NUM_SEGMENTS ) {
 
116
                semgment_step_sub -= NUM_SEGMENTS;
213
117
                end_time++;
214
118
        }
215
119
 
218
122
}
219
123
 
220
124
 
221
 
// ISR to handle the pulses from the fan's tachiometer
222
 
void fanPulseHandler()
223
 
{
224
 
        // the fan actually sends two pulses per revolution. These pulses
225
 
        // may not be exactly evenly distributed around the rotation, so
226
 
        // we can't recalculate times on every pulse. Instead, we ignore
227
 
        // every other pulse so timings are based on a complete rotation.
228
 
        static bool ignore = true;
229
 
        ignore = !ignore;
230
 
        if( !ignore )
231
 
        {
232
 
                // set a new pulse time
233
 
                new_pulse_at = micros();
234
 
        }
235
 
}
236
 
 
237
 
 
238
125
// main setup
239
126
void setup()
240
127
{
246
133
        for( int a = 4; a < 14; a++ )
247
134
                pinMode( a, OUTPUT );
248
135
 
249
 
        // set up mode-switch button on pin 3
250
 
        pinMode( 3, INPUT );
251
 
        digitalWrite( 3, HIGH );
252
 
        button.add_event_at( 5, 1 );
253
 
        button.add_event_at( 1000, 2 );
254
 
        button.add_event_at( 4000, 3 );
255
 
 
256
136
        // serial comms
257
137
        Serial.begin( 9600 );
258
138
}
264
144
        // if there has been a new pulse, we'll be resetting the display
265
145
        bool reset = new_pulse_at? true : false;
266
146
 
267
 
        // only do this stuff at the start of a display cycle, to ensure
268
 
        // that no state changes mid-display
269
 
        if( reset )
270
 
        {
271
 
                // check buttons
272
 
                checkButtons();
273
 
 
274
 
                // keep track of time
275
 
                Time &time = Time::get_instance();
276
 
                time.update();
277
 
        }
278
 
 
279
147
        // draw this segment
280
148
        drawNextSegment( reset );
281
149