|
|
/*
|
|
|
* 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 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);
|
|
|
int cambia_apuntamiento(char *puntero_char);
|
|
|
int carga_experimento(char *nombre_archivo);
|
|
|
int 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()");
|
|
|
}
|
|
|
|
|
|
/* Se procede a procesar los datos recibidos */
|
|
|
buff_peticion[numbytes_recibidos]= '\0';
|
|
|
|
|
|
/* procesamiento de la peticion */
|
|
|
rpta = 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){
|
|
|
int rpta;
|
|
|
// char *header = strtok(buff_peticion, ":");
|
|
|
// char *ipSource = strtok(buff_peticion, ":");
|
|
|
// char *ipDestino = strtok(buff_peticion, ":");
|
|
|
char *comando = strtok(buff_peticion, ":");
|
|
|
char *valor = strtok(NULL, ":");
|
|
|
|
|
|
if ((comando == NULL) || (valor == NULL)){
|
|
|
ERROR("procesarPeticion: formato de mensaje incorrecto");
|
|
|
}
|
|
|
else{
|
|
|
if(strcmp(comando,"CARGA") == 0)
|
|
|
rpta = carga_experimento(valor);
|
|
|
else if(strcmp(comando,"CAMBIA") == 0)
|
|
|
rpta = cambia_apuntamiento(valor);
|
|
|
else if(strcmp(comando,"CHEQUEO") == 0)
|
|
|
rpta = 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){
|
|
|
|
|
|
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{
|
|
|
|
|
|
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);
|
|
|
|
|
|
char *puntero= strstr(buffer_temporal,".abs"); // 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){
|
|
|
|
|
|
/*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){
|
|
|
|
|
|
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));
|
|
|
|
|
|
fclose(fd);
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
|
