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