/*! \file megaio.c \brief MegaIO Control/Access function library. */
//*****************************************************************************
//
// File Name	: 'megaio.c'
// Title		: MegaIO Control/Access function library
// Author		: Pascal Stang - Copyright (C) 2004
// Created		: 5/18/2004
// Revised		: 5/18/2004
// Version		: 0.1
// Target MCU	: Atmel AVR series
// Editor Tabs	: 4
//
// This code is distributed under the GNU Public License
//		which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************

#include "buffer.h"		// include buffer support
#include "i2c.h"		// include I2C functions
#include "megaio/megaioreg.h"	// include MegaIO register definitions

#include "megaio.h"

// MegaIO local receive buffer size
#define MEGAIO_UART_RX_BUFFER_SIZE		0x80
// MegaIO local receive buffer data array
static char megaioUartRxData[MEGAIO_UART_RX_BUFFER_SIZE];
// MegaIO local receive buffer
cBuffer megaioUartRxBuffer;

//! initialize the MegaIO interface
u08 megaioInit(void)
{
	// initialize the UART receive buffer
	bufferInit(&megaioUartRxBuffer, megaioUartRxData, MEGAIO_UART_RX_BUFFER_SIZE);
	// initialize i2c interface
	i2cInit();
	i2cSetBitrate(30);
	// check for presence of megaio chip
	if( megaioReadReg(MEGAIOREG_IDSTRING, 1) == 'M' )
	{
		// megaio responded correctly
		// initialization succeeded
		return TRUE;
	}
	else
	{
		// megaio responded incorrectly
		// initialization failed
		return FALSE;
	}
}

//! write an 8-32 bit number to a MegaIO register
void megaioWriteReg(unsigned char regnum, unsigned char nbytes, unsigned long data)
{
	u08 packet[5];

	// construct I2c data packet
	//   first byte is register address
	//   following bytes are the data that will be written to that register
	packet[0] = regnum;
	packet[1] = data;
	packet[2] = data>>8;
	packet[3] = data>>16;
	packet[4] = data>>24;
	// send 2 bytes (register and data) to MegaIO
	i2cMasterSend(MEGAIO_I2C_ADDR, 1+nbytes, packet);
}

//! read an 8-32 bit number from a MegaIO register
unsigned long megaioReadReg(unsigned char regnum, unsigned char nbytes)
{
	unsigned long data = 0;

	// first select the register by writing 1 byte (register)
	i2cMasterSend(MEGAIO_I2C_ADDR, 1, &regnum);
	// then read n byte(s) from the selected MegaIO register
	i2cMasterReceive(MEGAIO_I2C_ADDR, nbytes, (u08*)&data);
	// return the results
	return data;
}

//! set the baudrate of the megaio serial port
void megaioSetBaudRate(u32 baudrate)
{
	megaioWriteReg(MEGAIOREG_UARTBAUD, 4, baudrate);
}

//! send a byte out the megaio serial port
void megaioSendByte(u08 data)
{
	megaioWriteReg(MEGAIOREG_UARTDATA, 1, data);
}

//! get a byte from the megaio serial port
int megaioGetByte(void)
{
	u08 data;

	// check the number of bytes in the megaio receive buffer
	if( megaioReadReg(MEGAIOREG_UARTRXBUFBYTES, 1) )
	{
		// one or more bytes are available
		// get first byte
		data = megaioReadReg(MEGAIOREG_UARTDATA, 1);
		return data;
	}
	else
	{
		// no bytes were available
		// (no bytes have arrived and are waiting to be read)
		return -1;
	}
}

//! returns the receive buffer structure 
cBuffer* megaioGetRxBuffer(void)
{
	u08 nbytes;
	// get the number of bytes waiting in the MegaIO buffer
	nbytes = megaioReadReg(MEGAIOREG_UARTRXBUFBYTES, 1);
	// get all available bytes from the MegaIO chip
	// and add them to the receive buffer
	while(megaioReadReg(MEGAIOREG_UARTRXBUFBYTES, 1))
	{
		bufferAddToEnd(&megaioUartRxBuffer, megaioReadReg(MEGAIOREG_UARTDATA, 1));
		nbytes--;
	}
	// return rx buffer pointer
	return &megaioUartRxBuffer;
}

//! turn on megaio PWM and set for bitRes resolution
void megaioPWMInit(u08 bitRes)
{
	megaioWriteReg(MEGAIOREG_PWM1CTRL, 1, bitRes);
}

//! turn off megaio PWM
void megaioPWMOff(void)
{
	megaioWriteReg(MEGAIOREG_PWM1CTRL, 1, 0);
}

//! set megaio PWM1A duty cycle
void megaioPWMASet(u16 pwmDuty)
{
	megaioWriteReg(MEGAIOREG_PWM1ADUTY, 2, pwmDuty);
}

//! set megaio PWM1B duty cycle
void megaioPWMBSet(u16 pwmDuty)
{
	megaioWriteReg(MEGAIOREG_PWM1BDUTY, 2, pwmDuty);
}

//! set megaio prescaler division rate
void megaioSetPrescaler(u08 prescaleDiv)
{
	megaioWriteReg(MEGAIOREG_PWM1FREQ, 1, prescaleDiv);
}

//! do A/D conversion on channel [ch] and return result
u16 megaioA2DConvert(u08 ch)
{
	// set channel
	megaioWriteReg(MEGAIOREG_ADCCHSEL, 1, ch);
	// start single conversion
	megaioWriteReg(MEGAIOREG_ADCCTRL, 1, 0x01);
	// wait for conversion to be complete
	while( megaioReadReg(MEGAIOREG_ADCCTRL, 1) );
	// get result and return it
	return megaioReadReg(MEGAIOREG_ADCRESULT, 2);
}