UniSaSA  1.0
C Gateway
gateway.c
1 #include "gateway.h"
2 #include <math.h>
3 
4 
5 //------------------ global Variables -------------------------
6 device_t _devices[MAX_NUM_DEVICES];
7 union {
8  unsigned int integer;
9  unsigned char byte[MAX_NUM_DEVICES];
10 } _numDevices;
11 discoveredDevice_t _discoveredDevices[MAX_NUM_DEVICES_DISCOVERY];
12 connectorInterface_t _connectors[MAX_NUM_CONNECTORS];
13 unsigned int _numConnectors=0; // no effect in init_gateway
14 int _df_socket;
15 //----------------------------------------------------------------
16 
17 
18 unsigned char _getBytesNumDevices()
19 {
20  unsigned char size = 0;
21 
22  unsigned int i=0;
23  for(i=0; i<MAX_BYTES_ID_DEVICES;i++)
24  if(_numDevices.byte[i] != 0)
25  size=i;
26 
27  return size +1;
28 }
29 
30 void _reverseArray(unsigned char *src, unsigned int sizeSrc, unsigned char *dest)
31 {
32  if(sizeSrc == 1)
33  dest[0] = src[0];
34 //#ifdef LITTLE_ENDIAN
35  int i,j;
36  i=0;
37  j=sizeSrc -1;
38  while (i < j)
39  {
40  dest[i] = src[j];
41  dest[j] = src[i];
42  i++;
43  j--;
44  }
45 //#endif
46 }
47 
48 void _reverseSingleArray(unsigned char *array, unsigned int size)
49 {
50 //#ifdef LITTLE_ENDIAN
51  int i,j;
52  unsigned char tmp;
53  i=0;
54  j=size -1;
55  while (i < j)
56  {
57  tmp = array[i];
58  array[i] = array[j];
59  array[j] = tmp;
60  i++;
61  j--;
62  }
63 //#endif
64 }
65 
66 
67 void init_gateway()
68 {
69 
70  _numDevices.integer=0;
71 
72  //-------------------------------------------------
73 
74  int i=0;
75 
76  //Table: a device_t array
77  for(i=0;i<MAX_NUM_DEVICES;i++)
78  {
79  sensor_t *Ss= (sensor_t*) malloc(sizeof(sensor_t) * MAX_NUM_SENSORS);
80  _devices[i].sensors=Ss;
81  int *indexS= (int*) malloc(sizeof(int) * MAX_NUM_SENSORS);
82  _devices[i].indexSensors=indexS;
83 
84  actuator_t *Ac = (actuator_t*) malloc(sizeof(actuator_t) * MAX_NUM_ACTUATORS);
85  _devices[i].actuators=Ac;
86  int *indexA = (int*) malloc(sizeof(int) * MAX_NUM_ACTUATORS);
87  _devices[i].indexActuators=indexA;
88  }
89  //----------------------------------------------
90 
91 
92  //Buffer to search new devices
93  for(i=0;i<MAX_NUM_DEVICES_DISCOVERY;i++)
94  {
95  sensor_t *Ss= (sensor_t*) malloc(sizeof(sensor_t) * MAX_NUM_SENSORS);
96  _discoveredDevices[i].sensors=Ss;
97  actuator_t *Ac = (actuator_t*) malloc(sizeof(actuator_t) * MAX_NUM_ACTUATORS);
98  _discoveredDevices[i].actuators=Ac;
99  }
100  //----------------------------------------------
101 }
102 
103 /* Functions */
104 
105 void addConnector(connectorInterface_t newConnector)
106 {
107  _connectors[ _numConnectors ]=newConnector;
108  _numConnectors++;
109 }
110 
111 void discoveryAndCreateTable()
112 {
113 
114  unsigned int c=0,d=0, numDiscovered=0, s=0, a=0;
115  for(c=0;c < _numConnectors;c++)
116  {
117  numDiscovered = _connectors[c].discovery(_discoveredDevices);
118  for(d=0; d < numDiscovered; d++)
119  {
120  _devices[_numDevices.integer].ID.integer = _numDevices.integer;
121  _devices[_numDevices.integer].connector = _connectors[c];
122  _devices[_numDevices.integer].address.integer= _discoveredDevices[d].address.integer;//could reverse
123  _devices[_numDevices.integer].sizeIO = _discoveredDevices[d].sizeIODevice;
124 
125  _devices[_numDevices.integer].sizeIDSensor = _discoveredDevices[d].sizeIDSensor;
126  _devices[_numDevices.integer].numSensors.integer = _discoveredDevices[d].numSensors;//add reverse
127 
128  for(s=0;s<_discoveredDevices[d].numSensors;s++)
129  {
130  _devices[_numDevices.integer].sensors[s].ID = _discoveredDevices[d].sensors[s].ID;
131  _reverseSingleArray(_devices[_numDevices.integer].sensors[s].ID.byte,_devices[_numDevices.integer].sizeIDSensor);
132 
133  _devices[_numDevices.integer].sensors[s].typeSensor = _discoveredDevices[d].sensors[s].typeSensor;
134  _reverseSingleArray(_devices[_numDevices.integer].sensors[s].typeSensor.byte,SIZE_TYPE_SENSOR);
135 
136  _devices[_numDevices.integer].sensors[s].sizeOutput = _discoveredDevices[d].sensors[s].sizeOutput;
137 
138  _devices[_numDevices.integer].sensors[s].typeOutput = _discoveredDevices[d].sensors[s].typeOutput;
139 
140  _devices[_numDevices.integer].indexSensors[_discoveredDevices[d].sensors[s].ID.integer] = s;
141  }
142 
143  _devices[_numDevices.integer].sizeIDActuator = _discoveredDevices[d].sizeIDActuator;
144  _devices[_numDevices.integer].numActuators.integer = _discoveredDevices[d].numActuators;//add reverse
145 
146  for(a=0; a < _discoveredDevices[d].numActuators; a++)
147  {
148  _devices[_numDevices.integer].actuators[a].ID = _discoveredDevices[d].actuators[a].ID;
149  _reverseSingleArray(_devices[_numDevices.integer].actuators[a].ID.byte,_devices[_numDevices.integer].sizeIDActuator);
150 
151  _devices[_numDevices.integer].actuators[a].typeActuator = _discoveredDevices[d].actuators[a].typeActuator;
152  _reverseSingleArray(_devices[_numDevices.integer].actuators[a].typeActuator.byte,SIZE_TYPE_ACTUATOR);
153 
154  _devices[_numDevices.integer].actuators[a].sizeInput = _discoveredDevices[d].actuators[a].sizeInput;
155 
156  _devices[_numDevices.integer].actuators[a].typeInput = _discoveredDevices[d].actuators[a].typeInput;
157 
158  _devices[_numDevices.integer].indexActuators[_discoveredDevices[d].actuators[a].ID.integer] = a;
159  }
160 
161  _numDevices.integer++;
162 
163  } // end for devices
164  } // end for connectors
165 }
166 
167 void load_table(char *path)
168 {
169  /*
170  FILE *fp;
171  char *line = NULL;
172  size_t len = 0;
173  ssize_t read;
174  char *saveptr1,*token; // strtok_r
175  */
176 
177  /*
178  * ID ; Address ; TypeConnector ; SizeIODevice ; SizeIDSen ; ...
179  * ... SizeIDAct ; SYMBOL_[SEN|ACT] ;* ID S/A ; Type S/A ; ...
180  * ... Size I/O ; Type I/O
181  */
182 
183  /*
184  unsigned int id_device;
185  char* address;
186  char* stringConnector;
187  unsigned char sizeIODevice;
188 
189  unsigned int numSensors,numActuators;
190  unsigned char sizeIDSen,sizeIDAct;
191  char senOrAct;
192  unsigned int id_SA;
193  unsigned int type_SA;
194  unsigned char size_IO,type_IO;
195 
196 
197  fp = fopen(path, "r");
198  if (fp == NULL)
199  exit(EXIT_FAILURE);
200 
201 
202  while ((read = getline(&line, &len, fp)) != -1)
203  {
204  if(line[0] == '#')
205  continue;
206  //printf("%s", line);
207 
208  //ID Device
209  token = strtok_r(line, DELIM, &saveptr1);
210  id_device = (unsigned int) atoi(token);
211 
212  //Address
213  token = strtok_r(NULL, DELIM, &saveptr1);
214  address = token;
215 
216  //StringConnector
217  token = strtok_r(NULL, DELIM, &saveptr1);
218  stringConnector = token;
219 
220  // sizeIODevice
221  token = strtok_r(NULL, DELIM, &saveptr1);
222  sizeIODevice = (unsigned char) atoi(token);
223 
224  // sizeIDSen
225  token = strtok_r(NULL, DELIM, &saveptr1);
226  sizeIDSen = (unsigned char) atoi(token);
227 
228  // sizeIDAct
229  token = strtok_r(NULL, DELIM, &saveptr1);
230  sizeIDAct = (unsigned char) atoi(token);
231 
232  sensor_t sensors[MAX_NUM_SENSORS];
233  numSensors=0;
234  actuator_t actuators[MAX_NUM_ACTUATORS];
235  numActuators=0;
236 
237  while ( (token = strtok_r(NULL, DELIM, &saveptr1)) !=NULL)
238  {
239  // senOrAct
240  senOrAct = token[0];
241 
242  // id_SA
243  token = strtok_r(NULL, DELIM, &saveptr1);
244  id_SA = (unsigned int) atoi (token);
245 
246  // type_SA
247  token = strtok_r(NULL, DELIM, &saveptr1);
248  type_SA = (unsigned int) atoi(token);
249 
250  // size_IO
251  token = strtok_r(NULL, DELIM, &saveptr1);
252  size_IO = (unsigned char) atoi(token);
253 
254  // type_IO
255  token = strtok_r(NULL, DELIM, &saveptr1);
256  type_IO = (unsigned char) atoi(token);
257 
258  if(senOrAct == SYMBOL_SENSOR)
259  {
260  sensors[id_SA] = createSensor(id_SA,type_SA,size_IO,type_IO);
261  numSensors++;
262  }
263  else
264 
265  {
266  actuators[id_SA] = createActuator(id_SA, type_SA, size_IO, type_IO);
267  numActuators++;
268 
269  }
270 
271  }//end while sens/acts
272 
273  //devices[numDevices] = createDevice(id_device,numDevices,
274  connector,
275  address,
276  sizeIODevice,
277  sizeIDSen,
278  numSensors,
279  sensors,
280  sizeIDAct,
281  numActuators,
282  actuators);
283  //numDevices++;
284 
285  }// end while devices
286 
287  free(line);
288  fclose(fp);
289  */
290 }
291 
292 device_t *getDevices()
293 {
294  return _devices;
295 }
296 
297 unsigned int getNumDevices()
298 {
299  return _numDevices.integer;
300 }
301 
302 
303 void verifyDevices()
304 {
305  unsigned int i=0;
306  for(i=0; i< _numDevices.integer; i++)
307  {
308  if(_devices[i].connector.checkDevice(_devices[i].address.byte) == 0)
309  free(&_devices[i]);
310  }
311 }
312 
313 void verifyTable()
314 {
315  verifyDevices();
316 }
317 
318 void createNewTable()
319 {
320  unsigned int i;
321  for(i=0;i < MAX_NUM_DEVICES; i++)
322  free(&_devices[i]);
323  for(i=0;i < MAX_NUM_DEVICES_DISCOVERY; i++)
324  free(&_discoveredDevices[i]);
325  init_gateway();
326 }
327 
328 /* =========== Gateway <-> Libs =============== */
329 
330 void create_tcp_server(unsigned int port)
331 {
332  int sock;
333  struct sockaddr_in temp;
334 
335  printf("Starting Gateway...\n");
336 
337  //make socket
338  sock=socket(AF_INET,SOCK_STREAM,0);
339 
340  //address
341  temp.sin_family=AF_INET;
342  temp.sin_addr.s_addr=INADDR_ANY;
343  temp.sin_port=htons(port);
344 
345  //Non-blocking socket
346  //fcntl(sock,F_SETFL,O_NONBLOCK);
347 
348  //socket bind
349  bind(sock,(struct sockaddr*) &temp,sizeof(temp));
350  //set max number of socket request queue
351  listen(sock,SIZE_REQUEST_QUEUE);
352 
353  _df_socket=sock;
354 }
355 
356 void close_gateway()
357 {
358  printf("Closing Gateway...\n");
359  close(_df_socket);
360  return;
361 }
362 
363 int wait_client()
364 {
365  int client_socket;
366 
367  printf("Waiting connections...\n");
368  while ( (client_socket=accept(_df_socket,0,0)) < 0 )
369  ;
370 
371  return client_socket;
372 }
373 
374 void client_communication(int client_socket)
375 {
376  messageInt_t message;
377  messageInt_t answer;
378  int read_bytes=0;
379  unsigned int loop=1;
380  messageInt_t iddevice,idsensor,idactuator;
381  device_t curr_dev;
382  sensor_t curr_sen;
383  actuator_t curr_act;
384 
385 
386  while(loop)
387  {
388  //if ((read_bytes=read(client_socket,message.byte,sizeof(message.byte)))<0)
389  if ((read_bytes=read(client_socket,message.byte,1))<0)
390  {
391  printf("error reading data\n");
392  }
393  else if(read_bytes == 0)
394  {
395  printf("Read 0 byte\n");
396  }
397  else // good data
398  {
399  switch(message.byte[0])
400  {
401  case GET_DEVICES:
402  /* Reply Message.Byte: 'GetDevices', Gateway -> Library
403  *
404  * ------------------------------------------
405  * 1B size size 1B
406  * ID dev ID dev
407  * sizeIDDev numDevs *(IDDev SizeIODev ...
408  * A B C D
409  * -------------------------------------------------------
410  * 1B size size 2 B 1 B 1B
411  * ID Sen ID Sen
412  * ... SizeIDSen NumSens *(IDSen TypeSen SizeOut TypeOut) ...
413  * E F G H I J
414  * --------------------------------------------------------------
415  * 1B size size 2 B 1B 1B
416  * ID Act ID Act
417  * ... SizeIDAct NumActs *(IDAct TypeAct SizeIn TypeIn))
418  * K L M N O P
419  * -------------------------------------------------------------
420  */
421 
422  printf("Get Devices\n");
423 
424  message.byte[0] = _getBytesNumDevices();
425  write(client_socket,message.byte,_getBytesNumDevices()); // (A)
426 
427  _reverseArray(_numDevices.byte, _getBytesNumDevices(), message.byte);
428  write(client_socket, message.byte, _getBytesNumDevices()); // (B)
429 
430  unsigned int d=0;
431  for(d=0; d < _numDevices.integer; d++)
432  {
433 
434  _reverseArray(_devices[d].ID.byte, _getBytesNumDevices(), message.byte);
435  write(client_socket, message.byte, _getBytesNumDevices()); // (C) IDDev
436 
437  message.byte[0] = _devices[d].sizeIO;
438  write(client_socket, message.byte ,1); // (D)
439 
440  //Sensors
441  message.byte[0] = _devices[d].sizeIDSensor;
442  write(client_socket, message.byte ,1); // (E) sizeIDSen
443 
444  _reverseArray(_devices[d].numSensors.byte, _devices[d].sizeIDSensor , message.byte);
445  write(client_socket, message.byte, _devices[d].sizeIDSensor); // (F) numSens
446 
447  unsigned int s=0;
448  for(s=0;s<_devices[d].numSensors.integer;s++)
449  {
450  _reverseArray(_devices[d].sensors[s].ID.byte, _devices[d].sizeIDSensor, message.byte);
451  write(client_socket, message.byte, _devices[d].sizeIDSensor); // (G) IDSen
452 
453  _reverseArray( _devices[d].sensors[s].typeSensor.byte, SIZE_TYPE_SENSOR, message.byte);
454  write(client_socket, message.byte, SIZE_TYPE_SENSOR); // (H)
455 
456  message.byte[0] = _devices[d].sensors[s].sizeOutput; // (I)
457  write(client_socket, message.byte, 1);
458 
459  message.byte[0] = _devices[d].sensors[s].typeOutput; // (J)
460  write(client_socket, message.byte, 1);
461  }// end sensors
462 
463 
464  //Actuators
465  message.byte[0] = _devices[d].sizeIDActuator;
466  write(client_socket, message.byte ,1); // (K) sizeIDAct
467 
468  _reverseArray(_devices[d].numActuators.byte, _devices[d].sizeIDActuator , message.byte);
469  write(client_socket, message.byte, _devices[d].sizeIDActuator); // (L) numActs
470 
471  unsigned int a=0;
472  for(a=0;a<_devices[d].numActuators.integer;a++)
473  {
474  _reverseArray(_devices[d].actuators[a].ID.byte, _devices[d].sizeIDActuator, message.byte);
475  write(client_socket, message.byte, _devices[d].sizeIDActuator); // (M) IDAct
476 
477  _reverseArray( _devices[d].actuators[a].typeActuator.byte, SIZE_TYPE_ACTUATOR, message.byte);
478  write(client_socket, message.byte, SIZE_TYPE_ACTUATOR); // (N)
479 
480  message.byte[0] = _devices[d].actuators[a].sizeInput;
481  write(client_socket, message.byte, 1); // (O)
482 
483  message.byte[0] = _devices[d].actuators[a].typeInput;
484  write(client_socket, message.byte, 1); // (P)
485  }//end actuators
486 
487  } // end for devices
488  break;
489  case GET_SENSOR_VALUE:
490  printf("get sensor value\n");
491 
492  message.integer=0;
493  read(client_socket, message.byte, _getBytesNumDevices());
494  iddevice.integer=0;
495  _reverseArray(message.byte, _getBytesNumDevices(), iddevice.byte);
496  curr_dev = _devices[iddevice.integer];
497 
498  read(client_socket, message.byte, curr_dev.sizeIDSensor);
499  idsensor.integer=0;
500  _reverseArray(message.byte, _devices[iddevice.integer].sizeIDSensor, idsensor.byte);
501  curr_sen = curr_dev.sensors[curr_dev.indexSensors[idsensor.integer]];
502 
503  curr_dev.connector.getSensorValue(curr_dev.address.byte,curr_dev.sizeIDSensor,curr_sen.ID.byte,curr_sen.sizeOutput,message.byte);
504  write(client_socket,message.byte,curr_sen.sizeOutput);
505  break;
506  case SET_ACTUATOR_VALUE:
507  printf("set actuator value\n");
508  read(client_socket,message.byte,_getBytesNumDevices());
509  iddevice.integer=0;
510  _reverseArray(message.byte, _getBytesNumDevices(), iddevice.byte);
511  curr_dev = _devices[iddevice.integer];
512 
513  read(client_socket, message.byte, curr_dev.sizeIDActuator);
514  idactuator.integer=0;
515  _reverseArray(message.byte, _devices[iddevice.integer].sizeIDActuator, idactuator.byte);
516  curr_act = curr_dev.actuators[curr_dev.indexActuators[idactuator.integer]];
517 
518  read(client_socket, message.byte, curr_act.sizeInput);
519  curr_dev.connector.setActuatorValue(curr_dev.address.byte, curr_dev.sizeIDActuator, curr_act.ID.byte, curr_act.sizeInput,message.byte);
520  break;
521  case MSG_TO_DEVICE:
522  printf("msg to device\n");
523  read(client_socket,message.byte,_getBytesNumDevices());
524  iddevice.integer=0;
525  _reverseArray(message.byte, _getBytesNumDevices(), iddevice.byte);
526  curr_dev = _devices[iddevice.integer];
527 
528  read(client_socket, message.byte, curr_dev.sizeIO);
529  curr_dev.connector.msgToDevice(curr_dev.address.byte, curr_dev.sizeIO, message.byte);
530  break;
531  case MSG_AND_ANSWER_TO_DEVICE:
532  printf("msg to device and answer\n");
533  read(client_socket,message.byte,_getBytesNumDevices());
534  iddevice.integer=0;
535  _reverseArray(message.byte, _getBytesNumDevices(), iddevice.byte);
536  curr_dev = _devices[iddevice.integer];
537 
538  read(client_socket, message.byte, curr_dev.sizeIO);
539  curr_dev.connector.msgAndAnswerToDevice(curr_dev.address.byte, curr_dev.sizeIO, message.byte,answer.byte);
540  write(client_socket, answer.byte, curr_dev.sizeIO);
541  break;
542  case CLOSE_TCP_CONNECTION:
543  printf("close tcp connectio\n");
544  loop=0;
545  break;
546  }
547  }
548 
549  }
550 
551  close(client_socket);
552 
553  }
554 
555 
556 
557 
verifyDevices
void verifyDevices()
Definition: gateway.c:303
messageInt_t
Definition: gateway.h:45
getDevices
device_t * getDevices()
Definition: gateway.c:292
createNewTable
void createNewTable()
Definition: gateway.c:318
sensor_t
Definition: connector.h:26
close_gateway
void close_gateway()
Definition: gateway.c:356
device_t
Definition: connector.h:138
init_gateway
void init_gateway()
Definition: gateway.c:67
connectorInterface_t
Definition: connector.h:103
create_tcp_server
void create_tcp_server(unsigned int port)
Definition: gateway.c:330
addConnector
void addConnector(connectorInterface_t newConnector)
Definition: gateway.c:105
discoveryAndCreateTable
void discoveryAndCreateTable()
Definition: gateway.c:111
load_table
void load_table(char *path)
Definition: gateway.c:167
wait_client
int wait_client()
Definition: gateway.c:363
discoveredDevice_t
Definition: connector.h:75
verifyTable
void verifyTable()
Definition: gateway.c:313
getNumDevices
unsigned int getNumDevices()
Definition: gateway.c:297
client_communication
void client_communication(int client_sock)
Definition: gateway.c:374
actuator_t
Definition: connector.h:54
Generated by   doxygen 1.8.13