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