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