cedrusbox_windows_internal.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file cedrusbox_windows_internal.c
/// Definitions of Windows-specific cedrusbox functions.
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// @name Windows-specific cedrusbox functions
//@{
////////////////////////////////////////////////////////////////////////////////

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

HANDLE _ts5_cedrusbox_handle[TS5_CEDRUSBOX_MAXPORT] = {TS5_CEDRUSBOX_NODEVICE};

int ts5_install_cedrusbox_windows(char *calling_function);
void ts5_uninstall_cedrusbox_windows();
unsigned int ts5_read_cedrusbox_windows(int port, char *buff, unsigned long bytes_to_read);
unsigned int ts5_write_cedrusbox_windows(int port, char *buff, unsigned long bytes_to_write);
void ts5_fflush_cedrusbox_windows(int port);


////////////////////////////////////////////////////////////////////////////////
/// Windows-specific 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_windows(char *calling_function)
{
    int i, num_serial_devices=0;

    for (i=0; i<TS5_CEDRUSBOX_MAXPORT; i++) {

        // write port name
        char portname[TS5_MAX_CHAR];
        sprintf(portname, "COM%d", i+1);

        // try to open the port
        _ts5_cedrusbox_handle[num_serial_devices] = CreateFile(portname,
                                    GENERIC_READ | GENERIC_WRITE,
                                    0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        // if failed try next port
        if (_ts5_cedrusbox_handle[num_serial_devices] == INVALID_HANDLE_VALUE) {
            continue;
        }

        // if port is open mark it as a possible cedrus device
        ts5_log(TS5_LOGLEVEL_1,"%s: port %s is available\n", calling_function, portname);

        // read comm state
        DCB dcb;

        if (!GetCommState(_ts5_cedrusbox_handle[num_serial_devices], &dcb)) {
            ts5_log(TS5_LOGLEVEL_1,"%s: GetCommState failed with error code %d\n",
                        calling_function, GetLastError());
        }

        // set comm state
        dcb.BaudRate = 115200;
        dcb.ByteSize = (unsigned char) 8;
        dcb.Parity = 0;
        dcb.StopBits = 0;
        dcb.fBinary = 1;

        if (!SetCommState(_ts5_cedrusbox_handle[num_serial_devices], &dcb)) {
            ts5_log(TS5_LOGLEVEL_1,"%s: SetCommState failed with error code %d\n",
                        calling_function, GetLastError());
        }

        // set comm timeouts
        COMMTIMEOUTS ct;
        ct.ReadIntervalTimeout = MAXDWORD;
        ct.ReadTotalTimeoutMultiplier = 0;
        ct.ReadTotalTimeoutConstant = 0;
        ct.WriteTotalTimeoutMultiplier = 0;
        ct.WriteTotalTimeoutConstant = 5000;

        if (!SetCommTimeouts(_ts5_cedrusbox_handle[num_serial_devices], &ct)) {
            ts5_log(TS5_LOGLEVEL_1,"%s: SetCommTimeouts failed with error code %d\n",
                        calling_function, GetLastError());
        }

        // setup comm
        if (!SetupComm(_ts5_cedrusbox_handle[num_serial_devices], 2048, 2048)) {
            ts5_log(TS5_LOGLEVEL_1,"%s: SetupComm failed with error code %d\n",
                        calling_function, GetLastError());
        }

        // if we get here mark it as a possible cedrusbox
        num_serial_devices++;
    }

    return num_serial_devices;
}


////////////////////////////////////////////////////////////////////////////////
/// Windows-specific cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_cedrusbox_windows()
{
    int i;
    for (i=0; i<_ts5_status.timer.num_cedrusboxes; i++) {

        int port_num = _ts5_status.timer.cedrusbox[i].port_num;

        if (!CloseHandle(_ts5_cedrusbox_handle[port_num])) {
            ts5_log(TS5_LOGLEVEL_1,"ts5_uninstall_cedrusbox_windows:\n");
            ts5_log(TS5_LOGLEVEL_1,"\tcould not uninstall cedrusbox %d\n", i);
        }

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


////////////////////////////////////////////////////////////////////////////////
/// Windows-specific cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
unsigned int ts5_read_cedrusbox_windows(int port, char *buff, unsigned long bytes_to_read)
{
    unsigned long bytes_read;

    if (!ReadFile(_ts5_cedrusbox_handle[port], buff, bytes_to_read, &bytes_read, NULL)) {
        ts5_fatal("ts5_read_cedrusbox_windows: read error\n");
    }

    return bytes_read;
}


////////////////////////////////////////////////////////////////////////////////
/// Windows-specific cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
unsigned int ts5_write_cedrusbox_windows(int port, char *buff, unsigned long bytes_to_write)
{
    unsigned long bytes_written;

    if (!WriteFile(_ts5_cedrusbox_handle[port], buff, bytes_to_write, &bytes_written, NULL)) {
        ts5_fatal("ts5_write_cedrusbox_windows: write error 1\n");
    }

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

    ts5_wait(0.10);

    return bytes_written;
}


////////////////////////////////////////////////////////////////////////////////
/// Windows-specific cedrusbox function.
///
/// \warning This is an internal function. Do not call this function directly.
////////////////////////////////////////////////////////////////////////////////
void ts5_fflush_cedrusbox_windows(int port)
{
    char buff[TS5_MAX_CHAR];
    unsigned long bytes_read;

    do {
        ReadFile(_ts5_cedrusbox_handle[port], buff, 1, &bytes_read, NULL);
    } while (bytes_read > 0);
}

//@}