|
|
/*
|
|
|
* 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
|
|
|
*
|
|
|
* Modified by Iván Manay since Nov 2012
|
|
|
* -From UDP to TCP.
|
|
|
* -Use of a frame for TCP communications with the central control module.
|
|
|
*/
|
|
|
|
|
|
#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 <time.h>
|
|
|
#include <math.h>
|
|
|
|
|
|
#include "./Librerias/at91gpio.h"
|
|
|
//#include "./Librerias/Mensajes.h"
|
|
|
#include "./Librerias/at91adc.h"
|
|
|
//clock
|
|
|
#include "./Librerias/at91sysclock.h"
|
|
|
|
|
|
#define PUERTO_SERVIDOR 5500
|
|
|
#define TAM_BUFFER 1024
|
|
|
|
|
|
#define maskc_out_beam PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
|
|
|
#define maskc_out_cntl PC4+PC5+PC6 //MONITORING CONTROL
|
|
|
|
|
|
#define mask_sel_canal PC4 //MONITORING CONTROL
|
|
|
#define mask_sel_atenuacion PC5
|
|
|
#define mask_sel_calibracion PC6
|
|
|
|
|
|
#define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
|
|
|
|
|
|
#define maskc_in_adc PC0+PC1
|
|
|
|
|
|
#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
|
|
|
#define MAXPENDING 5 /* Maximum outstanding connection requests */
|
|
|
|
|
|
//parameters for the name of the output file
|
|
|
#define FPRE "AD" //prefix for the output file name
|
|
|
#define FEXT ".out" //file extension for the output file
|
|
|
#define FNAMELEN 40
|
|
|
|
|
|
//ADC parameters
|
|
|
#define REP 1 //defines how many times the data acquisation loop is repeated
|
|
|
#define NSAMPLES 10 //defines how many samples are taken in one data acqu-
|
|
|
// isation loop
|
|
|
|
|
|
#define NLOOPS 200 // Number of loops for the transmisor checking
|
|
|
#define CNVTIME 14.3 //defines how long it takes to get one sample. Value
|
|
|
// is only needed for the output file, doesn't change
|
|
|
// any ADC configurations
|
|
|
#define UREF 3.3 //Reference Voltage of ADC (max. ADC Voltage)
|
|
|
#define ADCRES 1023 //Resolution of ADC (10bit=1023)
|
|
|
|
|
|
|
|
|
char *buff_experimento= NULL;
|
|
|
|
|
|
AT91S_PIO *pioc;
|
|
|
AT91S_PIO *piob;
|
|
|
AT91S_PIO *pio_adc;
|
|
|
AT91S_ADC *padc;
|
|
|
AT91S_ADC *padd;
|
|
|
|
|
|
struct control_module_parameters {
|
|
|
char ID[20];
|
|
|
char param2[20];
|
|
|
char param3[20];
|
|
|
char param4[20];
|
|
|
};
|
|
|
|
|
|
typedef struct control_module_parameters cmp;
|
|
|
|
|
|
char *header = NULL;
|
|
|
char *TypeOfInstrument = NULL;
|
|
|
char *iDSource = NULL;
|
|
|
char *iDDestino = NULL;
|
|
|
char *rx_len = NULL;
|
|
|
char *cmd = NULL;
|
|
|
char *rx_data = NULL;
|
|
|
char *crc = NULL;
|
|
|
|
|
|
cmp parameters;
|
|
|
/*
|
|
|
* Zona de declaracion de cabeceras.
|
|
|
*/
|
|
|
cmp inicializa_modulo(cmp p, char *filename);
|
|
|
int inicializa_ethernet();
|
|
|
int rxData(int, char*);
|
|
|
void txData(int, char*);
|
|
|
void inicializa_gpio();
|
|
|
void inicializa_adc();
|
|
|
void procesa_peticion(char *rx_buffer, char *tx_buffer);
|
|
|
int cambia_apuntamiento(char *puntero_char);
|
|
|
int carga_experimento(char *nombre_archivo);
|
|
|
char *chequeo_sistema(char *filename, char *numero_muestras);
|
|
|
void escribe_experimento(char *data, char filename[]);
|
|
|
char *Lee_experimento(char *filename);
|
|
|
void consigue_nombre_experimento(char *rx_data, char filename[]);
|
|
|
void SplitFrame(char *frame);
|
|
|
void intToStr( int number, char* str );
|
|
|
|
|
|
//ABS monitoring
|
|
|
//int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
|
|
|
char* ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
|
|
|
AT91S_ADC * configADC1(void);
|
|
|
AT91S_ADC * configADC2(void);
|
|
|
|
|
|
FILE * create_Output(char*, time_t);
|
|
|
|
|
|
void writeOutput(float resultado, FILE * output);
|
|
|
|
|
|
int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth);
|
|
|
|
|
|
double mediana(long int *results, unsigned int cuenta);
|
|
|
float getPhase(long int results1[], long int results2[]);
|
|
|
|
|
|
int fExists(char *);
|
|
|
int configCLK();
|
|
|
//
|
|
|
|
|
|
/*
|
|
|
*
|
|
|
*/
|
|
|
int main(int argc, char *argv[]){
|
|
|
// arg[1] : Archivo de configuracion del modulo de control
|
|
|
int servSocket;
|
|
|
int clntSocket;
|
|
|
|
|
|
char *rx_buffer = (char *) malloc(TAM_BUFFER);
|
|
|
char *tx_buffer = (char *) malloc(TAM_BUFFER);
|
|
|
/* Inicializa parametros del modulo*/
|
|
|
parameters = inicializa_modulo(parameters, argv[1]);
|
|
|
printf("%s\n%s\n%s\n%s\n",parameters.ID, parameters.param2, parameters.param3, parameters.param4);
|
|
|
/* Inicializa red*/
|
|
|
servSocket = inicializa_ethernet();
|
|
|
/* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
|
|
|
inicializa_gpio();
|
|
|
inicializa_adc();
|
|
|
|
|
|
while(1){
|
|
|
// Recepción TCP de petición
|
|
|
clntSocket = rxData(servSocket, rx_buffer);
|
|
|
//testpoint
|
|
|
printf("rx:%s\n",rx_buffer);
|
|
|
// Procesamiento de la petición
|
|
|
procesa_peticion(rx_buffer, tx_buffer);
|
|
|
//testpoint
|
|
|
printf("tx:%s\n",tx_buffer);
|
|
|
// Respuesta del modulo de control
|
|
|
txData(clntSocket, tx_buffer);
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
int inicializa_ethernet(){
|
|
|
|
|
|
struct sockaddr_in inf_servidor;
|
|
|
|
|
|
int servSocket;
|
|
|
|
|
|
int resultado;
|
|
|
|
|
|
/* Haciendo la estructura local*/
|
|
|
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 */
|
|
|
servSocket = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
|
|
|
if (servSocket == -1){
|
|
|
printf("No se establecio correctamente el socket: socket()\n");
|
|
|
//ERROR_FATAL("No se establecio correctamente el socket: socket()\n");
|
|
|
exit(-1);
|
|
|
}
|
|
|
|
|
|
/* Se asocia el socket a un puerto y una IP */
|
|
|
resultado = bind(servSocket,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
|
|
|
if (resultado== -1){
|
|
|
printf("No se establecio correctamente el socket: bind()\n");
|
|
|
//ERROR_FATAL("No se establecio correctamente el socket: bind()\n");
|
|
|
exit(-1);
|
|
|
}
|
|
|
|
|
|
if (listen(servSocket, MAXPENDING) < 0){
|
|
|
printf("listen() failed\n");
|
|
|
exit(-1);
|
|
|
}
|
|
|
|
|
|
return servSocket;
|
|
|
|
|
|
}
|
|
|
|
|
|
int rxData(int servSocket, char* rx_buffer){
|
|
|
|
|
|
int clntSocket;
|
|
|
struct sockaddr_in inf_cliente;
|
|
|
int numbytes_recibidos;
|
|
|
unsigned int inf_client_Len;
|
|
|
|
|
|
printf("\nEsperando solicitud de cliente...\n");
|
|
|
|
|
|
/* Set the size of the in-out parameter */
|
|
|
inf_client_Len = sizeof(inf_cliente);
|
|
|
/* Se espera hasta que un cliente se conecte */
|
|
|
if ((clntSocket = accept(servSocket, (struct sockaddr *) &inf_cliente,
|
|
|
&inf_client_Len)) < 0)
|
|
|
printf("accept() failed\n");
|
|
|
|
|
|
if ((numbytes_recibidos = recv(clntSocket, rx_buffer, TAM_BUFFER, 0)) < 0)
|
|
|
printf("recv() failed\n");
|
|
|
|
|
|
/* Se procede a procesar los datos recibidos */
|
|
|
rx_buffer[numbytes_recibidos]= '\0';
|
|
|
|
|
|
return clntSocket;
|
|
|
}
|
|
|
|
|
|
void txData(int clntSocket, char* data){
|
|
|
|
|
|
/* Echo message back to client */
|
|
|
if (send(clntSocket, data, strlen(data), 0) != strlen(data))
|
|
|
printf("send() failed\n");
|
|
|
|
|
|
close(clntSocket); /* Close client socket */
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Esta funcion incializa el puerto GPIO
|
|
|
*/
|
|
|
void inicializa_gpio(){
|
|
|
|
|
|
int desplazamiento_beam[6]={30,28,26,24,22,20}; //Desplazamientos para los pines de apunte
|
|
|
int desplazamiento_cntl[3]={4,5,6}; //Desplazamientos para los pines de control de monitoreo
|
|
|
unsigned long acumulado_ceros=0;
|
|
|
int i;
|
|
|
|
|
|
// Configuracion de los pines de APUNTE y control de monitoreo
|
|
|
pioc = pio_map(PIOC_BASE);
|
|
|
pio_enable(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
pio_disable_irq(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
pio_disable_multiple_driver(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
pio_disable_pull_ups(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
pio_synchronous_data_output(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
pio_output_enable(pioc, maskc_out_beam + maskc_out_cntl);
|
|
|
|
|
|
// 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);
|
|
|
|
|
|
//Pînes de ADC
|
|
|
pio_adc = pio_map(PIOC_BASE);
|
|
|
pin_adc_enable(pio_adc,maskc_in_adc); //Habilitamos PC0 para usar con ADC0 y 1
|
|
|
pio_disable_irq(pio_adc, maskc_in_adc);
|
|
|
pio_disable_multiple_driver(pio_adc, maskc_in_adc);
|
|
|
pio_disable_pull_ups(pio_adc, maskc_in_adc);
|
|
|
pio_input_enable(pio_adc, maskc_in_adc);
|
|
|
|
|
|
//Inicializando a cero los pines de apunte
|
|
|
for(i=0;i<6;i++)
|
|
|
acumulado_ceros= acumulado_ceros + (1 << desplazamiento_beam[i]);
|
|
|
pio_out(pioc, maskc_out_beam, acumulado_ceros, 0);
|
|
|
|
|
|
//Inicializando a cero los pines de control de monitoreo: atenuacion, calibracion y canal
|
|
|
for(i=0;i<3;i++)
|
|
|
acumulado_ceros= acumulado_ceros + (1 << desplazamiento_cntl[i]);
|
|
|
pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
|
|
|
|
|
|
}
|
|
|
|
|
|
void inicializa_adc(){
|
|
|
|
|
|
if (configCLK() == 1)
|
|
|
printf("clock ADC enable.\n");
|
|
|
//configure ADC Settings
|
|
|
padc=configADC1();
|
|
|
padd=configADC2();
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Divide rx frame into the frame components
|
|
|
*/
|
|
|
void SplitFrame(char *frame){
|
|
|
header = malloc(4);
|
|
|
*header = *frame;
|
|
|
*(header + 1) = *(frame + 1);
|
|
|
*(header + 2) = *(frame + 2);
|
|
|
*(header + 3) = '\0';
|
|
|
TypeOfInstrument = malloc(4);
|
|
|
*TypeOfInstrument = *(frame + 3);
|
|
|
*(TypeOfInstrument + 1) = *(frame + 4);
|
|
|
*(TypeOfInstrument + 2) = *(frame + 5);
|
|
|
*(TypeOfInstrument + 3) = '\0';
|
|
|
iDSource = malloc(8);
|
|
|
*iDSource = *(frame + 6);
|
|
|
*(iDSource + 1) = *(frame + 7);
|
|
|
*(iDSource + 2) = *(frame + 8);
|
|
|
*(iDSource + 3) = *(frame + 9);
|
|
|
*(iDSource + 4) = *(frame + 10);
|
|
|
*(iDSource + 5) = *(frame + 11);
|
|
|
*(iDSource + 6) = *(frame + 12);
|
|
|
*(iDSource + 7) = '\0';
|
|
|
iDDestino = malloc(8);
|
|
|
*iDDestino = *(frame + 13);
|
|
|
*(iDDestino + 1) = *(frame + 14);
|
|
|
*(iDDestino + 2) = *(frame + 15);
|
|
|
*(iDDestino + 3) = *(frame + 16);
|
|
|
*(iDDestino + 4) = *(frame + 17);
|
|
|
*(iDDestino + 5) = *(frame + 18);
|
|
|
*(iDDestino + 6) = *(frame + 19);
|
|
|
*(iDDestino + 7) = '\0';
|
|
|
rx_len = malloc(7);
|
|
|
*rx_len = *(frame + 20);
|
|
|
*(rx_len + 1) = *(frame + 21);
|
|
|
*(rx_len + 2) = *(frame + 22);
|
|
|
*(rx_len + 3) = *(frame + 23);
|
|
|
*(rx_len + 4) = *(frame + 24);
|
|
|
*(rx_len + 5) = *(frame + 25);
|
|
|
*(rx_len + 6) = '\0';
|
|
|
cmd = malloc(5);
|
|
|
*cmd = *(frame + 26);
|
|
|
*(cmd + 1) = *(frame + 27);
|
|
|
*(cmd + 2) = *(frame + 28);
|
|
|
*(cmd + 3) = *(frame + 29);
|
|
|
*(cmd + 4) = '\0';
|
|
|
|
|
|
int l = atoi(rx_len);
|
|
|
rx_data = malloc(l + 1);
|
|
|
int i;
|
|
|
for (i = 30; i < 30 + l; i++)
|
|
|
*(rx_data + (i-30)) = *(frame + i);
|
|
|
*(rx_data + l) = '\0';
|
|
|
crc = malloc(2);
|
|
|
*crc = *(frame + 30 + l);
|
|
|
*(crc + 1) = '\0';
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Esta funcion procesa el mensaje de peticion y genera respuesta
|
|
|
*/
|
|
|
void procesa_peticion(char *rx_buffer, char *tx_buffer){
|
|
|
// int n = 0;
|
|
|
char filename1[50];
|
|
|
char filename2[] = "verificacion.txt";
|
|
|
char *tx_data = NULL;
|
|
|
char *tx_len = NULL;
|
|
|
SplitFrame(rx_buffer);
|
|
|
|
|
|
if ((cmd == NULL) || (rx_data == NULL)){
|
|
|
printf("procesarPeticion: formato de mensaje incorrecto");
|
|
|
//ERROR("procesarPeticion: formato de mensaje incorrecto");
|
|
|
|
|
|
}
|
|
|
else{
|
|
|
if(strcmp(cmd,"SNDF") == 0){
|
|
|
escribe_experimento(rx_data,filename1);
|
|
|
carga_experimento(filename1);
|
|
|
cambia_apuntamiento("0");
|
|
|
tx_data = (char*)malloc(3);
|
|
|
tx_data = "OK";
|
|
|
}
|
|
|
else if(strcmp(cmd,"GETF") == 0){
|
|
|
consigue_nombre_experimento(rx_data,filename1); //get a filename from frame
|
|
|
tx_data = Lee_experimento(filename1); //return a pointer to the content of the filename
|
|
|
printf("%s\n",tx_data);
|
|
|
}
|
|
|
else if(strcmp(cmd,"CHGB") == 0){
|
|
|
cambia_apuntamiento(rx_data);
|
|
|
tx_data = (char*)malloc(3);
|
|
|
tx_data = "OK";
|
|
|
}
|
|
|
else if(strcmp(cmd,"ANST") == 0){
|
|
|
tx_data = chequeo_sistema(filename2,rx_data);
|
|
|
printf("%s\n",tx_data);
|
|
|
}
|
|
|
else if(strcmp(cmd,"BGPH") == 0){
|
|
|
tx_data = ABS_monitoreo(1, 0, 50, 10);
|
|
|
// tx_data = "Not implemented\n";
|
|
|
printf("%s\n",tx_data);
|
|
|
}
|
|
|
else if(strcmp(cmd,"LWPH") == 0){
|
|
|
tx_data = ABS_monitoreo(0, 0, 50, 10);
|
|
|
// tx_data = "Not implemented\n";
|
|
|
printf("%s\n",tx_data);
|
|
|
}
|
|
|
else if(strcmp(cmd,"NTST") == 0){
|
|
|
tx_data = malloc(strlen(parameters.ID) + 1);
|
|
|
strcpy(tx_data,parameters.ID);
|
|
|
printf("%s\n",tx_data);
|
|
|
}
|
|
|
else{
|
|
|
tx_data = (char*)malloc(6);
|
|
|
tx_data = "Error";
|
|
|
printf("procesa_peticion: comando no reconocido");
|
|
|
//ERROR("procesa_peticion: comando no reconocido");
|
|
|
}
|
|
|
|
|
|
tx_len = malloc(7);
|
|
|
int number = strlen(tx_data);
|
|
|
intToStr(number, tx_len );
|
|
|
|
|
|
strcpy(tx_buffer,header); //3
|
|
|
strcat(tx_buffer,TypeOfInstrument); //3
|
|
|
strcat(tx_buffer,parameters.ID); //7
|
|
|
strcat(tx_buffer,iDSource); //7
|
|
|
strcat(tx_buffer,tx_len); //6
|
|
|
strcat(tx_buffer,cmd); //4
|
|
|
strcat(tx_buffer,tx_data); //?
|
|
|
strcat(tx_buffer,crc); //1
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
char* Lee_experimento(char filename[]){
|
|
|
char *buffer = NULL;
|
|
|
FILE * fd = fopen(filename,"r");
|
|
|
fseek(fd, 0, SEEK_END);
|
|
|
size_t sz = ftell(fd);
|
|
|
fseek(fd, 0, SEEK_SET);
|
|
|
buffer = malloc(sz);
|
|
|
fread(buffer,sizeof(char),sz,fd);
|
|
|
fclose(fd);
|
|
|
return buffer;
|
|
|
}
|
|
|
/*
|
|
|
* Esta función genera el archivo de experimento a partir de la trama TCP recibida
|
|
|
*/
|
|
|
void escribe_experimento(char *p_data, char filename[]){
|
|
|
FILE *fd;
|
|
|
int i = 0;
|
|
|
|
|
|
while (*p_data != '\n'){
|
|
|
filename[i] = *p_data;
|
|
|
i++;
|
|
|
p_data++;
|
|
|
}
|
|
|
filename[i] = '\0';
|
|
|
p_data = p_data - i;
|
|
|
fd = fopen(filename,"w");
|
|
|
fprintf(fd, p_data);
|
|
|
fclose(fd);
|
|
|
}
|
|
|
|
|
|
void consigue_nombre_experimento(char *p_data, char filename[]){
|
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
while (*p_data != '\n'){
|
|
|
filename[i] = *p_data;
|
|
|
i++;
|
|
|
p_data++;
|
|
|
}
|
|
|
filename[i] = '\0';
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* 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;
|
|
|
|
|
|
Archivo_Fd = fopen(nombre_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
|
|
|
if(!Archivo_Fd){
|
|
|
printf("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
|
|
|
//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,".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);
|
|
|
|
|
|
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("%s\n",puntero_char); // 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_beam, acumulado_unos, 1);
|
|
|
pio_out(pioc, maskc_out_beam, acumulado_ceros, 0);
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Esta funcion lee "n" veces el estado del APUNTE actual y reporta
|
|
|
* una cadena de Verificacion.
|
|
|
*/
|
|
|
char* chequeo_sistema(char *filename, char *numero_muestras){
|
|
|
|
|
|
int i;
|
|
|
int cnt = 0;
|
|
|
unsigned int entradac= 0;
|
|
|
|
|
|
char page0[250];
|
|
|
|
|
|
/*strcpy(page0,"Verificacion\n");
|
|
|
strcat(page0,parameters.ID);*/
|
|
|
strcpy(page0,parameters.ID);
|
|
|
strcat(page0,"\n-------\n");
|
|
|
|
|
|
char page1[8];
|
|
|
|
|
|
do{
|
|
|
//Inicializando arreglo
|
|
|
for(i=0;i<6;i++)
|
|
|
page1[i]='0';
|
|
|
page1[6] = '\n';
|
|
|
page1[7] = '\0';
|
|
|
//Lectura de puerto
|
|
|
entradac= pio_in(piob,maskb_in);
|
|
|
//Dandole formato al dato
|
|
|
if (!(entradac & bit_up_2))
|
|
|
page1[0] = '1';
|
|
|
if (!(entradac & bit_up_1))
|
|
|
page1[1] = '1';
|
|
|
if (!(entradac & bit_up_0))
|
|
|
page1[2] = '1';
|
|
|
if (!(entradac & bit_dow_2))
|
|
|
page1[3] = '1';
|
|
|
if (!(entradac & bit_dow_1))
|
|
|
page1[4] = '1';
|
|
|
if (!(entradac & bit_dow_0))
|
|
|
page1[5] = '1';
|
|
|
|
|
|
strcat(page0, page1);
|
|
|
cnt=cnt+1;
|
|
|
usleep(1*1000*1000);
|
|
|
|
|
|
}while(cnt < atoi(numero_muestras));
|
|
|
|
|
|
page0[strlen(page0)] = '\0';
|
|
|
|
|
|
char *all_pages = malloc(strlen(page0)+1);
|
|
|
strcpy(all_pages, page0);
|
|
|
return all_pages;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
*
|
|
|
*/
|
|
|
cmp inicializa_modulo(cmp p, char *filename){
|
|
|
//FILE *fd = fopen("configuration.txt","r");
|
|
|
FILE *fd = fopen(filename,"r");
|
|
|
fgets(p.ID,20,fd);
|
|
|
p.ID[7]='\0';
|
|
|
fgets(p.param2,20,fd);
|
|
|
p.param2[10]='\0';
|
|
|
fgets(p.param3,20,fd);
|
|
|
p.param3[10]='\0';
|
|
|
fgets(p.param4,20,fd);
|
|
|
p.param4[10]='\0';
|
|
|
fclose(fd);
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
*
|
|
|
*/
|
|
|
void intToStr( int number, char* str )
|
|
|
|
|
|
{
|
|
|
int index = 0;
|
|
|
|
|
|
while( number > 0 )
|
|
|
{
|
|
|
int digit = number%10;
|
|
|
str[index++] = digit + '0';
|
|
|
number /= 10;
|
|
|
}
|
|
|
str[index] = '\0';
|
|
|
//Adding zero to the left
|
|
|
int n= strlen(str);
|
|
|
if (n == 1) {
|
|
|
strcat(str,"00000");
|
|
|
index = index + 5;
|
|
|
}else if(n == 2){
|
|
|
strcat(str,"0000");
|
|
|
index = index + 4;
|
|
|
}else if(n == 3){
|
|
|
strcat(str,"000");
|
|
|
index = index + 3;
|
|
|
}else if(n == 4){
|
|
|
strcat(str,"00");
|
|
|
index = index + 2;
|
|
|
}else if(n == 5){
|
|
|
strcat(str,"0");
|
|
|
index = index + 1;
|
|
|
}
|
|
|
//Now reverse the numbers in the string.
|
|
|
int position;
|
|
|
for( position = 0; position <= (index-1)/2; ++position )
|
|
|
{
|
|
|
char tmp = str[position];
|
|
|
str[position] = str[(index-1)-position];
|
|
|
str[(index-1)-position] = tmp;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
//*****************************************************************
|
|
|
//ABS_monitoreo es la funci�n principal del proyecto ABS_Monitoreo.
|
|
|
//Esta funci�n es la que se debe agregar en otros c�digos.
|
|
|
//*****************************************************************
|
|
|
char* ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth){
|
|
|
|
|
|
//local variables
|
|
|
/* AT91S_PIO *pioc;
|
|
|
pioc = pio_map(PIOC_BASE);
|
|
|
unsigned int mask_sel_canal =PC4; //Aqu� se indican los pines que se desean usar como salidas. Las constantes PCx est�n defiidas en el header at91gpio.h
|
|
|
unsigned int mask_sel_atenuacion =PC5;
|
|
|
unsigned int mask_sel_calibracion =PC6;*/
|
|
|
|
|
|
unsigned long acumulado_ceros=0;
|
|
|
unsigned long acumulado_unos=0;
|
|
|
/* AT91S_ADC *padc;
|
|
|
AT91S_ADC *padd;*/
|
|
|
FILE *fp;
|
|
|
long int results1[NSAMPLES], results2[NSAMPLES], results3[NSAMPLES], results4[NSAMPLES];
|
|
|
unsigned int i=0;
|
|
|
char fname[FNAMELEN];
|
|
|
int j=0;
|
|
|
time_t now;
|
|
|
FILE *archivo;
|
|
|
float phase1;
|
|
|
float phase2;
|
|
|
char page0[30];
|
|
|
char page1[20];
|
|
|
|
|
|
int cnt = 0;
|
|
|
//system("./map_clock");
|
|
|
/*
|
|
|
if (configCLK() == 1)
|
|
|
printf("clock ADC enable.\n");
|
|
|
*/
|
|
|
/*
|
|
|
//configurar tres pines como salida usando als m�scaras mask_sel_canal, mask_sel_atenuacion y mask_sel_calibracion. En este caso corresponden a los pines pc4, pc5 y pc6.
|
|
|
pio_enable(pioc, mask_sel_canal);
|
|
|
pio_enable(pioc, mask_sel_atenuacion);
|
|
|
pio_enable(pioc, mask_sel_calibracion);
|
|
|
pio_output_enable(pioc, mask_sel_canal); //configurar pc4 como salida
|
|
|
pio_output_enable(pioc, mask_sel_atenuacion); //configurar pc5 como salida
|
|
|
pio_output_enable(pioc, mask_sel_calibracion); //configurar pc6 como salida
|
|
|
*/
|
|
|
|
|
|
//Se modifican las salidas correspondientes a la selecci�n del atenuador y calibraci�n, de acuerdo a los par�metros ingresados en la funci�n ABS_monitoreo.
|
|
|
/*if ( sel_atenuador == 1)
|
|
|
pio_out(pioc, mask_sel_atenuacion, sel_atenuador,1);
|
|
|
else
|
|
|
pio_out(pioc, mask_sel_atenuacion, sel_atenuador,0);
|
|
|
if ( sel_calibracion == 1)
|
|
|
pio_out(pioc, mask_sel_calibracion, sel_calibracion,1);
|
|
|
else
|
|
|
pio_out(pioc, mask_sel_calibracion, sel_calibracion,0);*/
|
|
|
|
|
|
if ( sel_atenuador == 1)
|
|
|
acumulado_unos = acumulado_unos + (1 << 5);
|
|
|
else
|
|
|
acumulado_ceros = acumulado_ceros + (1 << 5);
|
|
|
if ( sel_calibracion == 1)
|
|
|
acumulado_unos = acumulado_unos + (1 << 6);
|
|
|
else
|
|
|
acumulado_ceros = acumulado_ceros + (1 << 6);
|
|
|
|
|
|
|
|
|
strcpy (fname, "/mnt/sd/absmonitoreo.txt"); //Direcci�n y nombre del archivo donde se desea guardar los datos.
|
|
|
|
|
|
if (fExists(fname)==0){ //si el archivo no existe, crea uno y le asigna el titulo
|
|
|
archivo = fopen(fname,"a+");
|
|
|
fprintf(archivo,"%s"," Registro de datos del ABS Control \n");
|
|
|
fprintf(archivo,"%s"," Fecha y hora Fase UP Fase DOWN\n");
|
|
|
fclose(archivo);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
//configure ADC Settings
|
|
|
padc=configADC1();
|
|
|
padd=configADC2();
|
|
|
*/
|
|
|
//while (1){
|
|
|
|
|
|
ENABLE_CHANNEL(padc, ADC_CH0+ADC_CH1);
|
|
|
printf("\nAdquiriendo datos...\n"); //Indica en el terminal que se est�n adquiriendo datos (muestreando la se�al).
|
|
|
|
|
|
|
|
|
now = time(0); //Get current Time for File Name
|
|
|
|
|
|
//Se pone la salida de selecci�n de canal para seleccionar el canal 1 del detector de fase
|
|
|
acumulado_ceros = acumulado_ceros + (1 << 4);
|
|
|
pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
|
|
|
pio_out(pioc, maskc_out_cntl, acumulado_unos, 1);
|
|
|
sleep(1);
|
|
|
|
|
|
//Se toman muestras para el canal 1 del detector de fase
|
|
|
/*while(1){
|
|
|
for(i=0; i < NSAMPLES; i++){
|
|
|
|
|
|
ADC_INIT(padc);
|
|
|
results1[i] = GET_ADC0(padc);
|
|
|
results2[i] = GET_ADC1(padd);
|
|
|
}
|
|
|
|
|
|
if (checkTx(results1, results2, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 1 del datector de fase //correspondan a un pulso.
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
}*/
|
|
|
|
|
|
do{
|
|
|
for(i=0; i < NSAMPLES; i++){
|
|
|
|
|
|
ADC_INIT(padc);
|
|
|
results1[i] = GET_ADC0(padc);
|
|
|
results2[i] = GET_ADC1(padd);
|
|
|
}
|
|
|
|
|
|
if (checkTx(results1, results2, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 1 del datector de fase //correspondan a un pulso.
|
|
|
break;
|
|
|
}
|
|
|
cnt += 1;
|
|
|
}while (cnt < NLOOPS);
|
|
|
|
|
|
//Se pone la salida de selecci�n de canal para seleccionar el canal 2 del detector de fase
|
|
|
acumulado_ceros = acumulado_ceros - (1 << 4);
|
|
|
acumulado_unos = acumulado_unos + (1 << 4);
|
|
|
pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
|
|
|
pio_out(pioc, maskc_out_cntl, acumulado_unos, 1);
|
|
|
sleep(1);
|
|
|
|
|
|
|
|
|
//Setoman muestras para el canal 2 del detector de fase
|
|
|
/* while(1){
|
|
|
for(i=0; i < NSAMPLES; i++){
|
|
|
|
|
|
ADC_INIT(padc);
|
|
|
results3[i] = GET_ADC0(padc);
|
|
|
results4[i] = GET_ADC1(padd);
|
|
|
}
|
|
|
|
|
|
if (checkTx(results3, results4, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 2 del detector de fase //correspondan a un pulso.
|
|
|
break;
|
|
|
}
|
|
|
}*/
|
|
|
cnt = 0;
|
|
|
do{
|
|
|
for(i=0; i < NSAMPLES; i++){
|
|
|
|
|
|
ADC_INIT(padc);
|
|
|
results3[i] = GET_ADC0(padc);
|
|
|
results4[i] = GET_ADC1(padd);
|
|
|
}
|
|
|
|
|
|
if (checkTx(results3, results4, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 2 del detector de fase //correspondan a un pulso.
|
|
|
break;
|
|
|
}
|
|
|
cnt += 1;
|
|
|
}while(cnt < NLOOPS);
|
|
|
|
|
|
//Una vez que se ha encontrado un pulso en cada canal, se calcula la fase de ambos.
|
|
|
|
|
|
phase1 = getPhase(results1, results2); //Calcular la fase del canal 1 del detector de fase.
|
|
|
phase2 = getPhase(results3, results4); //Calcular la fase del canal 2 del detector de fase.
|
|
|
//create Output File
|
|
|
|
|
|
strcpy (fname, "/mnt/sd/absmonitoreo.txt");
|
|
|
printf("\nTerminada la prueba # %d \n", j++);
|
|
|
fp=create_Output(fname, now); //Coloca la fecha y la hora en el archivo de texto
|
|
|
printf("mediana ch1 = %1.2f\n", phase1); //muestra resultado en terminal
|
|
|
printf("mediana ch2 = %1.2f\n", phase2); //muestra resultado en terminal
|
|
|
writeOutput(phase1, fp); //graba el resultado en el archivo de texto
|
|
|
writeOutput(phase2, fp); //graba el resultado en el archivo de texto
|
|
|
fprintf(fp, "\n"); //Pasa a la siguiente l�nea del archivo de texto
|
|
|
fclose(fp);
|
|
|
printf("Resultado guardado en %s \n", fname);
|
|
|
|
|
|
sleep(1);
|
|
|
|
|
|
strcpy(page0,parameters.ID);
|
|
|
strcat(page0,"\n-------\n");
|
|
|
|
|
|
//sprintf(page1,"UP:%1.2f DW:%1.2f\n",phase1, phase2);
|
|
|
sprintf(page1,"%1.2f %1.2f\n",phase1, phase2);
|
|
|
strcat(page0,page1);
|
|
|
char *all_pages = malloc(strlen(page0)+1);
|
|
|
strcpy(all_pages, page0);
|
|
|
return all_pages;
|
|
|
|
|
|
// }
|
|
|
// return 0;
|
|
|
}
|
|
|
/*=============================================================================
|
|
|
Function definitions
|
|
|
=============================================================================*/
|
|
|
|
|
|
// Configures ADC registers in order to get a sample every 10us
|
|
|
AT91S_ADC * configADC1(void){
|
|
|
//Variables a usar:
|
|
|
/*
|
|
|
unsigned int maskc_adc =PC0; //Usamos ADC0 y ADC1
|
|
|
|
|
|
//configuro pin:
|
|
|
AT91S_PIO *pioc;
|
|
|
pioc = pio_map(PIOC_BASE);
|
|
|
pin_adc_enable(pioc,maskc_adc); //Habilitamos PC0 para usar con ADC0 y 1
|
|
|
pio_disable_irq(pioc, maskc_adc);
|
|
|
pio_disable_multiple_driver(pioc, maskc_adc);
|
|
|
pio_disable_pull_ups(pioc, maskc_adc);
|
|
|
pio_input_enable(pioc, maskc_adc);
|
|
|
*/
|
|
|
|
|
|
//Configuro el ADC:
|
|
|
//AT91S_ADC *padc;
|
|
|
|
|
|
padc = adc_map1(ADC_BASE);
|
|
|
|
|
|
//clock ADC = 1MHz
|
|
|
//time startup = 8us
|
|
|
//time sample and hold = 2us
|
|
|
// hold
|
|
|
// ___________
|
|
|
// start ___________| |___________
|
|
|
//
|
|
|
// | --1.2us-- | --0.15us-- |
|
|
|
//ADC_RESET(padc);
|
|
|
CONFIG_ADC(padc,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
|
|
|
ENABLE_CHANNEL(padc,ADC_CH0); //habilito canal 0
|
|
|
return padc;
|
|
|
}
|
|
|
|
|
|
AT91S_ADC * configADC2(void){
|
|
|
//Variables a usar:
|
|
|
/*
|
|
|
unsigned int maskc_adc =PC1; //Usamos ADC0 y ADC1
|
|
|
|
|
|
//configuro pin:
|
|
|
AT91S_PIO *piod;
|
|
|
piod = pio_map(PIOC_BASE);
|
|
|
pin_adc_enable(piod,maskc_adc); //Habilitamos PC1 para usar con ADC0 y 1
|
|
|
pio_disable_irq(piod, maskc_adc);
|
|
|
pio_disable_multiple_driver(piod, maskc_adc);
|
|
|
pio_disable_pull_ups(piod, maskc_adc);
|
|
|
pio_input_enable(piod, maskc_adc);
|
|
|
*/
|
|
|
//Configuro el ADC:
|
|
|
//AT91S_ADC *padd;
|
|
|
|
|
|
padd = adc_map1(ADC_BASE);
|
|
|
|
|
|
//clock ADC = 1MHz
|
|
|
//time startup = 8us
|
|
|
//time sample and hold = 2us
|
|
|
// hold
|
|
|
// ___________
|
|
|
// start ___________| |___________
|
|
|
//
|
|
|
// | --1.2us-- | --0.15us-- |
|
|
|
//ADC_RESET(padc);
|
|
|
CONFIG_ADC(padd,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
|
|
|
ENABLE_CHANNEL(padd,ADC_CH1); //habilito canal 1
|
|
|
return padd;
|
|
|
}
|
|
|
|
|
|
|
|
|
//++++++++++++++++++++
|
|
|
|
|
|
//creats the output file with a timestamp in the name
|
|
|
FILE * create_Output(char *fname, time_t rawtime){
|
|
|
FILE *file;
|
|
|
char timestamp[80];//, counter[5]="dcv";
|
|
|
//char str[4];
|
|
|
struct tm * timeinfo;
|
|
|
|
|
|
//format time
|
|
|
timeinfo = localtime ( &rawtime );
|
|
|
strftime (timestamp,sizeof(timestamp),"%a %y-%m-%d %H:%M:%S %Z",timeinfo);
|
|
|
|
|
|
|
|
|
//Creates the file name out of the #define parameters
|
|
|
|
|
|
strcpy (fname, "/mnt/sd/absmonitoreo.txt");
|
|
|
file = fopen(fname,"a+");
|
|
|
fprintf(file,"%s", timestamp);
|
|
|
//printf("\nTerminada la prueba # %d. Guardando resultado en %s\n",r, fname);
|
|
|
//printf("\nTerminada la prueba # %d/%d. Writing data to the file %s\n",r+1 , REP, fname);
|
|
|
//printf("\nAAAAAAAAAA %d...%s\n", counter[1], fname);
|
|
|
// return file pointer
|
|
|
return file;
|
|
|
}
|
|
|
|
|
|
//++++++++++++++++++++
|
|
|
|
|
|
//tests if a file already exists. returns 1 if it exists and 0 if it doesn't
|
|
|
|
|
|
|
|
|
|
|
|
//Funci�n checkTx verifica que la se�al muestreada corresponda a un pulso.
|
|
|
//results1 y results2 son los arreglos que contienen los datos muestreados por ambos canales del ADC del embebido.
|
|
|
//umbral indica qu� valor debe superar una muestra para considerarla un posible pulso o pico.
|
|
|
//pulsewidth indica cu�ntas muestras consecutivas deben superar el umbral para que se considere que se ha detectado un pulso.
|
|
|
int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth){
|
|
|
|
|
|
int i, cont;
|
|
|
float z[NSAMPLES], sum, avg;
|
|
|
int isSignal, pulse;
|
|
|
|
|
|
for(i=0;i<NSAMPLES;i++){
|
|
|
|
|
|
z[i] =sqrt(1.0*results1[i]*results1[i]+1.0*results2[i]*results2[i]);
|
|
|
}
|
|
|
|
|
|
pulse = 0;
|
|
|
isSignal = 0;
|
|
|
cont =0;
|
|
|
|
|
|
sum = 0;
|
|
|
for(i=0;i<NSAMPLES;i++){
|
|
|
|
|
|
sum += z[i];
|
|
|
avg = sum/(i+1);
|
|
|
if ((z[i] - avg) > umbral){
|
|
|
if (isSignal == 1){
|
|
|
cont += 1;
|
|
|
}
|
|
|
if (cont == pulsewidth){
|
|
|
pulse = 1;
|
|
|
break;
|
|
|
}
|
|
|
isSignal = 1;
|
|
|
continue;
|
|
|
isSignal = 0;
|
|
|
cont = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return pulse; //devuelve un entero: 1 si se ha detectado pulso, de lo contrario, 0.
|
|
|
}
|
|
|
|
|
|
|
|
|
int fExists(char * fname){
|
|
|
FILE * file;
|
|
|
|
|
|
file = fopen (fname, "r");
|
|
|
if (file == NULL)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
fclose(file);
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
|
|
|
//Funci�n que calcula la mediana de un conjunto de muestras
|
|
|
double mediana(long int *results,unsigned int cuenta){
|
|
|
unsigned int i=0,j=0,aux=0;
|
|
|
|
|
|
double median=0;
|
|
|
/*Calculo mediana */
|
|
|
|
|
|
for(i=0;i<cuenta-1;i++){
|
|
|
for (j=i+1;j<cuenta;j++){
|
|
|
if(results[i]>results[j] ){
|
|
|
|
|
|
aux=results[i];
|
|
|
results[i]=results[j];
|
|
|
results[j]=aux;
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
median=results[cuenta/2];
|
|
|
return median;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//Funci�n que halla la fase de la se�al.
|
|
|
//Tiene como entradas las muestras correspondientes a la parte real e imaginaria de la se�al.
|
|
|
float getPhase(long int results1[],long int results2[]){
|
|
|
|
|
|
unsigned int count=0, i=0,umbral=1000;
|
|
|
//long int results1[];
|
|
|
//long int results2[];
|
|
|
long int power[NSAMPLES];
|
|
|
long int sumI=0,sumQ=0,I[NSAMPLES], Q[NSAMPLES],II[NSAMPLES], QQ[NSAMPLES];
|
|
|
double median1=0,median2=0;
|
|
|
long int promedioI=0,promedioQ=0;/*Calculo mediana 1*/
|
|
|
float resultado=0;
|
|
|
|
|
|
for(i=0;i<NSAMPLES;i++){
|
|
|
|
|
|
I[i] =results1[i];
|
|
|
Q[i] =results2[i];
|
|
|
}
|
|
|
|
|
|
/*Calculo mediana 1*/
|
|
|
median1=mediana(I,NSAMPLES);
|
|
|
|
|
|
/*Calculo mediana 2*/
|
|
|
median2=mediana(Q,NSAMPLES);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for(i=0;i<NSAMPLES;i++){
|
|
|
|
|
|
I[i] =results1[i];
|
|
|
Q[i] =results2[i];
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for(i = 0; i < NSAMPLES ; i++){
|
|
|
|
|
|
I[i]=(I[i]-median1);
|
|
|
Q[i]=(Q[i]-median2);
|
|
|
|
|
|
}
|
|
|
|
|
|
for(i = 0; i < NSAMPLES ; i++){
|
|
|
|
|
|
power[i]=I[i]*I[i]+Q[i]*Q[i];
|
|
|
|
|
|
if(power[i] > umbral)
|
|
|
{
|
|
|
|
|
|
II[count]=I[i];
|
|
|
QQ[count]=Q[i];
|
|
|
count=count+1;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
for(i = 0; i < count ; i++){
|
|
|
|
|
|
sumI=sumI+II[i];
|
|
|
sumQ=sumQ+QQ[i];
|
|
|
|
|
|
}
|
|
|
|
|
|
promedioI=sumI;
|
|
|
promedioQ=sumQ;
|
|
|
|
|
|
resultado = atan2(1.0*promedioI,1.0*promedioQ)*180/3.1416+62-44;
|
|
|
|
|
|
|
|
|
return resultado;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//Funci�n que muestra la fase detectada en el terminal y tambi�n la graba en el archivo de texto.
|
|
|
void writeOutput(float resultado, FILE * output){
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
|
fprintf(output," %1.2f ",resultado); //graba resultado en archivo .txt
|
|
|
//
|
|
|
|
|
|
}
|
|
|
|
|
|
int configCLK(){
|
|
|
//configuro pin:
|
|
|
AT91S_PMC *sys_clock;
|
|
|
sys_clock = clock_map(CLOCK_BASE);
|
|
|
enable_clock_adc(sys_clock);
|
|
|
//printf("clock ADC enable.\n");
|
|
|
return 1;
|
|
|
}
|
|
|
|
