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

  • Committer: Tim Marston
  • Date: 2012-03-09 23:42:20 UTC
  • Revision ID: tim@ed.am-20120309234220-xr1vxzve0o5n2oss
added support for eclipse project and converted to a manual Makefile

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */
1
2
/*
2
 
 * propeller-clock.pde
 
3
 * propeller-clock.ino
3
4
 *
4
 
 * Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
 
5
 * Copyright (C) 2011 Tim Marston <tim@ed.am> and Dan Marston.
5
6
 *
6
7
 * This file is part of propeller-clock (hereafter referred to as "this
7
 
 * program"). See http://ed.am/software/arduino/propeller-clock for more
 
8
 * program"). See http://ed.am/dev/software/arduino/propeller-clock for more
8
9
 * information.
9
10
 *
10
11
 * This program is free software: you can redistribute it and/or modify
35
36
   13 is at the outside.
36
37
 
37
38
 * 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.
 
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.
40
41
 
41
42
 * a button should be attached to pin 3 that grounds it when pressed.
42
43
 
 
44
 * A DS1307 remote clock is connected via I2C on analog pins 4 and 5.
 
45
 
43
46
Implementation details:
44
47
 
45
 
 * for a schematic, see project/propeller-clock.sch.
 
48
 * for a schematic, see ../project/propeller-clock.sch.
46
49
 
47
50
 * the timing of the drawing of the clock face is recalculated with
48
51
   every rotation of the propeller.
67
70
    - pressing the button increments the field currently being set
68
71
    - pressing and holding the button for a second cycles through the
69
72
      fields that can be set
70
 
    - press and holding the button for 5 seconds to finish
 
73
    - pressing and holding the button for 5 seconds sets the time and
 
74
      exits "time set" mode
71
75
 
72
76
******************************************************************************/
73
77
 
74
 
 
75
 
#include <Bounce.h>
 
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"
76
85
 
77
86
//_____________________________________________________________________________
78
87
//                                                                         data
93
102
static unsigned long segment_step_sub_step = 0;
94
103
static unsigned long segment_step_sub = 0;
95
104
 
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 )
 
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 };
111
115
 
112
116
//_____________________________________________________________________________
113
117
//                                                                         code
114
118
 
115
119
 
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;
 
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
 
153
147
                }
154
148
        }
155
149
}
156
150
 
157
151
 
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_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
152
// draw a display segment
212
153
void drawNextSegment( bool reset )
213
154
{
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
 
        }
 
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
229
174
}
230
175
 
231
176
 
252
197
 
253
198
// wait until it is time to draw the next segment or a new pulse has
254
199
// occurred
255
 
void waitTillNextSegment( bool reset )
 
200
void waitTillEndOfSegment( bool reset )
256
201
{
257
202
        static unsigned long end_time = 0;
258
203
 
303
248
 
304
249
        // set up mode-switch button on pin 3
305
250
        pinMode( 3, INPUT );
 
251
        digitalWrite( 3, HIGH );
 
252
        static int event_times[] = { 5, 500, 4000, 0 };
 
253
        button.set_event_times( event_times );
306
254
 
307
 
        // serial comms
308
 
        Serial.begin( 9600 );
 
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();
309
260
}
310
261
 
311
262
 
315
266
        // if there has been a new pulse, we'll be resetting the display
316
267
        bool reset = new_pulse_at? true : false;
317
268
 
 
269
        // update button
 
270
        button.update();
 
271
 
318
272
        // only do this stuff at the start of a display cycle, to ensure
319
273
        // that no state changes mid-display
320
274
        if( reset )
321
275
        {
322
 
                // check buttons
323
 
                checkButtons();
 
276
                // calculate segment times
 
277
                calculateSegmentTimes();
324
278
 
325
279
                // keep track of time
326
 
                trackTime();
 
280
                Time &time = Time::get_instance();
 
281
                time.update();
 
282
 
 
283
                // perform button events
 
284
                doButtonEvents();
327
285
        }
328
286
 
329
287
        // draw this segment
330
288
        drawNextSegment( reset );
331
289
 
332
 
        // do we need to recalculate segment times?
333
 
        if( reset )
334
 
                calculateSegmentTimes();
335
 
 
336
290
        // wait till it's time to draw the next segment
337
 
        waitTillNextSegment( reset );
 
291
        waitTillEndOfSegment( reset );
338
292
}