BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.1 date 2005-12-14

3)  * Copyright 2004-2005 Stefan Schuermans <1stein@schuermans.info>
4)  * Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html
5)  * a blinkenarea.org project
6)  */
7) 
8) #include <errno.h>
9) #include <fcntl.h>
10) #include <stdlib.h>
11) #include <stdio.h>
12) #include <string.h>
13) #include <termios.h>
14) #include <time.h>
15) #include <unistd.h>
16) #include <arpa/inet.h>
17) #include <netinet/in.h>
18) #include <sys/types.h>

19) #include <sys/time.h>

20) #include <sys/socket.h>
21) 
22) #include "BlinkenLib.h"
23) 
24) //get serial settings from text
25) static int serial_settings_parse( char * str, int * settings )
26) {
27)   int baud, data, stop;
28)   char parity;
29)   int set = 0;
30) 
31)   //split and parse settings string
32)   if( sscanf( str, "%i,%c,%i,%i", &baud, &parity, &data, &stop ) != 4 )
33)     return 0;
34) 
35)   //baud rate
36)   if( baud == 300 ) set |= B300;
37)   else if( baud == 600 ) set |= B600;
38)   else if( baud == 1200 ) set |= B1200;
39)   else if( baud == 2400 ) set |= B2400;
40)   else if( baud == 4800 ) set |= B4800;
41)   else if( baud == 9600 ) set |= B9600;
42)   else if( baud == 19200 ) set |= B19200;
43)   else if( baud == 38400 ) set |= B38400;
44)   else if( baud == 57600 ) set |= B57600;
45)   else if( baud == 115200 ) set |= B115200;
46)   else
47)   {
48)     printf( "illegal baudrate: %d\n", baud );
49)     return 0;
50)   }
51) 
52)   //parity
53)   if( parity == 'n' || parity == 'N' ) set |= 0;
54)   else if( parity == 'e' || parity == 'E' ) set |= PARENB;
55)   else if( parity == 'o' || parity == 'O' ) set |= PARENB | PARODD;
56)   else
57)   {
58)     printf( "invalid parity: %c\n", parity );
59)     return 0;
60)   }
61) 
62)   //data bits
63)   if( data == 5 ) set |= CS5;
64)   else if( data == 6 ) set |= CS6;
65)   else if( data == 7 ) set |= CS7;
66)   else if( data == 8 ) set |= CS8;
67)   else
68)   {
69)     printf( "illegal number of data bits: %d\n", data );
70)     return 0;
71)   }
72) 
73)   //stop bits
74)   if( stop == 1 ) set |= 0;
75)   else if( stop == 2 ) set |= CSTOPB;
76)   else
77)   {
78)     printf( "illegal number of stop bits: %d\n", stop );
79)     return 0;
80)   }
81) 
82)   //success
83)   *settings = set;
84)   return 1;
85) }
86) 
87) //convert serial settings to text
88) static void serial_settings_to_str( int settings, char * buf, unsigned int maxlen )
89) {
90)   int baud, data, stop;
91)   char parity;
92) 
93)   //baud rate
94)   if( settings & B300 ) baud = 300;
95)   else if( settings & B600 ) baud = 600;
96)   else if( settings & B1200 ) baud = 1200;
97)   else if( settings & B2400 ) baud = 2400;
98)   else if( settings & B4800 ) baud = 4800;
99)   else if( settings & B9600 ) baud = 9600;
100)   else if( settings & B19200 ) baud = 19200;
101)   else if( settings & B38400 ) baud = 38400;
102)   else if( settings & B57600 ) baud = 57600;
103)   else if( settings & B115200 ) baud = 115200;
104)   else baud = 0;
105) 
106)   //parity
107)   if( settings & PARENB )
108)     if( settings & PARODD) parity = 'O';
109)     else parity = 'E';
110)   else parity = 'N';
111) 
112)   //data bits
113)   if( settings & CS5) data = 5;
114)   else if( settings & CS6) data = 6;
115)   else if( settings & CS7) data = 7;
116)   else if( settings & CS8) data = 8;
117)   else data = 0;
118)   
119)   //stop bits
120)   if( settings & CSTOPB ) stop = 2;
121)   else stop = 1;
122) 
123)   snprintf( buf, maxlen, "%d,%c,%d,%d", baud, parity, data, stop );
124) }
125) 
126) //set serial settings for fd
127) static int serial_settings_set( int fd, int settings )
128) {
129)   struct termios tio;
130) 
131)   //set port settings
132)   bzero( &tio, sizeof( tio ) );
133)   tio.c_cflag = CLOCAL | HUPCL | CREAD | settings;
134)   tio.c_iflag = IGNBRK | IGNPAR;
135)   tio.c_oflag = 0;
136)   tio.c_lflag = 0;
137)   tio.c_cc[VTIME] = 10; //1 sec timeout
138)   tio.c_cc[VMIN] = 0; //return on single char read
139)   if( tcsetattr( fd, TCSANOW, &tio ) == -1 )
140)   {
141)     printf( "tcsetattr: error: %s\n", strerror( errno ) );
142)     return 0;
143)   }
144) 
145)   //success
146)   return 1;
147) }
148) 

149) //receive frames from socket and output them
150) //dev_fd may be -1 for not doing anything with device
151) //returns error code (not for device-errors, 0 for success)
152) static int recv_and_out( int udpSocket, int dev_fd,
153)                          int * p_device_output_active,
154)                          unsigned int format_change,
155)                          unsigned int format_height, unsigned int format_width,
156)                          unsigned int format_channels, unsigned int format_colors,
157)                          etBlinkenProto proto,
158)                          int use_msecs, unsigned int msecs )

159) {
160)   fd_set readFds, errFds;

161)   stBlinkenFrame * pFrame;

162)   char buffer[65536]; //64kB is more than maximum UDP size

163)   int maxFd, len, dev_eof;
164)   struct timeval start, timeout, * p_timeout, end;

165) 

166)   dev_eof = 0;

167)   for( ; ; )
168)   {
169)     //wait for next frame
170)     FD_ZERO( &readFds );
171)     FD_SET( udpSocket, &readFds );

172)     if( dev_fd != -1 && ! dev_eof )

173)       FD_SET( dev_fd, &readFds );
174)     FD_ZERO( &errFds );
175)     FD_SET( udpSocket, &errFds );

176)     if( dev_fd != -1 )
177)       FD_SET( dev_fd, &errFds );

178)     maxFd = 0;
179)     if( udpSocket > maxFd )
180)       maxFd = udpSocket;

181)     if( dev_fd != -1 && dev_fd > maxFd )

182)       maxFd = dev_fd;

183)     if( use_msecs ) //timeout
184)     {
185)       gettimeofday( &start, NULL );
186)       timeout.tv_sec = msecs / 1000;
187)       timeout.tv_usec = msecs % 1000 * 1000;
188)       p_timeout = &timeout;
189)     }
190)     else
191)       p_timeout = NULL;
192)     if( select( maxFd + 1, &readFds, NULL, &errFds, p_timeout ) < 0 ) //error
193)     {
194)       printf( "error during select: %s\n", strerror( errno ) );
195)       return -1;
196)     }

197) 
198)     //error on socket or device
199)     if( FD_ISSET( udpSocket, &errFds ) )
200)     {
201)       printf( "error on socket\n" );

202)       return -1;

203)     }

204)     if( dev_fd != -1 && FD_ISSET( dev_fd, &errFds ) )

205)     {

206)       if( *p_device_output_active )
207)         printf( "error on device\n" );

208)       break;
209)     }
210) 
211)     //received frame
212)     if( FD_ISSET( udpSocket, &readFds ) )
213)     {
214)       //fetch data
215)       len = recv( udpSocket, buffer, sizeof( buffer ), 0 );
216)       if( len < 0 )
217)       {
218)         printf( "could not read from socket\n" );

219)         return -1;

220)       }
221)       if( len == 0 )

222)         return -1;

223) 
224)       //get frame from data
225)       pFrame = BlinkenFrameFromNetwork( buffer, len, NULL );
226)       if( pFrame != NULL )
227)       {
228)         //change format
229)         if( format_change )
230)           BlinkenFrameResize( pFrame, format_height, format_width, format_channels, format_colors - 1 );
231) 
232)         //create output data from frame
233)         len = BlinkenFrameToNetwork( pFrame, proto, buffer, sizeof( buffer ) );
234) 
235)         //free frame
236)         BlinkenFrameFree( pFrame );
237) 
238)         //output data to device

239)         if( dev_fd != -1 && len > 0 )
240)         {
241)           if( write( dev_fd, buffer, len ) != len )
242)           {
243)             if( *p_device_output_active )
244)               printf( "error writing to device\n" );
245)             break;
246)           }
247)           //message: output to device was restarted
248)           if( ! *p_device_output_active )
249)             printf( "restarted output to device...\n" );
250)           *p_device_output_active = 1;
251)         }

252)       }
253)     }
254) 
255)     //received data from device

256)     if( dev_fd != -1 && FD_ISSET( dev_fd, &readFds ) )

257)     {
258)       //read data
259)       len = read( dev_fd, buffer, sizeof( buffer ) );
260)       if( len < 0 )
261)       {

262)         if( *p_device_output_active )
263)           printf( "error reading from device\n" );

264)         break;
265)       }
266)       if( len == 0 )
267)         dev_eof = 1;
268)     }

269) 
270)     //using time limit
271)     if( use_msecs )
272)     {
273)       //get time elapsed
274)       gettimeofday( &end, NULL );
275)       int sec, usec;
276)       unsigned int msec;
277)       sec = end.tv_sec - start.tv_sec;
278)       usec = end.tv_usec - start.tv_usec;
279)       if( usec < 0 )
280)       {
281)         usec += 1000000;
282)         sec--;
283)       }
284)       if( usec < 0 )
285)         usec = 0;
286)       if( sec < 0 )
287)         sec = 0;
288)       msec = sec * 1000 + usec / 1000;
289)       //more than rest of timeout (or exact match)
290)       if( msec >= msecs )
291)         break;
292)       msecs -= msec;
293)     }
294) 

295)   } //for( ; ; )

296) 
297)   return 0;
298) }
299) 
300) //open device and output frames
301) //returns error code (not for device-errors, 0 for success)
302) static int open_and_output( int udpSocket, char * device,
303)                             int * p_device_output_active,
304)                             int serial_settings_change, int serial_settings,
305)                             unsigned int format_change,
306)                             unsigned int format_height, unsigned int format_width,
307)                             unsigned int format_channels, unsigned int format_colors,
308)                             etBlinkenProto proto )
309) {
310)   int dev_fd, err;
311)   char txt[64];
312) 
313)   //open device
314)   dev_fd = open( device, O_RDWR | O_NOCTTY | O_NONBLOCK );
315)   if( dev_fd == -1 )
316)   {
317)     if( *p_device_output_active )
318)       printf( "could not open \"%s\": error: %s\n", device, strerror( errno ) );
319)     return 0;
320)   }
321) 
322)   //setup serial port
323)   if( serial_settings_change )
324)   {
325)     if( ! serial_settings_set( dev_fd, serial_settings ) )
326)     {
327)       if( *p_device_output_active )
328)       {
329)         serial_settings_to_str( serial_settings, txt, sizeof( txt ) );
330)         printf( "could not set serial port to \"%s\"\n", txt );
331)       }
332)       close( dev_fd );
333)       return 0;
334)     }
335)   }
336) 
337)   //receive frames and output to device
338)   err = recv_and_out( udpSocket, dev_fd, p_device_output_active,
339)                       format_change, format_height, format_width, format_channels, format_colors,
340)                       proto, 0, 0 );
341) 
342)   //close device
343)   close( dev_fd );
344) 
345)   return err;
346) }
347) 
348) //open device and output frames in a loop
349) //returns error code (not for device-errors, 0 for success)
350) static int open_and_output_loop( int udpSocket, char * device,
351)                                  int serial_settings_change, int serial_settings,
352)                                  int reopen_device, unsigned int reopen_device_ms,
353)                                  unsigned int format_change,
354)                                  unsigned int format_height, unsigned int format_width,
355)                                  unsigned int format_channels, unsigned int format_colors,
356)                                  etBlinkenProto proto )
357) {
358)   int device_output_active, err;
359) 
360)   printf( "receiving frames and outputting them to \"%s\"...\n", device );
361)   device_output_active = 1;
362) 
363)   for( ; ; )
364)   {
365) 
366)     //try to open device and output frames
367)     err = open_and_output( udpSocket, device,
368)                            &device_output_active,
369)                            serial_settings_change, serial_settings,
370)                            format_change, format_height, format_width, format_channels, format_colors,
371)                            proto );
372)     if( err != 0 || ! reopen_device )
373)       break;
374) 
375)     //output to device stopped
376)     if( device_output_active )
377)       printf( "output to device stopped...\n" );
378)     device_output_active = 0;
379) 
380)     //only fetch data from socket for a short time
381)     err = recv_and_out( udpSocket, -1, &device_output_active,
382)                         format_change, format_height, format_width, format_channels, format_colors,
383)                         proto, 1, reopen_device_ms );
384)     if( err != 0 )
385)       break;;
386) 
387)   }
388) 
389)   //output to device finshed
390)   if( device_output_active )
391)     printf( "output to device finished...\n" );
392)   device_output_active = 0;
393) 
394)   return err;

395) }
396) 
397) int main( int argCnt, char * * args )
398) {

399)   int i, udpSocket, bound, serial_settings;

400)   etBlinkenProto proto;
401)   unsigned int format_change, format_height, format_width, format_channels, format_colors;

402)   unsigned int height, width, channels, colors, reopen_device_ms;
403)   int serial_settings_change, reopen_device;

404)   char txt[64];
405)   unsigned short port;
406)   struct sockaddr_in addr;
407)   char * device;
408) 
409)   //print info
410)   printf( "BlinkenLib - BlinkenOutput\n"

411)           "version 0.5.1 date 2005-12-14\n"

412)           "Copyright 2004-2005 Stefan Schuermans <1stein@schuermans.info>\n"
413)           "Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html\n"
414)           "a blinkenarea.org project\n\n" );
415) 
416)   //print syntax
417)   if( argCnt <= 1 )
418)   {
419)     printf( "syntax: %s <parameter> [...]\n\n"
420)             "parameters:\n"
421)             "  -l [<ip>:]<port>\n"
422)             "     local address (defaults to 0.0.0.0:2323)\n"

423)             "     must occur before -r, may only occur once\n"

424)             "  -r <ip>[:<port>]\n"
425)             "     remote addess (defaults to every remote address)\n"
426)             "  -p [BLP|EBLP|MCUF]\n"
427)             "     protocol to outputframes in (defaults to MCUF)\n"
428)             "  -f <width>x<height>-<channels>/<colors>\n"
429)             "     format to output frames in (defaults to no change)\n"
430)             "  -d <device>\n"
431)             "     device to output frames to (defaults to \"/dev/null\")\n"
432)             "  -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"

433)             "     settings to use for serial devices (defaults to no change)\n"
434)             "  -o <milliseconds>\n"
435)             "     reopen device after short time on error (defaults to not reopen)\n"
436)             "\n",

437)             args[0] );
438)     return 0;
439)   }
440) 
441)   //create udp socket
442)   udpSocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
443)   if( udpSocket == -1 )
444)   {
445)     printf( "cannot create UDP socket\n" );
446)     return -1;
447)   }
448)   bound = 0;
449) 
450)   //process parameters
451)   proto = BlinkenProtoMcuf;
452)   format_change = 0;

453)   format_height = 0;
454)   format_width = 0;
455)   format_channels = 0;
456)   format_colors = 0;

457)   device = "/dev/null";
458)   serial_settings_change = 0;

459)   reopen_device = 0;

460)   for( i = 1; i < argCnt; i++ )
461)   {
462) 
463)     //local address
464)     if( strcmp( args[i], "-l" ) == 0 )
465)     {
466)       if( i + 1 < argCnt )
467)       {
468)         i++;
469)         if( sscanf( args[i], "%32[0-9.]:%hu", txt, &port ) == 2 )
470)         {
471)           addr.sin_family = AF_INET;
472)           addr.sin_port = htons( port );
473)           addr.sin_addr.s_addr = inet_addr( txt );
474)           if( bind( udpSocket, (struct sockaddr *)&addr, sizeof( addr ) ) != 0 )
475)             printf( "could not set local address to \"%s\"\n", args[i] );
476)           else
477)             bound = 1;
478)         }
479)         else if( sscanf( args[i], "%hu", &port ) == 1 )
480)         {
481)           addr.sin_family = AF_INET;
482)           addr.sin_port = htons( port );
483)           addr.sin_addr.s_addr = htonl( INADDR_ANY );
484)           if( bind( udpSocket, (struct sockaddr *)&addr, sizeof( addr ) ) != 0 )
485)             printf( "could not set local address to \"%s\"\n", args[i] );
486)           else
487)             bound = 1;
488)         }
489)         else
490)           printf( "invalid local address \"%s\"\n", args[i] );
491)       }
492)       else
493)         printf( "missing local address for \"-l\"\n" );
494)     }
495) 
496)     //remote address
497)     else if( strcmp( args[i], "-r" ) == 0 )
498)     {
499)       if( i + 1 < argCnt )
500)       {
501)         i++;
502)         if( sscanf( args[i], "%32[0-9.]:%hu", txt, &port ) == 2 )
503)         {
504)           addr.sin_family = AF_INET;
505)           addr.sin_port = htons( port );
506)           addr.sin_addr.s_addr = inet_addr( txt );
507)           if( connect( udpSocket, (struct sockaddr *)&addr, sizeof( addr ) ) != 0 )
508)             printf( "could not set remote address to \"%s\"\n", args[i] );
509)         }
510)         else if( sscanf( args[i], "%32[0-9.]", txt ) == 1 )
511)         {
512)           addr.sin_family = AF_INET;
513)           addr.sin_port = htons( 23230 );
514)           addr.sin_addr.s_addr = inet_addr( txt );
515)           if( connect( udpSocket, (struct sockaddr *)&addr, sizeof( addr ) ) != 0 )
516)             printf( "could not set remote address to \"%s\"\n", args[i] );
517)         }
518)         else
519)           printf( "invalid remote address \"%s\"\n", args[i] );
520)       }
521)       else
522)         printf( "missing remote address for \"-r\"\n" );
523)     }
524) 
525)     //protocol to output frames in
526)     else if( strcmp( args[i], "-p" ) == 0 )
527)     {
528)       if( i + 1 < argCnt )
529)       {
530)         i++;
531)         if( strcasecmp( args[i], "BLP" ) == 0 )
532)           proto = BlinkenProtoBlp;
533)         else if( strcasecmp( args[i], "EBLP" ) == 0 )
534)           proto = BlinkenProtoEblp;
535)         else if( strcasecmp( args[i], "MCUF" ) == 0 )
536)           proto = BlinkenProtoMcuf;
537)         else
538)           printf( "unknown protocol \"%s\"\n", args[i] );
539)       }
540)       else
541)         printf( "missing protocol for \"-p\"\n" );
542)     }
543) 
544)     //format to output frames in
545)     else if( strcmp( args[i], "-f" ) == 0 )
546)     {
547)       if( i + 1 < argCnt )
548)       {
549)         i++;
550)         if( sscanf( args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors ) == 4 &&
551)             width > 0 && width < 1000 && height > 0 && height < 1000 &&
552)             channels > 0 && channels < 20 && colors > 1 && colors <= 256 )
553)         {
554)           format_change = 1;
555)           format_height = height;
556)           format_width = width;
557)           format_channels = channels;
558)           format_colors = colors;
559)         }
560)         else
561)           printf( "invalid frame format \"%s\"\n", args[i] );
562)       }
563)       else
564)         printf( "missing frame format for \"-r\"\n" );
565)     }
566) 
567)     //device to output frames to
568)     else if( strcmp( args[i], "-d" ) == 0 )
569)     {
570)       if( i + 1 < argCnt )
571)       {
572)         i++;
573)         device = args[i];
574)       }
575)       else
576)         printf( "missing device name for \"-d\"\n" );
577)     }
578) 
579)     //settings for serial output devices
580)     else if( strcmp( args[i], "-s" ) == 0 )
581)     {
582)       if( i + 1 < argCnt )
583)       {
584)         i++;
585)         if( serial_settings_parse( args[i], &serial_settings ) )
586)         {
587)           serial_settings_change = 1;
588)         }
589)         else
590)           printf( "invalid serial settings \"%s\"\n", args[i] );
591)       }
592)       else
593)         printf( "missing serial settings for \"-s\"\n" );
594)     }
595) 

596)     //reopen device on error after some time
597)     else if( strcmp( args[i], "-o" ) == 0 )
598)     {
599)       if( i + 1 < argCnt )
600)       {
601)         i++;
602)         if( sscanf( args[i], "%u", &reopen_device_ms ) == 1 && reopen_device_ms >= 1 )
603)           reopen_device = 1;
604)         else
605)           printf( "invalid number of milliseconds \"%s\"\n", args[i] );
606)       }
607)       else
608)         printf( "missing time for \"-o\"\n" );
609)     }
610) 

611)     //unknown parameter
612)     else
613)       printf( "unknown parameter \"%s\", call without parameters to get help\n", args[i] );
614) 
615)   } //for( i ...
616) 
617)   //try to bind if not bound
618)   if( ! bound )
619)   {
620)     printf( "no local address to receive frames on,\n"
621)             "  using default local address \"0.0.0.0:2323\"\n" );
622)     addr.sin_family = AF_INET;
623)     addr.sin_port = htons( 2323 );
624)     addr.sin_addr.s_addr = htonl( INADDR_ANY );
625)     if( bind( udpSocket, (struct sockaddr *)&addr, sizeof( addr ) ) == 0 )
626)       bound = 1;
627)     else
628)     {
629)       printf( "could not set local address to \"0.0.0.0:2323\"\n" );
630)       close( udpSocket );
631)       return -1;
632)     }
633)   }
634) 

635)   //open device and output frames in a loop
636)   open_and_output_loop( udpSocket, device,
637)                         serial_settings_change, serial_settings,
638)                         reopen_device, reopen_device_ms,
639)                         format_change, format_height, format_width, format_channels, format_colors,
640)                         proto );

641) 

642)   //close socket