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