/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/TODO

src/button.cc

src/button.h

src/common.cc

src/common.h

src/config.h

src/modes

src/modes/analogue_clock.cc

src/modes/analogue_clock.h

src/modes/digital_clock.cc

src/modes/digital_clock.h

src/modes/info_mode.cc

src/modes/info_mode.h

src/modes/settings_mode.cc

src/modes/settings_mode.h

src/modes/test_pattern.cc

src/modes/test_pattern.h

src/nvram.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 "modes/analogue_clock.h"

#include "modes/digital_clock.h"

#include "modes/test_pattern.h"

#include "modes/settings_mode.h"

#include "modes/info_mode.h"

#include "text.h"

#include "text_renderer.h"

#include "common.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

100

static unsigned long _last_pulse_at = 0;

101

102

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

103

static unsigned long _segment_step = 0;

104

105

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

106

static unsigned long _segment_step_sub_step = 0;

107

static unsigned long _segment_step_sub = 0;

108

109

// the button

110

static Button _button( 3 );

111

112

// modes

113

static int _major_mode = 0;

114

static int _minor_mode = 0;

115

116

#define SETTINGS_MODE_IDX 1

117

#define MAIN_MODE_IDX 0

118

119

#define ANALOGUE_CLOCK_IDX 0

120

#define DIGITAL_CLOCK_IDX 1

121

#define INFO_MODE_IDX 2

122

#define TEST_PATTERN_IDX 3

123

124

//_____________________________________________________________________________

125

// code

126

127

128

// activate the current minor mode

129

void activate_minor_mode()

130

{

131

// reset text

132

Text::reset();

133

leds_off();

134

135

// give the mode a chance to init

136

switch( _minor_mode ) {

137

case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;

138

case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

139

case INFO_MODE_IDX: info_mode_activate(); break;

140

}

141

}

142

143

144

// activate major mode

145

void activate_major_mode()

146

{

147

// reset text

148

Text::reset();

149

leds_off();

150

151

// reset buttons

152

_button.set_press_mode( _major_mode != SETTINGS_MODE_IDX );

153

154

// give the mode a chance to init

155

switch( _major_mode ) {

156

case MAIN_MODE_IDX: activate_minor_mode(); break;

157

case SETTINGS_MODE_IDX: settings_mode_activate(); break;

158

}

159

}

160

161

162

// perform button events

163

void do_button_events()

164

{

165

// loop through pending events

166

while( int event = _button.get_event() )

167

{

168

switch( event )

169

{

170

case 1:

171

// short press

172

switch( _major_mode ) {

173

case MAIN_MODE_IDX:

174

switch( _minor_mode ) {

175

case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;

176

case DIGITAL_CLOCK_IDX: digital_clock_press(); break;

177

case INFO_MODE_IDX: info_mode_press(); break;

178

}

179

break;

180

case SETTINGS_MODE_IDX: settings_mode_press(); break;

181

}

182

break;

183

184

case 2:

185

// long press

186

switch( _major_mode ) {

187

case MAIN_MODE_IDX:

188

if( ++_minor_mode >= 4 )

189

_minor_mode = 0;

190

activate_minor_mode();

191

break;

192

case SETTINGS_MODE_IDX: settings_mode_long_press(); break;

193

}

194

break;

195

196

case 3:

197

// looooong press (change major mode)

198

if( ++_major_mode > 1 )

199

_major_mode = 0;

200

activate_major_mode();

201

break;

202

}

203

}

204

}

205

206

207

// draw a display segment

208

void draw_next_segment( bool reset )

209

{

210

// keep track of segment

211

#if CLOCK_FORWARD

212

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

213

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

214

#else

215

static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;

216

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

217

#endif

218

219

// reset the text renderer

220

TextRenderer::reset_buffer();

221

222

// frame reset

223

if( reset ) {

224

switch( _major_mode ) {

225

case MAIN_MODE_IDX:

226

switch( _minor_mode ) {

227

case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;

228

case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;

229

case INFO_MODE_IDX: info_mode_draw_reset(); break;

230

}

231

break;

232

case SETTINGS_MODE_IDX: settings_mode_draw_reset(); break;

233

}

234

235

// tell the text services we're starting a new frame

236

Text::draw_reset();

237

}

238

239

// draw

240

switch( _major_mode ) {

241

case MAIN_MODE_IDX:

242

switch( _minor_mode ) {

243

case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;

244

case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;

245

case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;

246

case INFO_MODE_IDX: info_mode_draw( segment ); break;

247

}

248

break;

249

case SETTINGS_MODE_IDX: settings_mode_draw( segment ); break;

250

}

251

Text::post_draw();

252

253

// draw any text that was rendered

254

TextRenderer::output_buffer();

255

256

#if CLOCK_FORWARD

257

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

258

#else

259

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

260

#endif

261

}

262

263

264

// calculate time constants when a new pulse has occurred

265

void calculate_segment_times()

266

{

267

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

268

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

269

if( _new_pulse_at > _last_pulse_at )

270

{

271

// new segment stepping times

272

unsigned long delta = _new_pulse_at - _last_pulse_at;

273

_segment_step = delta / NUM_SEGMENTS;

274

_segment_step_sub = 0;

275

_segment_step_sub_step = delta % NUM_SEGMENTS;

276

}

277

278

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

279

// clear new_pulse_at, ready for the next pulse

280

_last_pulse_at = _new_pulse_at;

281

_new_pulse_at = 0;

282

}

283

284

285

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

286

// occurred

287

void wait_till_end_of_segment( bool reset )

288

{

289

static unsigned long end_time = 0;

290

291

// handle reset

292

if( reset )

293

end_time = _last_pulse_at;

294

295

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

296

end_time += _segment_step;

297

_segment_step_sub += _segment_step_sub_step;

298

if( _segment_step_sub >= NUM_SEGMENTS ) {

299

_segment_step_sub -= NUM_SEGMENTS;

300

end_time++;

301

}

302

303

// wait

304

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

305

}

306

307

308

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

309

void fan_pulse_handler()

310

{

311

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

312

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

313

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

314

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

315

static bool ignore = true;

316

ignore = !ignore;

317

if( !ignore )

318

{

319

// set a new pulse time

320

_new_pulse_at = micros();

321

}

322

}

323

324

325

// main setup

// propeller-clock.pde

// A propeller clock.

326

void setup()

327

{

328

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

329

attachInterrupt( 0, fan_pulse_handler, RISING );

330

digitalWrite( 2, HIGH );

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

attachInterrupt( 0, fanPulseHandler, RISING );

digitalWrite( 2, HIGH );

331

332

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

333

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

334

pinMode( a, OUTPUT );

335

336

// set up mode-switch button on pin 3

337

pinMode( 3, INPUT );

338

digitalWrite( 3, HIGH );

339

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

340

_button.set_event_times( event_times );

341

342

// initialise RTC

343

Time::init();

344

345

// init text renderer

346

TextRenderer::init();

347

348

// activate the minor mode

349

activate_major_mode();

350

}

351

352

353

// 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 );

}

354

void loop()

355

{

356

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

357

bool reset = _new_pulse_at? true : false;

358

359

// update button

360

_button.update();

361

362

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

363

// that no state changes mid-display

364

if( reset )

365

{

366

// calculate segment times

367

calculate_segment_times();

368

369

// keep track of time

370

Time::update();

371

372

// perform button events

373

do_button_events();

374

}

375

376

// draw this segment

377

draw_next_segment( reset );

378

379

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

380

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

381

}