#include <stdio.h>
#include <stdlib.h>

#include "c8051f350.h"

#define PULLUP1 P1_4	// 10k pullup resistor on channel 1 (0=ON, 1=OFF)
#define PULLDN1 P1_5	// 10k pulldown resistor on channel 1 (0=OFF, 1=ON)
#define PULLUP2 P0_0	// 10k pullup resistor on channel 2 (0=ON, 1=OFF)
#define PULLDN2 P0_1	// 10k pulldown resistor on channel 2 (0=OFF, 1=ON)
#define LED P0_6		// on board LED

unsigned char BinaryData=0;

// Peripheral specific initialization functions,
// Called from the Init_Device() function
void PCA_Init()
{
	PCA0MD    &= ~0x40;	// disable watchdog timer
	PCA0MD    = 0x00;
}

void Timer_Init()
{
	TCON      = 0x40;	// enable Timer 1
	TMOD      = 0x20;	// Timer 1 mode is 8-bit auto reload
	CKCON     = 0x08;	// Timer 1 timebase is system clock (24,5MHz)
	TH1       = 0xCB;	// configure timers for 230400 bit/s UART data rate
}

void UART_Init()
{
	SCON0     = 0x10;	// enable UART for 8-bit, variable baud mode
	TI=1;			// set this flag to indicate empty output buffer
}

// Configure the ADC:
// 10Hz sample rate, unipolar mode
// gain=1, internal voltage reference
// analog input buffers are bypassed
// ADC input is Channel 2 and Channel 1
void ADC_Init()
{
	ADC0MD    = 0x80;	// disable ADC, will be enabled later
	ADC0CN    = 0x10;
	ADC0CLK   = 0x09;	// 10Hz sample rate
	ADC0DECH  = 0x07;	// 10Hz sample rate
	ADC0DECL  = 0x79;	// 10Hz sample rate
	ADC0MUX   = 0x32;	// default ADC multiplexer selection is ADC positive=Input1 and ADC negative=Input2
}

void Voltage_Reference_Init()
{
	REF0CN    = 0x03;	// enable internal reference and bias generator
}

void Port_IO_Init()
{
	// P0.0  -  Unassigned,  Open-Drain, Digital
	// P0.1  -  Unassigned,  Open-Drain, Digital
	// P0.2  -  Unassigned,  Open-Drain, Digital
	// P0.3  -  Unassigned,  Open-Drain, Digital
	// P0.4  -  TX0 (UART0), Push-Pull,  Digital
	// P0.5  -  RX0 (UART0), Open-Drain, Digital
	// P0.6  -  Unassigned,  Push-Pull,  Digital
	// P0.7  -  Unassigned,  Open-Drain, Digital

	// P1.0  -  Unassigned,  Open-Drain, Digital
	// P1.1  -  Unassigned,  Open-Drain, Digital
	// P1.2  -  Unassigned,  Open-Drain, Digital
	// P1.3  -  Unassigned,  Open-Drain, Digital
	// P1.4  -  Unassigned,  Open-Drain, Digital
	// P1.5  -  Unassigned,  Open-Drain, Digital
	// P1.6  -  Unassigned,  Open-Drain, Digital
	// P1.7  -  Unassigned,  Open-Drain, Digital

	P0MDOUT   = 0x50;
	XBR0      = 0x01;
	XBR1      = 0x40;
}

void Oscillator_Init()
{
	OSCICN    = 0x83;	// internal oscillator, 24.5MHz
}

// Initialization function for device,
void Init_Device(void)
{
	PCA_Init();
	Timer_Init();
	UART_Init();
	ADC_Init();
	Voltage_Reference_Init();
	Port_IO_Init();
	Oscillator_Init();
}

/**************************************************************************
waits for the specified time
***************************************************************************/
void Delay_ms(unsigned int ms)
{
	unsigned int i;
	for(i=0; i<ms; i++)
	{
		{	// this code will take 1ms
			__asm
				mov b,#25		// put here the system clock frequency in MHz
			00001$:
				mov a,#250		// 3 cycles
			00002$:
				djnz acc,00002$ // 4 cycles
				djnz b,00001$	// 3 cycles
			__endasm;
		}
	}
}

/**************************************************************************
Wait for a byte from serial port (UART1-FT232RL USB) 
***************************************************************************/
char SIn(void)
{
	while (!RI);	// wait for a byte
	RI=0;		// clear receive flag
	return SBUF;	// return the byte
}

/**************************************************************************
sends a byte over the serial port to the host computer
***************************************************************************/
void SOut(unsigned char a)
{
	while (!TI);	// wait for end of possible previous transmission
	TI=0;		// clear transmit flag
	SBUF=a;		// put the byte into the transmit buffer
}

/**************************************************************************
waits for a byte, and when arrived, sends back and returns the value
software handshaking for guaranteed data reception
***************************************************************************/
unsigned char SInOut(void)
{
	unsigned char c;

	c=SIn();	// wait for a byte
	while (!TI0);	// wait for end of possible previous transmission
	TI0=0;		// clear transmit flag
	SBUF0=c;	// put received byte to transmit buffer
	return c;	// return the received byte
}

/**************************************************************************
Performs internal ADC calibration. Call it after reset and also when a 
continuous measurement started
***************************************************************************/
void CalibrateADC(void)
{
	ADC0MD = 0x81;			// ADC0 MODE: FULL INTERNAL CALIBRATION 
	while(AD0CBSY); 		// end of cal step 
	while(ADC0MD & 0x07); 	// wait return to IDLE!!! 
	AD0INT=0;
}

/**************************************************************************
Initiates a single A/D conversion and sends the result to the host
***************************************************************************/
void SingleSample(void)
{
	unsigned char c;
	unsigned char x=0;
	
	ADC0MD = 0x82;				// enable ADC in single conversion mode
	while(!AD0INT); 			// wait for end of conversion 
	AD0INT=0;				// clear flag
	if (BinaryData)				// if data must be sent in binary form
	{
		SOut(ADC0H);			// send ADC most significant byte
		SOut(ADC0M);			// send ADC middle byte
		SOut(ADC0L);			// send ADC least significant byte
	}
	else
	{
		long x;
		((char *)&x)[3] = ((ADC0H & 0x80) && (ADC0CN & 0x10)) ? 0xFF:00;
		((char *)&x)[2] = ADC0H;
		((char *)&x)[1] = ADC0M;
		((char *)&x)[0] = ADC0L;
		printf("%ld\r",x);		// send data in decimal format
	}
	if (RI) c=SIn();			// check if any byte has been received
	ADC0MD = 0x80;				// disable ADC
}

/**************************************************************************
Starts continuos sampling. Every sample will be sent to the host
Sending an ESC character (27) will abort the process
***************************************************************************/
void ContSampling(void)
{
	unsigned char c;
	unsigned char x=0;
	
	CalibrateADC();				// ADC calibration is required before measurements
	c=0;					// initialize UART input variable, will be used to detect request to terminate sampling
	ADC0MD = 0x83;				// enable ADC
	do
	{
		while(!AD0INT); 		// wait for end of conversion 
		AD0INT=0;			// clear flag
		if (BinaryData)
		{
			SOut(ADC0H);			// send ADC most significant byte
			SOut(ADC0M);			// send ADC middle byte
			SOut(ADC0L);			// send ADC least significant byte
		}
		else
		{
			long x;
			((char *)&x)[3] = ((ADC0H & 0x80) && (ADC0CN & 0x10)) ? 0xFF:00;
			((char *)&x)[2] = ADC0H;
			((char *)&x)[1] = ADC0M;
			((char *)&x)[0] = ADC0L;
			printf("%ld\r",x);		// send data in decimal format
		}
		if (RI) c=SIn();
	} while (c!=27);	// stop if ESC has been received
	ADC0MD = 0x80;		// disable the ADC
}

/**************************************************************************
Sends an identification string to the host
***************************************************************************/
void SendID()
{
	printf("EDAQ24 (c) 12/01/2011 www.inf.u-szeged.hu/~gingl/edaq24\r");
}

/**************************************************************************
Used by the standar I/O library, e.g. for the prinf function
***************************************************************************/
void putchar(char c)
{
	SOut(c);
}

void main(void)
{
	char c;

	Init_Device();	

	CalibrateADC();				// ADC calibration is required before measurements

	PULLUP1=1;		// 10k pullup resistor on channel 1 (0=ON, 1=OFF)
	PULLDN1=0;		// 10k pulldown resistor on channel 1 (0=OFF, 1=ON)
	PULLUP2=1;		// 10k pullup resistor on channel 2 (0=ON, 1=OFF)
	PULLDN2=0;		// 10k pulldown resistor on channel 2 (0=OFF, 1=ON)
	ADC0MUX   = 0x23;	// set ADC differential inputs to Input1 and Input2 


	for(c=0; c<3; c++)	// flash the power LED three times to indicate booting
	{
		LED=1;	Delay_ms(200);
		LED=0;	Delay_ms(200);
	}
	LED=1;

	while (1)
	{
		while (SInOut()!='@');	// all commands must be started with a '@' character
		c=SInOut();
		if (c=='I')			// send identification string command
		{
			SendID();
		}
		else if (c=='T') 		// set ADC data format to text
		{
			BinaryData = 0;
		}
		else if (c=='t') 		// set ADC data format to binary
		{
			BinaryData = 1;
		}
		else if (c=='s')		// measure a single sample with the current settings
		{
			SingleSample();
		}
		else if (c=='S') 		// start continuous sampling and data streaming, ESC exits
		{
			ContSampling();
		}
		else if (c=='f') 		// set sampling frequency
		{
			c=SInOut();
			ADC0CLK   = 0x09;
			if (c=='1') 		ADC0DECH  = 0x07, ADC0DECL  = 0x79;	// 10Hz
			else if (c=='2') 	ADC0DECH  = 0x03, ADC0DECL  = 0xBC;	// 20Hz
			else if (c=='5') 	ADC0DECH  = 0x01, ADC0DECL  = 0x7E;	// 50Hz
			else if (c=='A') 	ADC0DECH  = 0x00, ADC0DECL  = 0xBE;	// 100Hz
			else if (c=='B') 	ADC0DECH  = 0x00, ADC0DECL  = 0x5F;	// 200Hz
			else if (c=='C') 	ADC0DECH  = 0x00, ADC0DECL  = 0x25;	// 500Hz
		}
		else if (c=='c') 		// do calibration
		{
			CalibrateADC();
		}
		else if (c=='C') 		// select channel (1: ch1, 2:ch2, 3:ch2-ch1; 4:ch1-ch2
		{
			c=SInOut();
			if (c=='0') ADC0MUX = 0x88;		// both inputs are grounded
			else if (c=='1') ADC0MUX = 0x28;	// Channel 1 - GND
			else if (c=='2') ADC0MUX = 0x38;	// Channel 2 - GND
			else if (c=='3') ADC0MUX = 0x32;	// Channel 2 - Channel 1
			else if (c=='4') ADC0MUX = 0x23;	// Channel 1 - Channel 2
			else if (c=='c') ADC0MUX = 0x78;	// cold junction compensator thermstor, 10k, B=4350
			else if (c=='d') ADC0MUX = 0x18;	// Dac 0 - GND
			else if (c=='D') ADC0MUX = 0x08;	// Dac 1 - GND
			else if (c=='T') ADC0MUX = 0xFF;	// Temp sensor in differential mode
		}
		else if (c=='a') 		// select input buffer amplifier configuration for negative input
		{
			c=SInOut();
			if (c=='0') ADC0BUF = ADC0BUF & 0xF0;			// bypass buffers
			else if (c=='L') ADC0BUF = (ADC0BUF & 0xF0) | 0x05;	// low buffer is on
			else if (c=='H') ADC0BUF = (ADC0BUF & 0xF0) | 0x0A;	// high buffer is on
		}
		else if (c=='d') 		// set DAC0
		{
			unsigned char c;
			if (BinaryData)
			{
				c=SInOut();
			}
			else
			{
				c=(SInOut()-'0')*100;
				c=c+(SInOut()-'0')*10;
				c=c+(SInOut()-'0');
			}
			IDA0=c;
		}
		else if (c=='D') 		// set DAC1
		{
			unsigned char c;
			if (BinaryData)
			{
				c=SInOut();
			}
			else
			{
				c=(SInOut()-'0')*100;
				c=c+(SInOut()-'0')*10;
				c=c+(SInOut()-'0');
			}
			IDA1=c;
		}
		else if (c=='A') 		// select input buffer amplifier configuration for positive input
		{
			c=SInOut();
			if (c=='0') ADC0BUF = ADC0BUF & 0x0F;			// bypass buffers
			else if (c=='L') ADC0BUF = (ADC0BUF & 0x0F) | 0x50;	// low buffer is on
			else if (c=='H') ADC0BUF = (ADC0BUF & 0x0F) | 0xA0;	// high buffer is on
		}
		else if (c=='b') 		// select unipolar operation
		{
			ADC0CN = ADC0CN & 0x7F;
		}
		else if (c=='B') 		// select bipolar operation
		{
			ADC0CN = ADC0CN | 0x80;
		}
		else if (c=='G') 		// select gain as 2^x, where x can be 0..7
		{
			c=SInOut();
			if (c<'0') c='0';
			if (c>'7') c='7';
			ADC0CN = (ADC0CN & 0xF8) | ((c-'0') & 0x7);
		}
		else if (c=='1') 		// input 1, switch pullup and down resistors on or off
		{
			c=SInOut();
			if (c=='U') PULLUP1 = 0;	// switch pullup on
			else if (c=='u') PULLUP1 = 1;	// switch pullup off
			else if (c=='D') PULLDN1 = 1;	// switch pulldown on
			else if (c=='d') PULLDN1 = 0;	// switch pulldown off
		}
		else if (c=='2') 		// input 2, switch pullup and down resistors on or off
		{
			c=SInOut();
			if (c=='U') PULLUP2 = 0;	// switch pullup on
			else if (c=='u') PULLUP2 = 1;	// switch pullup off
			else if (c=='D') PULLDN2 = 1;	// switch pulldown on
			else if (c=='d') PULLDN2 = 0;	// switch pulldown off
		}
		else if (c=='p') 		// get port bits
		{
			if (BinaryData)
			{
				SOut((P0 >> 7) | ((P1 & 0x0F) << 1));
			}
			else
			{
				SOut((P0_7) ? '1':'0');
				SOut((P1_0) ? '1':'0');
				SOut((P1_1) ? '1':'0');
				SOut((P1_2) ? '1':'0');
				SOut((P1_3) ? '1':'0');
			}
		}
		else if (c=='P') 		// get port bits
		{
			if (BinaryData)
			{
				c=SInOut();
				P0_7 = c & 1;
				P1_0 = c & 2;
				P1_1 = c & 4;
				P1_2 = c & 8;
				P1_3 = c & 16;
			}
			else
			{
				P0_7 = SInOut() & 1;
				P1_0 = SInOut() & 1;
				P1_1 = SInOut() & 1;
				P1_2 = SInOut() & 1;
				P1_3 = SInOut() & 1;
			}
		}
		else if (c=='x') 		// write ADC configuration registers directly
		{
			ADC0CN    = SInOut();
			ADC0CF    = SInOut();
			ADC0CLK   = SInOut();
			ADC0DECH  = SInOut();
			ADC0DECL  = SInOut();
			ADC0DAC   = SInOut();
			ADC0BUF   = SInOut();
			ADC0MUX   = SInOut();
		}
		else if (c=='X') 		// configure DACs and GPIO
		{
			IDA0CN    = (SInOut()=='0') ? 0x72:0xF2;
			IDA1CN    = (SInOut()=='0') ? 0x72:0xF2;
			c=((SInOut()-'0') & 1) << 4;
			c=c | ((SInOut()-'0') & 0x0F);
			P0MDOUT   = (P1MDOUT & 0x80) | (c << 7);
			P1MDOUT   = (P1MDOUT & 0x0F) | (c >> 1);
		}
	}
}