76
76
******************************************************************************/
82
#include "modes/switcher_major_mode.h"
83
#include "modes/settings_major_mode.h"
84
#include "modes/analogue_clock_mode.h"
85
#include "modes/digital_clock_mode.h"
86
#include "modes/info_mode.h"
87
#include "modes/test_pattern_mode.h"
89
#include "text_renderer.h"
83
92
//_____________________________________________________________________________
87
95
// when non-zero, the time (in microseconds) of a new fan pulse that
88
96
// has just occurred, which means that segment drawing needs to be
90
static unsigned long new_pulse_at = 0;
98
static unsigned long _new_pulse_at = 0;
92
100
// the time (in microseconds) when the last fan pulse occurred
93
static unsigned long last_pulse_at = 0;
101
static unsigned long _last_pulse_at = 0;
95
103
// duration (in microseconds) that a segment should be displayed
96
static unsigned long segment_step = 0;
104
static unsigned long _segment_step = 0;
98
106
// remainder after divisor and a tally of the remainders for each segment
99
static unsigned long segment_step_sub_step = 0;
100
static unsigned long segment_step_sub = 0;
102
// flag to indicate that the drawing mode should be cycled to the next one
103
static bool inc_draw_mode = false;
105
// a bounce-managed button
106
static Bounce button( 3, 50 );
109
static int time_hours = 0;
110
static int time_minutes = 0;
111
static int time_seconds = 0;
113
// number of segments in a full display (rotation) is 60 (one per
114
// second) times the desired number of sub-divisions of a second
115
#define NUM_SECOND_SEGMENTS 5
116
#define NUM_SEGMENTS ( 60 * NUM_SECOND_SEGMENTS )
119
#define CLOCK_FORWARD 0
107
static unsigned long _segment_step_sub_step = 0;
108
static unsigned long _segment_step_sub = 0;
111
static Button _button( 3 );
114
static MajorMode *_modes[ 3 ];
116
// current major mode
117
static int _mode = 0;
119
// interupt handler's "ignore every other" flag
120
static bool _pulse_ignore = true;
121
122
//_____________________________________________________________________________
125
// check for button presses
131
// notice button presses
132
if( button.risingEdge() )
133
inc_draw_mode = true;
137
// keep track of time
140
// previous time and any carried-over milliseconds
141
static unsigned long last_time = millis();
142
static unsigned long carry = 0;
144
// how many milliseonds have elapsed since we last checked?
145
unsigned long next_time = millis();
146
unsigned long delta = next_time - last_time + carry;
148
// update the previous time and carried-over milliseconds
149
last_time = next_time;
150
carry = delta % 1000;
152
// add the seconds that have passed to the time
153
time_seconds += delta / 1000;
154
while( time_seconds >= 60 ) {
157
if( time_minutes >= 60 ) {
160
if( time_hours >= 24 )
125
// perform button events
126
void do_button_events()
128
// loop through pending events
129
while( int event = _button.get_event() )
135
_modes[ _mode ]->press();
139
_modes[ _mode ]->long_press();
142
// looooong press (change major mode)
143
_modes[ _mode ]->deactivate();
144
if( !_modes[ ++_mode ] ) _mode = 0;
145
_modes[ _mode ]->activate();
148
// switch display upside-down
149
_pulse_ignore = !_pulse_ignore;
167
// turn an led on/off
168
void ledOn( int num, bool on )
170
if( num < 0 || num > 9 ) return;
172
// convert to pin no.
175
// pin 4 needs to be inverted (it's driving a PNP)
176
// NOTE: PIN 4 TEMPORARILY DISABLED
177
// if( num == 4 ) on = true;
178
if( num == 4 ) on = !on;
180
digitalWrite( num, on? HIGH : LOW );
184
// draw a segment for the test display
185
void drawNextSegment_test( int segment )
187
// turn on inside and outside LEDs
190
// display segment number in binary across in the inside LEDs,
191
// with the LED on pin 12 showing the least-significant bit
192
for( int a = 0; a < 9; a++ )
193
ledOn( 8 - a, ( segment >> a ) & 1 );
197
// draw a segment for the time display
198
void drawNextSegment_time( int segment )
200
int second = segment / NUM_SECOND_SEGMENTS;
201
int second_segment = segment % NUM_SECOND_SEGMENTS;
203
// what needs to be drawn?
204
bool draw_tick = !second_segment && second % 5 == 0;
205
bool draw_second = !second_segment && second == time_seconds;
206
bool draw_minute = !second_segment && second == time_minutes;
207
bool draw_hour = !second_segment && second == time_hours;
211
ledOn( 8, draw_tick || draw_minute );
212
for( int a = 6; a <= 7; a++ )
213
ledOn( a, draw_minute || draw_second );
214
for( int a = 0; a <= 5; a++ )
215
ledOn( a, draw_minute || draw_second || draw_hour );
219
156
// draw a display segment
220
void drawNextSegment( bool reset )
157
void draw_next_segment( bool reset )
222
static int draw_mode = 0;
224
159
// keep track of segment
226
160
static int segment = 0;
227
if( reset ) segment = 0;
162
if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;
229
static int segment = NUM_SEGMENTS - 1;
230
if( reset ) segment = NUM_SEGMENTS - 1;
164
if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;
233
// handle mode switch requests
234
if( reset && inc_draw_mode ) {
235
inc_draw_mode = false;
242
switch( draw_mode ) {
243
case 0: drawNextSegment_test( segment ); break;
244
case 1: drawNextSegment_time( segment ); break;
167
// reset the text renderer's buffer
168
TextRenderer::reset_buffer();
172
_modes[ _mode ]->draw_reset();
174
// tell the text services we're starting a new frame
179
_modes[ _mode ]->draw( segment );
182
Text::draw( segment );
184
// draw text rednerer's buffer
185
TextRenderer::output_buffer();
247
187
#if CLOCK_FORWARD
188
if( ++segment >= NUM_SEGMENTS ) segment = 0;
190
if( --segment < 0 ) segment = NUM_SEGMENTS - 1;
255
195
// calculate time constants when a new pulse has occurred
256
void calculateSegmentTimes()
196
void calculate_segment_times()
258
198
// check for overflows, and only recalculate times if there isn't
259
199
// one (if there is, we'll just go with the last pulse's times)
260
if( new_pulse_at > last_pulse_at )
200
if( _new_pulse_at > _last_pulse_at )
262
202
// new segment stepping times
263
unsigned long delta = new_pulse_at - last_pulse_at;
264
segment_step = delta / NUM_SEGMENTS;
265
segment_step_sub = 0;
266
segment_step_sub_step = delta % NUM_SEGMENTS;
203
unsigned long delta = _new_pulse_at - _last_pulse_at;
204
_segment_step = delta / NUM_SEGMENTS;
205
_segment_step_sub = 0;
206
_segment_step_sub_step = delta % NUM_SEGMENTS;
269
209
// now we have dealt with this pulse, save the pulse time and
270
210
// clear new_pulse_at, ready for the next pulse
271
last_pulse_at = new_pulse_at;
211
_last_pulse_at = _new_pulse_at;
276
216
// wait until it is time to draw the next segment or a new pulse has
278
void waitTillNextSegment( bool reset )
218
void wait_till_end_of_segment( bool reset )
280
220
static unsigned long end_time = 0;
284
end_time = last_pulse_at;
224
end_time = _last_pulse_at;
286
226
// work out the time that this segment should be displayed until
287
end_time += segment_step;
288
segment_step_sub += segment_step_sub_step;
289
if( segment_step_sub >= NUM_SEGMENTS ) {
290
segment_step_sub -= NUM_SEGMENTS;
227
end_time += _segment_step;
228
_segment_step_sub += _segment_step_sub_step;
229
if( _segment_step_sub >= NUM_SEGMENTS ) {
230
_segment_step_sub -= NUM_SEGMENTS;
295
while( micros() < end_time && !new_pulse_at );
235
while( micros() < end_time && !_new_pulse_at );
299
// ISR to handle the pulses from the fan's tachiometer
300
void fanPulseHandler()
239
// ISR to handle the pulses from the fan's tachometer
240
void fan_pulse_handler()
302
242
// the fan actually sends two pulses per revolution. These pulses
303
243
// may not be exactly evenly distributed around the rotation, so
304
244
// we can't recalculate times on every pulse. Instead, we ignore
305
245
// every other pulse so timings are based on a complete rotation.
306
static bool ignore = true;
246
_pulse_ignore = !_pulse_ignore;
310
249
// set a new pulse time
311
new_pulse_at = micros();
250
_new_pulse_at = micros();