/*

 * Project Frontplatte

 *

 * comm.c  -  Handle incoming commands

 *

 * This file is released under the GNU General Public License. Refer

 * to the COPYING file distributed with this package.

 *

 * (c) 2007 Carsten Presser cpresser AT fsing.uni-sb.de

 */

/** I N C L U D E S **********************************************************/

#include <p18cxxx.h>

#include <pwm.h>

#include <eep.h>

#include "typedefs.h"

#include "usb.h"

#include "cdc.h"

#include "io_cfg.h"

#include "comm.h"

#include "user.h"

#include "delay.h"

#include "t6963.h"

#include "myi2c.h"

#include "rc5.h"

/** P R I V A T E  P R O T O T Y P E S ***************************************/

void comm_send_data(unsigned char *data, unsigned char numbytes); 

void comm_send_ack(void);

void comm_send_nack(void); 

void comm_send_nimp(void);

/** C O D E ********************************************************/

void ProcessInput(void)

{   

	unsigned char len;			// command length

	unsigned char input[64];	// input buffer

	unsigned char i;			// default counter

/* C H E C K   I N P U T */

	//do we have some data ?

    len=getsUSBUSART((char*)&(input[0]), 64); 

	if (len < CMD_HD_LENGTH) return;

	//check if input is valid

	if (input[CMD_HD_SYNC] == CMD_SYNC_SEND)

		if ((input[CMD_HD_LENGTH+1] == (len-4)) && (input[CMD_HD_LENGTH] == 0) )// TODO!!

		{

			// looks like we recieved a valid command...

			switch(input[CMD_HD_COMMAND])

			{

/* S Y S T E M    C O M M A N D S */

				case CMD_GET_VERSION:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					input[0] = FW_VERSION;

					comm_send_data(input, 0x01);

					break;

				case CMD_BOOT:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					comm_send_ack();

					// stolen from microchip forum

					INTCONbits.GIE = 0;              // shut down global interrupts 

					USBSoftDetach();

					Delay15ms();

 					_asm goto BOOTLOAD_START _endasm;

					break;

/* E E P R O M    C O M M A N D S */

				case CMD_READ_EEPROM:

					if (input[CMD_HD_LENGTH+1] != 1) { comm_send_nack(); break;}

					input[0] = Read_b_eep (input[CMD_DATA_START]);

					comm_send_data(input, 0x01);

					break;

				case CMD_WRITE_EEPROM:

					if (input[CMD_HD_LENGTH+1] != 2) { comm_send_nack(); break;}

					Write_b_eep (input[CMD_DATA_START],input[CMD_DATA_START+1]);

					comm_send_ack();

					break;

/* D I S P L A Y    C O M M A N D S */

				case CMD_DISP_CLEAR_SCREEN:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					lcd_ClearScreen();

					// now send ack

					comm_send_ack();

					break;

				case CMD_DISP_SET_ROW_DATA:

					if (input[CMD_HD_LENGTH+1] < 3) { comm_send_nack(); break;}

					// goto desired address

					lcd_WriteData(input[CMD_DATA_START]);	// lower byte

					lcd_WriteData(input[CMD_DATA_START+1]);	// upper byte

					lcd_WriteCommand(0x24);

					// now write data

					//lcd_SetAutomode(MODE_AUTO);

					for(i = (CMD_DATA_START+2); i<=(len-1); i++) 

					{

						//lcd_WriteData(input[i]);

						lcd_WriteByte(input[i]);

					}

					//lcd_SetAutomode(MODE_NOAUTO);

					comm_send_ack();							// now send ack

					break;

				case CMD_DISP_SET_ADDRESS:

					if (input[CMD_HD_LENGTH+1] != 2) { comm_send_nack(); break;}

					// goto desired position

					lcd_WriteData(input[CMD_DATA_START]);	// lower byte

					lcd_WriteData(input[CMD_DATA_START+1]);	// upper byte

					lcd_WriteCommand(0x24);

					// now send ack

					comm_send_ack();

					break; 

/* C L O C K    C O M M A N D S */

				case CMD_READ_CLOCK:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					LDPageReadI2C(pcf8583, 0x00, input, 0x10);

					comm_send_data(input, 0x10);

					break;

				case CMD_WRITE_CLOCK:

					if (input[CMD_HD_LENGTH+1] != 0x10) { comm_send_nack(); break;}

					LDPageWriteI2C(pcf8583, 0x00, &input[CMD_DATA_START], 0x10);

					comm_send_ack();;

					break;

/* P W M    C O M M A N D S */

				case CMD_SET_PWM1:

					if (input[CMD_HD_LENGTH+1] != 1) { comm_send_nack(); break;}

					SetDCPWM1((int)input[CMD_DATA_START] << 2);

					comm_send_ack();

					break;

				case CMD_SET_PWM2:

					if (input[CMD_HD_LENGTH+1] != 1) { comm_send_nack(); break;}

					SetDCPWM2((int)input[CMD_DATA_START] << 2);

					comm_send_ack();

					break;

/* M O D E    C O M M A N D S */

				case CMD_SET_MODE_MANAGED:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					gg_mode = MODE_MANAGED;

					comm_send_ack();

					break;

				case CMD_SET_MODE_UNMANAGED:

					if (input[CMD_HD_LENGTH+1] != 0) { comm_send_nack(); break;}

					gg_mode = MODE_UNMANAGED;

					comm_send_ack();

					break;

				default:

					// not implemented...

					comm_send_nimp();

					break;

		}

	}

	else

	{

		// input data is somehow invalid

		comm_send_nack();

	}

}//end ProcessInput

/* S E N D   D A T A  &  R E T U R N C O D E S */

void comm_send_data(unsigned char *data, unsigned char numbytes) 

{

    // send a data packet

	unsigned char cmd[64];

	unsigned char i;

	cmd[CMD_HD_SYNC] = CMD_SYNC_RECV;

	cmd[CMD_HD_COMMAND] = CMD_SYS_ACK;

	cmd[CMD_HD_LENGTH] = 0;

	cmd[CMD_HD_LENGTH+1] = numbytes;

	for (i=0; i<numbytes; i++) {

		cmd[CMD_DATA_START + i] = data[i];

	}

	if mUSBUSARTIsTxTrfReady()

		mUSBUSARTTxRam((byte*)&cmd[0],(4+numbytes));

}

void comm_send_ir(unsigned char address, unsigned char command) 

{

    // send a data packet

	unsigned char ir_cmd[7];

	ir_cmd[CMD_HD_SYNC] 		= CMD_SYNC_RECV;

	ir_cmd[CMD_HD_COMMAND] 		= CMD_SYS_IR;

	ir_cmd[CMD_HD_LENGTH]		= 0x00;

	ir_cmd[CMD_HD_LENGTH+1]		= 0x02;

	ir_cmd[CMD_DATA_START]		= address;

	ir_cmd[CMD_DATA_START+1]	= command;

	if mUSBUSARTIsTxTrfReady()

		mUSBUSARTTxRam((byte*)&ir_cmd[0],6);

}

void comm_send_ack(void) 

{

    // send a ack-packet

	unsigned char cmd[5];

	cmd[CMD_HD_SYNC] = CMD_SYNC_RECV;

	cmd[CMD_HD_COMMAND] = CMD_SYS_ACK;

	cmd[CMD_HD_LENGTH] = 0;

	cmd[CMD_HD_LENGTH+1] = 0;

	if mUSBUSARTIsTxTrfReady()

		mUSBUSARTTxRam((byte*)&cmd[0],4);

}

void comm_send_nack(void) 

{

    // send a NOTack-packet

	unsigned char cmd[5];

	cmd[CMD_HD_SYNC] = CMD_SYNC_RECV;

	cmd[CMD_HD_COMMAND] = CMD_SYS_NACK;

	cmd[CMD_HD_LENGTH] = 0;

	cmd[CMD_HD_LENGTH+1] = 0;

	while (!mUSBUSARTIsTxTrfReady()) Nop();

	mUSBUSARTTxRam((byte*)&cmd[0],4);

}

void comm_send_nimp(void) 

{

	// send a NOTimplementet-packet

	unsigned char cmd[3];

	cmd[CMD_HD_SYNC] = CMD_SYNC_RECV;

	cmd[CMD_HD_COMMAND] = CMD_SYS_NIMP;

	cmd[CMD_HD_LENGTH] = 0;

	cmd[CMD_HD_LENGTH+1] = 0;

	if mUSBUSARTIsTxTrfReady()

		mUSBUSARTTxRam((byte*)&cmd[0],4);

}