BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.2 date 2006-05-10
3)  * Copyright 2004-2006 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( SOCKET 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)       int sec, usec;
275)       unsigned int msec;

276)       gettimeofday( &end, NULL );

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( SOCKET 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( SOCKET 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, bound, serial_settings;
400)   SOCKET udpSocket;

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

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

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

412)           "version 0.5.2 date 2006-05-10\n"
413)           "Copyright 2004-2006 Stefan Schuermans <1stein@schuermans.info>\n"

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

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

425)             "  -r <ip>[:<port>]\n"
426)             "     remote addess (defaults to every remote address)\n"
427)             "  -p [BLP|EBLP|MCUF]\n"

428)             "     protocol to output frames in (defaults to MCUF)\n"

429)             "  -f <width>x<height>-<channels>/<colors>\n"
430)             "     format to output frames in (defaults to no change)\n"
431)             "  -d <device>\n"
432)             "     device to output frames to (defaults to \"/dev/null\")\n"
433)             "  -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"

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

438)             args[0] );
439)     return 0;
440)   }
441) 
442)   //create udp socket
443)   udpSocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );

444)   if( udpSocket == INVALID_SOCKET )

445)   {
446)     printf( "cannot create UDP socket\n" );
447)     return -1;
448)   }
449)   bound = 0;
450) 
451)   //process parameters
452)   proto = BlinkenProtoMcuf;
453)   format_change = 0;

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

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

460)   reopen_device = 0;

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

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

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

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

642) 

643)   //close socket