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