/elec/quadcopter

//
// main.ino
//
// Testing to see if we can read all 8 channels, multiplexed together on to two
// interrupts (odd channels on one, and even on the other).  We read the
// channels by measuring the pulse width.
//
// Ideally, it would be nice if we could read the raw PPM stream from the
// receiver.  Sometimes you can open up your receiver and get to this stream,
// but we have been unable.  And since this isn't guaranteed to ever be
// available, reading the analogue outputs is certainly more portable.  So, we
// are multiplexing the separate channels to two streams of pulses, like this:
//
//     ch.1  ch.3  ch.5  ch.7  ch.2  ch.4  ch.6  ch.8
//       |     |     |     |     |     |     |     |
//       ▼     ▼     ▼     ▼     ▼     ▼     ▼     ▼
//       ¯     ¯     ¯     ¯     ¯     ¯     ¯     ¯
//       |     |     |     |     |     |     |     |
//       '-----+-----+-----+     +-----+-----+-----'
//                         |     |
//    ____________________ | ___ | _____________________
//                         |     |
//         (int. 0) pin 2  o     o  pin 3 (int. 1)
//
// (Note that on our receiver, and contrary to the above diagram, the channels
// are not actually sent in order.  Channels 2 and 3 are reversed.  To this end,
// the order that channels are received can be adjusted below.)


#include <limits.h>


// minimum pulse width (in ms), used to weed out crappy signals
#define MIN_PULSE_WIDTH 1000UL

// maximum pulse width (in ms), used to weed out crappy signals
#define MAX_PULSE_WIDTH 2000UL

// number of channels
#define NUM_CHANNELS 8

// minimum frame gap time (in ms), used to check that the frame gap is where we
// expect it to be and that we have read the channels properly
#define MIN_FRAME_GAP_WIDTH ( 4000UL + MIN_PULSE_WIDTH )

// the width of the display of a single channel (in chars)
#define GRAPH_SIZE 7

// the channel's expected range for use in drawing (should be similar to
// {MAX,MIN}_PULSE_WIDTH values)
#define GRAPH_MIN 1000
#define GRAPH_MAX 2000


// channel sequence order
const int channel_order_[] = { 1, 3, 2, 4, 5, 6, 7, 8 };

// set to the time of the last pulse edges
static unsigned long new_pulse_up_[2] = { 0, 0 };
static unsigned long new_pulse_down_ = 0;
static char new_pulse_interrupt_;


// ISR to handle the PPM signals
inline void signal_handler( int interrupt, int pin )
{
	// record rising/falling edge
	if( digitalRead( pin ) )
		new_pulse_up_[ interrupt ] = micros();
	else {
		new_pulse_down_ = micros();

		// record which interrupt just had a falling edge
		new_pulse_interrupt_ = interrupt;
	}
}
void signal_handler_0()
{
	signal_handler( 0, 2 );
}
void signal_handler_1()
{
	signal_handler( 1, 3 );
}


void setup()
{
	// set up an interrupts
	attachInterrupt( 0, signal_handler_0, CHANGE );
	attachInterrupt( 1, signal_handler_1, CHANGE );
	digitalWrite( 2, LOW );
	digitalWrite( 3, LOW );

	Serial.begin( 9600 );
}


unsigned long calculate_duration( unsigned long then, unsigned long now )
{
	return now - then;
	
	if( now < then )
		return now + ( ULONG_MAX - then );
	else
		return now - then;
}


static int count_ = 0, good_ = 0;


bool read_channels( unsigned long channel_values[] )
{
	static unsigned long last_pulse_down = 0;
	static int next_channel = 0;

	// capture pulse values atomically
	noInterrupts();
	unsigned long pulse_up = new_pulse_up_[ new_pulse_interrupt_ ];
	unsigned long pulse_down = new_pulse_down_;
	char new_pulse_interrupt = new_pulse_interrupt_;
	interrupts();

	// if the amount of time that has passed since the last falling edge is
	// greater than the frame gap, reset the next channel so that we can start
	// reading them again
	if( next_channel &&
		new_pulse_interrupt == 1 &&
		calculate_duration( pulse_down, micros() ) > MIN_FRAME_GAP_WIDTH )
	{
		// reset the next channel (which restarts reading them)
		next_channel = 0;
	}

	// check for a new complete pulse
	if( pulse_down != last_pulse_down )
	{
		// are there still pulses to read?
		if( next_channel < NUM_CHANNELS )
		{
			unsigned long duration =
				calculate_duration( pulse_up, pulse_down );

			// does this pulse look ok?
			if( duration >= MIN_PULSE_WIDTH &&
				duration <= MAX_PULSE_WIDTH )
			{
				// store channel value
				int channel = channel_order_[ next_channel ] - 1;
				channel_values[ channel ] = duration;

				// we got a channel
				next_channel++;
			}
			else {
				// set invalid channel number (to indicate error)
				next_channel = NUM_CHANNELS + 1;
			}
		}

		last_pulse_down = pulse_down;
	}

	// if we've read a frame, invalidate the frame (so we don't report it a
	// second time) and return true
	if( next_channel == NUM_CHANNELS ) {
		next_channel++;
		return true;
	}
	
	return false;
}


void draw_graph( unsigned long channel_values[] )
{
	// init graph
	static char graph[ GRAPH_SIZE + 2 ];
	static char inited_graph = false;
	if( !inited_graph ) {
		for( int a = 1; a < GRAPH_SIZE + 1; a++ )
			graph[ a ] = '_';
		graph[ 0 ] = '|';
		graph[ GRAPH_SIZE + 1 ] = 0;
		inited_graph = true;
	}

	// draw channels
	for( int a = 0; a < NUM_CHANNELS; a++ ) {
		unsigned long value = max( 0,
			min( channel_values[ a ], GRAPH_MAX ) - GRAPH_MIN );
		int pos = ( GRAPH_SIZE ) * value / ( GRAPH_MAX - GRAPH_MIN );
		graph[ pos + 1 ] = '^';
		Serial.print( graph );
		graph[ pos + 1 ] = '_';
	}
	Serial.println( "|" );
}


void loop()
{
	unsigned long channel_values[ NUM_CHANNELS ];

	while( true )
	{
		if( read_channels( channel_values ) )
			draw_graph( channel_values );
	}
}