/*
 * Servidor.c
 *
 *  Created on: Nov 3, 2009
 *      Author: Jose Francisco Quenta
 *
 *  Se implementa:
 *   -Carga en memoria los apuntes contenidos en un archivo de experimentos: apunte0 -> GPIO
 *   -Cambio de apunte.
 *   -Lectura del estado actual del apunte y grabado del mismo en un archivo
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include "./Librerias/AT91gpio_Funciones.h"
#include "./Librerias/Mensajes.h"

#define PUERTO_SERVIDOR 5500
#define TAM_BUFFER 100

#define 	maskc_out 	PC30+PC28+PC26+PC24+PC22+PC20		//MSB-UP-LSB MSB-DOWN-LSB	//APUNTE

#define 	maskb_in 	PB16+PB18+PB20+PB30+PB24+PB22		//MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION

#define 	bit_up_2 	0x00010000				//Mascara de cada bit a revisar:  bit_up_2 es MSB
#define 	bit_up_1 	0x00040000
#define 	bit_up_0 	0x00100000
#define 	bit_dow_2 	0x40000000
#define 	bit_dow_1 	0x01000000
#define 	bit_dow_0 	0x00400000

#define 	MyID		192.168.1.11

char *buff_experimento= NULL;

AT91S_PIO *pioc;
AT91S_PIO *piob;

/*
 *  Zona de declaracion de cabeceras.
 */
void inicializa_gpio();
//int procesa_peticion(char *buff_peticion);
void procesa_peticion(char *buff_peticion);
//int cambia_apuntamiento(char *puntero_char);
void cambia_apuntamiento(char *puntero_char);
//int carga_experimento(char *nombre_archivo);
void carga_experimento(char *nombre_archivo);
//int chequeo_sistema(char *numero_muestras);
void chequeo_sistema(char *numero_muestras);

/*
 *
 */
int main(){

	int conexion_servidorFd;
	struct sockaddr_in inf_servidor;
	struct sockaddr_storage inf_cliente;
	int resultado;
	int numbytes_recibidos;
	//int rpta;

	char *buff_peticion = (char *) malloc(TAM_BUFFER);

	size_t addr_len;

	memset(&inf_servidor, 0, sizeof(inf_servidor));
	inf_servidor.sin_family= AF_INET;
	inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
	inf_servidor.sin_addr.s_addr= INADDR_ANY;

	/* Se establece el socket */
	conexion_servidorFd = socket(AF_INET,SOCK_DGRAM,0);
	if (conexion_servidorFd == -1){
		ERROR_FATAL("No se establecio correctamente el socket: socket()");
	}

	/* Se asocia el socket a un puerto y una IP */
	resultado = bind(conexion_servidorFd,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
	if (resultado== -1){
		ERROR_FATAL("No se establecio correctamente el socket: bind()");
	}

	/* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
	inicializa_gpio();

	while(1){
		LOG_SERVIDOR("Esperando solicitud de cliente...\n");

		/* Se espera hasta que un cliente se conecte */
		addr_len = sizeof(inf_cliente);
		numbytes_recibidos = recvfrom(conexion_servidorFd, buff_peticion, TAM_BUFFER-1, 0, (struct sockaddr *)&inf_cliente, &addr_len);
		if (numbytes_recibidos == -1){
			ERROR_FATAL("Error en la recepcion de datos: recvfrom()");
		}else
			printf("Recibidos: %i\n",numbytes_recibidos);

		/* Se procede a procesar los datos recibidos */
		buff_peticion[numbytes_recibidos]= '\0';
		printf("%s\n",buff_peticion);

		/* procesamiento de la peticion  */
		//rpta = procesa_peticion(buff_peticion);
		procesa_peticion(buff_peticion);

		//Respuesta del modulo de control
		//


	}
}

/*
 * Esta funcion incializa el puerto GPIO
 */
void inicializa_gpio(){

	// Configuracion de los pines de APUNTE
	pioc = pio_map(PIOC_BASE);
	pio_enable(pioc, maskc_out);
	pio_disable_irq(pioc, maskc_out);
	pio_disable_multiple_driver(pioc, maskc_out);
	pio_disable_pull_ups(pioc, maskc_out);
	pio_synchronous_data_output(pioc, maskc_out);
	pio_output_enable(pioc, maskc_out);

	// Configuracion de los pines de VERIFICACION
	piob = pio_map(PIOB_BASE);
	pio_enable(piob, maskb_in);
	pio_disable_irq(piob, maskb_in);
	pio_disable_multiple_driver(piob, maskb_in);
	pio_disable_pull_ups(piob, maskb_in);
	pio_input_enable(piob, maskb_in);

}

/*
 * Esta funcion procesa el mensaje de peticion y genera respuesta
 */
//int procesa_peticion(char *buff_peticion){
void procesa_peticion(char *buff_peticion){
	//int rpta = 0;

//	char *header = strtok(buff_peticion, ":");
//	char *ipSource = strtok(buff_peticion, ":");
//	char *ipDestino = strtok(buff_peticion, ":");
    char *comando = strtok(buff_peticion, ":");
    char *valor = strtok(NULL, ":");

	printf("Testpoint_1\n");
    if ((comando == NULL) || (valor == NULL)){
        ERROR("procesarPeticion: formato de mensaje incorrecto");
    }
    else{
        if(strcmp(comando,"CARGA") == 0)
            //rpta = carga_experimento(valor);
        	carga_experimento(valor);
        else if(strcmp(comando,"CAMBIA") == 0)
            //rpta = cambia_apuntamiento(valor);
        	cambia_apuntamiento(valor);
        else if(strcmp(comando,"CHEQUEO") == 0)
			//rpta = chequeo_sistema(valor);
        	chequeo_sistema(valor);
        else
            ERROR("procesa_peticion: comando no reconocido");
    }

    //return rpta;
}


/*
 *	Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
 *	este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
 *	que sera usado en el cambio de apuntamiento.
 */
//int carga_experimento(char *nombre_archivo){
void carga_experimento(char *nombre_archivo){

	FILE *Archivo_Fd;

	char *cadena = (char *) malloc(25);

	int longitud_cadena;
	int num_bytes= 0;
	int num_filas= 0;

	char ruta_archivo[50];		// Se crea la ruta para abrir el archivo
	strcpy(ruta_archivo,"/mnt/sd/archivos/");
	strcat(ruta_archivo,nombre_archivo);

	Archivo_Fd = fopen(ruta_archivo,"r");	// Se procede a abrir el archivo, segun la ruta especificada
	if(!Archivo_Fd){
		ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
//		return -1;
	}else{
		printf("Testpoint_2\n");
		while(!feof(Archivo_Fd)){			// Se procede a calcular la longitud del archivo para separar memoria
			fgets(cadena,20,Archivo_Fd);
			longitud_cadena= strlen(cadena);
			cadena[longitud_cadena-1] = '\0';
			num_bytes = num_bytes + longitud_cadena;
			num_filas++;
		}

		rewind(Archivo_Fd);		// Se reinicia el puntero del archivo

		char *buffer_temporal = (char *) malloc(num_bytes+1);		// Se separa espacio de memoria segun
																	// la longitud del archivo
		fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);

		printf("Testpoint_3\n");
		char *puntero= strstr(buffer_temporal,".ab1");		// Se procede a eliminar la cabecera del archivo
		puntero= puntero + 12;

		buff_experimento = (char *) malloc(7*(num_filas-3));	// num_bytes_fila*(num_filas-3);
		strncpy(buff_experimento,puntero,7*(num_filas-3));		// Se carga en memoria la informacion del archivo

		fclose(Archivo_Fd);

		//cambia_apuntamiento("0");								// Se apunta a la direccion 0

//		return 1;
	}
}

/*
 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
 * traves del puerto GPIO.
 */
//int cambia_apuntamiento(char *puntero_char){
void cambia_apuntamiento(char *puntero_char){

																			/*MSB-UP-LSB MSB-DOWN-LSB*/
	int desplazamiento[6]={30,28,26,24,22,20};	// Defino los dezplazamientos que se aplicara
												// al dato que ingresa para formar el número
												// entero que se le pasara al puerto GPIO
												// Estos números son los pines del puerto GPIO
												// que se estan usando para el control

	int puntero= atoi(puntero_char);			// Se convierte a entero la direccion del puntero

	int base= 7*puntero;						// base= cantidad_bytes del dato x puntero
												// cantidad de bytes es el numero de bytes que
	printf("%i\n",puntero);											// contiene cada dato, para este caso es 7
												// porque es 6 bits de datos + 1 bit del cambio
												// de linea.
	char valor_char;
	unsigned long valor;
	unsigned long acumulado_ceros=0;
	unsigned long acumulado_unos=0;

	int offset;									// Defino offset para el desplazamiento a traves
	for(offset=0;offset<6;offset++){			// de cada dato que se obtiene del "buff_experimento"

		valor_char= buff_experimento[base+offset];	// Obtengo el dato

		if (valor_char == '0'){					// Obtengo el número acumulado segun sea un cero o un uno
			valor= 0;
			acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
		}else{
			valor= 1;
			acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
		}

	}

	pio_out(pioc, maskc_out, acumulado_unos, 1);
	pio_out(pioc, maskc_out, acumulado_ceros, 0);

	//return 1;

}

/*
 * Esta funcion lee "n" veces el estado del APUNTE actual y lo guarda en el
 * archivo Verificacion.
 */

//int chequeo_sistema(char *numero_muestras){
void chequeo_sistema(char *numero_muestras){

	char valor[7];
	int i,cnt;
	unsigned int entradac= 0;
	FILE *fd;
	fd=fopen("/mnt/sd/archivos/Verificacion","w");
	fprintf(fd,"%s\n","Verificacion");
	fprintf(fd,"%s\n","------------");
	cnt=0;
	do
	{
		//Inicializando arreglo
		for(i=0;i<6;i++)
			valor[i]='0';

		valor[6]='\0';

		//Lectura de puerto
		entradac= pio_in(piob,maskb_in);

		//Dandole formato al dato
		if (!(entradac & bit_up_2))
			valor[0] = '1';
		if (!(entradac & bit_up_1))
			valor[1] = '1';
		if (!(entradac & bit_up_0))
			valor[2] = '1';
		if (!(entradac & bit_dow_2))
			valor[3] = '1';
		if (!(entradac & bit_dow_1))
			valor[4] = '1';
		if (!(entradac & bit_dow_0))
			valor[5] = '1';

		//Escribiendo en archivo
		fprintf(fd,"%s\n",valor);
		cnt=cnt+1;
		usleep(1*1000*1000);

	}while(cnt < (atoi(numero_muestras)+1));

	fclose(fd);

	//return 1;
}