##// END OF EJS Templates
ABS » abscontrol
RSS
imanay -
r130:131
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1035 +1,1106
1 1 /*
2 2 * Servidor.c
3 3 *
4 4 * Created on: Nov 3, 2009
5 5 * Author: Jose Francisco Quenta
6 6 *
7 7 * Se implementa:
8 8 * -Carga en memoria los apuntes contenidos en un archivo de experimentos: apunte0 -> GPIO
9 9 * -Cambio de apunte.
10 10 * -Lectura del estado actual del apunte y grabado del mismo en un archivo
11 11 *
12 12 * Modified by Iván Manay since Nov 2012
13 13 * -From UDP to TCP.
14 14 * -Use of a frame for TCP communications with the central control module.
15 15 */
16 16
17 17 #include <stdio.h>
18 18 #include <stdlib.h>
19 19 #include <string.h>
20 20 #include <unistd.h>
21 21 #include <errno.h>
22 22
23 23 #include <sys/types.h>
24 24 #include <sys/socket.h>
25 25 #include <netinet/in.h>
26 26 #include <arpa/inet.h>
27 27 #include <netdb.h>
28 28 #include <time.h>
29 29 #include <math.h>
30 30
31 31 #include "./Librerias/at91gpio.h"
32 32 //#include "./Librerias/Mensajes.h"
33 33 #include "./Librerias/at91adc.h"
34 34 //clock
35 35 #include "./Librerias/at91sysclock.h"
36 36
37 37 #define PUERTO_SERVIDOR 5500
38 38 #define TAM_BUFFER 1024
39 39
40 #define maskc_out PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
41
42 #define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
43
44 #define bit_up_2 0x00010000 //Mascara de cada bit a revisar: bit_up_2 es MSB
45 #define bit_up_1 0x00040000
46 #define bit_up_0 0x00100000
47 #define bit_dow_2 0x40000000
48 #define bit_dow_1 0x01000000
49 #define bit_dow_0 0x00400000
50
51 #define MyID 11
52 #define MAXPENDING 5 /* Maximum outstanding connection requests */
40 #define maskc_out_beam PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
41 #define maskc_out_cntl PC4+PC5+PC6 //MONITORING CONTROL
42
43 #define mask_sel_canal PC4 //MONITORING CONTROL
44 #define mask_sel_atenuacion PC5
45 #define mask_sel_calibracion PC6
46
47 #define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
48
49 #define maskc_in_adc PC0+PC1
50
51 #define bit_up_2 0x00010000 //Mascara de cada bit a revisar: bit_up_2 es MSB
52 #define bit_up_1 0x00040000
53 #define bit_up_0 0x00100000
54 #define bit_dow_2 0x40000000
55 #define bit_dow_1 0x01000000
56 #define bit_dow_0 0x00400000
57
58 #define MyID 11
59 #define MAXPENDING 5 /* Maximum outstanding connection requests */
53 60
54 61 //parameters for the name of the output file
55 62 #define FPRE "AD" //prefix for the output file name
56 63 #define FEXT ".out" //file extension for the output file
57 64 #define FNAMELEN 40
58 65
59 66 //ADC parameters
60 67 #define REP 1 //defines how many times the data acquisation loop is repeated
61 #define NSAMPLES 100 //defines how many samples are taken in one data acqu-
68 #define NSAMPLES 10 //defines how many samples are taken in one data acqu-
62 69 // isation loop
63 70 #define CNVTIME 14.3 //defines how long it takes to get one sample. Value
64 71 // is only needed for the output file, doesn't change
65 72 // any ADC configurations
66 73 #define UREF 3.3 //Reference Voltage of ADC (max. ADC Voltage)
67 74 #define ADCRES 1023 //Resolution of ADC (10bit=1023)
68 75
69 76
70 77 char *buff_experimento= NULL;
71 78
72 79 AT91S_PIO *pioc;
73 80 AT91S_PIO *piob;
81 AT91S_PIO *pio_adc;
82 AT91S_ADC *padc;
83 AT91S_ADC *padd;
74 84
75 85 struct control_module_parameters {
76 86 char ID[20];
77 87 char param2[20];
78 88 char param3[20];
79 89 char param4[20];
80 90 };
81 91
82 92 typedef struct control_module_parameters cmp;
83 93
84 94 char *header = NULL;
85 95 char *TypeOfInstrument = NULL;
86 96 char *iDSource = NULL;
87 97 char *iDDestino = NULL;
88 98 char *rx_len = NULL;
89 99 char *cmd = NULL;
90 100 char *rx_data = NULL;
91 101 char *crc = NULL;
92 102
93 103 cmp parameters;
94 104 /*
95 105 * Zona de declaracion de cabeceras.
96 106 */
97 107 cmp inicializa_modulo(cmp p);
98 108 int inicializa_ethernet();
99 109 int rxData(int, char*);
100 110 void txData(int, char*);
101 111 void inicializa_gpio();
112 void inicializa_adc();
102 113 void procesa_peticion(char *rx_buffer, char *tx_buffer);
103 114 int cambia_apuntamiento(char *puntero_char);
104 115 int carga_experimento(char *nombre_archivo);
105 116 char *chequeo_sistema(char *filename, char *numero_muestras);
106 117 void recibe_experimento(char *data, char filename[]);
107 118 void SplitFrame(char *frame);
108 119 void intToStr( int number, char* str );
109 120
110 121 //ABS monitoring
111 int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
112
122 //int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
123 char* ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth);
113 124 AT91S_ADC * configADC1(void);
114 125 AT91S_ADC * configADC2(void);
115 126
116 127 FILE * create_Output(char*, time_t);
117 128
118 129 void writeOutput(float resultado, FILE * output);
119 130
120 131 int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth);
121 132
122 133 double mediana(long int *results, unsigned int cuenta);
123 134 float getPhase(long int results1[], long int results2[]);
124 135
125 136 int fExists(char *);
126 137 int configCLK();
127 138 //
128 139
129 140 /*
130 141 *
131 142 */
132 143 int main(){
133 144
134 145 int servSocket;
135 146 int clntSocket;
136 147
137 148
138 149 char *rx_buffer = (char *) malloc(TAM_BUFFER);
139 150 char *tx_buffer = (char *) malloc(TAM_BUFFER);
140 151 /* Inicializa parametros del modulo*/
141 152 parameters = inicializa_modulo(parameters);
142 153 printf("%s\n%s\n%s\n%s\n",parameters.ID, parameters.param2, parameters.param3, parameters.param4);
143 154 /* Inicializa red*/
144 155 servSocket = inicializa_ethernet();
145 156 /* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
146 157 inicializa_gpio();
158 inicializa_adc();
147 159
148 160 while(1){
149 161 // Recepción TCP de petición
150 162 clntSocket = rxData(servSocket, rx_buffer);
151 163 //testpoint
152 164 printf("rx:%s\n",rx_buffer);
153 165 // Procesamiento de la petición
154 166 procesa_peticion(rx_buffer, tx_buffer);
155 167 //testpoint
156 168 printf("tx:%s\n",tx_buffer);
157 169 // Respuesta del modulo de control
158 170 txData(clntSocket, tx_buffer);
159 171
160 172 }
161 173 }
162 174
163 175
164 176 int inicializa_ethernet(){
165 177
166 178 struct sockaddr_in inf_servidor;
167 179
168 180 int servSocket;
169 181
170 182 int resultado;
171 183
172 184 /* Haciendo la estructura local*/
173 185 memset(&inf_servidor, 0, sizeof(inf_servidor));
174 186 inf_servidor.sin_family= AF_INET;
175 187 inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
176 188 inf_servidor.sin_addr.s_addr= INADDR_ANY;
177 189
178 190 /* Se establece el socket */
179 191 servSocket = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
180 192 if (servSocket == -1){
181 193 printf("No se establecio correctamente el socket: socket()\n");
182 194 //ERROR_FATAL("No se establecio correctamente el socket: socket()\n");
183 195 exit(-1);
184 196 }
185 197
186 198 /* Se asocia el socket a un puerto y una IP */
187 199 resultado = bind(servSocket,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
188 200 if (resultado== -1){
189 201 printf("No se establecio correctamente el socket: bind()\n");
190 202 //ERROR_FATAL("No se establecio correctamente el socket: bind()\n");
191 203 exit(-1);
192 204 }
193 205
194 206 if (listen(servSocket, MAXPENDING) < 0){
195 207 printf("listen() failed\n");
196 208 exit(-1);
197 209 }
198 210
199 211 return servSocket;
200 212
201 213 }
202 214
203 215 int rxData(int servSocket, char* rx_buffer){
204 216
205 217 int clntSocket;
206 218 struct sockaddr_in inf_cliente;
207 219 int numbytes_recibidos;
208 220 unsigned int inf_client_Len;
209 221
210 222 printf("\nEsperando solicitud de cliente...\n");
211 223
212 224 /* Set the size of the in-out parameter */
213 225 inf_client_Len = sizeof(inf_cliente);
214 226 /* Se espera hasta que un cliente se conecte */
215 227 if ((clntSocket = accept(servSocket, (struct sockaddr *) &inf_cliente,
216 228 &inf_client_Len)) < 0)
217 229 printf("accept() failed\n");
218 230
219 231 if ((numbytes_recibidos = recv(clntSocket, rx_buffer, TAM_BUFFER, 0)) < 0)
220 232 printf("recv() failed\n");
221 233
222 234 /* Se procede a procesar los datos recibidos */
223 235 rx_buffer[numbytes_recibidos]= '\0';
224 236
225 237 return clntSocket;
226 238 }
227 239
228 240 void txData(int clntSocket, char* data){
229 241
230 242 /* Echo message back to client */
231 243 if (send(clntSocket, data, strlen(data), 0) != strlen(data))
232 244 printf("send() failed\n");
233 245
234 246 close(clntSocket); /* Close client socket */
235 247 }
236 248
237 249 /*
238 250 * Esta funcion incializa el puerto GPIO
239 251 */
240 252 void inicializa_gpio(){
241 253
242 // Configuracion de los pines de APUNTE
254 int desplazamiento_beam[6]={30,28,26,24,22,20}; //Desplazamientos para los pines de apunte
255 int desplazamiento_cntl[3]={4,5,6}; //Desplazamientos para los pines de control de monitoreo
256 unsigned long acumulado_ceros=0;
257 int i;
258
259 // Configuracion de los pines de APUNTE y control de monitoreo
243 260 pioc = pio_map(PIOC_BASE);
244 pio_enable(pioc, maskc_out);
245 pio_disable_irq(pioc, maskc_out);
246 pio_disable_multiple_driver(pioc, maskc_out);
247 pio_disable_pull_ups(pioc, maskc_out);
248 pio_synchronous_data_output(pioc, maskc_out);
249 pio_output_enable(pioc, maskc_out);
261 pio_enable(pioc, maskc_out_beam + maskc_out_cntl);
262 pio_disable_irq(pioc, maskc_out_beam + maskc_out_cntl);
263 pio_disable_multiple_driver(pioc, maskc_out_beam + maskc_out_cntl);
264 pio_disable_pull_ups(pioc, maskc_out_beam + maskc_out_cntl);
265 pio_synchronous_data_output(pioc, maskc_out_beam + maskc_out_cntl);
266 pio_output_enable(pioc, maskc_out_beam + maskc_out_cntl);
250 267
251 268 // Configuracion de los pines de VERIFICACION
252 269 piob = pio_map(PIOB_BASE);
253 270 pio_enable(piob, maskb_in);
254 271 pio_disable_irq(piob, maskb_in);
255 272 pio_disable_multiple_driver(piob, maskb_in);
256 273 pio_disable_pull_ups(piob, maskb_in);
257 274 pio_input_enable(piob, maskb_in);
275
276 //Pînes de ADC
277 pio_adc = pio_map(PIOC_BASE);
278 pin_adc_enable(pio_adc,maskc_in_adc); //Habilitamos PC0 para usar con ADC0 y 1
279 pio_disable_irq(pio_adc, maskc_in_adc);
280 pio_disable_multiple_driver(pio_adc, maskc_in_adc);
281 pio_disable_pull_ups(pio_adc, maskc_in_adc);
282 pio_input_enable(pio_adc, maskc_in_adc);
283
284 //Inicializando a cero los pines de apunte
285 for(i=0;i<6;i++)
286 acumulado_ceros= acumulado_ceros + (1 << desplazamiento_beam[i]);
287 pio_out(pioc, maskc_out_beam, acumulado_ceros, 0);
288
289 //Inicializando a cero los pines de control de monitoreo: atenuacion, calibracion y canal
290 for(i=0;i<3;i++)
291 acumulado_ceros= acumulado_ceros + (1 << desplazamiento_cntl[i]);
292 pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
293
294 }
295
296 void inicializa_adc(){
297
298 if (configCLK() == 1)
299 printf("clock ADC enable.\n");
300 //configure ADC Settings
301 padc=configADC1();
302 padd=configADC2();
258 303 }
259 304
260 305
261 306 /*
262 307 * Divide rx frame into the frame components
263 308 */
264 309 void SplitFrame(char *frame){
265 310 header = malloc(4);
266 311 *header = *frame;
267 312 *(header + 1) = *(frame + 1);
268 313 *(header + 2) = *(frame + 2);
269 314 *(header + 3) = '\0';
270 315 TypeOfInstrument = malloc(4);
271 316 *TypeOfInstrument = *(frame + 3);
272 317 *(TypeOfInstrument + 1) = *(frame + 4);
273 318 *(TypeOfInstrument + 2) = *(frame + 5);
274 319 *(TypeOfInstrument + 3) = '\0';
275 320 iDSource = malloc(8);
276 321 *iDSource = *(frame + 6);
277 322 *(iDSource + 1) = *(frame + 7);
278 323 *(iDSource + 2) = *(frame + 8);
279 324 *(iDSource + 3) = *(frame + 9);
280 325 *(iDSource + 4) = *(frame + 10);
281 326 *(iDSource + 5) = *(frame + 11);
282 327 *(iDSource + 6) = *(frame + 12);
283 328 *(iDSource + 7) = '\0';
284 329 iDDestino = malloc(8);
285 330 *iDDestino = *(frame + 13);
286 331 *(iDDestino + 1) = *(frame + 14);
287 332 *(iDDestino + 2) = *(frame + 15);
288 333 *(iDDestino + 3) = *(frame + 16);
289 334 *(iDDestino + 4) = *(frame + 17);
290 335 *(iDDestino + 5) = *(frame + 18);
291 336 *(iDDestino + 6) = *(frame + 19);
292 337 *(iDDestino + 7) = '\0';
293 338 rx_len = malloc(7);
294 339 *rx_len = *(frame + 20);
295 340 *(rx_len + 1) = *(frame + 21);
296 341 *(rx_len + 2) = *(frame + 22);
297 342 *(rx_len + 3) = *(frame + 23);
298 343 *(rx_len + 4) = *(frame + 24);
299 344 *(rx_len + 5) = *(frame + 25);
300 345 *(rx_len + 6) = '\0';
301 346 cmd = malloc(5);
302 347 *cmd = *(frame + 26);
303 348 *(cmd + 1) = *(frame + 27);
304 349 *(cmd + 2) = *(frame + 28);
305 350 *(cmd + 3) = *(frame + 29);
306 351 *(cmd + 4) = '\0';
307 352
308 353 int l = atoi(rx_len);
309 354 rx_data = malloc(l + 1);
310 355 int i;
311 356 for (i = 30; i < 30 + l; i++)
312 357 *(rx_data + (i-30)) = *(frame + i);
313 358 *(rx_data + l) = '\0';
314 359 crc = malloc(2);
315 360 *crc = *(frame + 30 + l);
316 361 *(crc + 1) = '\0';
317 362 }
318 363
319
320 364 /*
321 365 * Esta funcion procesa el mensaje de peticion y genera respuesta
322 366 */
323 367 void procesa_peticion(char *rx_buffer, char *tx_buffer){
324 368 // int n = 0;
325 369 char filename1[50];
326 370 char filename2[] = "verificacion.txt";
327 371 char *tx_data = NULL;
328 372 char *tx_len = NULL;
329 373 SplitFrame(rx_buffer);
330 374
331 375 if ((cmd == NULL) || (rx_data == NULL)){
332 376 printf("procesarPeticion: formato de mensaje incorrecto");
333 377 //ERROR("procesarPeticion: formato de mensaje incorrecto");
334 378
335 379 }
336 380 else{
337 381 if(strcmp(cmd,"SNDF") == 0){
338 382 recibe_experimento(rx_data,filename1);
339 383 carga_experimento(filename1);
340 384 cambia_apuntamiento("0");
341 385 tx_data = (char*)malloc(3);
342 386 tx_data = "OK";
343 387 }
344 388 else if(strcmp(cmd,"CHGB") == 0){
345 389 cambia_apuntamiento(rx_data);
346 390 tx_data = (char*)malloc(3);
347 391 tx_data = "OK";
348 392 }
349 393 else if(strcmp(cmd,"ANST") == 0){
350 394 tx_data = chequeo_sistema(filename2,rx_data);
351 395 printf("%s\n",tx_data);
352 396 }
353 397 else if(strcmp(cmd,"ANPH") == 0){
354 ABS_monitoreo(1, 1, 50, 10);
355 tx_data = "Not implemented\n";
398 tx_data = ABS_monitoreo(1, 1, 50, 10);
399 // tx_data = "Not implemented\n";
356 400 printf("%s\n",tx_data);
357 401 }
358 402 else if(strcmp(cmd,"NTST") == 0){
359 403 tx_data = malloc(strlen(parameters.ID) + 1);
360 404 strcpy(tx_data,parameters.ID);
361 405 printf("%s\n",tx_data);
362 406 }
363 407 else{
364 408 tx_data = (char*)malloc(6);
365 409 tx_data = "Error";
366 410 printf("procesa_peticion: comando no reconocido");
367 411 //ERROR("procesa_peticion: comando no reconocido");
368 412 }
369 413
370 414 tx_len = malloc(7);
371 415 int number = strlen(tx_data);
372 416 intToStr(number, tx_len );
373 417
374 418 strcpy(tx_buffer,header); //3
375 419 strcat(tx_buffer,TypeOfInstrument); //3
376 420 strcat(tx_buffer,parameters.ID); //7
377 421 strcat(tx_buffer,iDSource); //7
378 422 strcat(tx_buffer,tx_len); //6
379 423 strcat(tx_buffer,cmd); //4
380 424 strcat(tx_buffer,tx_data); //?
381 425 strcat(tx_buffer,crc); //1
382 426
383 427 }
384 428
385 429 }
386 430
387 431 /*
388 432 * Esta función genera el archivo de experimento a partir de la trama TCP recibida
389 433 */
390 434 void recibe_experimento(char *p_data, char filename[]){
391 435 FILE *fd;
392 436 int i = 0;
393 437
394 438 while (*p_data != '\n'){
395 439 filename[i] = *p_data;
396 440 i++;
397 441 p_data++;
398 442 }
399 443 filename[i] = '\0';
400 444 p_data = p_data - i;
401 445 fd = fopen(filename,"w");
402 446 fprintf(fd, p_data);
403 447 fclose(fd);
404 448 }
405 449
406 450 /*
407 451 * Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
408 452 * este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
409 453 * que sera usado en el cambio de apuntamiento.
410 454 */
411 455 int carga_experimento(char *nombre_archivo){
412 456
413 457 FILE *Archivo_Fd;
414 458
415 459 char *cadena = (char *) malloc(25);
416 460
417 461 int longitud_cadena;
418 462 int num_bytes= 0;
419 463 int num_filas= 0;
420 464
421 465 Archivo_Fd = fopen(nombre_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
422 466 if(!Archivo_Fd){
423 467 printf("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
424 468 //ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
425 469 return -1;
426 470 }else{
427 471
428 472 while(!feof(Archivo_Fd)){ // Se procede a calcular la longitud del archivo para separar memoria
429 473 fgets(cadena,20,Archivo_Fd);
430 474 longitud_cadena= strlen(cadena);
431 475 cadena[longitud_cadena-1] = '\0';
432 476 num_bytes = num_bytes + longitud_cadena;
433 477 num_filas++;
434 478 }
435 479
436 480 rewind(Archivo_Fd); // Se reinicia el puntero del archivo
437 481
438 482 char *buffer_temporal = (char *) malloc(num_bytes+1); // Se separa espacio de memoria segun
439 483 // la longitud del archivo
440 484 fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);
441 485
442 486 char *puntero= strstr(buffer_temporal,".ab1"); // Se procede a eliminar la cabecera del archivo
443 487 puntero= puntero + 12;
444 488
445 489 buff_experimento = (char *) malloc(7*(num_filas-3)); // num_bytes_fila*(num_filas-3);
446 490 strncpy(buff_experimento,puntero,7*(num_filas-3)); // Se carga en memoria la informacion del archivo
447 491
448 492 fclose(Archivo_Fd);
449 493
450 494 return 1;
451 495 }
452 496 }
453 497
454 498 /*
455 499 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
456 500 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
457 501 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
458 502 * traves del puerto GPIO.
459 503 */
460 504 int cambia_apuntamiento(char *puntero_char){
461 505
462 506 /*MSB-UP-LSB MSB-DOWN-LSB*/
463 507 int desplazamiento[6]={30,28,26,24,22,20}; // Defino los dezplazamientos que se aplicara
464 508 // al dato que ingresa para formar el número
465 509 // entero que se le pasara al puerto GPIO
466 510 // Estos números son los pines del puerto GPIO
467 511 // que se estan usando para el control
468 512
469 513 int puntero= atoi(puntero_char); // Se convierte a entero la direccion del puntero
470 514
471 515 int base= 7*puntero; // base= cantidad_bytes del dato x puntero
472 516 // cantidad de bytes es el numero de bytes que
473 517 printf("%s\n",puntero_char); // contiene cada dato, para este caso es 7
474 518 // porque es 6 bits de datos + 1 bit del cambio
475 519 // de linea.
476 520 char valor_char;
477 521 unsigned long valor;
478 522 unsigned long acumulado_ceros=0;
479 523 unsigned long acumulado_unos=0;
480 524
481 525 int offset; // Defino offset para el desplazamiento a traves
482 526 for(offset=0;offset<6;offset++){ // de cada dato que se obtiene del "buff_experimento"
483 527
484 528 valor_char= buff_experimento[base+offset]; // Obtengo el dato
485 529
486 530 if (valor_char == '0'){ // Obtengo el número acumulado segun sea un cero o un uno
487 531 valor= 0;
488 532 acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
489 533 }else{
490 534 valor= 1;
491 535 acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
492 536 }
493 537 }
494 pio_out(pioc, maskc_out, acumulado_unos, 1);
495 pio_out(pioc, maskc_out, acumulado_ceros, 0);
538 pio_out(pioc, maskc_out_beam, acumulado_unos, 1);
539 pio_out(pioc, maskc_out_beam, acumulado_ceros, 0);
496 540
497 541 return 1;
498 542
499 543 }
500 544
501 545 /*
502 546 * Esta funcion lee "n" veces el estado del APUNTE actual y reporta
503 547 * una cadena de Verificacion.
504 548 */
505 549 char* chequeo_sistema(char *filename, char *numero_muestras){
506 550
507 551 int i;
508 552 int cnt = 0;
509 553 unsigned int entradac= 0;
510 554
511 555 char page0[250];
512 556
513 557 /*strcpy(page0,"Verificacion\n");
514 558 strcat(page0,parameters.ID);*/
515 559 strcpy(page0,parameters.ID);
516 560 strcat(page0,"\n-------\n");
517 561
518 562 char page1[8];
519 563
520 564 do{
521 565 //Inicializando arreglo
522 566 for(i=0;i<6;i++)
523 567 page1[i]='0';
524 568 page1[6] = '\n';
525 569 page1[7] = '\0';
526 570 //Lectura de puerto
527 571 entradac= pio_in(piob,maskb_in);
528 572 //Dandole formato al dato
529 573 if (!(entradac & bit_up_2))
530 574 page1[0] = '1';
531 575 if (!(entradac & bit_up_1))
532 576 page1[1] = '1';
533 577 if (!(entradac & bit_up_0))
534 578 page1[2] = '1';
535 579 if (!(entradac & bit_dow_2))
536 580 page1[3] = '1';
537 581 if (!(entradac & bit_dow_1))
538 582 page1[4] = '1';
539 583 if (!(entradac & bit_dow_0))
540 584 page1[5] = '1';
541 585
542 586 strcat(page0, page1);
543 587 cnt=cnt+1;
544 588 usleep(1*1000*1000);
545 589
546 590 }while(cnt < atoi(numero_muestras));
547 591
548 592 page0[strlen(page0)] = '\0';
549 593
550 594 char *all_pages = malloc(strlen(page0)+1);
551 595 strcpy(all_pages, page0);
552 596 return all_pages;
553 597 }
554 598
555 599 /*
556 600 *
557 601 */
558 602 cmp inicializa_modulo(cmp p){
559 603 FILE *fd = fopen("configuration.txt","r");
560 604 fgets(p.ID,20,fd);
561 605 p.ID[7]='\0';
562 606 fgets(p.param2,20,fd);
563 607 p.param2[10]='\0';
564 608 fgets(p.param3,20,fd);
565 609 p.param3[10]='\0';
566 610 fgets(p.param4,20,fd);
567 611 p.param4[10]='\0';
568 612 fclose(fd);
569 613 return p;
570 614 }
571 615
572 616 /*
573 617 *
574 618 */
575 619 void intToStr( int number, char* str )
576 620
577 621 {
578 622 int index = 0;
579 623
580 624 while( number > 0 )
581 625 {
582 626 int digit = number%10;
583 627 str[index++] = digit + '0';
584 628 number /= 10;
585 629 }
586 630 str[index] = '\0';
587 631 //Adding zero to the left
588 632 int n= strlen(str);
589 633 if (n == 1) {
590 634 strcat(str,"00000");
591 635 index = index + 5;
592 636 }else if(n == 2){
593 637 strcat(str,"0000");
594 638 index = index + 4;
595 639 }else if(n == 3){
596 640 strcat(str,"000");
597 641 index = index + 3;
598 642 }else if(n == 4){
599 643 strcat(str,"00");
600 644 index = index + 2;
601 645 }else if(n == 5){
602 646 strcat(str,"0");
603 647 index = index + 1;
604 648 }
605 649 //Now reverse the numbers in the string.
606 650 int position;
607 651 for( position = 0; position <= (index-1)/2; ++position )
608 652 {
609 653 char tmp = str[position];
610 654 str[position] = str[(index-1)-position];
611 655 str[(index-1)-position] = tmp;
612 656 }
613 657 }
614 658
615 659
616 660 //*****************************************************************
617 661 //ABS_monitoreo es la funci�n principal del proyecto ABS_Monitoreo.
618 662 //Esta funci�n es la que se debe agregar en otros c�digos.
619 663 //*****************************************************************
620 int ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth){
664 char* ABS_monitoreo(int sel_atenuador, int sel_calibracion, float umbral, int pulsewidth){
621 665
622 666 //local variables
623 AT91S_PIO *pioc;
667 /* AT91S_PIO *pioc;
624 668 pioc = pio_map(PIOC_BASE);
625 669 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
626 670 unsigned int mask_sel_atenuacion =PC5;
627 unsigned int mask_sel_calibracion =PC6;
628 AT91S_ADC *padc;
629 AT91S_ADC *padd;
671 unsigned int mask_sel_calibracion =PC6;*/
672
673 unsigned long acumulado_ceros=0;
674 unsigned long acumulado_unos=0;
675 /* AT91S_ADC *padc;
676 AT91S_ADC *padd;*/
630 677 FILE *fp;
631 678 long int results1[NSAMPLES], results2[NSAMPLES], results3[NSAMPLES], results4[NSAMPLES];
632 679 unsigned int i=0;
633 680 char fname[FNAMELEN];
634 681 int j=0;
635 682 time_t now;
636 683 FILE *archivo;
637 684 float phase1;
638 685 float phase2;
686 char page0[30];
687 char page1[20];
639 688 //system("./map_clock");
640
689 /*
641 690 if (configCLK() == 1)
642 691 printf("clock ADC enable.\n");
643
644
692 */
693 /*
645 694 //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.
646 695 pio_enable(pioc, mask_sel_canal);
647 696 pio_enable(pioc, mask_sel_atenuacion);
648 697 pio_enable(pioc, mask_sel_calibracion);
649 698 pio_output_enable(pioc, mask_sel_canal); //configurar pc4 como salida
650 699 pio_output_enable(pioc, mask_sel_atenuacion); //configurar pc5 como salida
651 700 pio_output_enable(pioc, mask_sel_calibracion); //configurar pc6 como salida
652
701 */
653 702
654 703 //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.
655 if ( sel_atenuador == 1)
704 /*if ( sel_atenuador == 1)
656 705 pio_out(pioc, mask_sel_atenuacion, sel_atenuador,1);
657 706 else
658 707 pio_out(pioc, mask_sel_atenuacion, sel_atenuador,0);
659 708 if ( sel_calibracion == 1)
660 709 pio_out(pioc, mask_sel_calibracion, sel_calibracion,1);
661 710 else
662 pio_out(pioc, mask_sel_calibracion, sel_calibracion,0);
663
664
665 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt"); //Direcci�n y nombre del archivo donde se desea guardar los datos.
711 pio_out(pioc, mask_sel_calibracion, sel_calibracion,0);*/
712
713 if ( sel_atenuador == 1)
714 acumulado_unos = acumulado_unos + (1 << 5);
715 else
716 acumulado_ceros = acumulado_ceros + (1 << 5);
717 if ( sel_calibracion == 1)
718 acumulado_unos = acumulado_unos + (1 << 6);
719 else
720 acumulado_ceros = acumulado_ceros + (1 << 6);
721
722
723 strcpy (fname, "/mnt/sd/absmonitoreo.txt"); //Direcci�n y nombre del archivo donde se desea guardar los datos.
666 724
667 725 if (fExists(fname)==0){ //si el archivo no existe, crea uno y le asigna el titulo
668 726 archivo = fopen(fname,"a+");
669 727 fprintf(archivo,"%s"," Registro de datos del ABS Control \n");
670 728 fprintf(archivo,"%s"," Fecha y hora Fase UP Fase DOWN\n");
671 729 fclose(archivo);
672 730 }
673 731
674
732 /*
675 733 //configure ADC Settings
676 734 padc=configADC1();
677 735 padd=configADC2();
678
679 while (1){
680
681 ENABLE_CHANNEL(padc, ADC_CH0+ADC_CH1);
682 printf("\nAdquiriendo datos...\n"); //Indica en el terminal que se est�n adquiriendo datos (muestreando la se�al).
683
684
685 now = time(0); //Get current Time for File Name
686
687
688 //Se pone la salida de selecci�n de canal para seleccionar el canal 1 del detector de fase
689 // pio_out(pioc, mask_sel_canal, 0,1);
690 pio_out(pioc, mask_sel_canal, 0,1);
691
692
693 //Se toman muestras para el canal 1 del detector de fase
694 while(1){
736 */
737 //while (1){
738
739 ENABLE_CHANNEL(padc, ADC_CH0+ADC_CH1);
740 printf("\nAdquiriendo datos...\n"); //Indica en el terminal que se est�n adquiriendo datos (muestreando la se�al).
741
742
743 now = time(0); //Get current Time for File Name
744
745 //Se pone la salida de selecci�n de canal para seleccionar el canal 1 del detector de fase
746 acumulado_ceros = acumulado_ceros + (1 << 4);
747 pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
748 pio_out(pioc, maskc_out_cntl, acumulado_unos, 1);
749 sleep(1);
750
751 //Se toman muestras para el canal 1 del detector de fase
752 //while(1){
695 753 for(i=0; i < NSAMPLES; i++){
696 754
697 755 ADC_INIT(padc);
698 756 results1[i] = GET_ADC0(padc);
699 757 results2[i] = GET_ADC1(padd);
700 758 }
701
702
759 /*
703 760 if (checkTx(results1, results2, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 1 del datector de fase //correspondan a un pulso.
704 761 break;
705 762 }
706 }
707
708
709 //Se pone la salida de selecci�n de canal para seleccionar el canal 2 del detector de fase
710 pio_out(pioc, mask_sel_canal, 1,1);
711
712
713
714 //Setoman muestras para el canal 2 del detector de fase
715 while(1){
763 */
764 //}
765
766
767 //Se pone la salida de selecci�n de canal para seleccionar el canal 2 del detector de fase
768 acumulado_ceros = acumulado_ceros - (1 << 4);
769 acumulado_unos = acumulado_unos + (1 << 4);
770 pio_out(pioc, maskc_out_cntl, acumulado_ceros, 0);
771 pio_out(pioc, maskc_out_cntl, acumulado_unos, 1);
772 sleep(1);
773
774
775 //Setoman muestras para el canal 2 del detector de fase
776 // while(1){
716 777 for(i=0; i < NSAMPLES; i++){
717 778
718 779 ADC_INIT(padc);
719 780 results3[i] = GET_ADC0(padc);
720 781 results4[i] = GET_ADC1(padd);
721 782 }
722
783 /*
723 784 if (checkTx(results3, results4, umbral, pulsewidth)==1){ //Se verifica que las muestras tomadas del canal 2 del detector de fase //correspondan a un pulso.
724 785 break;
725 786 }
726 }
727
728
729 //Una vez que se ha encontrado un pulso en cada canal, se calcula la fase de ambos.
730
731 phase1 = getPhase(results1, results2); //Calcular la fase del canal 1 del detector de fase.
732 phase2 = getPhase(results3, results4); //Calcular la fase del canal 2 del detector de fase.
733 //create Output File
734
735 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt");
736 printf("\nTerminada la prueba # %d \n", j++);
737 fp=create_Output(fname, now); //Coloca la fecha y la hora en el archivo de texto
738 printf("mediana ch1 = %1.2f\n", phase1); //muestra resultado en terminal
739 printf("mediana ch2 = %1.2f\n", phase2); //muestra resultado en terminal
740 writeOutput(phase1, fp); //graba el resultado en el archivo de texto
741 writeOutput(phase2, fp); //graba el resultado en el archivo de texto
742 fprintf(fp, "\n"); //Pasa a la siguiente l�nea del archivo de texto
743 fclose(fp);
744 printf("Resultado guardado en %s \n", fname);
745
746 sleep(1);
747
748 }
749 return 0;
787 */
788 // }
789
790
791 //Una vez que se ha encontrado un pulso en cada canal, se calcula la fase de ambos.
792
793 phase1 = getPhase(results1, results2); //Calcular la fase del canal 1 del detector de fase.
794 phase2 = getPhase(results3, results4); //Calcular la fase del canal 2 del detector de fase.
795 //create Output File
796
797 strcpy (fname, "/mnt/sd/absmonitoreo.txt");
798 printf("\nTerminada la prueba # %d \n", j++);
799 fp=create_Output(fname, now); //Coloca la fecha y la hora en el archivo de texto
800 printf("mediana ch1 = %1.2f\n", phase1); //muestra resultado en terminal
801 printf("mediana ch2 = %1.2f\n", phase2); //muestra resultado en terminal
802 writeOutput(phase1, fp); //graba el resultado en el archivo de texto
803 writeOutput(phase2, fp); //graba el resultado en el archivo de texto
804 fprintf(fp, "\n"); //Pasa a la siguiente l�nea del archivo de texto
805 fclose(fp);
806 printf("Resultado guardado en %s \n", fname);
807
808 sleep(1);
809
810 strcpy(page0,parameters.ID);
811 strcat(page0,"\n-------\n");
812
813 sprintf(page1,"UP:%1.2f DW:%1.2f\n",phase1, phase2);
814 strcat(page0,page1);
815 char *all_pages = malloc(strlen(page0)+1);
816 strcpy(all_pages, page0);
817 return all_pages;
818
819 // }
820 // return 0;
750 821 }
751 822 /*=============================================================================
752 823 Function definitions
753 824 =============================================================================*/
754 825
755 826 // Configures ADC registers in order to get a sample every 10us
756 827 AT91S_ADC * configADC1(void){
757 828 //Variables a usar:
829 /*
758 830 unsigned int maskc_adc =PC0; //Usamos ADC0 y ADC1
759 831
760 832 //configuro pin:
761 833 AT91S_PIO *pioc;
762 834 pioc = pio_map(PIOC_BASE);
763 835 pin_adc_enable(pioc,maskc_adc); //Habilitamos PC0 para usar con ADC0 y 1
764 836 pio_disable_irq(pioc, maskc_adc);
765 837 pio_disable_multiple_driver(pioc, maskc_adc);
766 838 pio_disable_pull_ups(pioc, maskc_adc);
767 839 pio_input_enable(pioc, maskc_adc);
768
840 */
769 841
770 842 //Configuro el ADC:
771 AT91S_ADC *padc;
843 //AT91S_ADC *padc;
772 844
773 845 padc = adc_map1(ADC_BASE);
774 846
775 847 //clock ADC = 1MHz
776 848 //time startup = 8us
777 849 //time sample and hold = 2us
778 850 // hold
779 851 // ___________
780 852 // start ___________| |___________
781 853 //
782 854 // | --1.2us-- | --0.15us-- |
783 855 //ADC_RESET(padc);
784 856 CONFIG_ADC(padc,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
785 857 ENABLE_CHANNEL(padc,ADC_CH0); //habilito canal 0
786
787
788 858 return padc;
789 859 }
790 860
791 861 AT91S_ADC * configADC2(void){
792 862 //Variables a usar:
863 /*
793 864 unsigned int maskc_adc =PC1; //Usamos ADC0 y ADC1
794 865
795 866 //configuro pin:
796 867 AT91S_PIO *piod;
797 868 piod = pio_map(PIOC_BASE);
798 pin_adc_enable(piod,maskc_adc); //Habilitamos PC0 para usar con ADC0 y 1
869 pin_adc_enable(piod,maskc_adc); //Habilitamos PC1 para usar con ADC0 y 1
799 870 pio_disable_irq(piod, maskc_adc);
800 871 pio_disable_multiple_driver(piod, maskc_adc);
801 872 pio_disable_pull_ups(piod, maskc_adc);
802 873 pio_input_enable(piod, maskc_adc);
803
874 */
804 875 //Configuro el ADC:
805 AT91S_ADC *padd;
876 //AT91S_ADC *padd;
806 877
807 878 padd = adc_map1(ADC_BASE);
808 879
809 880 //clock ADC = 1MHz
810 881 //time startup = 8us
811 882 //time sample and hold = 2us
812 883 // hold
813 884 // ___________
814 885 // start ___________| |___________
815 886 //
816 887 // | --1.2us-- | --0.15us-- |
817 888 //ADC_RESET(padc);
818 889 CONFIG_ADC(padd,ADC_TRGEN_DIS | ADC_RES_10BIT | ADC_SLEEP_NORMAL_MODE | ADC_PRESCAL | ADC_STARTUP | ADC_SHTIM);
819 890 ENABLE_CHANNEL(padd,ADC_CH1); //habilito canal 1
820 891 return padd;
821 892 }
822 893
823 894
824 895 //++++++++++++++++++++
825 896
826 897 //creats the output file with a timestamp in the name
827 898 FILE * create_Output(char *fname, time_t rawtime){
828 899 FILE *file;
829 900 char timestamp[80];//, counter[5]="dcv";
830 901 //char str[4];
831 902 struct tm * timeinfo;
832 903
833 904 //format time
834 905 timeinfo = localtime ( &rawtime );
835 906 strftime (timestamp,sizeof(timestamp),"%a %y-%m-%d %H:%M:%S %Z",timeinfo);
836 907
837 908
838 909 //Creates the file name out of the #define parameters
839 910
840 strcpy (fname, "/mnt/sd/archivos/absmonitoreo.txt");
911 strcpy (fname, "/mnt/sd/absmonitoreo.txt");
841 912 file = fopen(fname,"a+");
842 913 fprintf(file,"%s", timestamp);
843 914 //printf("\nTerminada la prueba # %d. Guardando resultado en %s\n",r, fname);
844 915 //printf("\nTerminada la prueba # %d/%d. Writing data to the file %s\n",r+1 , REP, fname);
845 916 //printf("\nAAAAAAAAAA %d...%s\n", counter[1], fname);
846 917 // return file pointer
847 918 return file;
848 919 }
849 920
850 921 //++++++++++++++++++++
851 922
852 923 //tests if a file already exists. returns 1 if it exists and 0 if it doesn't
853 924
854 925
855 926
856 927 //Funci�n checkTx verifica que la se�al muestreada corresponda a un pulso.
857 928 //results1 y results2 son los arreglos que contienen los datos muestreados por ambos canales del ADC del embebido.
858 929 //umbral indica qu� valor debe superar una muestra para considerarla un posible pulso o pico.
859 930 //pulsewidth indica cu�ntas muestras consecutivas deben superar el umbral para que se considere que se ha detectado un pulso.
860 931 int checkTx(long int results1[],long int results2[], float umbral, int pulsewidth){
861 932
862 933 int i, cont;
863 934 float z[NSAMPLES], sum, avg;
864 935 int isSignal, pulse;
865 936
866 937 for(i=0;i<NSAMPLES;i++){
867 938
868 939 z[i] =sqrt(1.0*results1[i]*results1[i]+1.0*results2[i]*results2[i]);
869 940 }
870 941
871 942 pulse = 0;
872 943 isSignal = 0;
873 944 cont =0;
874 945
875 946 sum = 0;
876 947 for(i=0;i<NSAMPLES;i++){
877 948
878 949 sum += z[i];
879 950 avg = sum/(i+1);
880 951 if ((z[i] - avg) > umbral){
881 952 if (isSignal == 1){
882 953 cont += 1;
883 954 }
884 955 if (cont == pulsewidth){
885 956 pulse = 1;
886 957 break;
887 958 }
888 959 isSignal = 1;
889 960 continue;
890 961 isSignal = 0;
891 962 cont = 0;
892 963 }
893 964 }
894 965
895 966 return pulse; //devuelve un entero: 1 si se ha detectado pulso, de lo contrario, 0.
896 967 }
897 968
898 969
899 970 int fExists(char * fname){
900 971 FILE * file;
901 972
902 973 file = fopen (fname, "r");
903 974 if (file == NULL)
904 975 {
905 976 return 0;
906 977 }
907 978 fclose(file);
908 979 return 1;
909 980 }
910 981
911 982
912 983 //Funci�n que calcula la mediana de un conjunto de muestras
913 984 double mediana(long int *results,unsigned int cuenta){
914 985 unsigned int i=0,j=0,aux=0;
915 986
916 987 double median=0;
917 988 /*Calculo mediana */
918 989
919 990 for(i=0;i<cuenta-1;i++){
920 991 for (j=i+1;j<cuenta;j++){
921 992 if(results[i]>results[j] ){
922 993
923 994 aux=results[i];
924 995 results[i]=results[j];
925 996 results[j]=aux;
926 997
927 998 }
928 999 }
929 1000
930 1001 }
931 1002 median=results[cuenta/2];
932 1003 return median;
933 1004 }
934 1005
935 1006
936 1007
937 1008 //Funci�n que halla la fase de la se�al.
938 1009 //Tiene como entradas las muestras correspondientes a la parte real e imaginaria de la se�al.
939 1010 float getPhase(long int results1[],long int results2[]){
940 1011
941 1012 unsigned int count=0, i=0,umbral=1000;
942 1013 //long int results1[];
943 1014 //long int results2[];
944 1015 long int power[NSAMPLES];
945 1016 long int sumI=0,sumQ=0,I[NSAMPLES], Q[NSAMPLES],II[NSAMPLES], QQ[NSAMPLES];
946 1017 double median1=0,median2=0;
947 1018 long int promedioI=0,promedioQ=0;/*Calculo mediana 1*/
948 1019 float resultado=0;
949 1020
950 1021 for(i=0;i<NSAMPLES;i++){
951 1022
952 1023 I[i] =results1[i];
953 1024 Q[i] =results2[i];
954 1025 }
955 1026
956 1027 /*Calculo mediana 1*/
957 1028 median1=mediana(I,NSAMPLES);
958 1029
959 1030 /*Calculo mediana 2*/
960 1031 median2=mediana(Q,NSAMPLES);
961 1032
962 1033
963 1034
964 1035
965 1036
966 1037
967 1038 for(i=0;i<NSAMPLES;i++){
968 1039
969 1040 I[i] =results1[i];
970 1041 Q[i] =results2[i];
971 1042
972 1043 }
973 1044
974 1045
975 1046
976 1047 for(i = 0; i < NSAMPLES ; i++){
977 1048
978 1049 I[i]=(I[i]-median1);
979 1050 Q[i]=(Q[i]-median2);
980 1051
981 1052 }
982 1053
983 1054 for(i = 0; i < NSAMPLES ; i++){
984 1055
985 1056 power[i]=I[i]*I[i]+Q[i]*Q[i];
986 1057
987 1058 if(power[i] > umbral)
988 1059 {
989 1060
990 1061 II[count]=I[i];
991 1062 QQ[count]=Q[i];
992 1063 count=count+1;
993 1064
994 1065 }
995 1066
996 1067 }
997 1068
998 1069 for(i = 0; i < count ; i++){
999 1070
1000 1071 sumI=sumI+II[i];
1001 1072 sumQ=sumQ+QQ[i];
1002 1073
1003 1074 }
1004 1075
1005 1076 promedioI=sumI;
1006 1077 promedioQ=sumQ;
1007 1078
1008 1079 resultado = atan2(1.0*promedioI,1.0*promedioQ)*180/3.1416+62-44;
1009 1080
1010 1081
1011 1082 return resultado;
1012 1083
1013 1084 }
1014 1085
1015 1086
1016 1087
1017 1088 //Funci�n que muestra la fase detectada en el terminal y tambi�n la graba en el archivo de texto.
1018 1089 void writeOutput(float resultado, FILE * output){
1019 1090
1020 1091
1021 1092 //
1022 1093
1023 1094 fprintf(output," %1.2f ",resultado); //graba resultado en archivo .txt
1024 1095 //
1025 1096
1026 1097 }
1027 1098
1028 1099 int configCLK(){
1029 1100 //configuro pin:
1030 1101 AT91S_PMC *sys_clock;
1031 1102 sys_clock = clock_map(CLOCK_BASE);
1032 1103 enable_clock_adc(sys_clock);
1033 1104 //printf("clock ADC enable.\n");
1034 1105 return 1;
1035 1106 }
General Comments 0
You need to be logged in to leave comments. Login now