/elec/propeller-clock

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

/*

 * propeller-clock.ino

 *

 * Copyright (C) 2011 Tim Marston <tim@ed.am> and Dan Marston.

 *

 * 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

static unsigned long _last_pulse_at = 0;

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

static unsigned long _segment_step = 0;

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

static unsigned long _segment_step_sub_step = 0;

static unsigned long _segment_step_sub = 0;

// the button

static Button _button( 3 );

// modes

static int _major_mode = 0;

static int _minor_mode = 0;

#define SETTINGS_MODE_IDX 1

#define MAIN_MODE_IDX 0

#define ANALOGUE_CLOCK_IDX 0

#define DIGITAL_CLOCK_IDX 1

#define INFO_MODE_IDX 2

#define TEST_PATTERN_IDX 3

//_____________________________________________________________________________

//                                                                         code

// activate the current minor mode

void activate_minor_mode()

{

	// reset text

	Text::reset();

	leds_off();

	// give the mode a chance to init

	switch( _minor_mode ) {

	case ANALOGUE_CLOCK_IDX: analogue_clock_activate(); break;

	case DIGITAL_CLOCK_IDX: digital_clock_activate(); break;

	case INFO_MODE_IDX: info_mode_activate(); break;

	}

}

// activate major mode

void activate_major_mode()

{

	// reset text

	Text::reset();

	leds_off();

	// reset buttons

	_button.set_press_mode( _major_mode != SETTINGS_MODE_IDX );

	// give the mode a chance to init

	switch( _major_mode ) {

	case MAIN_MODE_IDX: activate_minor_mode(); break;

	case SETTINGS_MODE_IDX: settings_mode_activate(); break;

	}

}

// perform button events

void do_button_events()

{

	// loop through pending events

	while( int event = _button.get_event() )

	{

		switch( event )

		{

		case 1:

			// short press

			switch( _major_mode ) {

			case MAIN_MODE_IDX:

				switch( _minor_mode ) {

				case ANALOGUE_CLOCK_IDX: analogue_clock_press(); break;

				case DIGITAL_CLOCK_IDX: digital_clock_press(); break;

				case INFO_MODE_IDX: info_mode_press(); break;

				}

				break;

			case SETTINGS_MODE_IDX: settings_mode_press(); break;

			}

			break;

		case 2:

			// long press

			switch( _major_mode ) {

			case MAIN_MODE_IDX:

				if( ++_minor_mode >= 4 )

					_minor_mode = 0;

				activate_minor_mode();

				break;

			case SETTINGS_MODE_IDX: settings_mode_long_press(); break;

			}

			break;

		case 3:

			// looooong press (change major mode)

			if( ++_major_mode > 1 )

				_major_mode = 0;

			activate_major_mode();

			break;

		}

	}

}

// draw a display segment

void draw_next_segment( bool reset )

{

	// keep track of segment

#if CLOCK_FORWARD

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

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

#else

	static int segment = NUM_SEGMENTS - 1 - CLOCK_SHIFT;

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

#endif

	// reset the text renderer

	TextRenderer::reset_buffer();

	// frame reset

	if( reset ) {

		switch( _major_mode ) {

		case MAIN_MODE_IDX:

			switch( _minor_mode ) {

			case ANALOGUE_CLOCK_IDX: analogue_clock_draw_reset(); break;

			case DIGITAL_CLOCK_IDX: digital_clock_draw_reset(); break;

			case INFO_MODE_IDX: info_mode_draw_reset(); break;

			}

			break;

		case SETTINGS_MODE_IDX: settings_mode_draw_reset(); break;

		}

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

		Text::draw_reset();

	}

	// draw

	switch( _major_mode ) {

	case MAIN_MODE_IDX:

		switch( _minor_mode ) {

		case ANALOGUE_CLOCK_IDX: analogue_clock_draw( segment ); break;

		case DIGITAL_CLOCK_IDX: digital_clock_draw( segment ); break;

		case TEST_PATTERN_IDX: test_pattern_draw( segment ); break;

		case INFO_MODE_IDX: info_mode_draw( segment ); break;

		}

		break;

	case SETTINGS_MODE_IDX: settings_mode_draw( segment ); break;

	}

	Text::post_draw();

	// draw any text that was rendered

	TextRenderer::output_buffer();

#if CLOCK_FORWARD

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

#else

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

#endif

}

// calculate time constants when a new pulse has occurred

void calculate_segment_times()

{

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

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

	if( _new_pulse_at > _last_pulse_at )

	{

		// new segment stepping times

		unsigned long delta = _new_pulse_at - _last_pulse_at;

		_segment_step = delta / NUM_SEGMENTS;

		_segment_step_sub = 0;

		_segment_step_sub_step = delta % NUM_SEGMENTS;

	}

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

	// clear new_pulse_at, ready for the next pulse

	_last_pulse_at = _new_pulse_at;

	_new_pulse_at = 0;

}

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

// occurred

void wait_till_end_of_segment( bool reset )

{

	static unsigned long end_time = 0;

	// handle reset

	if( reset )

		end_time = _last_pulse_at;

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

	end_time += _segment_step;

	_segment_step_sub += _segment_step_sub_step;

	if( _segment_step_sub >= NUM_SEGMENTS ) {

		_segment_step_sub -= NUM_SEGMENTS;

		end_time++;

	}

	// wait

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

}

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

void fan_pulse_handler()

{

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

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

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

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

	static bool ignore = true;

	ignore = !ignore;

	if( !ignore )

	{

		// set a new pulse time

		_new_pulse_at = micros();

	}

}

// main setup

void setup()

{

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

	attachInterrupt( 0, fan_pulse_handler, RISING );

	digitalWrite( 2, HIGH );

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

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

		pinMode( a, OUTPUT );

	// set up mode-switch button on pin 3

	pinMode( 3, INPUT );

	digitalWrite( 3, HIGH );

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

	_button.set_event_times( event_times );

	// initialise RTC

	Time::init();

	// init text renderer

	TextRenderer::init();

	// activate the minor mode

	activate_major_mode();

}

// main loop

void loop()

{

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

	bool reset = _new_pulse_at? true : false;

	// update button

	_button.update();

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

	// that no state changes mid-display

	if( reset )

	{

		// calculate segment times

		calculate_segment_times();

		// keep track of time

		Time::update();

		// perform button events

		do_button_events();

	}

	// draw this segment

	draw_next_segment( reset );

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

	wait_till_end_of_segment( reset );

}