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

#include "DigitalModule.h"
#include "Resource.h"
#include "WPIErrors.h"

// Allocate each direction separately.
static Resource *relayChannels = NULL;

void Relay::InitRelay (UINT8 moduleNumber)
{
        char buf[64];
        Resource::CreateResourceObject(&relayChannels, tDIO::kNumSystems * kRelayChannels * 2);
        if (!SensorBase::CheckRelayModule(moduleNumber))
        {
                snprintf(buf, 64, "Digital Module %d", moduleNumber);
                wpi_setWPIErrorWithContext(ModuleIndexOutOfRange, buf);
                return;
        }
        if (!SensorBase::CheckRelayChannel(m_channel))
        {
                snprintf(buf, 64, "Relay Channel %d", m_channel);
                wpi_setWPIErrorWithContext(ChannelIndexOutOfRange, buf);
                return;
        }

        if (m_direction == kBothDirections || m_direction == kForwardOnly)
        {
                snprintf(buf, 64, "Forward Relay %d (Module: %d)", m_channel, moduleNumber);
                if (relayChannels->Allocate(((moduleNumber - 1) * kRelayChannels + m_channel - 1) * 2, buf) == ~0ul)
                {
                        CloneError(relayChannels);
                        return;
                }
        }
        if (m_direction == kBothDirections || m_direction == kReverseOnly)
        {
                snprintf(buf, 64, "Reverse Relay %d (Module: %d)", m_channel, moduleNumber);
                if (relayChannels->Allocate(((moduleNumber - 1) * kRelayChannels + m_channel - 1) * 2 + 1, buf) == ~0ul)
                {
                        CloneError(relayChannels);
                        return;
                }
        }
        m_module = DigitalModule::GetInstance(moduleNumber);
        m_module->SetRelayForward(m_channel, false);
        m_module->SetRelayReverse(m_channel, false);
}

Relay::Relay(UINT8 moduleNumber, UINT32 channel, Relay::Direction direction)
        : m_channel (channel)
        , m_direction (direction)
{
        InitRelay(moduleNumber);
}

Relay::Relay(UINT32 channel, Relay::Direction direction)
        : m_channel (channel)
        , m_direction (direction)
{
        InitRelay(GetDefaultDigitalModule());
}

Relay::~Relay()
{
        m_module->SetRelayForward(m_channel, false);
        m_module->SetRelayReverse(m_channel, false);

        if (m_direction == kBothDirections || m_direction == kForwardOnly)
        {
                relayChannels->Free(((m_module->GetNumber() - 1) * kRelayChannels + m_channel - 1) * 2);
        }
        if (m_direction == kBothDirections || m_direction == kReverseOnly)
        {
                relayChannels->Free(((m_module->GetNumber() - 1) * kRelayChannels + m_channel - 1) * 2 + 1);
        }
}

void Relay::Set(Relay::Value value)
{
        if (StatusIsFatal()) return;
        switch (value)
        {
        case kOff:
                if (m_direction == kBothDirections || m_direction == kForwardOnly)
                {
                        m_module->SetRelayForward(m_channel, false);
                }
                if (m_direction == kBothDirections || m_direction == kReverseOnly)
                {
                        m_module->SetRelayReverse(m_channel, false);
                }
                break;
        case kOn:
                if (m_direction == kBothDirections || m_direction == kForwardOnly)
                {
                        m_module->SetRelayForward(m_channel, true);
                }
                if (m_direction == kBothDirections || m_direction == kReverseOnly)
                {
                        m_module->SetRelayReverse(m_channel, true);
                }
                break;
        case kForward:
                if (m_direction == kReverseOnly)
                {
                        wpi_setWPIError(IncompatibleMode);
                        break;
                }
                if (m_direction == kBothDirections || m_direction == kForwardOnly)
                {
                        m_module->SetRelayForward(m_channel, true);
                }
                if (m_direction == kBothDirections)
                {
                        m_module->SetRelayReverse(m_channel, false);
                }
                break;
        case kReverse:
                if (m_direction == kForwardOnly)
                {
                        wpi_setWPIError(IncompatibleMode);
                        break;
                }
                if (m_direction == kBothDirections)
                {
                        m_module->SetRelayForward(m_channel, false);
                }
                if (m_direction == kBothDirections || m_direction == kReverseOnly)
                {
                        m_module->SetRelayReverse(m_channel, true);
                }
                break;
        }
}