AnalogTrigger.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 "AnalogTrigger.h"

#include "AnalogChannel.h"
#include "AnalogModule.h"
#include "Resource.h"
#include "WPIErrors.h"

static Resource *triggers = NULL;

void AnalogTrigger::InitTrigger(UINT8 moduleNumber, UINT32 channel)
{
        Resource::CreateResourceObject(&triggers, tAnalogTrigger::kNumSystems);
        UINT32 index = triggers->Allocate("Analog Trigger");
        if (index == ~0ul)
        {
                CloneError(triggers);
                return;
        }
        m_index = (UINT8)index;
        m_channel = channel;
        m_analogModule = AnalogModule::GetInstance(moduleNumber);

        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_trigger = tAnalogTrigger::create(m_index, &localStatus);
        m_trigger->writeSourceSelect_Channel(m_channel - 1, &localStatus);
        m_trigger->writeSourceSelect_Module(moduleNumber - 1, &localStatus);
        wpi_setError(localStatus);
}

AnalogTrigger::AnalogTrigger(UINT32 channel)
{
        InitTrigger(GetDefaultAnalogModule(), channel);
}

AnalogTrigger::AnalogTrigger(UINT8 moduleNumber, UINT32 channel)
{
        InitTrigger(moduleNumber, channel);
}

AnalogTrigger::AnalogTrigger(AnalogChannel *channel)
{
        InitTrigger(channel->GetModuleNumber(), channel->GetChannel());
}

AnalogTrigger::~AnalogTrigger()
{
        triggers->Free(m_index);
        delete m_trigger;
}

void AnalogTrigger::SetLimitsRaw(INT32 lower, INT32 upper)
{
        if (StatusIsFatal()) return;
        if (lower > upper)
        {
                wpi_setWPIError(AnalogTriggerLimitOrderError);
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_trigger->writeLowerLimit(lower, &localStatus);
        m_trigger->writeUpperLimit(upper, &localStatus);
        wpi_setError(localStatus);
}

void AnalogTrigger::SetLimitsVoltage(float lower, float upper)
{
        if (StatusIsFatal()) return;
        if (lower > upper)
        {
                wpi_setWPIError(AnalogTriggerLimitOrderError);
        }
        // TODO: This depends on the averaged setting.  Only raw values will work as is.
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_trigger->writeLowerLimit(m_analogModule->VoltsToValue(m_channel, lower), &localStatus);
        m_trigger->writeUpperLimit(m_analogModule->VoltsToValue(m_channel, upper), &localStatus);
        wpi_setError(localStatus);
}

void AnalogTrigger::SetAveraged(bool useAveragedValue)
{
        if (StatusIsFatal()) return;
        tRioStatusCode localStatus = NiFpga_Status_Success;
        if (m_trigger->readSourceSelect_Filter(&localStatus) != 0)
                wpi_setWPIErrorWithContext(IncompatibleMode, "Hardware does not support average and filtering at the same time.");
        m_trigger->writeSourceSelect_Averaged(useAveragedValue, &localStatus);
        wpi_setError(localStatus);
}

void AnalogTrigger::SetFiltered(bool useFilteredValue)
{
        if (StatusIsFatal()) return;
        tRioStatusCode localStatus = NiFpga_Status_Success;
        if (m_trigger->readSourceSelect_Averaged(&localStatus) != 0)
                wpi_setWPIErrorWithContext(IncompatibleMode, "Hardware does not support average and filtering at the same time.");
        m_trigger->writeSourceSelect_Filter(useFilteredValue, &localStatus);
        wpi_setError(localStatus);
}

UINT32 AnalogTrigger::GetIndex()
{
        if (StatusIsFatal()) return ~0ul;
        return m_index;
}

bool AnalogTrigger::GetInWindow()
{
        if (StatusIsFatal()) return false;
        tRioStatusCode localStatus = NiFpga_Status_Success;
        bool result = m_trigger->readOutput_InHysteresis(m_index, &localStatus) != 0;
        wpi_setError(localStatus);
        return result;
}

bool AnalogTrigger::GetTriggerState()
{
        if (StatusIsFatal()) return false;
        tRioStatusCode localStatus = NiFpga_Status_Success;
        bool result = m_trigger->readOutput_OverLimit(m_index, &localStatus) != 0;
        wpi_setError(localStatus);
        return result;
}

AnalogTriggerOutput *AnalogTrigger::CreateOutput(AnalogTriggerOutput::Type type)
{
        if (StatusIsFatal()) return NULL;
        return new AnalogTriggerOutput(this, type);
}