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

#include "DriverStation.h"
#include "MotorSafety.h"
#include "Timer.h"
#include "WPIErrors.h"

#include <stdio.h>

MotorSafetyHelper *MotorSafetyHelper::m_headHelper = NULL;
ReentrantSemaphore MotorSafetyHelper::m_listMutex;

MotorSafetyHelper::MotorSafetyHelper(MotorSafety *safeObject)
{
        m_safeObject = safeObject;
        m_enabled = false;
        m_expiration = DEFAULT_SAFETY_EXPIRATION;
        m_stopTime = Timer::GetFPGATimestamp();

        Synchronized sync(m_listMutex);
        m_nextHelper = m_headHelper;
        m_headHelper = this;
}


MotorSafetyHelper::~MotorSafetyHelper()
{
        Synchronized sync(m_listMutex);
        if (m_headHelper == this)
        {
                m_headHelper = m_nextHelper;
        }
        else
        {
                MotorSafetyHelper *prev = NULL;
                MotorSafetyHelper *cur = m_headHelper;
                while (cur != this && cur != NULL)
                        prev = cur, cur = cur->m_nextHelper;
                if (cur == this)
                        prev->m_nextHelper = cur->m_nextHelper;
        }
}

/*
 * Feed the motor safety object.
 * Resets the timer on this object that is used to do the timeouts.
 */
void MotorSafetyHelper::Feed()
{
        Synchronized sync(m_syncMutex);
        m_stopTime = Timer::GetFPGATimestamp() + m_expiration;
}

/*
 * Set the expiration time for the corresponding motor safety object.
 * @param expirationTime The timeout value in seconds.
 */
void MotorSafetyHelper::SetExpiration(float expirationTime)
{
        Synchronized sync(m_syncMutex);
        m_expiration = expirationTime;
}

float MotorSafetyHelper::GetExpiration()
{
        Synchronized sync(m_syncMutex);
        return m_expiration;
}

bool MotorSafetyHelper::IsAlive()
{
        Synchronized sync(m_syncMutex);
        return !m_enabled || m_stopTime > Timer::GetFPGATimestamp();
}

void MotorSafetyHelper::Check()
{
        DriverStation *ds = DriverStation::GetInstance();
        if (!m_enabled || ds->IsDisabled() || ds->IsTest()) return;

        Synchronized sync(m_syncMutex);
        if (m_stopTime < Timer::GetFPGATimestamp())
        {
                char buf[128];
                char desc[64];
                m_safeObject->GetDescription(desc);
                snprintf(buf, 128, "%s... Output not updated often enough.", desc);
                wpi_setWPIErrorWithContext(Timeout, buf);
                m_safeObject->StopMotor();
        }
}

void MotorSafetyHelper::SetSafetyEnabled(bool enabled)
{
        Synchronized sync(m_syncMutex);
        m_enabled = enabled;
}

bool MotorSafetyHelper::IsSafetyEnabled()
{
        Synchronized sync(m_syncMutex);
        return m_enabled;
}

void MotorSafetyHelper::CheckMotors()
{
        Synchronized sync(m_listMutex);
        for (MotorSafetyHelper *msh = m_headHelper; msh != NULL; msh = msh->m_nextHelper)
        {
                msh->Check();
        }
}