/elec/propeller-clock : revision 12

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 11:38:11 UTC
Revision ID: edam@waxworlds.org-20111117113811-os1jlwxwukdxt6um

added info about RC circuits

files added:
propeller-clock.sch

files removed:
.bzrignore

arduino.mk

pcb.psd

project

project/propeller-clock.pro

project/propeller-clock.sch

src/analogue_clock.cc

src/analogue_clock.h

src/button.cc

src/button.h

src/common.cc

src/common.h

src/config.h

src/digital_clock.cc

src/digital_clock.h

src/test_pattern.cc

src/test_pattern.h

src/text.cc

src/text.h

src/text_renderer.cc

src/text_renderer.h

src/time.cc

src/time.h

src/util

src/util/DS1307.cpp

src/util/DS1307.h

src/util/PString.cpp

src/util/PString.h

test/fan-test

test/fan-test/Makefile

test/led-test

test/led-test/Makefile

test/led-test/led-test.ino

test/phantom-button-presses

test/phantom-button-presses/Makefile

test/phantom-button-presses/main.ino

test/rtc-test

test/rtc-test/Makefile

test/rtc-test/rtc-ds1307.ino

test/rtc-test/util

test/rtc-test/util/DS1307.cpp

test/rtc-test/util/DS1307.h

files renamed:
src/Makefile => Makefile

notes => Notes

test/ => fan_test/

test/fan-test/fan-test.ino => fan_test/fan_test.pde

src/ => propeller-clock/

src/propeller-clock.cc => propeller-clock/propeller-clock.pde

files modified:
electronics-information

Show diffs side-by-side

added added

removed removed

propeller-clock/propeller-clock.pde

/* -*- mode: c++; compile-command: "BOARD=pro5v make"; -*- */

* propeller-clock.ino

* This file is part of propeller-clock (hereafter referred to as "this

* program"). See http://ed.am/dev/software/arduino/propeller-clock for more

* information.

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published

* by the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

/******************************************************************************

Set up:

* a PC fan is wired up to a 12V power supply

* the fan's SENSE (tachometer) pin connected to pin 2 on the

Arduino.

* the pins 4 to 13 on the Arduino should directly drive an LED (the

LED on pin 4 is in the centre of the clock face and the LED on pin

13 is at the outside.

* if a longer hand (and a larger clock face) is desired, pin 4 can be

used to indirectly drive a transistor which in turn drives several

LEDs that turn on and off in unison in the centre of the clock.

* a button should be attached to pin 3 that grounds it when pressed.

* A DS1307 remote clock is connected via I2C on analogue pins 4 and 5.

Implementation details:

* for a schematic, see ../project/propeller-clock.sch.

* the timing of the drawing of the clock face is recalculated with

every rotation of the propeller.

* a PC fan actually sends 2 tachometer pulses per revolution, so the

software skips every other one. This means that the clock may

appear upside-down if started with the propeller in the wrong

position. You will need to experiment to discover the position that

the propeller must be in when starting the clock.

Usage instructions:

* pressing the button cycles between variations of the current

display mode.

* pressing and holding the button for a second cycles between display

modes (e.g., analogue and digital).

* pressing and holding the button for 5 seconds enters "time set"

mode. In this mode, the following applies:

- the field that is being set flashes

- pressing the button increments the field currently being set

- pressing and holding the button for a second cycles through the

fields that can be set

- pressing and holding the button for 5 seconds sets the time and

exits "time set" mode

******************************************************************************/

#include "config.h"

#include "button.h"

#include "time.h"

#include "Arduino.h"

#include "analogue_clock.h"

#include "digital_clock.h"

#include "test_pattern.h"

//_____________________________________________________________________________

// data

// when non-zero, the time (in microseconds) of a new fan pulse that

// has just occurred, which means that segment drawing needs to be

// restarted

static unsigned long _new_pulse_at = 0;

// the time (in microseconds) when the last fan pulse occurred

static unsigned long _last_pulse_at = 0;

// duration (in microseconds) that a segment should be displayed

static unsigned long _segment_step = 0;

100

// remainder after divisor and a tally of the remainders for each segment

101

static unsigned long _segment_step_sub_step = 0;

102

static unsigned long _segment_step_sub = 0;

103

104

// the button

105

static Button _button( 3 );

106

107

// modes

108

static int _major_mode = 0;

109

static int _minor_mode = 0;

110

111

#define MAIN_MODE_IDX 0

112

113

#define ANALOGUE_CLOCK_IDX 0

114

#define DIGITAL_CLOCK_IDX 1

115

#define TEST_PATTERN_IDX 2

116

117

//_____________________________________________________________________________

118

// code

119

120

121

// activate the current minor mode

122

void activate_minor_mode()

123

{

124

switch( _minor_mode ) {

125

case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;

126

case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

127

}

128

}

129

130

// perform button events

131

void do_button_events()

132

{

133

// loop through pending events

134

while( int event = _button.get_event() )

135

{

136

switch( event )

137

{

138

case 1:

139

// short press

140

switch( _major_mode ) {

141

case MAIN_MODE_IDX:

142

switch( _minor_mode ) {

143

case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;

144

case DIGITAL_CLOCK_IDX: digital_clock_press(); break;

145

}

146

break;

147

}

148

break;

149

150

case 2:

151

// long press

152

switch( _major_mode ) {

153

case MAIN_MODE_IDX:

154

if( ++_minor_mode >= 3 )

155

_minor_mode = 0;

156

switch( _minor_mode ) {

157

case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

158

}

159

break;

160

}

161

break;

162

163

case 3:

164

// looooong press (change major mode)

165

if( ++_major_mode > 0 )

166

_major_mode = 0;

167

switch( _major_mode ) {

168

case MAIN_MODE_IDX: _minor_mode = 0; break;

169

}

170

activate_minor_mode();

171

break;

172

}

173

}

174

}

175

176

177

// draw a display segment

178

void draw_next_segment( bool reset )

179

{

180

// keep track of segment

181

#if CLOCK_FORWARD

182

static int segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;

183

if( reset ) segment = ( NUM_SEGMENTS - CLOCK_SHIFT ) % NUM_SEGMENTS;

184

#else

185

static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;

186

if( reset ) segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;

187

#endif

188

189

// frame reset

190

if( reset ) {

191

switch( _major_mode ) {

192

case MAIN_MODE_IDX:

193

switch( _minor_mode ) {

194

case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;

195

case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;

196

}

197

break;

198

}

199

}

200

201

// draw

202

switch( _major_mode ) {

203

case MAIN_MODE_IDX:

204

switch( _minor_mode ) {

205

case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;

206

case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;

207

case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;

208

}

209

break;

210

}

211

212

#if CLOCK_FORWARD

213

if( ++segment >= NUM_SEGMENTS ) segment = 0;

214

#else

215

if( --segment < 0 ) segment = NUM_SEGMENTS - 1;

216

#endif

217

}

218

219

220

// calculate time constants when a new pulse has occurred

221

void calculate_segment_times()

222

{

223

// check for overflows, and only recalculate times if there isn't

224

// one (if there is, we'll just go with the last pulse's times)

225

if( _new_pulse_at > _last_pulse_at )

226

{

227

// new segment stepping times

228

unsigned long delta = _new_pulse_at - _last_pulse_at;

229

_segment_step = delta / NUM_SEGMENTS;

230

_segment_step_sub = 0;

231

_segment_step_sub_step = delta % NUM_SEGMENTS;

232

}

233

234

// now we have dealt with this pulse, save the pulse time and

235

// clear new_pulse_at, ready for the next pulse

236

_last_pulse_at = _new_pulse_at;

237

_new_pulse_at = 0;

238

}

239

240

241

// wait until it is time to draw the next segment or a new pulse has

242

// occurred

243

void wait_till_end_of_segment( bool reset )

244

{

245

static unsigned long end_time = 0;

246

247

// handle reset

248

if( reset )

249

end_time = _last_pulse_at;

250

251

// work out the time that this segment should be displayed until

252

end_time += _segment_step;

253

_segment_step_sub += _segment_step_sub_step;

254

if( _segment_step_sub >= NUM_SEGMENTS ) {

255

_segment_step_sub -= NUM_SEGMENTS;

256

end_time++;

257

}

258

259

// wait

260

while( micros() < end_time && !_new_pulse_at );

261

}

262

263

264

// ISR to handle the pulses from the fan's tachiometer

265

void fan_pulse_handler()

266

{

267

// the fan actually sends two pulses per revolution. These pulses

268

// may not be exactly evenly distributed around the rotation, so

269

// we can't recalculate times on every pulse. Instead, we ignore

270

// every other pulse so timings are based on a complete rotation.

271

static bool ignore = true;

272

ignore = !ignore;

273

if( !ignore )

274

{

275

// set a new pulse time

276

_new_pulse_at = micros();

277

}

278

}

279

280

281

// main setup

// propeller-clock.pde

// A propeller clock.

282

void setup()

283

{

284

// set up an interrupt handler on pin 2 to nitice fan pulses

285

attachInterrupt( 0, fan_pulse_handler, RISING );

286

digitalWrite( 2, HIGH );

// set up an interrupt handler on pin 2 to nitice fan pulses

attachInterrupt( 0, fanPulseHandler, RISING );

digitalWrite( 2, HIGH );

287

288

// set up output pins (4 to 13) for the led array

289

for( int a = 4; a < 14; a++ )

290

pinMode( a, OUTPUT );

291

292

// set up mode-switch button on pin 3

293

pinMode( 3, INPUT );

294

digitalWrite( 3, HIGH );

295

static int event_times[] = { 5, 500, 4000, 0 };

296

_button.set_event_times( event_times );

297

298

// initialise RTC

299

Time::init();

300

301

// activate the minor mode

302

switch( _major_mode ) {

303

case MAIN_MODE_IDX: activate_minor_mode(); break;

304

}

305

}

306

307

308

// main loop

// set up output pins (4 to 13) for the led array

for( int a = 4; a < 14; a++ )

pinMode( a, OUTPUT );

// serial comms

Serial.begin( 9600 );

}

// when non-zero, the time (in microseconds) of a new fan pulse that has just

// occurred, which means that segment drawing needs to be restarted

static unsigned long new_pulse_at = 0;

// interrupt handler to count the number of fan pulses

void fanPulseHandler()

{

// ignore every other pulse

static bool ignore = true;

ignore = !ignore;

if( !ignore )

{

// set a new pulse time

new_pulse_at = micros();

}

// wait until it is time to draw the next segment or a new pulse has occurred

void endOfSegmentDelay()

{

while( micros() < next_segment_at && !new_pulse_at );

}

309

void loop()

310

{

311

// if there has been a new pulse, we'll be resetting the display

312

bool reset = _new_pulse_at? true : false;

313

314

// update button

315

_button.update();

316

317

// only do this stuff at the start of a display cycle, to ensure

318

// that no state changes mid-display

319

if( reset )

320

{

321

// calculate segment times

322

calculate_segment_times();

323

324

// keep track of time

325

Time::update();

326

327

// perform button events

328

do_button_events();

329

}

330

331

// draw this segment

332

draw_next_segment( reset );

333

334

// wait till it's time to draw the next segment

335

wait_till_end_of_segment( reset );

static int led = 4;

unsigned long loop_start_time = micros();

// wait till it's time to draw the next segment

336

}