/*
 * acquisitiond.c
 *
 *  Created on: Mar 24, 2015
 *      Author: shinobi
 */

#include "acquisitiond.h"
#include "fpgaport.h"

volatile uint8_t is_acquiring = 0;
volatile uint8_t send_flg = 0;

// Comandos para el ADC
#define CMD_ACTV    0
#define CMD_DACTV   1
#define CMD_RATE    2
#define CMD_RPARAM  3
#define CMD_WPARAM  4
#define CMD_START   5
#define CMD_STOP    6
#define CMD_INFO    7
#define CMD_GAIN    8
#define CMD_ID      9
#define CMD_STATUS 10
#define CMD_PPS    11


/*!
 * \fn acq_chn_activate
 * \breif activa la comunicacion con el IC ADC
 * \see acq_chn_deactivate
 */
void acq_chn_activate(){
	adcport_open();
}


/*!
 * \fn acq_chn_deactivate
 * \breif desactiva la comunicacion con el IC ADC
 * \see acq_chn_activate
 */
void acq_chn_deactivate(){
	adcport_close();
}


/*!
 * \fn acq_chn_datarate
 * \breif Configura el datarate del ADC
 * \param datarate El datarate deseado
 */
void acq_chn_datarate(uint16_t datarate){
	if(is_acquiring==1){
		acq_stop_acquisiton();
	}
	acq_set_param_to_adc(CMD_RATE,datarate);
}


/*!
 * \fn acq_send_information
 * \breif Envia informacion relevante al Embebido (a traves de FPGA)
 */
void acq_send_information(){
	if(is_acquiring==1){
		acq_stop_acquisiton();
	}
	acq_send_param(CMD_RATE);
	acq_send_param(CMD_GAIN);
	acq_send_param(CMD_ID);
	acq_send_param(CMD_STATUS);
	acq_send_param(CMD_PPS);
}


/*!
 * \fn acq_chn_datarate
 * \breif Envia parametros al embebido a traves del FPGA (este se debe encargar
 * de hacer el puente al embebido)
 * \param param El parametro que se quiere enviar al embebido
 */
void acq_send_param(uint8_t param){
	uint8_t data;
	fpgaport_open();
	fpgaport_write(param);
	switch(param){
	case CMD_RATE:
		// TODO secuencia de comandos para obtener el datarate del ADC
		break;
	case CMD_GAIN:
		data=adcport_get_param(GAIN0);
		break;
	case CMD_ID:
		data=adcport_get_param(ID);
		break;
	case CMD_STATUS:
		data=adcport_get_param(STATUS);
		break;
	case CMD_PPS:
		break;// TODO
	default:
		// con esta opcion se puede leer los registros del ADC definidos en
		// "adcpot.h" y enviarlos al embebido
		data= adcport_get_param(param);
		break;
	}

	fpgaport_write(data);
	fpgaport_close();
}


/*!
 * \fn acq_send_buff
 * \breif Envia el contenido de un buffer de datos hacia el
 * FPGA para que sean pre-procesados.
 */
/*
 * Esta funcion debe ser ejecutada con la señal de una interrupcion externa
 * manejada por software, que le indicara que hay un buffer lleno listo
 * para pre-procesar (vea adcport.c ).
 */
void acq_send_buff(){
	uint8_t i=0;
	uint32_t* pbuff = adcport_getbuff();
	fpgaport_open();
	while(!(i==BUFF_SIZE)){
		fpgaport_write(pbuff[i]);
		i++;
	}
	fpgaport_close();
}


/*!
 * \fn acq_chn_set_datarate
 * \breif configura edl datarate del ADC
 * \param datarate
 */
void acq_chn_set_datarate(uint8_t datarate){
	// TODO secuencia de comandos para configurar el data rate
}


/*!
 * \fn acq_process_cmd
 * \breif Procesa todos los comandos enviados desde el FPGA.
 * \param cmd Comando a procesar.
 */
/*
 * Esta funcion debe ejecutarse al haber una interrupcion en el puerto que
 * conecta al FPGA
 */
void acq_process_cmd(uint8_t cmd){
	static uint8_t param;
	static uint8_t data;
	cli();// desactiva interrupciones
	fpgaport_open();
	switch(cmd){
	case CMD_ACTV: acq_chn_activate();
			   break;
	case CMD_DACTV:acq_chn_deactivate();
	           break;
	case CMD_RATE:
		param=fpgaport_read();
		acq_chn_set_datarate(param);
		break;
	case CMD_RPARAM:
		param=fpgaport_read();
		acq_send_param(param);
		break;
	case CMD_WPARAM:
		cmd=fpgaport_read();//lee
		data=fpgaport_read();//lee valor
		acq_set_param_to_adc(cmd,data);
		break;
	case CMD_START:
		acq_start_acquisition();
		break;
	case CMD_STOP:
		acq_stop_acquisition();
		break;
	case CMD_INFO:
		acq_send_information();
		break;
	default: break;
	}
	fpgaport_close();
	sei();//acvtiva interrupciones
}


/*!
 * \fn acq_set_param
 * \breif Procesa todos los comandos enviados desde el FPGA.
 * \param param Parametro a configurar.
 * \param value Valor del parametro
 */
void acq_set_param(uint8_t param, uint8_t value){
	adcport_tranceiv(param);
	adcport_tranceiv(value);
}


/*!
 * \fn acq_start_acquisition
 * \breif Inicia la adquisicion de datos, esta se hara a traves de interrupciones
 * "software" (ver adcport.c)
 */
void acq_start_acquisition(){
	is_acquiring = 1;
	adcport_start();
}

/*!
 * \fn acq_stop_acquisition
 * \breif Para la adquisicion de datos. Las interrupciones utilizadas para
 * este fin son desactivadas.
 */
void acq_stop_acquisition(){
	is_acquiring=0;
	adcport_stop();
}


/*
 * interrupcion en algun pin que no se este usdando.
 * Interrupcion software. No puede ser PORTC_INT0_vect
 * Se usara para le indiquen que ya hay un buffer lleno
 * (ver adcport.c)
 */
ISR(PORTx_INTx_vect){ // FIXME
	send_flg=1;
}



/*
 * interrupcion en algun pin que no se este usdando.
 * Interrupcion software. No puede ser PORTC_INT0_vect
 * Se usara para le indiquen que ya hay un buffer lleno
 * (ver adcport.c)
 */
ISR(PORTx_INTx_vect){ // FIXME
	send_flg=1;
}

/*!
 * \brief Espera que un buffer este lleno para enviarlo al fpga
 */
int main(){
	do{
		if(send_flg==1){
			send_flg=0;
			acq_send_buff();
		}
	}while(1);
	return 0;
}