flashlight.cpp

Go to the documentation of this file.

#include "flashlight.h"

#include <fcntl.h>
#include <stdexcept>

#include "alarmconfiguration.h"
#include "exceptionhandler.h"

using namespace AlarmNotifications;

FlashLight& FlashLight::instance() noexcept
{
    static FlashLight global_instance;
    return global_instance;
}


FlashLight::FlashLight()
    : _deviceNode ( AlarmConfiguration::instance().getFlashLightRelaisDeviceNode() ),
      _fd ( -1 ),
      _fdOpen ( false )
{
}

FlashLight::~FlashLight()
{
    if ( _fdOpen )
        closeSerialInterface();
}

void FlashLight::switchOn() noexcept
{
    try{
        FlashLight::instance().switchInternal ( true );
    }
    catch ( std::exception& e )
    {
        ExceptionHandler ( e, "switching on the flash light." );
    }
    catch ( ... )
    {
        ExceptionHandler ( "switching on the flash light." );
    }
}

void FlashLight::switchOff() noexcept
{
    try {
        FlashLight::instance().switchInternal ( false );
    }
    catch ( std::exception& e )
    {
        ExceptionHandler ( e, "switching off the flash light." );
    }
    catch ( ... )
    {
        ExceptionHandler ( "switching off the flash light." );
    }
}

void FlashLight::switchInternal ( const bool lightSwitch )
{
    const deviceCommand command = createCommand ( lightSwitch );
    boost::lock_guard<boost::mutex> concurrencylock ( _serialLineMutex );

    openSerialInterface();
    configureSerialInterface();
    writeSerialInteface ( command );
    closeSerialInterface();
}

FlashLight::deviceCommand FlashLight::createCommand ( const bool lightSwitch )
{
    deviceCommand command;
    // Command: Set relais
    command.push_back ( '\xff' );
    // Selected relais: number one (device has only one)
    command.push_back ( '\x01' );
    // Select action:
    if ( lightSwitch )
        command.push_back ( '\x01' );
    else
        command.push_back ( '\x00' );
    return command;
}

void FlashLight::openSerialInterface()
{
    _fd = open ( _deviceNode.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK );
    if ( _fd < 0 )
        throw std::runtime_error ( "Cannot open serial interface for flashlight." );
    _fdOpen = true;
}

void FlashLight::configureSerialInterface()
{
    if ( !_fdOpen )
        throw std::logic_error ( "configureSerialInterface() called on closed interface." );
    termios serialConfig;
    const int getattr_result = tcgetattr ( _fd, &serialConfig );
    if ( getattr_result < 0 )
        throw std::runtime_error ( "Error while reading configuration of serial interface." );

    // Return immediately on read if no bytes are available
    serialConfig.c_cc[VMIN] = 0;
    serialConfig.c_cc[VTIME] = 0;

    // Ignore modem control lines
    serialConfig.c_cflag |= CREAD | CLOCAL;

    // Switch off software handshake
    serialConfig.c_iflag &= ~IXON & ~IXOFF;

    // Set 8bit character size
    serialConfig.c_cflag &= ~CSIZE;
    serialConfig.c_cflag |= CS8;

    // Set parity to none
    serialConfig.c_cflag &= ~PARENB & ~PARODD;
    serialConfig.c_iflag |= IGNPAR;

    // Set number of stop bits to 1
    serialConfig.c_cflag &= ~CSTOPB;

    // Disable hardware handshake
    serialConfig.c_cflag &= ~CRTSCTS;

    // Set baud rate
    const int ispeed_result = cfsetispeed ( &serialConfig, deviceBaudRate );
    if ( ispeed_result < 0 )
        throw std::runtime_error ( "Cannot set input baud rate." );
    const int ospeed_result = cfsetospeed ( &serialConfig, deviceBaudRate );
    if ( ospeed_result < 0 )
        throw std::runtime_error ( "Cannot set input baud rate." );

    //Write new configuration to interface
    const int setattr_result = tcsetattr ( _fd, TCSANOW, &serialConfig );
    if ( setattr_result < 0 )
        throw std::runtime_error ( "Error while writing configuration of serial interface." );
}

void FlashLight::writeSerialInteface ( const FlashLight::deviceCommand command )
{
    if ( !_fdOpen )
        throw std::logic_error ( "writeSerialInterface() called on closed interface." );
    const long unsigned int numBytes = command.size();
    uint8_t* buffer = nullptr;
    try
    {
        // Create a local character buffer to be passed to write()
        buffer = new uint8_t[numBytes+1]; // One byte safety, just to be sure
        if ( buffer == nullptr )
            throw std::bad_alloc(); // If new returns a null pointer, there is not enough memory available
        // Set all bytes in the buffer to zero.
        memset ( buffer, 0, numBytes+1 );
        // Copy string content into buffer
        std::copy ( command.begin(), command.end(), buffer );
        // Write buffer to serial interface
        long int bytesWritten = -1;
        do
        {
            bytesWritten = write ( _fd, buffer, numBytes );
        }
        while ( ( bytesWritten < 0 && EAGAIN == errno ) ); // Repeat if error code EAGAIN occurs

        if ( bytesWritten < 0 )
            throw std::runtime_error ( "An error occured while writing to the serial interface" );
        if ( ( long unsigned int ) ( bytesWritten ) < numBytes )
            throw std::runtime_error ( "Could not write all bytes to serial interface" );

        delete[] buffer;
    }
    catch ( ... )
    {
        delete[] buffer;
    }
}

void FlashLight::closeSerialInterface()
{
    _fdOpen = false;
    close ( _fd );
    _fd = -1;
}