SerialPort.cpp

/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved.                                                         */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
/*----------------------------------------------------------------------------*/

#include "SerialPort.h"

#include "NetworkCommunication/UsageReporting.h"
#include "visa/visa.h"

//static ViStatus _VI_FUNCH ioCompleteHandler (ViSession vi, ViEventType eventType, ViEvent event, ViAddr userHandle);

SerialPort::SerialPort(uint32_t baudRate, uint8_t dataBits, SerialPort::Parity parity, SerialPort::StopBits stopBits)
        : m_resourceManagerHandle (0)
        , m_portHandle (0)
        , m_consoleModeEnabled (false)
{
        ViStatus localStatus = VI_SUCCESS;
        localStatus = viOpenDefaultRM((ViSession*)&m_resourceManagerHandle);
        wpi_setError(localStatus);

        localStatus = viOpen(m_resourceManagerHandle, const_cast<char*>("ASRL1::INSTR"), VI_NULL, VI_NULL, (ViSession*)&m_portHandle);
        wpi_setError(localStatus);
        if (localStatus != 0)
        {
                m_consoleModeEnabled = true;
                return;
        }

        localStatus = viSetAttribute(m_portHandle, VI_ATTR_ASRL_BAUD, baudRate);
        wpi_setError(localStatus);
        localStatus = viSetAttribute(m_portHandle, VI_ATTR_ASRL_DATA_BITS, dataBits);
        wpi_setError(localStatus);
        localStatus = viSetAttribute(m_portHandle, VI_ATTR_ASRL_PARITY, parity);
        wpi_setError(localStatus);
        localStatus = viSetAttribute(m_portHandle, VI_ATTR_ASRL_STOP_BITS, stopBits);
        wpi_setError(localStatus);

        // Set the default timeout to 5 seconds.
        SetTimeout(5.0f);

        // Don't wait until the buffer is full to transmit.
        SetWriteBufferMode(kFlushOnAccess);

        EnableTermination();

        //viInstallHandler(m_portHandle, VI_EVENT_IO_COMPLETION, ioCompleteHandler, this);
        //viEnableEvent(m_portHandle, VI_EVENT_IO_COMPLETION, VI_HNDLR, VI_NULL);

        nUsageReporting::report(nUsageReporting::kResourceType_SerialPort, 0);
}

SerialPort::~SerialPort()
{
        if (!m_consoleModeEnabled)
        {
                //viUninstallHandler(m_portHandle, VI_EVENT_IO_COMPLETION, ioCompleteHandler, this);
                viClose(m_portHandle);
        }
        viClose(m_resourceManagerHandle);
}

void SerialPort::SetFlowControl(SerialPort::FlowControl flowControl)
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viSetAttribute (m_portHandle, VI_ATTR_ASRL_FLOW_CNTRL, flowControl);
                wpi_setError(localStatus);
        }
}

void SerialPort::EnableTermination(char terminator)
{
        if (!m_consoleModeEnabled)
        {
                viSetAttribute(m_portHandle, VI_ATTR_TERMCHAR_EN, VI_TRUE); 
                viSetAttribute(m_portHandle, VI_ATTR_TERMCHAR, terminator);
                viSetAttribute(m_portHandle, VI_ATTR_ASRL_END_IN, VI_ASRL_END_TERMCHAR);
        }
}

void SerialPort::DisableTermination()
{
        if (!m_consoleModeEnabled)
        {
                viSetAttribute(m_portHandle, VI_ATTR_TERMCHAR_EN, VI_FALSE); 
                viSetAttribute(m_portHandle, VI_ATTR_ASRL_END_IN, VI_ASRL_END_NONE);
        }
}

int32_t SerialPort::GetBytesReceived()
{
        int32_t bytes = 0;
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viGetAttribute(m_portHandle, VI_ATTR_ASRL_AVAIL_NUM, &bytes);
                wpi_setError(localStatus);
        }
        return bytes;
}

void SerialPort::Printf(const char *writeFmt, ...)
{
        if (!m_consoleModeEnabled)
        {
                va_list args;
                va_start (args, writeFmt);
                ViStatus localStatus = viVPrintf(m_portHandle, (ViString)writeFmt, args);
                va_end (args);
                wpi_setError(localStatus);
        }
}

void SerialPort::Scanf(const char *readFmt, ...)
{
        if (!m_consoleModeEnabled)
        {
                va_list args;
                va_start (args, readFmt);
                ViStatus localStatus = viVScanf(m_portHandle, (ViString)readFmt, args);
                va_end (args);
                wpi_setError(localStatus);
        }
}

uint32_t SerialPort::Read(char *buffer, int32_t count)
{
        uint32_t retCount = 0;
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viBufRead(m_portHandle, (ViPBuf)buffer, count, (ViPUInt32)&retCount);
                switch (localStatus)
                {
                case VI_SUCCESS_TERM_CHAR:
                case VI_SUCCESS_MAX_CNT:
                case VI_ERROR_TMO: // Timeout
                        break;
                default:
                        wpi_setError(localStatus);
                }
        }
        return retCount;
}

uint32_t SerialPort::Write(const char *buffer, int32_t count)
{
        uint32_t retCount = 0;
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viBufWrite(m_portHandle, (ViPBuf)buffer, count, (ViPUInt32)&retCount);
                wpi_setError(localStatus);
        }
        return retCount;
}

void SerialPort::SetTimeout(float timeout)
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viSetAttribute(m_portHandle, VI_ATTR_TMO_VALUE, (uint32_t)(timeout * 1e3));
                wpi_setError(localStatus);
        }
}

void SerialPort::SetReadBufferSize(uint32_t size)
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viSetBuf(m_portHandle, VI_READ_BUF, size);
                wpi_setError(localStatus);
        }
}

void SerialPort::SetWriteBufferSize(uint32_t size)
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viSetBuf(m_portHandle, VI_WRITE_BUF, size);
                wpi_setError(localStatus);
        }
}

void SerialPort::SetWriteBufferMode(SerialPort::WriteBufferMode mode)
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viSetAttribute(m_portHandle, VI_ATTR_WR_BUF_OPER_MODE, mode);
                wpi_setError(localStatus);
        }
}

void SerialPort::Flush()
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viFlush(m_portHandle, VI_WRITE_BUF);
                wpi_setError(localStatus);
        }
}

void SerialPort::Reset()
{
        if (!m_consoleModeEnabled)
        {
                ViStatus localStatus = viClear(m_portHandle);
                wpi_setError(localStatus);
        }
}

//void SerialPort::_internalHandler(uint32_t port, uint32_t eventType, uint32_t event)
//{
//}

//ViStatus _VI_FUNCH ioCompleteHandler (ViSession vi, ViEventType eventType, ViEvent event, ViAddr userHandle)
//{
//      ((SerialPort*) userHandle)->_internalHandler(vi, eventType, event);
//      return VI_SUCCESS;
//}