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

src/modes/info_mode.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 "modes/info_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

100

static unsigned long _last_pulse_at = 0;

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;

static unsigned long segment_step = 0;

104

105

100

// 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 MAIN_MODE_IDX 1

117

#define SETTINGS_MODE_IDX 0

118

119

#define ANALOGUE_CLOCK_IDX 0

120

#define DIGITAL_CLOCK_IDX 1

121

#define TEST_PATTERN_IDX 2

122

#define INFO_MODE_IDX 3

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

123

109

124

110

//_____________________________________________________________________________

125

111

// code

126

112

127

113

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 >= 3 )

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

}

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

204

141

}

205

142

206

143

207

144

// draw a display segment

208

void draw_next_segment( bool reset )

145

void drawNextSegment( bool reset )

209

146

{

147

static ModeSwitcher mode_switcher;

148

static bool init = false;

149

150

if( !init ) {

151

init = true;

152

mode_switcher.activate();

153

}

154

210

155

// keep track of segment

211

156

#if CLOCK_FORWARD

212

157

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

216

161

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

217

162

#endif

218

163

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

164

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

252

// draw any text that was rendered

253

TextRenderer::output_buffer();

165

Drawer &drawer = mode_switcher.get_drawer();

166

if( reset ) drawer.draw_reset();

167

drawer.draw( segment );

254

168

255

169

#if CLOCK_FORWARD

256

170

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

261

175

262

176

263

177

// calculate time constants when a new pulse has occurred

264

void calculate_segment_times()

178

void calculateSegmentTimes()

265

179

{

266

180

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

267

181

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

268

if( _new_pulse_at > _last_pulse_at )

182

if( new_pulse_at > last_pulse_at )

269

183

{

270

184

// new segment stepping times

271

unsigned long delta = _new_pulse_at - _last_pulse_at;

272

_segment_step = delta / NUM_SEGMENTS;

273

_segment_step_sub = 0;

274

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

275

189

}

276

190

277

191

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

278

192

// clear new_pulse_at, ready for the next pulse

279

_last_pulse_at = _new_pulse_at;

280

_new_pulse_at = 0;

193

last_pulse_at = new_pulse_at;

194

new_pulse_at = 0;

281

195

}

282

196

283

197

284

198

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

285

199

// occurred

286

void wait_till_end_of_segment( bool reset )

200

void waitTillNextSegment( bool reset )

287

201

{

288

202

static unsigned long end_time = 0;

289

203

290

204

// handle reset

291

205

if( reset )

292

end_time = _last_pulse_at;

206

end_time = last_pulse_at;

293

207

294

208

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

295

end_time += _segment_step;

296

_segment_step_sub += _segment_step_sub_step;

297

if( _segment_step_sub >= NUM_SEGMENTS ) {

298

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

299

213

end_time++;

300

214

}

301

215

302

216

// wait

303

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

217

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

304

218

}

305

219

306

220

307

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

308

void fan_pulse_handler()

221

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

222

void fanPulseHandler()

309

223

{

310

224

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

311

225

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

316

230

if( !ignore )

317

231

{

318

232

// set a new pulse time

319

_new_pulse_at = micros();

233

new_pulse_at = micros();

320

234

}

321

235

}

322

236

324

238

// main setup

325

239

void setup()

326

240

{

327

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

328

attachInterrupt( 0, fan_pulse_handler, RISING );

241

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

242

attachInterrupt( 0, fanPulseHandler, RISING );

329

243

digitalWrite( 2, HIGH );

330

244

331

245

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

335

249

// set up mode-switch button on pin 3

336

250

pinMode( 3, INPUT );

337

251

digitalWrite( 3, HIGH );

338

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

339

_button.set_event_times( event_times );

340

341

// initialise RTC

342

Time::init();

343

344

// init text renderer

345

TextRenderer::init();

346

347

// activate the minor mode

348

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

349

258

}

350

259

351

260

353

262

void loop()

354

263

{

355

264

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

356

bool reset = _new_pulse_at? true : false;

357

358

// update button

359

_button.update();

265

bool reset = new_pulse_at? true : false;

360

266

361

267

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

362

268

// that no state changes mid-display

363

269

if( reset )

364

270

{

365

// calculate segment times

366

calculate_segment_times();

271

// check buttons

272

checkButtons();

367

273

368

274

// keep track of time

369

Time::update();

370

371

// perform button events

372

do_button_events();

275

Time &time = Time::get_instance();

276

time.update();

373

277

}

374

278

375

279

// draw this segment

376

draw_next_segment( reset );

280

drawNextSegment( reset );

281

282

// do we need to recalculate segment times?

283

if( reset )

284

calculateSegmentTimes();

377

285

378

286

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

379

wait_till_end_of_segment( reset );

287

waitTillNextSegment( reset );

380

288

}