cedrusbox_posix_internal.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file cedrusbox_posix_internal.c
/// Definitions of Posix-specific (Mac OS X, Linux) cedrusbox functions.
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// @name Posix-specific (Mac OS X, Linux) cedrusbox functions
//@{
////////////////////////////////////////////////////////////////////////////////

#include <sys/types.h>
#include <sys/ioctl.h>
#include <dirent.h>
#include <termios.h>
#include <errno.h>

#include "../include/tscope5/timer.h"

int _ts5_cedrusbox_fd[TS5_CEDRUSBOX_MAXPORT] = {TS5_CEDRUSBOX_NODEVICE};
struct termios _ts5_cedrusbox_oldoptions[TS5_CEDRUSBOX_MAXPORT];

int ts5_install_cedrusbox_posix(char *calling_function);
void ts5_uninstall_cedrusbox_posix();
unsigned int ts5_read_cedrusbox_posix(int port, char *buff, unsigned long bytes_to_read);
unsigned int ts5_write_cedrusbox_posix(int port, char *buff, unsigned long bytes_to_write);
void ts5_fflush_cedrusbox_posix(int port);


////////////////////////////////////////////////////////////////////////////////
/// Posix-specific (Mac OS X, Linux) cedrusbox function.
///
/// \param calling_function Name the function that calls for this check or installation.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
int ts5_install_cedrusbox_posix(char *calling_function)
{
    int num_serial_devices = 0;

    // get directory listing of /dev
    DIR *dp;
    struct dirent *ep;
    dp = opendir ("/dev");

    if (!dp) {
        ts5_fatal("%s: could not get directory listing\n", calling_function);
    }

    // look for a tty.usbserial entry in the /dev directory
    char device_path[TS5_CEDRUSBOX_MAXPORT][TS5_MAX_CHAR];

    while ((ep = readdir (dp)) && num_serial_devices<TS5_CEDRUSBOX_MAXPORT) {

        char devicename[TS5_MAX_CHAR];

        #ifdef TS5_MACOSX
            strcpy(devicename, "tty.usbserial");

        #else
            strcpy(devicename, "ttyUSB");

        #endif

        if (strstr(ep->d_name, devicename)!=0) {

            sprintf(device_path[num_serial_devices], "/dev/%s", ep->d_name);
            ts5_log(TS5_LOGLEVEL_1,"%s: found a usb serial device at %s\n",
                        calling_function, device_path[num_serial_devices]);

            // open the device
            _ts5_cedrusbox_fd[num_serial_devices] = open(device_path[num_serial_devices],
                                                        O_RDWR | O_NOCTTY | O_NDELAY);

            if (_ts5_cedrusbox_fd[num_serial_devices] == -1) {
                ts5_fatal("%s: could not open usb serial device at %s\n",
                            calling_function, device_path[num_serial_devices]);
            }

            // get exclusive io
            if (ioctl(_ts5_cedrusbox_fd[num_serial_devices], TIOCEXCL) == -1) {
                ts5_fatal("%s: could not get exclusivity on usb serial device at %s\n",
                    calling_function, device_path[num_serial_devices]);
            }

            // set options for the connection
            struct termios options;
            tcgetattr(_ts5_cedrusbox_fd[num_serial_devices] ,
                        &_ts5_cedrusbox_oldoptions[num_serial_devices]);
            bzero (&options, sizeof (options));

            cfsetispeed(&options, B115200);
            cfsetospeed(&options, B115200);

            options.c_iflag = IGNBRK;
            options.c_lflag = 0;
            options.c_oflag = 0;
            options.c_cflag |= CLOCAL | CREAD;
            options.c_iflag = IGNPAR;
            options.c_oflag = 0;
            options.c_cflag &= ~(PARENB|PARODD) ;
            options.c_cflag &= ~CSTOPB ;
            options.c_cflag &= ~CSIZE;
            options.c_cflag |= CS8;
            options.c_cflag &= ~CRTSCTS;
            options.c_iflag &= ~(IXON | IXOFF | IXANY);

            if (tcsetattr (_ts5_cedrusbox_fd[num_serial_devices], TCSANOW, &options) == -1) {
                ts5_fatal("%s: could not set options on usb serial device at %s\n",
                            calling_function, device_path[num_serial_devices]);
            }

            if (fcntl(_ts5_cedrusbox_fd[num_serial_devices], F_SETFL, FNDELAY) == -1) {
                ts5_fatal("%s: could not set delay on usb serial device at %s\n",
                            calling_function, device_path[num_serial_devices]);
            }

            // if we get here mark it as a possible cedrusbox
            num_serial_devices++;
        }
    }
    al_rest(0.2);

    return num_serial_devices;
}


////////////////////////////////////////////////////////////////////////////////
/// Posix-specific (Mac OS X, Linux) cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_cedrusbox_posix()
{
    int i;
    for (i=0; i<_ts5_status.timer.num_cedrusboxes; i++) {

        if (_ts5_cedrusbox_fd[i] > 0) {

            tcdrain(_ts5_cedrusbox_fd[i]);
            tcsetattr(_ts5_cedrusbox_fd[i], TCSANOW, &_ts5_cedrusbox_oldoptions[i]);

            if (close(_ts5_cedrusbox_fd[i]) == -1) {
                ts5_log(TS5_LOGLEVEL_1, "ts5_uninstall_cedrusbox_posix:\n");
                ts5_log(TS5_LOGLEVEL_1, "\tcould not uninstall cedrusbox %d\n", i);
            }

            ts5_log(TS5_LOGLEVEL_1, "ts5_uninstall_cedrusbox_posix: uninstalled cedrusbox %d\n", i);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Posix-specific (Mac OS X, Linux) cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
unsigned int ts5_read_cedrusbox_posix(int port, char *buff, unsigned long bytes_to_read)
{
    unsigned int bytes_read;
    bytes_read = read(_ts5_cedrusbox_fd[port], buff, bytes_to_read);

    if ((int)bytes_read == -1) {
        ts5_fatal("ts5_read_cedrusbox_posix: read error\n");
    }

    return bytes_read;
}


////////////////////////////////////////////////////////////////////////////////
/// Posix-specific (Mac OS X, Linux) cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
unsigned int ts5_write_cedrusbox_posix(int port, char *buff, unsigned long bytes_to_write)
{
    unsigned int bytes_written;
    bytes_written = write(_ts5_cedrusbox_fd[port], buff, bytes_to_write);

    if (bytes_written != bytes_to_write) {
        ts5_fatal("ts5_write_cedrusbox_posix: write error\n");
    }

    ts5_wait(0.10);

    return bytes_written;
}


////////////////////////////////////////////////////////////////////////////////
/// Posix-specific (Mac OS X, Linux) cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
void ts5_fflush_cedrusbox_posix(int port)
{
    char buff[TS5_MAX_CHAR];
    unsigned int bytes_read;

    do {
        bytes_read = read (_ts5_cedrusbox_fd[port], buff, 6);
    } while (bytes_read > 0);
}

//@}