/elec/propeller-clock : revision 56

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.ino

Committer: edam
Date: 2012-02-25 01:31:17 UTC
Revision ID: tim@ed.am-20120225013117-53ed8yahoreoms76

updated software to include drawing abstraction infrastructure

files added:
src/drawer.cc

src/drawer.h

src/major_mode.h

src/minor_mode.cc

src/minor_mode.h

src/mode_switcher.cc

src/mode_switcher.h

src/util/Bounce.cpp

src/util/Bounce.h

files removed:
src/common.cc

src/common.h

src/modes

src/modes/digital_clock.cc

src/modes/digital_clock.h

src/modes/settings_mode.cc

src/modes/settings_mode.h

src/nvram.h

src/text.cc

src/text.h

src/text_renderer.cc

src/text_renderer.h

src/util/PString.cpp

src/util/PString.h

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/modes/analogue_clock.cc => src/analogue_clock_mode.cc

src/modes/analogue_clock.h => src/analogue_clock_mode.h

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

src/modes/test_pattern.cc => src/test_mode.cc

src/modes/test_pattern.h => src/test_mode.h

files modified:
.bzrignore

arduino.mk

electronics-information

notes

project/propeller-clock.sch

src/Makefile

src/button.cc

src/button.h

src/config.h

src/time.cc

src/time.h

Show diffs side-by-side

added added

removed removed

src/propeller-clock.ino

* 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 fan's SENSE (tachiometer) pin connected to pin 2 on the

arduino.

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

* 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.

LEDs that turn on anf 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.

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

Implementation details:

* 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

* a PC fan actually sends 2 tachiometer 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

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

the propeller must be in when starting the clock.

Usage instructions:

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

#include <button.h>

#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 "text.h"

#include "text_renderer.h"

#include "common.h"

#include "mode_switcher.h"

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

static unsigned long new_pulse_at = 0;

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

static unsigned long _last_pulse_at = 0;

static unsigned long last_pulse_at = 0;

100

101

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

102

static unsigned long _segment_step = 0;

static unsigned long segment_step = 0;

103

104

100

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

105

static unsigned long _segment_step_sub_step = 0;

106

static unsigned long _segment_step_sub = 0;

107

108

// the button

109

static Button _button( 3 );

110

111

// modes

112

static int _major_mode = 0;

113

static int _minor_mode = 0;

114

115

#define MAIN_MODE_IDX 1

116

#define SETTINGS_MODE_IDX 0

117

118

#define ANALOGUE_CLOCK_IDX 0

119

#define DIGITAL_CLOCK_IDX 1

120

#define TEST_PATTERN_IDX 2

101

static unsigned long segment_step_sub_step = 0;

102

static unsigned long segment_step_sub = 0;

103

104

// flag to indicate that the drawing mode should be cycled to the next one

105

static bool inc_draw_mode = false;

106

107

// a bounce-managed button

108

static Button button( 3 );

121

109

122

110

//_____________________________________________________________________________

123

111

// code

124

112

125

113

126

// activate the current minor mode

127

void activate_minor_mode()

128

{

129

// reset text

130

Text::reset();

131

leds_off();

132

133

// give the mode a chance to init

134

switch( _minor_mode ) {

135

case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;

136

case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

137

}

138

}

139

140

141

// activate major mode

142

void activate_major_mode()

143

{

144

// reset text

145

Text::reset();

146

leds_off();

147

148

// reset buttons

149

_button.set_press_mode( _major_mode != SETTINGS_MODE_IDX );

150

151

// give the mode a chance to init

152

switch( _major_mode ) {

153

case MAIN_MODE_IDX: activate_minor_mode(); break;

154

case SETTINGS_MODE_IDX: settings_mode_activate(); break;

155

}

156

}

157

158

159

// perform button events

160

void do_button_events()

161

{

162

// loop through pending events

163

while( int event = _button.get_event() )

164

{

165

switch( event )

166

{

167

case 1:

168

// short press

169

switch( _major_mode ) {

170

case MAIN_MODE_IDX:

171

switch( _minor_mode ) {

172

case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;

173

case DIGITAL_CLOCK_IDX: digital_clock_press(); break;

174

}

175

break;

176

case SETTINGS_MODE_IDX: settings_mode_press(); break;

177

}

178

break;

179

180

case 2:

181

// long press

182

switch( _major_mode ) {

183

case MAIN_MODE_IDX:

184

if( ++_minor_mode >= 3 )

185

_minor_mode = 0;

186

activate_minor_mode();

187

break;

188

case SETTINGS_MODE_IDX: settings_mode_long_press(); break;

189

}

190

break;

191

192

case 3:

193

// looooong press (change major mode)

194

if( ++_major_mode > 1 )

195

_major_mode = 0;

196

activate_major_mode();

197

break;

198

}

199

}

114

// check for button presses

115

void checkButtons()

116

{

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;

125

}

126

}

127

128

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

200

141

}

201

142

202

143

203

144

// draw a display segment

204

void draw_next_segment( bool reset )

145

void drawNextSegment( bool reset )

205

146

{

147

static ModeSwitcher mode_switcher;

148

static bool init = false;

149

150

if( !init ) {

151

init = true;

152

mode_switcher.activate();

153

}

154

206

155

// keep track of segment

207

156

#if CLOCK_FORWARD

208

157

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

212

161

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

213

162

#endif

214

163

215

// reset the text renderer

216

TextRenderer::reset_buffer();

217

218

// frame reset

219

if( reset ) {

220

switch( _major_mode ) {

221

case MAIN_MODE_IDX:

222

switch( _minor_mode ) {

223

case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;

224

case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;

225

}

226

break;

227

case SETTINGS_MODE_IDX: settings_mode_draw_reset(); break;

228

}

229

230

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

231

Text::draw_reset();

232

}

233

234

164

// draw

235

switch( _major_mode ) {

236

case MAIN_MODE_IDX:

237

switch( _minor_mode ) {

238

case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;

239

case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;

240

case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;

241

}

242

break;

243

case SETTINGS_MODE_IDX: settings_mode_draw( segment ); break;

244

}

245

246

// draw any text that was rendered

247

TextRenderer::output_buffer();

165

Drawer &drawer = mode_switcher.get_drawer();

166

if( reset ) drawer.draw_reset();

167

drawer.draw( segment );

248

168

249

169

#if CLOCK_FORWARD

250

170

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

255

175

256

176

257

177

// calculate time constants when a new pulse has occurred

258

void calculate_segment_times()

178

void calculateSegmentTimes()

259

179

{

260

180

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

261

181

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

262

if( _new_pulse_at > _last_pulse_at )

182

if( new_pulse_at > last_pulse_at )

263

183

{

264

184

// new segment stepping times

265

unsigned long delta = _new_pulse_at - _last_pulse_at;

266

_segment_step = delta / NUM_SEGMENTS;

267

_segment_step_sub = 0;

268

_segment_step_sub_step = delta % NUM_SEGMENTS;

185

unsigned long delta = new_pulse_at - last_pulse_at;

186

segment_step = delta / NUM_SEGMENTS;

187

segment_step_sub = 0;

188

segment_step_sub_step = delta % NUM_SEGMENTS;

269

189

}

270

190

271

191

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

272

192

// clear new_pulse_at, ready for the next pulse

273

_last_pulse_at = _new_pulse_at;

274

_new_pulse_at = 0;

193

last_pulse_at = new_pulse_at;

194

new_pulse_at = 0;

275

195

}

276

196

277

197

278

198

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

279

199

// occurred

280

void wait_till_end_of_segment( bool reset )

200

void waitTillNextSegment( bool reset )

281

201

{

282

202

static unsigned long end_time = 0;

283

203

284

204

// handle reset

285

205

if( reset )

286

end_time = _last_pulse_at;

206

end_time = last_pulse_at;

287

207

288

208

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

289

end_time += _segment_step;

290

_segment_step_sub += _segment_step_sub_step;

291

if( _segment_step_sub >= NUM_SEGMENTS ) {

292

_segment_step_sub -= NUM_SEGMENTS;

209

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;

293

213

end_time++;

294

214

}

295

215

296

216

// wait

297

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

217

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

298

218

}

299

219

300

220

301

221

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

302

void fan_pulse_handler()

222

void fanPulseHandler()

303

223

{

304

224

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

305

225

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

310

230

if( !ignore )

311

231

{

312

232

// set a new pulse time

313

_new_pulse_at = micros();

233

new_pulse_at = micros();

314

234

}

315

235

}

316

236

319

239

void setup()

320

240

{

321

241

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

322

attachInterrupt( 0, fan_pulse_handler, RISING );

242

attachInterrupt( 0, fanPulseHandler, RISING );

323

243

digitalWrite( 2, HIGH );

324

244

325

245

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

329

249

// set up mode-switch button on pin 3

330

250

pinMode( 3, INPUT );

331

251

digitalWrite( 3, HIGH );

332

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

333

_button.set_event_times( event_times );

334

335

// initialise RTC

336

Time::init();

337

338

// init text renderer

339

TextRenderer::init();

340

341

// activate the minor mode

342

activate_major_mode();

252

button.add_event_at( 5, 1 );

253

button.add_event_at( 1000, 2 );

254

button.add_event_at( 4000, 3 );

255

256

// serial comms

257

Serial.begin( 9600 );

343

258

}

344

259

345

260

347

262

void loop()

348

263

{

349

264

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

350

bool reset = _new_pulse_at? true : false;

351

352

// update button

353

_button.update();

265

bool reset = new_pulse_at? true : false;

354

266

355

267

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

356

268

// that no state changes mid-display

357

269

if( reset )

358

270

{

359

// calculate segment times

360

calculate_segment_times();

271

// check buttons

272

checkButtons();

361

273

362

274

// keep track of time

363

Time::update();

364

365

// perform button events

366

do_button_events();

275

Time &time = Time::get_instance();

276

time.update();

367

277

}

368

278

369

279

// draw this segment

370

draw_next_segment( reset );

280

drawNextSegment( reset );

281

282

// do we need to recalculate segment times?

283

if( reset )

284

calculateSegmentTimes();

371

285

372

286

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

373

wait_till_end_of_segment( reset );

287

waitTillNextSegment( reset );

374

288

}