//////////////////////////////////////////////////////////////////////////////
// pov.c - persistence of vision display for bicycle wheels
//    Authored by John R. Dawson (www.johndawson.org), circa 2009
//    email:  povboard <at> johndawson <d0t> org
//
// APPLICATION NOTES:
//    Chip used is Atmel ATMega644p
//    Ports:
//    Ports A and C comprise one row of LED's (LEFT side)
//    Ports B and D comprise the other row    (RIGHT side)
//    POV board is two-sided, 15-LED's per side, individually controlled.
//
//    All pins on ports A and B are used (top 8 LED's in each row), and
//    the first 7 pins on ports C and D are used (bottom 7 LED's in each
//    row). Total of 15 LED's in each row.
//
//    Pin 21 (PORTD7/PIND7) is the input for the "mode select" shorting block.
//    Pin 29 (PORTC7/PINC7) is the input for the hall effect rotation sensor.
//
//    We should be able to get away with writing a full 8 bits to ports C
//    and D for convenience. The only side effect will be constantly toggling
//    the pull-up resistor for pin 7 of each port. This shouldn't affect the
//    operation of the circuit because we have used external pull-ups on
//    these pins.
//
//    Timers:
//    timer0 is used for short delays (controlling on/off time of LED's).
//       The timer0 compare match interrupt vector (TIMER0_COMPA_vect) is used.
//    timer1 is used for timing wheel rotation.
//       The timer1 overflow vector (TIMER1_OVF_vect) is used.
//    timer2 is used for ignoring spurious/multiple triggers from hall sensor.
//       The timer2 overflow vector (TIMER2_OVF_vect) is used.
//////////////////////////////////////////////////////////////////////////////
// BUGS:
// 1. At certain speeds the display seems to be "smeared" while the LED's
//    freeze in their current state for an extended period of time (maybe 1/4
//    to half a revolution). Looks like the on-time (sometimes the off-time)
//    for the LED's gets stretched out as though the chip is zoning out and
//    ignoring me. This seems to be speed/timing related since it happens
//    frequently at certain fixed speeds, and not much at all at other speeds.
//    If you have any ideas on what may be causing this, please educate me via
//    email:  povboard <at> johndawson <d0t> org
//////////////////////////////////////////////////////////////////////////////
// FUTURE ENHANCEMENTS:
// 1. Add an IR detector in place of the mode selector. Use this to program
//    the board with a remote control.
// 2. Add a clock crystal to allow displaying date/time. May have to get
//    creative with the timers since all of them are already in use.
//    To avoid having to set the time every time the board is powered up,
//    may have to leave the board running all the time. Must research the
//    power saving modes and turn off every system not required for keeping
//    time. This also would require recharging while the board is still under
//    power. Considering the hassle factor and the not-very-useful factor,
//    this may never happen.
// 3. Use the non-volatile memory to store total distance traveled so that
//    we have a permanent odometer.
//////////////////////////////////////////////////////////////////////////////
// GENERAL NOTES:
// m644p interrupt vector mnemonics are defined in:
// /usr/local/avr/avr/include/avr/iomxx4.h (which is included by iom644.h)
//////////////////////////////////////////////////////////////////////////////
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>			// For sleep_enable(), etc.
#include <inttypes.h>
#include <string.h>
#include <stdio.h>
//#include <stdlib.h>
//#include <util/delay.h>
#include "pov.h"
#include "characters8.h"
#include "characters15.h"
#include "font8_Plain.h"
//#include "font15_Chancery.h"


//
// Local function prototypes
//
void ShowChar8(unsigned char, char);
void ShowChar15(unsigned char, char);
void ShowString8(char *, char);
void ShowSpeed(void);
void ShowSpaceInvaders(void);
void TinyPause(unsigned char, char);
void PowerOnVisual(void);
void GetTptr8(unsigned char, unsigned char **);


//
// Global variables
//
// Number of clock counts per wheel revolution
static volatile unsigned long Clicks=0, TmpClicks=0;
static volatile unsigned long Revolutions=0;		// Revs since last mile mark
static volatile int Miles=0;							// Miles traveled (duh)
static volatile float MPH=0;							// Miles per hour (duh)
// Used to ignore spurious sensor signals
static volatile char DetectRotation=1;
// Used as a condition variable for pause/wait loops
static volatile char TinyPauseDone=0;
// Revolution interrupt triggered - start anew
static volatile char RestartCycle=0;
// Character display on/off times
static volatile int PauseTime, OnPauseTime, OffPauseTime;
static volatile int PrescaleFactor;
// Doubled these values to get scale factor correct after 8MHz clock change.
static const float BASE_ONTIME=0.13;
static const float BASE_OFFTIME=0.20;
static const float SHORT_ONTIME=0.09;
static const float SHORT_OFFTIME=0.13;
static const float LONG_ONTIME=0.20;
static const float LONG_OFFTIME=0.32;
static volatile float CONST_ONTIME=0.13;
static volatile float CONST_OFFTIME=0.20;
static volatile unsigned char Mode;		// Mode of operation (jumper on board)



//////////////////////////////////////////////////////////////////////////////
// ISR for hall effect sensor interrupt (PCINT23/PORTC7)
//////////////////////////////////////////////////////////////////////////////
ISR(PCINT2_vect)
{
	if( ! DetectRotation )
	{	// Ignore spurious signals from rotation sensor
		return;
	}
	else
	{	DetectRotation=0;	// Ignore signals after this run.
		// Start timer2. When it overflows a set number of times, signal
		// detection will be re-enabled.
		TCNT2=0;
		TCCR2B &= ~( (1<<CS22)|(1<<CS21)|(1<<CS20) );	// Clear clock source
		// Now we're running the chip at 8MHz, so instead of prescaling by 256,
		// we'll prescale by 1024. We still need to divide by an additional 2
		// to get back to our original time base. That will be handled in the
		// timer2 overflow ISR.
//		TCCR2B |= (1<<CS22)|(1<<CS21);						// Prescale by 256
		TCCR2B |= (1<<CS22)|(1<<CS21)|(1<<CS20);			// Prescale by 1024
	}

	// Check our speed (TmpClicks keeps the running total, taking into account
	// any timer overflows). Note that all our constants regarding speed were
	// calculated for a 1MHz MCU speed. Since we are now running at 8MHz, we
	// can either change all those constants, or take the easy way out (for now)
	// and simply divide our "Clicks" variable by the appropriate amount.
	// Since we need to divide by 8, and we've already divided by 4 via the
	// 1024 prescaler (vs. the previous 256 prescaler), we now need only
	// to divide by 2.
	Clicks=(TmpClicks+TCNT1)/2;
	// Reset counter(s)
	TCNT1=0;
	TmpClicks=0;

	// Update trip counter
	Revolutions++;
	if( Revolutions >= REVS_PER_MILE )
	{	Miles++;
		Revolutions=0;
	}

	// Tell main() to restart output from beginning
	RestartCycle=1;


	// Check external jumpers for display mode (Note: Pins are active low)
	Mode=( PIND & (1<<7) ? 1 : 0 );
}	// End ISR for hall effect sensor interrupt (PCINT23/PORTC7)


//////////////////////////////////////////////////////////////////////////////
// ISR for Compare Match on timer0
//
// This timer is used for short delays such as for determining on-time and
// off-time of the LED's.
//////////////////////////////////////////////////////////////////////////////
ISR(TIMER0_COMPA_vect)
{
	// Disable timer0 by selecting no clock source
	TCCR0B &= ~( (1<<CS02) | (1<<CS01) | (1<<CS00) );
	// Set condition variable
	TinyPauseDone=1;
}	// End ISR for timer0 compare-match


//////////////////////////////////////////////////////////////////////////////
// ISR for Timer1 overflow
//    Timer1 times how long it takes for each wheel revolution. If that time
//    exceeds timer1's resolution, we simply add that value to a temporary
//    variable and then use that variable as our elapsed time.
//    Timer1 overflows when it reaches 0xff, so that is what we add.
//////////////////////////////////////////////////////////////////////////////
ISR(TIMER1_OVF_vect)
{	TmpClicks+=0xff;
}	// End ISR for Timer1 overflow


//////////////////////////////////////////////////////////////////////////////
// ISR for Overflow on timer2
//
// Timer2 is used to ignore rotation sensor input for a short period after
// a trigger is received. This is to prevent multiple triggers for a single
// event, which seems to be happining only with the 644p.
// Note that using this scheme will eliminate the need for the previous
// "ignore every other signal" scheme which handled the fact that the hall
// effect sensor puts out a signal on both the rise and fall of event
// detection.
//
// We want to wait about 50ms before re-enabling.
// At an MCU speed of 8Mhz, a 50ms pause is about 400000 clicks. If we
// overflow at a count of 256, we can then use a prescaler of 256 to get
// one overflow every 256 * 256 clicks, or every 65,536 clicks.
// To get 400000 clicks (approximately), we'll just overflow 6 times.
// This will get us 393216 clicks, which is only 1.7% off. This gives
// us "safe" timing up to almost 100 miles per hour.
// The static const variable TARGET_OVF_COUNT is therefore initialized to 6.
// (Note: We are running at 1 Mhz, not 8. Therefore TARGET_OVF_COUNT is
// initialized to 1 instead of 6, meaning we need only 50000 clicks for a
// 50ms window, meaning we're actually suppressing the sensor signal for
// about 30% longer than that (65k clicks), or about 80ms.
//
// Additional note: MCU speed has been changed from 1MHz to 8MHz, so all
// figures above need to be adjusted accordingly. We have changed the
// initialization of timer2 to use a prescaler of 1024 instead of 256, so we
// still need to divide by 2 to get the original intended time span. We'll
// do this with the TARGET_OVF_COUNT constant, setting it to 2 instead of 1.
//////////////////////////////////////////////////////////////////////////////
ISR(TIMER2_OVF_vect)
{
	static volatile int OverflowCount=0;
	static const int TARGET_OVF_COUNT=2;

	OverflowCount++;

	if( OverflowCount >= TARGET_OVF_COUNT )
	{	// Disable timer2 by selecting no clock source
		TCCR2B &= ~( (1<<CS22)|(1<<CS21)|(1<<CS20) );
		// Set "detect rotation sensor signal" variable
		DetectRotation=1;
		// Reset the overflow counter
		OverflowCount=0;
	}
}	// End ISR for timer2 overflow vector


//////////////////////////////////////////////////////////////////////////////
// MAIN - main - MAIN - main - MAIN - main - MAIN - main - MAIN - main - MAIN
//////////////////////////////////////////////////////////////////////////////
int
main()
{
	// Set all pins for all ports as outputs, except for PC7 and PD7.
	DDRA = 0xff;
	DDRB = 0xff;
	DDRC |= (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6);
	DDRD |= (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6);
	// Set PC7 and PD7 as inputs.
	DDRC &= ~(1<<7);
	DDRD &= ~(1<<7);
	// Don't bother with internal pull-up resistors for PC7 and PD7
	// They are pulled up externally so we can ignore whether or not
	// the internal pull-ups are enabled (they'll be toggled frequently).
	// PORTC |= (1<<7);
	// PORTD |= (1<<7);

	//
	// Initialize timer/counter0 (used for short delays)
	//
	// Configure for CTC mode, TOP is OCRA
	TCCR0A |= (1<<WGM01);
	// Enable interrupt for timer0 output compare A
	TIMSK0 |= (1<<OCIE0A);

	//
	// Initialize timer/counter1 (used to determine wheel speed)
	//
	// Configure for normal mode, TOP is 0xffff
	// (Nothing to do - this is the default mode of operation)

	//
	// Initialize timer/counter2 (used to ignore spurious sensor signals)
	//
	// Configure for normal mode, TOP is 0xFF
	//	(Nothing to do for normal mode -- TCCR2A defaults are what we want)
	// Enable timer2 overflow interrupt
	TIMSK2 |= (1<<TOIE2);


	// Activate interrupts globally
	sei();


	//
	// Do a startup chase sequence so user knows board is on and working.
	//
	PowerOnVisual();


	//
	// Set up external interrupt PCINT23 (PORTC7) for hall effect sensor.
	//
	// Enable interrupts for interrupt group encompassing PCINTs 16-23.
	PCICR |= (1<<PCIE2);
	// Allow only PCINT23 to generate an interrupt.
	PCMSK2 = 0x00;
	PCMSK2 |= (1<<PCINT23);


	// Start timer1 (for wheel speed) by selecting a clock source.
	// We'll use /1024 prescaler.
	TCCR1B |= (1<<CS12)|(1<<CS10);


	volatile int SwitchPatternCounter=0;	// Track 100's of rotations
	const int SwitchPatternTrigger=1;	// Change output every X hundred rot's
	int PatternNum=0;					// Current image/text pattern to display
	int MaxPatternNum=0;				// Max pattern num for a given mode
	int ContinuousDisplay=0;		// Display continuously or only once per rev?
	char AdjustCounter=1;			// See notes below

	//
	// Main loop
	//
	while(1)
	{
		RestartCycle=0;

		switch( Mode )
		{	case MODE_1:				// "Various images" mode
				MaxPatternNum=13;		// 12 patterns to display in this mode
				break;
			case MODE_2:				// web addr, speed, disc mode
				MaxPatternNum=2;		// 3 patterns to display in this mode
				break;
			default:						// default to web addr, speed, disc mode
				MaxPatternNum=2;		// 3 patterns to display in this mode
				Mode=MODE_2;
				break;
		}	// End switch() for determining MaxPatternNum

		// Do we need to switch to a different image/text pattern?
		if( (Revolutions % 10) == 0 )
		{	if( AdjustCounter )
			{	// We may have LOTS of iterations of this loop during a single
				// wheel revolution, and revs % X will equal zero the whole time.
				// Therefore, if Revs % X == 0, we need to ensure that we increment
				// SwitchPatternCounter only once during the entire revolution.
				// We'll do this with the AdjustCounter flag.
				// We'll set it to false here since we're incrementing the
				// counter now, and it'll remain that way until Revs % X != 0.
				AdjustCounter=0;
				if( SwitchPatternCounter++ >= SwitchPatternTrigger )
				{	SwitchPatternCounter=0;
					if( PatternNum++ >= MaxPatternNum )
					{	PatternNum=0;
					}
				}
			}
		}	// End if() for Revs % X
		else
		{	AdjustCounter=1;
		}

		if( RestartCycle )
			continue;

		//
		// Display the actual image/text pattern
		//
		switch( Mode )
		{	case MODE_1:
				switch( PatternNum )
				{	case 0:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(BLACKBAT,DEFAULT_STYLE);
						ShowChar8(' ',DEFAULT_STYLE);
						ContinuousDisplay=1; break;
					case 1:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(ALLSUITS,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 2:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(CHECKERED,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 3:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(Egypt,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 4:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(Bug,DEFAULT_STYLE);
						ShowChar8(' ',DEFAULT_STYLE);
						ContinuousDisplay=1; break;
					case 5:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(Circuit,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 6:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowSpaceInvaders();
						ContinuousDisplay=1; break;
					case 7:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(WAVYTRIANGLES,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 8:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(MULTIDOTS,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 9:
						CONST_ONTIME=SHORT_ONTIME;
						CONST_OFFTIME=SHORT_OFFTIME;
						ShowChar15(OPPOSEDTREES,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 10:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowChar15(OPPOSEDTRIANGLES,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
					case 11:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar8(Notes,DEFAULT_STYLE);
						ContinuousDisplay=1; break;
					case 12:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar8(ZigZag,ADJACENT_CHARACTERS);
						ContinuousDisplay=1; break;
/*
					case 13:
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(LightningBolt,DEFAULT_STYLE);
						ShowChar8(' ',DEFAULT_STYLE);
						ContinuousDisplay=1; break;
*/
					default:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						char TexT[25];
						sprintf(TexT,"MODE %d: BAD IMG %d ",Mode,PatternNum);
						ShowString8(TexT,DEFAULT_STYLE);
						ContinuousDisplay=0; break;
						break;
				}	// End switch() for MODE_1
				break;

			case MODE_2:	// Rotate between web addr, speed, and disc images
				switch( PatternNum )
				{	
/*
					case 0:	// Web address
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(CCC,DEFAULT_STYLE);
						ContinuousDisplay=0; break;
*/
					case 1:	// Speed/distance
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						ShowSpeed();
						ContinuousDisplay=0; break;
/*
					case 2:	// Disc/diskette images
						CONST_ONTIME=LONG_ONTIME;
						CONST_OFFTIME=LONG_OFFTIME;
						ShowChar15(Discs,DEFAULT_STYLE);
						ContinuousDisplay=1; break;
*/
					default:
						CONST_ONTIME=BASE_ONTIME;
						CONST_OFFTIME=BASE_OFFTIME;
						char TexT[25];
						sprintf(TexT,"MODE %d: BAD IMG %d ",Mode,PatternNum);
						ShowString8(TexT,DEFAULT_STYLE);
						ContinuousDisplay=0; break;
						break;
				}	// End switch() for MODE_2 patterns
				break;

			default:		// WTF???
				CONST_ONTIME=BASE_ONTIME;
				CONST_OFFTIME=BASE_OFFTIME;
				char TexT[20];
				sprintf(TexT,"BAD MODE: 0X%02x ",Mode);
				ShowString8(TexT,DEFAULT_STYLE);
				ContinuousDisplay=0; break;
				break;
		}	// End switch() for displaying patterns



		if( RestartCycle )
			continue;


		// Now go to sleep. We'll be awakened by the revolution sensor interrupt.
		if( ! ContinuousDisplay )
		{	sleep_enable();
			while( ! RestartCycle )
			{	sleep_cpu();
			}
			sleep_disable();
		}
	}	// End while() loop


	return 0;
}	// End function main()


//////////////////////////////////////////////////////////////////////////////
// TinyPause() - function puts the MCU to sleep for very short periods of
//    time, such as the length of time a single row of character data is
//    on, or the length of time all LED's are off to create space between
//    adjacent characters.
//
// Parameters:
//    char clicks [in] - The number of clock ticks to sleep.
//
// Returns:
//    (none)
//
// Notes:
//    Prescaler settings (from data sheet pg. 105):
//    CS02  CS01  CS00  Description
//     0     0     0    No clock source selected
//     0     0     1    System clock (no prescaling)
//     0     1     0    /8 prescaler
//     0     1     1    /64 prescaler
//     1     0     0    /256 prescaler
//     1     0     1    /1024 prescaler
//     1     1     0    External clock on T0 pin (clock on falling edge)
//     1     1     1    External clock on T0 pin (clock on rising edge)
//////////////////////////////////////////////////////////////////////////////
void
TinyPause(unsigned char clicks, char prescaler)
{
	// Set OCR0A (TOP) to desired value
	OCR0A=clicks;
	// Set counter to zero
	TCNT0=0;
	// Initialize our (global) condition variable
	TinyPauseDone=0;

	// Select clock source to enable timer
	TCCR0B &= ~( (1<<CS02)|(1<<CS01)|(1<<CS00) );	// Clear flags
	switch(prescaler)
	{	case PRESCALE_NONE:	// No prescaling - full system clock speed
			TCCR0B |= (1<<CS00);
			break;
		case PRESCALE_8:		// divide-by-8 prescaler
			TCCR0B |= (1<<CS01);
			break;
		case PRESCALE_256:	// divide-by-256 prescaler
			TCCR0B |= (1<<CS02);
			break;
		case PRESCALE_1024:	// divide-by-1024 prescaler
			TCCR0B |= (1<<CS02)|(1<<CS00);
			break;
		case PRESCALE_64: default:		// divide-by-64 prescaler (default)
			TCCR0B |= (1<<CS01)|(1<<CS00);
			break;
	}	// End switch() for determining prescaler

	// Now go to sleep. We'll be awakened either by the timer0 compare match
	// or the external interrupt (revolution sensor).
	sleep_enable();
	while( ! TinyPauseDone && ! RestartCycle )
	{	sleep_cpu();
	}
	sleep_disable();
}	// End function TinyPause()


//////////////////////////////////////////////////////////////////////////////
// ShowChar8() - function displays a single 8-dot character on the POV device.
//
// Parameters:
//    unsigned char character [in] - the character to be displayed.
//    int size [in] - the number of columns which comprise the character.
//    char style [in] - controls the way in which the character is displayed.
//         (i.e., reverse video, etc)
//
// Returns:
//    (none)
//////////////////////////////////////////////////////////////////////////////
void
ShowChar8(unsigned char character, char style)
{
	unsigned char *tptr;
	int countF, countB, size;


	PrescaleFactor=PRESCALE_64;
	// Most characters are 7 bytes. We'll change it where needed.
	size=7;

	switch(character)
	{
		//
		// Space Invaders
		//
		case SI_1: tptr=si_1; size=sizeof(si_1); break;
		case SI_2: tptr=si_2; size=sizeof(si_2); break;
		case SI_3: tptr=si_3; size=sizeof(si_3); break;
		case SI_4: tptr=si_4; size=sizeof(si_4); break;

		case Notes: tptr=notes; size=sizeof(notes); break;
		case ZigZag: tptr=zigzag; size=sizeof(zigzag); break;

		case 'A': tptr=A; break;
		case 'B': tptr=B; break;
		case 'C': tptr=C; break;
		case 'D': tptr=D; break;
		case 'E': tptr=E; break;
		case 'F': tptr=F; break;
		case 'G': tptr=G; break;
		case 'H': tptr=H; break;
		case 'I': tptr=I; break;
		case 'J': tptr=J; break;
		case 'K': tptr=K; break;
		case 'L': tptr=L; break;
		case 'M': tptr=M; break;
		case 'N': tptr=N; break;
		case 'O': tptr=O; break;
		case 'P': tptr=P; break;
		case 'Q': tptr=Q; break;
		case 'R': tptr=R; break;
		case 'S': tptr=S; break;
		case 'T': tptr=T; break;
		case 'U': tptr=U; break;
		case 'V': tptr=V; break;
		case 'W': tptr=W; break;
		case 'X': tptr=X; break;
		case 'Y': tptr=Y; break;
		case 'Z': tptr=Z; break;

		case 'a': tptr=a; break;
		case 'c': tptr=c; break;
		case 'e': tptr=e; break;
		case 'i': tptr=i; break;
		case 'g': tptr=g; break;
		case 'l': tptr=l; break;
		case 'm': tptr=m; break;
		case 'n': tptr=n; break;
		case 'o': tptr=o; break;
		case 'p': tptr=p; break;
		case 'r': tptr=r; break;
		case 't': tptr=t; break;
		case 'u': tptr=u; break;

		case '1': tptr=num_1; break;
		case '2': tptr=num_2; break;
		case '3': tptr=num_3; break;
		case '4': tptr=num_4; break;
		case '5': tptr=num_5; break;
		case '6': tptr=num_6; break;
		case '7': tptr=num_7; break;
		case '8': tptr=num_8; break;
		case '9': tptr=num_9; break;
		case '0': tptr=num_0; break;

		case ' ': tptr=Punct_Space; break;
		case '!': tptr=Punct_Exclaim; break;
		case '?': tptr=Punct_Question; break;
		case ':': tptr=Punct_Colon; break;
		case ',': tptr=Punct_Comma; break;
		case '.': tptr=Punct_Period; break;
		case '_': tptr=Punct_Underline; break;
		case '-': tptr=Punct_Minus; break;
		case '/': tptr=Punct_Slash; break;
		case ';': tptr=Punct_Semicolon; break;
		case '#': tptr=Punct_Pound; break;
		case '$': tptr=Punct_Dollar; break;
		case '%': tptr=Punct_Percent; break;
		case '&': tptr=Punct_Ampersand; break;
		case '=': tptr=Punct_Equals; break;
		case '+': tptr=Punct_Plus; break;
		case '<': tptr=Punct_LessThan; break;
		case '>': tptr=Punct_GreaterThan; break;
		case '\'': tptr=Punct_Tic; break;
		case '"': tptr=Punct_DoubleQuotes; break;
		case '(': tptr=Punct_OpenParen; break;
		case ')': tptr=Punct_CloseParen; break;

		default:  tptr=Punct_Question; break;
	}	// End switch()

	for(countF=0,countB=size-1;countF<size&&countB>=0;countF++,countB--)
	{	if( style & INVERTED_TEXT )
		{	PORTA=~(tptr[countF]);		// Dark text, light background, front side
			PORTB=~(tptr[countB]);		// Dark text, light background, back side
		}
		else
		{	PORTA=tptr[countF];			// Light text, dark background, front side
			PORTB=tptr[countB];			// Light text, dark background, back side
		}


		// Next we'll calculate on-time based on speed (for a stable display).
		// We also need to time how long this calculation takes so we can
		// subtract it from the total on-time. Floating point arithmetic
		// is extremely slow, so we really need to allow for it here.
		// At 1MHz MCU speed, it is so slow that it took twice as long to
		// do the arithmetic as we wanted to wait. Adding the actual wait
		// on top of that made the characters 3 times as wide as desired.
		OCR0A=0xff;			// Set top to MAX (which we hopefully won't reach)
		TCNT0=0;				// Set counter to zero
		TCCR0B |= (1<<CS01)|(1<<CS00);						// Start timer
		PauseTime=(int)( (float)((float)Clicks*CONST_ONTIME) );
		PauseTime-=TCNT0;	// Subtract calculation time
		TCCR0B &= ~( (1<<CS02)|(1<<CS01)|(1<<CS00) );	// Stop timer

		// Now if we are moving very slowly (say, below 10 MPH), we need to
		// adjust our timer so we can wait even longer periods of time to
		// keep the display stable.
		if( Clicks > SLOW_SPEED_TRANSITION )
		{	PrescaleFactor=PRESCALE_256;
			PauseTime/=4;
		}

		// Final sanity check
		if( PauseTime > 255 )
		{	PauseTime=255;
		}
		else if( PauseTime <= 0 )
		{	PauseTime=1;
		}

		// Do the actual on-time pause.
		TinyPause((unsigned char)PauseTime,PrescaleFactor);


		if( RestartCycle )
		{	// Revolution interrupt occurred - we're done with this run.
			// Extinguish output
			if( style & INVERTED_TEXT )
			{	PORTA=PORTB=0xff;
			}
			else
			{	PORTA=PORTB=0x00;
			}
			return;
		}
	}	// End for() loop

	if( ! (style & ADJACENT_CHARACTERS) )
	{	// Create a small gap between characters
		if( style & INVERTED_TEXT )
		{	PORTA=PORTB=0xff;
		}
		else
		{	PORTA=PORTB=0x00;
		}

		// Calculate size of gap based on speed (for stable display)
		// Time how long the calculation takes (it's significant!)
		OCR0A=0xff;			// Set top to MAX (which we hopefully won't reach)
		TCNT0=0;				// Set counter to zero
		TCCR0B |= (1<<CS01)|(1<<CS00);						// Start timer
		PauseTime=(int)( (float)((float)Clicks*CONST_OFFTIME) );
		PauseTime-=TCNT0;	// Subtract calculation time
		TCCR0B &= ~( (1<<CS02)|(1<<CS01)|(1<<CS00) );	// Stop timer

		// Now if we are moving very slowly (say, below 10 MPH), we need to
		// adjust our timer so we can wait even longer periods of time to
		// keep the display stable.
		if( Clicks > SLOW_SPEED_TRANSITION )
		{	PrescaleFactor=PRESCALE_256;
			PauseTime/=4;
		}

		// Final sanity check
		if( PauseTime > 255 )
		{	PauseTime=255;
		}
		else if( PauseTime <= 0 )
		{	PauseTime=1;
		}

		// Do the actual pause for our gap between characters
		TinyPause((unsigned char)PauseTime,PrescaleFactor);
	}	// End if() for styles
}	// End function ShowChar8()


//////////////////////////////////////////////////////////////////////////////
// GetTptr8() - function maps an ASCII character to its dot definition.
//
// Parameters:
//    unsigned char character [in] - the character to be displayed.
//    unsigned char *tptr [out] - pointer to dot definition.
//
// Returns:
//    (none)
//////////////////////////////////////////////////////////////////////////////
void
GetTptr8(unsigned char character, unsigned char **tptr)
{
	switch(character)
	{
		//
		// Space Invaders
		//
		case SI_1: *tptr=si_1; break;
		case SI_2: *tptr=si_2; break;
		case SI_3: *tptr=si_3; break;
		case SI_4: *tptr=si_4; break;

		case Notes: *tptr=notes; break;

		case 'A': *tptr=A; break;
		case 'B': *tptr=B; break;
		case 'C': *tptr=C; break;
		case 'D': *tptr=D; break;
		case 'E': *tptr=E; break;
		case 'F': *tptr=F; break;
		case 'G': *tptr=G; break;
		case 'H': *tptr=H; break;
		case 'I': *tptr=I; break;
		case 'J': *tptr=J; break;
		case 'K': *tptr=K; break;
		case 'L': *tptr=L; break;
		case 'M': *tptr=M; break;
		case 'N': *tptr=N; break;
		case 'O': *tptr=O; break;
		case 'P': *tptr=P; break;
		case 'Q': *tptr=Q; break;
		case 'R': *tptr=R; break;
		case 'S': *tptr=S; break;
		case 'T': *tptr=T; break;
		case 'U': *tptr=U; break;
		case 'V': *tptr=V; break;
		case 'W': *tptr=W; break;
		case 'X': *tptr=X; break;
		case 'Y': *tptr=Y; break;
		case 'Z': *tptr=Z; break;

		case 'a': *tptr=a; break;
		case 'c': *tptr=c; break;
		case 'e': *tptr=e; break;
		case 'i': *tptr=i; break;
		case 'g': *tptr=g; break;
		case 'l': *tptr=l; break;
		case 'm': *tptr=m; break;
		case 'n': *tptr=n; break;
		case 'o': *tptr=o; break;
		case 'p': *tptr=p; break;
		case 'r': *tptr=r; break;
		case 't': *tptr=t; break;
		case 'u': *tptr=u; break;

		case '1': *tptr=num_1; break;
		case '2': *tptr=num_2; break;
		case '3': *tptr=num_3; break;
		case '4': *tptr=num_4; break;
		case '5': *tptr=num_5; break;
		case '6': *tptr=num_6; break;
		case '7': *tptr=num_7; break;
		case '8': *tptr=num_8; break;
		case '9': *tptr=num_9; break;
		case '0': *tptr=num_0; break;

		case ' ': *tptr=Punct_Space; break;
		case '!': *tptr=Punct_Exclaim; break;
		case '?': *tptr=Punct_Question; break;
		case ':': *tptr=Punct_Colon; break;
		case ',': *tptr=Punct_Comma; break;
		case '.': *tptr=Punct_Period; break;
		case '_': *tptr=Punct_Underline; break;
		case '-': *tptr=Punct_Minus; break;
		case '/': *tptr=Punct_Slash; break;
		case ';': *tptr=Punct_Semicolon; break;
		case '#': *tptr=Punct_Pound; break;
		case '$': *tptr=Punct_Dollar; break;
		case '%': *tptr=Punct_Percent; break;
		case '&': *tptr=Punct_Ampersand; break;
		case '=': *tptr=Punct_Equals; break;
		case '+': *tptr=Punct_Plus; break;
		case '<': *tptr=Punct_LessThan; break;
		case '>': *tptr=Punct_GreaterThan; break;
		case '\'': *tptr=Punct_Tic; break;
		case '"': *tptr=Punct_DoubleQuotes; break;
		case '(': *tptr=Punct_OpenParen; break;
		case ')': *tptr=Punct_CloseParen; break;

		default:  *tptr=Punct_Question; break;
	}	// End switch()
}	// End function GetTptr8()


//////////////////////////////////////////////////////////////////////////////
// ShowChar15() - function displays a single 15-dot character on the POV device.
//
// Parameters:
//    unsigned char character [in] - the character to be displayed.
//    int size [in] - the number of columns which comprise the character.
//    char style [in] - controls the way in which the character is displayed.
//         (i.e., reverse video, etc)
//
// Returns:
//    (none)
//////////////////////////////////////////////////////////////////////////////
void
ShowChar15(unsigned char character, char style)
{
	unsigned char (*tptr)[2];
	int countF, countB, size;


	PrescaleFactor=PRESCALE_64;

	switch(character)
	{
//		case CCC: tptr=ccc; size=sizeof(ccc)/2; break;			// web address
//		case Discs: tptr=discs; size=sizeof(discs)/2; break;	// 5.25"
//		case Flame: tptr=flame; size=sizeof(flame)/2; break;
//		case LightningBolt: tptr=lightningbolt; size=sizeof(lightningbolt)/2;
//			break;

		case ALLSUITS: tptr=allsuits; size=sizeof(allsuits)/2; break;
		case BLACKBAT: tptr=blackbat; size=sizeof(blackbat)/2; break;
		case CHECKERED: tptr=checkered; size=sizeof(checkered)/2; break;
		case MULTIDOTS: tptr=multidots; size=sizeof(multidots)/2; break;
		case OPPOSEDTREES: tptr=opposedtrees; size=sizeof(opposedtrees)/2; break;
		case OPPOSEDTRIANGLES: tptr=opposedtriangles;
			size=sizeof(opposedtriangles)/2; break;
		case WAVYTRIANGLES: tptr=wavytriangles; size=sizeof(wavytriangles)/2;
			break;
		case Bug: tptr=bug; size=sizeof(bug)/2; break;
		case Circuit: tptr=circuit; size=sizeof(circuit)/2; break;
		case Egypt: tptr=egypt; size=sizeof(egypt)/2; break;
//		case AnalogClock: tptr=analogclock; size=sizeof(analogclock)/2; break;

//		case ENVELOPE: tptr=envelope; break;
//		case SLANTYSTRIPES: tptr=slantystripes; break;
//		case STAR_1: tptr=star_1; break;
//		case TRACEFAMILY: tptr=tracefamily; break;
//		case TRIANGLEXES: tptr=trianglexes; break;
//		case Jack_O_Lantern: tptr=jack_o_lantern; break;
//		case Ghost: tptr=ghost; break;
//		case Grid: tptr=grid; break;
//		case SkullSolid: tptr=skull_solid; break;


		default:  tptr=egypt; size=sizeof(egypt)/2; break;
	}	// End switch()


	for(countF=0,countB=size-1;countF<size&&countB>=0;countF++,countB--)
	{	if( style & INVERTED_TEXT )
		{	PORTA=~(tptr[countF][0]);		// front side, top half
			PORTB=~(tptr[countB][0]);		// back side, top half
			PORTC=~(tptr[countF][1]);		// front side, bottom half
			PORTD=~(tptr[countB][1]);		// back side, bottom half
		}
		else
		{	PORTA=tptr[countF][0];			// front side, top half
			PORTB=tptr[countB][0];			// back side, top half
			PORTC=tptr[countF][1];			// front side, bottom half
			PORTD=tptr[countB][1];			// back side, bottom half
		}

		// Next we'll calculate on-time based on speed (for a stable display).
		// We also need to time how long this calculation takes so we can
		// subtract it from the total on-time. Floating point arithmetic
		// is extremely slow, so we really need to allow for it here.
		// At 1MHz MCU speed, it is so slow that it took twice as long to
		// do the arithmetic as we wanted to wait. Adding the actual wait
		// on top of that made the characters 3 times as wide as desired.
		OCR0A=0xff;			// Set top to MAX (which we hopefully won't reach)
		TCNT0=0;				// Set counter to zero
		TCCR0B |= (1<<CS01)|(1<<CS00);						// Start timer
		PauseTime=(int)( (float)((float)Clicks*CONST_ONTIME) );
		PauseTime-=TCNT0;	// Subtract calculation time
		TCCR0B &= ~( (1<<CS02)|(1<<CS01)|(1<<CS00) );	// Stop timer

		// Now if we are moving very slowly (say, below 10 MPH), we need to
		// adjust our timer so we can wait even longer periods of time to
		// keep the display stable.
		if( Clicks > SLOW_SPEED_TRANSITION )
		{	PrescaleFactor=PRESCALE_256;
			PauseTime/=4;
		}

		// Final sanity check
		if( PauseTime > 255 )
		{	PauseTime=255;
		}
		else if( PauseTime <= 0 )
		{	PauseTime=1;
		}

		// Do the actual on-time pause.
		TinyPause(PauseTime,PrescaleFactor);

		if( RestartCycle )
		{	// Revolution interrupt occurred - we're done with this run.
			// Extinguish output
			if( style & INVERTED_TEXT )
			{	PORTA=PORTB=0xff;
				PORTC=PORTD=0xfe;
			}
			else
			{	PORTA=PORTB=PORTC=PORTD=0x00;
			}
			return;
		}
	}	// End for() loop

	if( ! (style & ADJACENT_CHARACTERS) )
	{	// Create a small gap between characters
		if( style & INVERTED_TEXT )
		{	PORTA=PORTB=0xff;
			PORTC=PORTD=0xfe;
		}
		else
		{	PORTA=PORTB=PORTC=PORTD=0x00;
		}

		// Calculate size of gap based on speed (for stable display)
		// Time how long the calculation takes (it's significant!)
		OCR0A=0xff;			// Set top to MAX (which we hopefully won't reach)
		TCNT0=0;				// Set counter to zero
		TCCR0B |= (1<<CS01)|(1<<CS00);						// Start timer
		PauseTime=(int)( (float)((float)Clicks*CONST_OFFTIME) );
		PauseTime-=TCNT0;
		TCCR0B &= ~( (1<<CS02)|(1<<CS01)|(1<<CS00) );	// Stop timer

		// Now if we are moving very slowly (say, below 10 MPH), we need to
		// adjust our timer so we can wait even longer periods of time to
		// keep the display stable.
		if( Clicks > SLOW_SPEED_TRANSITION )
		{	PrescaleFactor=PRESCALE_256;
			PauseTime/=4;
		}

		// Final sanity check
		if( PauseTime > 255 )
		{	PauseTime=255;
		}
		else if( PauseTime <= 0 )
		{	PauseTime=1;
		}

		// Do the actual pause for our gap between characters
		TinyPause(PauseTime,PrescaleFactor);
	}	// End if() for styles
}	// End function ShowChar15()


//////////////////////////////////////////////////////////////////////////////
// PowerOnVisual() - Do a little light show so user knows board is on/working.
//////////////////////////////////////////////////////////////////////////////
void
PowerOnVisual()
{
	int Slot, iters;

	for(iters=0;iters<2;iters++)
	{	// Move down the top 8 bits
		for(Slot=0;Slot<8;Slot++)
		{	PORTA=PORTB=(1<<Slot);
			TinyPause((char)80,PRESCALE_1024);
		}
		PORTA=PORTB=0x00;
		// Move down the bottom 7 bits
		for(Slot=0;Slot<7;Slot++)
		{	PORTC=PORTD=(1<<Slot);
			TinyPause((char)80,PRESCALE_1024);
		}
		// Move up the bottom 7 bits
		for(Slot=5;Slot>=0;Slot--)
		{	PORTC=PORTD=(1<<Slot);
			TinyPause((char)80,PRESCALE_1024);
		}
		PORTC=PORTD=0x00;
		// Move up the top 8 bits.
		// We use "Slot>=1" instead of "Slot>=0" for our test condition
		// because we don't want to repeat the top dot when "bouncing",
		// which would cause the bounce to hang on the top dot just a bit
		// too long. This requires us to hit the top dot manually after the
		// outer loop completes so it isn't skipped on the last run.
		for(Slot=7;Slot>=1;Slot--)
		{	PORTA=PORTB=(1<<Slot);
			TinyPause((char)80,PRESCALE_1024);
		}
	}	// End for() loop
	// Pickup the top LED which was missed in the last iteration of the loop
	PORTA=PORTB=(1<<0);
	TinyPause((char)80,PRESCALE_1024);
	PORTA=PORTB=PORTC=PORTD=0x00;		// Clear (turn off) all ports
}	// End function PowerOnVisual()


//////////////////////////////////////////////////////////////////////////////
// ShowString8() - function displays a string to the POV device similarly
//    to the ShowChar*() functions, but reverses the string on the right
//    side of the board/bike as well as each character.
//
// Parameters:
//    unsigned char *string [in] - the string to be displayed.
//    char style [in] - controls the way in which the characters are displayed.
//         (i.e., reverse video, etc)
//
// Returns:
//    (none)
//
// Notes:
//    This implementation requires a fixed-width font. For a variable-width
//    font it would be necessary to build a super-character which is really
//    just one big character consisting of all the data from each individual
//    character concatenated into one entity. That super-character could then
//    be passed to the regular ShowChar8() function, which handles mirroring
//    the character automatically.
//////////////////////////////////////////////////////////////////////////////
void
ShowString8(char *string, char style)
{
	if( ! string )
	{	return;
	}

	PrescaleFactor=PRESCALE_64;

	// Calculate "on" and "off" times based on speed (for a stable display).
	OnPauseTime=(int)( (float)((float)Clicks*CONST_ONTIME) );

	// Now if we are moving very slowly (say, below 10 MPH), we need to
	// adjust our prescaler so we can wait even longer periods of time to
	// keep the display stable.
	if( Clicks > SLOW_SPEED_TRANSITION )
	{	PrescaleFactor=PRESCALE_256;
		OnPauseTime/=4;
	}

	// Final sanity check
	if( OnPauseTime > 255 )
	{	OnPauseTime=255;
	}
	else if( OnPauseTime <= 0 )
	{	OnPauseTime=1;
	}

	if( RestartCycle )
	{	return;
	}

	// Now calculate "Off" time
	if( ! (style & ADJACENT_CHARACTERS) )
	{	OffPauseTime=(int)( (float)((float)Clicks*CONST_OFFTIME) );

		// Now if we are moving very slowly (say, below 10 MPH), we need to
		// adjust our timer so we can wait even longer periods of time to
		// keep the display stable.
		if( Clicks > SLOW_SPEED_TRANSITION )
		{	//PrescaleFactor=PRESCALE_256;	// Already done for "on" time.
			OffPauseTime/=4;
		}

		// Final sanity check
		if( OffPauseTime > 255 )
		{	OffPauseTime=255;
		}
		else if( OffPauseTime <= 0 )
		{	OffPauseTime=1;
		}
	}


	if( RestartCycle )
	{	return;
	}

	// Now display the characters
	int size=7;		// Size (in bytes) of 8-dot character
	int idxLeft, idxRight, countLeft, countRight;
	unsigned char *tptrLeft, *tptrRight;
	for(idxLeft=0, idxRight=strlen(string)-1;
		idxLeft<strlen(string) && idxRight>=0;
		idxLeft++, idxRight--)
	{	// Get character definition pointers
		GetTptr8(string[idxLeft],&tptrLeft);
		GetTptr8(string[idxRight],&tptrRight);
		if( RestartCycle )
		{	break;
		}


		for(countLeft=0,countRight=size-1;
			countLeft<size && countRight>=0;
			countLeft++,countRight--)
		{	if( style & INVERTED_TEXT )
			{	PORTA=~(tptrLeft[countLeft]);		// Dark text, light background
				PORTB=~(tptrRight[countRight]);
			}
			else
			{	PORTA=tptrLeft[countLeft];			// Light text, dark background
				PORTB=tptrRight[countRight];
			}

			// Do the actual on-time pause.
			TinyPause((unsigned char)OnPauseTime,PrescaleFactor);

			if( RestartCycle )
			{	// Revolution interrupt occurred - we're done with this run.
				// Extinguish output
				if( style & INVERTED_TEXT )
				{	PORTA=PORTB=0xff;
				}
				else
				{	PORTA=PORTB=0x00;
				}
				return;
			}
		}	// End for() loop


		// Create a small gap between characters
		if( ! (style & ADJACENT_CHARACTERS) )
		{	if( style & INVERTED_TEXT )
			{	PORTA=PORTB=0xff;
			}
			else
			{	PORTA=PORTB=0x00;
			}
			// Do the actual pause for our gap between characters
			TinyPause((unsigned char)OffPauseTime,PrescaleFactor);
		}	// End if() for "off" time
	}	// End for() loop


	// Turn off display after run.
	if( style & INVERTED_TEXT )
	{	PORTA=PORTB=0xff;
	}
	else
	{	PORTA=PORTB=0x00;
	}
}	// End function ShowString8()


//////////////////////////////////////////////////////////////////////////////
// ShowSpeed() - function displays speed in MPH, and possibly other info
//    as needed, such as distance traveled or clicks/revolution.
//////////////////////////////////////////////////////////////////////////////
void
ShowSpeed()
{
	volatile char text[50];

	// If we are moving too slowly, extinguish output
	if( Clicks > MIN_SPEED )
	{	PORTA=PORTB=PORTC=PORTD=0x00;
		return;
	}

	// Calculate MPH
	MPH=CONST_26_INCH_WHEEL / (float)Clicks;
	volatile int LeftPart=(int)MPH;
	volatile int RightPart=(int)( (MPH-(float)LeftPart)*100.0 );

	// Calculate fractional-mile distance traveled
	int FractionalMiles=(Revolutions*100)/REVS_PER_MILE;

	// Output results
	sprintf((char *)text,"%d.%02d MPH  %d.%02d MILES",
		LeftPart,RightPart,Miles,FractionalMiles);
	if( RestartCycle )
	{	return;
	}
	ShowString8((char *)text,DEFAULT_STYLE);

	return;
}	// End function ShowSpeed()


void
ShowSpaceInvaders()
{
	ShowChar8(SI_1,DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(' ',DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(SI_2,DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(' ',DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(SI_3,DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(' ',DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(SI_4,DEFAULT_STYLE);
	if( RestartCycle ) return;
	ShowChar8(' ',DEFAULT_STYLE);
	return;
}	// End function ShowSpaceInvaders()