##// END OF EJS Templates
ABS » abscontrol
RSS
Se corrigió bug de funcion file2buffer. Faltaba '\0' al final de la cadena.
imanay -
r77:78
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,460 +1,459
1 1 /*
2 2 * Servidor.c
3 3 *
4 4 * Created on: Nov 3, 2009
5 5 * Author: Jose Francisco Quenta
6 6 *
7 7 * Se implementa:
8 8 * -Carga en memoria los apuntes contenidos en un archivo de experimentos: apunte0 -> GPIO
9 9 * -Cambio de apunte.
10 10 * -Lectura del estado actual del apunte y grabado del mismo en un archivo
11 11 */
12 12
13 13 #include <stdio.h>
14 14 #include <stdlib.h>
15 15 #include <string.h>
16 16 #include <unistd.h>
17 17 #include <errno.h>
18 18
19 19 #include <sys/types.h>
20 20 #include <sys/socket.h>
21 21 #include <netinet/in.h>
22 22 #include <arpa/inet.h>
23 23 #include <netdb.h>
24 24
25 25 #include "./Librerias/AT91gpio_Funciones.h"
26 26 #include "./Librerias/Mensajes.h"
27 27
28 28 #define PUERTO_SERVIDOR 5500
29 29 #define TAM_BUFFER 1024
30 30
31 31 #define maskc_out PC30+PC28+PC26+PC24+PC22+PC20 //MSB-UP-LSB MSB-DOWN-LSB //APUNTE
32 32
33 33 #define maskb_in PB16+PB18+PB20+PB30+PB24+PB22 //MSB-UP-LSB MSB-DOWN-LSB //VERIFICACION
34 34
35 35 #define bit_up_2 0x00010000 //Mascara de cada bit a revisar: bit_up_2 es MSB
36 36 #define bit_up_1 0x00040000
37 37 #define bit_up_0 0x00100000
38 38 #define bit_dow_2 0x40000000
39 39 #define bit_dow_1 0x01000000
40 40 #define bit_dow_0 0x00400000
41 41
42 42 #define MyID 11
43 43 #define MAXPENDING 5 /* Maximum outstanding connection requests */
44 44
45 45 char *buff_experimento= NULL;
46 46
47 47 AT91S_PIO *pioc;
48 48 AT91S_PIO *piob;
49 49
50 50 struct control_module_parameters {
51 51 char ID[20];
52 52 char param2[20];
53 53 char param3[20];
54 54 char param4[20];
55 55 };
56 56
57 57 typedef struct control_module_parameters cmp;
58 58
59
59 cmp parameters;
60 60 /*
61 61 * Zona de declaracion de cabeceras.
62 62 */
63 63 cmp inicializa_modulo(cmp p);
64 64 int inicializa_ethernet();
65 65 int rxData(int, char*);
66 66 void txData(int, char*);
67 67 void inicializa_gpio();
68 68 void procesa_peticion(char *rx_buffer, char *tx_buffer);
69 69 int cambia_apuntamiento(char *puntero_char);
70 70 int carga_experimento(char *nombre_archivo);
71 71 int chequeo_sistema(char *filename, char *numero_muestras);
72 72 void recibe_experimento(char *data, char filename[]);
73 73 char* File2buffer(char *filename2, int n);
74 74
75 75 /*
76 76 *
77 77 */
78 78 int main(){
79 79
80 80 int servSocket;
81 81 int clntSocket;
82 cmp parameters;
82
83 83
84 84 char *rx_buffer = (char *) malloc(TAM_BUFFER);
85 85 char *tx_buffer = (char *) malloc(TAM_BUFFER);
86 86 /* Inicializa parametros del modulo*/
87 87 parameters = inicializa_modulo(parameters);
88 88 printf("%s%s%s%s",parameters.ID, parameters.param2, parameters.param3, parameters.param4);
89 89 /* Inicializa red*/
90 90 servSocket = inicializa_ethernet();
91 91 /* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
92 92 inicializa_gpio();
93 93
94 94 while(1){
95 95 // Recepción TCP de petición
96 96 clntSocket = rxData(servSocket, rx_buffer);
97 97 //testpoint
98 98 printf("rx:%s\n",rx_buffer);
99 99 // Procesamiento de la petición
100 100 procesa_peticion(rx_buffer, tx_buffer);
101 101 //testpoint
102 102 printf("tx:%s\n",tx_buffer);
103 103 // Respuesta del modulo de control
104 104 txData(clntSocket, tx_buffer);
105 105
106 106 }
107 107 }
108 108
109 109
110 110 int inicializa_ethernet(){
111 111
112 112 struct sockaddr_in inf_servidor;
113 113
114 114 int servSocket;
115 115
116 116 int resultado;
117 117
118 118 /* Haciendo la estructura local*/
119 119 memset(&inf_servidor, 0, sizeof(inf_servidor));
120 120 inf_servidor.sin_family= AF_INET;
121 121 inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
122 122 inf_servidor.sin_addr.s_addr= INADDR_ANY;
123 123
124 124 /* Se establece el socket */
125 125 servSocket = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
126 126 if (servSocket == -1){
127 127 ERROR_FATAL("No se establecio correctamente el socket: socket()\n");
128 128 exit(-1);
129 129 }
130 130
131 131 /* Se asocia el socket a un puerto y una IP */
132 132 resultado = bind(servSocket,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
133 133 if (resultado== -1){
134 134 ERROR_FATAL("No se establecio correctamente el socket: bind()\n");
135 135 exit(-1);
136 136 }
137 137
138 138 if (listen(servSocket, MAXPENDING) < 0){
139 139 printf("listen() failed\n");
140 140 exit(-1);
141 141 }
142 142
143 143 return servSocket;
144 144
145 145 }
146 146
147 147 int rxData(int servSocket, char* rx_buffer){
148 148
149 149 int clntSocket;
150 150 struct sockaddr_in inf_cliente;
151 151 int numbytes_recibidos;
152 152 unsigned int inf_client_Len;
153 153
154 154 printf("\nEsperando solicitud de cliente...\n");
155 155
156 156 /* Set the size of the in-out parameter */
157 157 inf_client_Len = sizeof(inf_cliente);
158 158 /* Se espera hasta que un cliente se conecte */
159 159 if ((clntSocket = accept(servSocket, (struct sockaddr *) &inf_cliente,
160 160 &inf_client_Len)) < 0)
161 161 printf("accept() failed\n");
162 162
163 163 if ((numbytes_recibidos = recv(clntSocket, rx_buffer, TAM_BUFFER, 0)) < 0)
164 164 printf("recv() failed\n");
165 165
166 166 /* Se procede a procesar los datos recibidos */
167 167 rx_buffer[numbytes_recibidos]= '\0';
168 168
169 169 return clntSocket;
170 170 }
171 171
172 172 void txData(int clntSocket, char* data){
173 173
174 174 /* Echo message back to client */
175 175 if (send(clntSocket, data, strlen(data), 0) != strlen(data))
176 176 printf("send() failed\n");
177 177
178 178 close(clntSocket); /* Close client socket */
179 179 }
180 180 /*
181 181 * Esta funcion incializa el puerto GPIO
182 182 */
183 183 void inicializa_gpio(){
184 184
185 185 // Configuracion de los pines de APUNTE
186 186 pioc = pio_map(PIOC_BASE);
187 187 pio_enable(pioc, maskc_out);
188 188 pio_disable_irq(pioc, maskc_out);
189 189 pio_disable_multiple_driver(pioc, maskc_out);
190 190 pio_disable_pull_ups(pioc, maskc_out);
191 191 pio_synchronous_data_output(pioc, maskc_out);
192 192 pio_output_enable(pioc, maskc_out);
193 193
194 194 // Configuracion de los pines de VERIFICACION
195 195 piob = pio_map(PIOB_BASE);
196 196 pio_enable(piob, maskb_in);
197 197 pio_disable_irq(piob, maskb_in);
198 198 pio_disable_multiple_driver(piob, maskb_in);
199 199 pio_disable_pull_ups(piob, maskb_in);
200 200 pio_input_enable(piob, maskb_in);
201 201
202 202 }
203 203
204 204 /*
205 205 * Esta funcion procesa el mensaje de peticion y genera respuesta
206 206 */
207 207 void procesa_peticion(char *rx_buffer, char *tx_buffer){
208 208 int n = 0;
209 209 char filename1[50];
210 210 char filename2[] = "verificacion.txt";
211 211 char *tx_data = NULL;
212 212 char *header = strtok(rx_buffer, ":");
213 213 char *TypeOfInstrument = strtok(NULL, ":");
214 214 char *iDSource = strtok(NULL, ":");
215 215 char *iDDestino = strtok(NULL, ":");
216 216 char *len = strtok(NULL, ":");
217 217 char *cmd = strtok(NULL, ":");
218 218 char *rx_data = strtok(NULL, ":");
219 219 char *crc = strtok(NULL, ":");
220 220
221 221 if ((cmd == NULL) || (rx_data == NULL)){
222 222 ERROR("procesarPeticion: formato de mensaje incorrecto");
223 223 }
224 224 else{
225 225 if(strcmp(cmd,"SNDF") == 0){
226 226 recibe_experimento(rx_data,filename1);
227 227 carga_experimento(filename1);
228 228 cambia_apuntamiento("0");
229 229 tx_data = (char*)malloc(3);
230 230 tx_data = "OK";
231 231 }
232 232 else if(strcmp(cmd,"CHGB") == 0){
233 //cambia_apuntamiento(rx_data);
234 printf("%s\n",rx_data);
235 //cambia_apuntamiento(rx_data);
236 cambia_apuntamiento("1");
233 cambia_apuntamiento(rx_data);
237 234 tx_data = (char*)malloc(3);
238 235 tx_data = "OK";
239 236
240 237 }
241 238
242 239 else if(strcmp(cmd,"ANST") == 0){
243 240 n = chequeo_sistema(filename2,rx_data);
244 241 printf("%i\n",n);
245 242 tx_data = File2buffer(filename2, n);
246 243 }
247 244 else{
248 245 tx_data = (char*)malloc(6);
249 246 tx_data = "Error";
250 247 ERROR("procesa_peticion: comando no reconocido");
251 248 }
252 249
253 250 strcpy(tx_buffer,header);
254 251 strcat(tx_buffer,":");
255 252 strcat(tx_buffer,TypeOfInstrument);
256 253 strcat(tx_buffer,":");
257 254 strcat(tx_buffer,iDDestino);
258 255 strcat(tx_buffer,":");
259 256 strcat(tx_buffer,iDSource);
260 257 strcat(tx_buffer,":");
261 258 strcat(tx_buffer,len);
262 259 strcat(tx_buffer,":");
263 260 strcat(tx_buffer,cmd);
264 261 strcat(tx_buffer,":");
265 262 strcat(tx_buffer,tx_data);
266 263 strcat(tx_buffer,":");
267 264 strcat(tx_buffer,crc);
265 strcat(tx_buffer,":");
266 strcat(tx_buffer,"quit");
268 267
269 268 }
270 269
271 270 }
272 271
273 272 /*
274 273 * Esta función genera el archivo de experimento a partir de la trama TCP recibida
275 274 */
276 275
277 276 void recibe_experimento(char *p_data, char filename[]){
278 277 FILE *fd;
279 278 int i = 0;
280 279
281 280 while (*p_data != '\n'){
282 281 filename[i] = *p_data;
283 282 i++;
284 283 p_data++;
285 284 }
286 285 filename[i] = '\0';
287 286 p_data = p_data - i;
288 287 fd = fopen(filename,"w");
289 288 fprintf(fd, p_data);
290 289 fclose(fd);
291 290 }
292 291
293 292 /*
294 293 * Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
295 294 * este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
296 295 * que sera usado en el cambio de apuntamiento.
297 296 */
298 297 int carga_experimento(char *nombre_archivo){
299 298
300 299 FILE *Archivo_Fd;
301 300
302 301 char *cadena = (char *) malloc(25);
303 302
304 303 int longitud_cadena;
305 304 int num_bytes= 0;
306 305 int num_filas= 0;
307 306
308 307 Archivo_Fd = fopen(nombre_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
309 308 if(!Archivo_Fd){
310 309 ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
311 310 return -1;
312 311 }else{
313 312
314 313 while(!feof(Archivo_Fd)){ // Se procede a calcular la longitud del archivo para separar memoria
315 314 fgets(cadena,20,Archivo_Fd);
316 315 longitud_cadena= strlen(cadena);
317 316 cadena[longitud_cadena-1] = '\0';
318 317 num_bytes = num_bytes + longitud_cadena;
319 318 num_filas++;
320 319 }
321 320
322 321 rewind(Archivo_Fd); // Se reinicia el puntero del archivo
323 322
324 323 char *buffer_temporal = (char *) malloc(num_bytes+1); // Se separa espacio de memoria segun
325 324 // la longitud del archivo
326 325 fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);
327 326
328 char *puntero= strstr(buffer_temporal,".abs"); // Se procede a eliminar la cabecera del archivo
327 char *puntero= strstr(buffer_temporal,".ab1"); // Se procede a eliminar la cabecera del archivo
329 328 puntero= puntero + 12;
330 329
331 330 buff_experimento = (char *) malloc(7*(num_filas-3)); // num_bytes_fila*(num_filas-3);
332 331 strncpy(buff_experimento,puntero,7*(num_filas-3)); // Se carga en memoria la informacion del archivo
333 332
334 333 fclose(Archivo_Fd);
335 334
336 335 return 1;
337 336 }
338 337 }
339 338
340 339 /*
341 340 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
342 341 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
343 342 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
344 343 * traves del puerto GPIO.
345 344 */
346 345 int cambia_apuntamiento(char *puntero_char){
347 346
348 347 /*MSB-UP-LSB MSB-DOWN-LSB*/
349 348 int desplazamiento[6]={30,28,26,24,22,20}; // Defino los dezplazamientos que se aplicara
350 349 // al dato que ingresa para formar el número
351 350 // entero que se le pasara al puerto GPIO
352 351 // Estos números son los pines del puerto GPIO
353 352 // que se estan usando para el control
354 353
355 354 int puntero= atoi(puntero_char); // Se convierte a entero la direccion del puntero
356 355
357 356 int base= 7*puntero; // base= cantidad_bytes del dato x puntero
358 357 // cantidad de bytes es el numero de bytes que
359 printf("%s\n%i\n",puntero_char,puntero); // contiene cada dato, para este caso es 7
358 printf("%s\n",puntero_char); // contiene cada dato, para este caso es 7
360 359 // porque es 6 bits de datos + 1 bit del cambio
361 360 // de linea.
362 361 char valor_char;
363 362 unsigned long valor;
364 363 unsigned long acumulado_ceros=0;
365 364 unsigned long acumulado_unos=0;
366 365
367 366 int offset; // Defino offset para el desplazamiento a traves
368 367 for(offset=0;offset<6;offset++){ // de cada dato que se obtiene del "buff_experimento"
369 printf("tp1\n");
370 printf("%i\n",base+offset);
368
371 369 valor_char= buff_experimento[base+offset]; // Obtengo el dato
372 370
373 371 if (valor_char == '0'){ // Obtengo el número acumulado segun sea un cero o un uno
374 372 valor= 0;
375 373 acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
376 374 }else{
377 375 valor= 1;
378 376 acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
379 377 }
380 378 }
381 printf("tp2\n");
382 379 pio_out(pioc, maskc_out, acumulado_unos, 1);
383 printf("tp3\n");
384 380 pio_out(pioc, maskc_out, acumulado_ceros, 0);
385 printf("tp4\n");
386 381
387 382 return 1;
388 383
389 384 }
390 385
391 386 /*
392 387 * Esta funcion lee "n" veces el estado del APUNTE actual y lo guarda en el
393 388 * archivo Verificacion.
394 389 */
395 390
396 391 int chequeo_sistema(char *filename, char *numero_muestras){
397 392
398 393 char valor[7];
399 394 int i,cnt;
400 395 unsigned int entradac= 0;
401 396 FILE *fd;
402 397 fd=fopen(filename,"w");
403 398 fprintf(fd,"%s\n","Verificacion");
399 fprintf(fd,"%s",parameters.ID);
404 400 fprintf(fd,"%s\n","------------");
405 401 cnt=0;
406 402 do
407 403 {
408 404 //Inicializando arreglo
409 405 for(i=0;i<6;i++)
410 406 valor[i]='0';
411 407
412 408 valor[6]='\0';
413 409
414 410 //Lectura de puerto
415 411 entradac= pio_in(piob,maskb_in);
416 412
417 413 //Dandole formato al dato
418 414 if (!(entradac & bit_up_2))
419 415 valor[0] = '1';
420 416 if (!(entradac & bit_up_1))
421 417 valor[1] = '1';
422 418 if (!(entradac & bit_up_0))
423 419 valor[2] = '1';
424 420 if (!(entradac & bit_dow_2))
425 421 valor[3] = '1';
426 422 if (!(entradac & bit_dow_1))
427 423 valor[4] = '1';
428 424 if (!(entradac & bit_dow_0))
429 425 valor[5] = '1';
430 426
431 427 //Escribiendo en archivo
432 428 fprintf(fd,"%s\n",valor);
433 429 cnt=cnt+1;
434 430 usleep(1*1000*1000);
435 431
436 432 }while(cnt < atoi(numero_muestras));
437 433
438 434 fclose(fd);
439 435
440 return 7*atoi(numero_muestras) + 26 + 1; //incluye eof
436 return 7*atoi(numero_muestras) + 26 + 4 + 1; //incluye eof
441 437 }
442 438
443 439 char* File2buffer(char *filename, int n){
444 440 FILE *fd;
445 441 char* tx_data = (char *)malloc(n);
446 442 fd = fopen(filename,"r");
447 fread(tx_data, 1, n, fd);
443 fread(tx_data, 1, n-1, fd);
448 444 fclose(fd);
445 tx_data = tx_data + n - 1;
446 *tx_data = '\0';
447 tx_data = tx_data - n + 1;
449 448 return tx_data;
450 449 }
451 450
452 451 cmp inicializa_modulo(cmp p){
453 452 FILE *fd = fopen("configuration.txt","r");
454 453 fgets(p.ID,20,fd);
455 454 fgets(p.param2,20,fd);
456 455 fgets(p.param3,20,fd);
457 456 fgets(p.param4,20,fd);
458 457 fclose(fd);
459 458 return p;
460 459 }
General Comments 0
You need to be logged in to leave comments. Login now