##// END OF EJS Templates
ABS » abscontrol
RSS
Ending the test of change
imanay -
r12:13
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,302 +1,301
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 100
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
44 44 char *buff_experimento= NULL;
45 45
46 46 AT91S_PIO *pioc;
47 47 AT91S_PIO *piob;
48 48
49 49 /*
50 50 * Zona de declaracion de cabeceras.
51 51 */
52 52 void inicializa_gpio();
53 53 void procesa_peticion(char *buff_peticion);
54 54 void cambia_apuntamiento(char *puntero_char);
55 55 int carga_experimento(char *nombre_archivo);
56 56 void chequeo_sistema(char *numero_muestras);
57 57
58 58 /*
59 59 *
60 60 */
61 61 int main(){
62 printf("Testpoint");
63 62
64 63 int conexion_servidorFd;
65 64 struct sockaddr_in inf_servidor;
66 65 struct sockaddr_storage inf_cliente;
67 66 int resultado;
68 67 int numbytes_recibidos;
69 68
70 69 char *buff_peticion = (char *) malloc(TAM_BUFFER);
71 70
72 71 size_t addr_len;
73 72
74 73 memset(&inf_servidor, 0, sizeof(inf_servidor));
75 74 inf_servidor.sin_family= AF_INET;
76 75 inf_servidor.sin_port= htons(PUERTO_SERVIDOR);
77 76 inf_servidor.sin_addr.s_addr= INADDR_ANY;
78 77
79 78 /* Se establece el socket */
80 79 conexion_servidorFd = socket(AF_INET,SOCK_DGRAM,0);
81 80 if (conexion_servidorFd == -1){
82 81 ERROR_FATAL("No se establecio correctamente el socket: socket()");
83 82 }
84 83
85 84 /* Se asocia el socket a un puerto y una IP */
86 85 resultado = bind(conexion_servidorFd,(struct sockaddr *)&inf_servidor,sizeof(inf_servidor));
87 86 if (resultado== -1){
88 87 ERROR_FATAL("No se establecio correctamente el socket: bind()");
89 88 }
90 89
91 90 /* Inicializamos el puerto GPIO del sistema embebido GSBC-9260S */
92 91 inicializa_gpio();
93 92
94 93 while(1){
95 94 LOG_SERVIDOR("Esperando solicitud de cliente...\n");
96 95
97 96 /* Se espera hasta que un cliente se conecte */
98 97 addr_len = sizeof(inf_cliente);
99 98 numbytes_recibidos = recvfrom(conexion_servidorFd, buff_peticion, TAM_BUFFER-1, 0, (struct sockaddr *)&inf_cliente, &addr_len);
100 99 if (numbytes_recibidos == -1){
101 100 ERROR_FATAL("Error en la recepcion de datos: recvfrom()");
102 101 }
103 102
104 103 /* Se procede a procesar los datos recibidos */
105 104 buff_peticion[numbytes_recibidos]= '\0';
106 105
107 106 /* procesamiento de la peticion */
108 107 procesa_peticion(buff_peticion);
109 108 }
110 109 }
111 110
112 111 /*
113 112 * Esta funcion incializa el puerto GPIO
114 113 */
115 114 void inicializa_gpio(){
116 115
117 116 // Configuracion de los pines de APUNTE
118 117 pioc = pio_map(PIOC_BASE);
119 118 pio_enable(pioc, maskc_out);
120 119 pio_disable_irq(pioc, maskc_out);
121 120 pio_disable_multiple_driver(pioc, maskc_out);
122 121 pio_disable_pull_ups(pioc, maskc_out);
123 122 pio_synchronous_data_output(pioc, maskc_out);
124 123 pio_output_enable(pioc, maskc_out);
125 124
126 125 // Configuracion de los pines de VERIFICACION
127 126 piob = pio_map(PIOB_BASE);
128 127 pio_enable(piob, maskb_in);
129 128 pio_disable_irq(piob, maskb_in);
130 129 pio_disable_multiple_driver(piob, maskb_in);
131 130 pio_disable_pull_ups(piob, maskb_in);
132 131 pio_input_enable(piob, maskb_in);
133 132
134 133 }
135 134
136 135 /*
137 136 * Esta funcion procesa el mensaje de peticion y genera respuesta
138 137 */
139 138 void procesa_peticion(char *buff_peticion){
140 139
141 140 char *comando = strtok(buff_peticion, ":");
142 141 char *valor = strtok(NULL, ":");
143 142
144 143 if ((comando == NULL) || (valor == NULL)){
145 144 ERROR("procesarPeticion: formato de mensaje incorrecto");
146 145 }else{
147 146 if(strcmp(comando,"CARGA") == 0){
148 147 carga_experimento(valor);
149 148 }else if(strcmp(comando,"CAMBIA") == 0){
150 149 cambia_apuntamiento(valor);
151 150 }else if(strcmp(comando,"CHEQUEO") == 0){
152 151 chequeo_sistema(valor);
153 152 }else{
154 153 ERROR("procesa_peticion: comando no reconocido");
155 154 }
156 155 }
157 156 }
158 157
159 158
160 159 /*
161 160 * Esta funcion carga un archivo en un buffer que esta ubicado en memoria, luego
162 161 * este buffer es usado en la funcion "cambia_apuntamiento" para obtener el dato
163 162 * que sera usado en el cambio de apuntamiento.
164 163 */
165 164 int carga_experimento(char *nombre_archivo){
166 165
167 166 FILE *Archivo_Fd;
168 167
169 168 char *cadena = (char *) malloc(25);
170 169
171 170 int longitud_cadena;
172 171 int num_bytes= 0;
173 172 int num_filas= 0;
174 173
175 174 char ruta_archivo[50]; // Se crea la ruta para abrir el archivo
176 175 strcpy(ruta_archivo,"/mnt/sd/archivos/");
177 176 strcat(ruta_archivo,nombre_archivo);
178 177
179 178 Archivo_Fd = fopen(ruta_archivo,"r"); // Se procede a abrir el archivo, segun la ruta especificada
180 179 if(!Archivo_Fd){
181 180 ERROR("carga_archivo: No se pudo abrir el archivo!!! --> fopen()\n");
182 181 return -1;
183 182 }else{
184 183
185 184 while(!feof(Archivo_Fd)){ // Se procede a calcular la longitud del archivo para separar memoria
186 185 fgets(cadena,20,Archivo_Fd);
187 186 longitud_cadena= strlen(cadena);
188 187 cadena[longitud_cadena-1] = '\0';
189 188 num_bytes = num_bytes + longitud_cadena;
190 189 num_filas++;
191 190 }
192 191
193 192 rewind(Archivo_Fd); // Se reinicia el puntero del archivo
194 193
195 194 char *buffer_temporal = (char *) malloc(num_bytes+1); // Se separa espacio de memoria segun
196 195 // la longitud del archivo
197 196 fread(buffer_temporal, sizeof(char), num_bytes, Archivo_Fd);
198 197
199 198 char *puntero= strstr(buffer_temporal,".abs"); // Se procede a eliminar la cabecera del archivo
200 199 puntero= puntero + 12;
201 200
202 201 buff_experimento = (char *) malloc(7*(num_filas-3)); // num_bytes_fila*(num_filas-3);
203 202 strncpy(buff_experimento,puntero,7*(num_filas-3)); // Se carga en memoria la informacion del archivo
204 203
205 204 fclose(Archivo_Fd);
206 205
207 206 cambia_apuntamiento("0"); // Se apunta a la direccion 0
208 207
209 208 return 0;
210 209 }
211 210 }
212 211
213 212 /*
214 213 * Esta funcion recibe un numero en formato char, el dato se transforma a su equivalente en
215 214 * un numero entero, que sera usado para sacar un dato del buffer "buff_experimento", esta
216 215 * dato es el valor que se enviara al sistema de conmutacion RF para el cambio de apunte a
217 216 * traves del puerto GPIO.
218 217 */
219 218 void cambia_apuntamiento(char *puntero_char){
220 219
221 220 /*MSB-UP-LSB MSB-DOWN-LSB*/
222 221 int desplazamiento[6]={30,28,26,24,22,20}; // Defino los dezplazamientos que se aplicara
223 222 // al dato que ingresa para formar el nΓΊmero
224 223 // entero que se le pasara al puerto GPIO
225 224 // Estos nΓΊmeros son los pines del puerto GPIO
226 225 // que se estan usando para el control
227 226
228 227 int puntero= atoi(puntero_char); // Se convierte a entero la direccion del puntero
229 228
230 229 int base= 7*puntero; // base= cantidad_bytes del dato x puntero
231 230 // cantidad de bytes es el numero de bytes que
232 231 printf("%i\n",puntero); // contiene cada dato, para este caso es 7
233 232 // porque es 6 bits de datos + 1 bit del cambio
234 233 // de linea.
235 234 char valor_char;
236 235 unsigned long valor;
237 236 unsigned long acumulado_ceros=0;
238 237 unsigned long acumulado_unos=0;
239 238
240 239 int offset; // Defino offset para el desplazamiento a traves
241 240 for(offset=0;offset<6;offset++){ // de cada dato que se obtiene del "buff_experimento"
242 241
243 242 valor_char= buff_experimento[base+offset]; // Obtengo el dato
244 243
245 244 if (valor_char == '0'){ // Obtengo el nΓΊmero acumulado segun sea un cero o un uno
246 245 valor= 0;
247 246 acumulado_ceros= acumulado_ceros + (1 << desplazamiento[offset]);
248 247 }else{
249 248 valor= 1;
250 249 acumulado_unos= acumulado_unos + (1 << desplazamiento[offset]);
251 250 }
252 251
253 252 }
254 253
255 254 pio_out(pioc, maskc_out, acumulado_unos, 1);
256 255 pio_out(pioc, maskc_out, acumulado_ceros, 0);
257 256
258 257 }
259 258
260 259 /*
261 260 * Esta funcion lee "n" veces el estado del APUNTE actual y lo guarda en el
262 261 * archivo Verificacion.
263 262 */
264 263
265 264 void chequeo_sistema(char *numero_muestras){
266 265
267 266 char valor[7];
268 267 int i,cnt;
269 268 unsigned int entradac= 0;
270 269 FILE *fd;
271 270 fd=fopen("/mnt/sd/archivos/Verificacion","w");
272 271 fprintf(fd,"%s\n","Verificacion");
273 272 fprintf(fd,"%s\n","------------");
274 273 cnt=0;
275 274 do
276 275 {
277 276 //Inicializando arreglo
278 277 for(i=0;i<6;i++)
279 278 valor[i]='0';
280 279 valor[6]='\0';
281 280 //Lectura de puerto
282 281 entradac= pio_in(piob,maskb_in);
283 282 //Dandole formato al dato
284 283 if (!(entradac & bit_up_2))
285 284 valor[0] = '1';
286 285 if (!(entradac & bit_up_1))
287 286 valor[1] = '1';
288 287 if (!(entradac & bit_up_0))
289 288 valor[2] = '1';
290 289 if (!(entradac & bit_dow_2))
291 290 valor[3] = '1';
292 291 if (!(entradac & bit_dow_1))
293 292 valor[4] = '1';
294 293 if (!(entradac & bit_dow_0))
295 294 valor[5] = '1';
296 295 //Escribiendo en archivo
297 296 fprintf(fd,"%s\n",valor);
298 297 cnt=cnt+1;
299 298 usleep(1*1000*1000);
300 299 }while(cnt < atoi(numero_muestras));
301 300 fclose(fd);
302 301 }
General Comments 0
You need to be logged in to leave comments. Login now