/elec/propeller-clock : revision 55

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:29:52 UTC
Revision ID: tim@ed.am-20120225012952-32q8gg07aovk3qxh

updated arduino.mk

files added:
src/util/Bounce.cpp

src/util/Bounce.h

files removed:
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/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/propeller-clock.cc => src/propeller-clock.ino

files modified:
.bzrignore

arduino.mk

src/Makefile

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 "config.h"

#include "button.h"

#include "time.h"

#include "Arduino.h"

#include "analogue_clock.h"

#include "digital_clock.h"

#include "test_pattern.h"

#include <Bounce.h>

#include <DS1307.h>

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

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

static unsigned long _segment_step = 0;

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

static unsigned long segment_step_sub_step = 0;

100

static unsigned long segment_step_sub = 0;

101

102

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

103

static bool inc_draw_mode = false;

104

105

// a bounce-managed button

106

static Bounce button( 3, 50 );

107

108

// the time

109

static int time_hours = 0;

110

static int time_minutes = 0;

111

static int time_seconds = 0;

112

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 )

117

118

// clock draw direction

119

#define CLOCK_FORWARD 0

120

121

// rotate display (in segments)

122

#define CLOCK_SHIFT ( 58 * NUM_SECOND_SEGMENTS - 1 )

116

123

117

124

//_____________________________________________________________________________

118

125

// code

119

126

120

127

121

// activate the current minor mode

122

void activate_minor_mode()

128

// check for button presses

129

void checkButtons()

123

130

{

124

switch( _minor_mode ) {

125

case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;

126

case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

127

}

131

// update buttons

132

button.update();

133

134

// notice button presses

135

if( button.risingEdge() )

136

inc_draw_mode = true;

128

137

}

129

138

130

// perform button events

131

void do_button_events()

139

140

// keep track of time

141

void trackTime()

132

142

{

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;

143

// previous time and any carried-over milliseconds

144

static unsigned long last_time = millis();

145

static unsigned long carry = 0;

146

147

// how many milliseonds have elapsed since we last checked?

148

unsigned long next_time = millis();

149

unsigned long delta = next_time - last_time + carry;

150

151

// update the previous time and carried-over milliseconds

152

last_time = next_time;

153

carry = delta % 1000;

154

155

// add the seconds that have passed to the time

156

time_seconds += delta / 1000;

157

while( time_seconds >= 60 ) {

158

time_seconds -= 60;

159

time_minutes++;

160

if( time_minutes >= 60 ) {

161

time_minutes -= 60;

162

time_hours++;

163

if( time_hours >= 24 )

164

time_hours -= 24;

172

165

}

173

166

}

174

167

}

175

168

176

169

170

// turn an led on/off

171

void ledOn( int num, bool on )

172

{

173

if( num < 0 || num > 9 ) return;

174

175

// convert to pin no.

176

num += 4;

177

178

// pin 4 needs to be inverted (it's driving a PNP)

179

if( num == 4 ) on = !on;

180

181

digitalWrite( num, on? HIGH : LOW );

182

}

183

184

185

// draw a segment for the test display

186

void drawNextSegment_test( int segment )

187

{

188

// turn on outside LEDs

189

ledOn( 9, true );

190

191

// display segment number in binary across in the inside LEDs,

192

// with the LED on pin 12 showing the least-significant bit

193

for( int a = 0; a < 9; a++ )

194

ledOn( 8 - a, ( segment >> a ) & 1 );

195

}

196

197

198

// draw a segment for the time display

199

void drawNextSegment_time( int segment )

200

{

201

int second = segment / NUM_SECOND_SEGMENTS;

202

int second_segment = segment % NUM_SECOND_SEGMENTS;

203

204

// what needs to be drawn?

205

bool draw_tick = ( !second_segment && second % 5 == 0 && second ) ||

206

( second == 0 && second_segment == 1 ) ||

207

( second == 59 && second_segment == NUM_SECOND_SEGMENTS - 1 );

208

bool draw_second = !second_segment && second == time_seconds;

209

bool draw_minute = !second_segment && second == time_minutes;

210

bool draw_hour = segment == time_hours * 5 * NUM_SECOND_SEGMENTS +

211

( 5 * NUM_SECOND_SEGMENTS * time_minutes / 60 );

212

213

// set the LEDs

214

ledOn( 9, true );

215

ledOn( 8, draw_tick || draw_second );

216

for( int a = 6; a <= 7; a++ )

217

ledOn( a, draw_minute || draw_second );

218

for( int a = 0; a <= 5; a++ )

219

ledOn( a, draw_minute || draw_second || draw_hour );

220

}

221

222

177

223

// draw a display segment

178

void draw_next_segment( bool reset )

224

void drawNextSegment( bool reset )

179

225

{

226

static int draw_mode = 0;

227

180

228

// keep track of segment

181

229

#if CLOCK_FORWARD

182

230

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

186

234

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

187

235

#endif

188

236

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

}

237

// handle mode switch requests

238

if( reset && inc_draw_mode ) {

239

inc_draw_mode = false;

240

draw_mode++;

241

if( draw_mode >= 2 )

242

draw_mode = 0;

199

243

}

200

244

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;

245

// draw the segment

246

switch( draw_mode ) {

247

case 0: drawNextSegment_test( segment ); break;

248

case 1: drawNextSegment_time( segment ); break;

210

249

}

211

250

212

251

#if CLOCK_FORWARD

218

257

219

258

220

259

// calculate time constants when a new pulse has occurred

221

void calculate_segment_times()

260

void calculateSegmentTimes()

222

261

{

223

262

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

224

263

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

225

if( _new_pulse_at > _last_pulse_at )

264

if( new_pulse_at > last_pulse_at )

226

265

{

227

266

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

267

unsigned long delta = new_pulse_at - last_pulse_at;

268

segment_step = delta / NUM_SEGMENTS;

269

segment_step_sub = 0;

270

segment_step_sub_step = delta % NUM_SEGMENTS;

232

271

}

233

272

234

273

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

235

274

// clear new_pulse_at, ready for the next pulse

236

_last_pulse_at = _new_pulse_at;

237

_new_pulse_at = 0;

275

last_pulse_at = new_pulse_at;

276

new_pulse_at = 0;

238

277

}

239

278

240

279

241

280

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

242

281

// occurred

243

void wait_till_end_of_segment( bool reset )

282

void waitTillNextSegment( bool reset )

244

283

{

245

284

static unsigned long end_time = 0;

246

285

247

286

// handle reset

248

287

if( reset )

249

end_time = _last_pulse_at;

288

end_time = last_pulse_at;

250

289

251

290

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

291

end_time += segment_step;

292

segment_step_sub += segment_step_sub_step;

293

if( segment_step_sub >= NUM_SEGMENTS ) {

294

segment_step_sub -= NUM_SEGMENTS;

256

295

end_time++;

257

296

}

258

297

259

298

// wait

260

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

299

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

261

300

}

262

301

263

302

264

303

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

265

void fan_pulse_handler()

304

void fanPulseHandler()

266

305

{

267

306

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

268

307

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

273

312

if( !ignore )

274

313

{

275

314

// set a new pulse time

276

_new_pulse_at = micros();

315

new_pulse_at = micros();

277

316

}

278

317

}

279

318

282

321

void setup()

283

322

{

284

323

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

285

attachInterrupt( 0, fan_pulse_handler, RISING );

324

attachInterrupt( 0, fanPulseHandler, RISING );

286

325

digitalWrite( 2, HIGH );

287

326

288

327

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

292

331

// set up mode-switch button on pin 3

293

332

pinMode( 3, INPUT );

294

333

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

}

334

335

// get the time from the real-time clock

336

int rtc_data[ 7 ];

337

RTC.get( rtc_data, true );

338

time_hours = rtc_data[ DS1307_HR ];

339

time_minutes = rtc_data[ DS1307_MIN ];

340

time_seconds = rtc_data[ DS1307_SEC ];

341

342

// serial comms

343

Serial.begin( 9600 );

305

344

}

306

345

307

346

309

348

void loop()

310

349

{

311

350

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

351

bool reset = new_pulse_at? true : false;

316

352

317

353

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

318

354

// that no state changes mid-display

319

355

if( reset )

320

356

{

321

// calculate segment times

322

calculate_segment_times();

357

// check buttons

358

checkButtons();

323

359

324

360

// keep track of time

325

Time::update();

326

327

// perform button events

328

do_button_events();

361

trackTime();

329

362

}

330

363

331

364

// draw this segment

332

draw_next_segment( reset );

365

drawNextSegment( reset );

366

367

// do we need to recalculate segment times?

368

if( reset )

369

calculateSegmentTimes();

333

370

334

371

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

335

wait_till_end_of_segment( reset );

372

waitTillNextSegment( reset );

336

373

}