RedAlertJaguar.cpp

#if 0
#include "Jaguar.h"
#include "CANJaguar.h"
#include "RedAlertJaguar.h"
#include <stdlib.h>

RedAlertJaguar::RedAlertJaguar(UINT8 motorNumber, CANJaguar::ControlMode mode,
		RedAlertJaguar::JaguarType mytype) {
	if (mytype != RedAlertJaguar::kCANJaguar && mytype
			!= RedAlertJaguar::kJaguar && mytype != RedAlertJaguar::kStub) {
		mytype = RedAlertJaguar::kStub;
	}
	mm_type = mytype;
	switch (mm_type) {
	case RedAlertJaguar::kCANJaguar:
		m_can_ptr = new CANJaguar(motorNumber, mode);
		break;
	case RedAlertJaguar::kJaguar:
		m_jag_ptr = new Jaguar(motorNumber);
		break;
	case RedAlertJaguar::kStub:
		// Nothing.
		break;
	default:
		// UH-OH!
		break;
	}
}

bool RedAlertJaguar::IAmCan()
{
	return mm_type == RedAlertJaguar::kCANJaguar;
}

bool RedAlertJaguar::IAmStub()
{
	return mm_type == RedAlertJaguar::kStub;
}

Jaguar * RedAlertJaguar::GetMyJaguar()
{
	if (IAmStub()) return NULL;
	if (IAmCan()) return (Jaguar*)m_can_ptr;
	else return m_jag_ptr;
}

RedAlertJaguar::JaguarType RedAlertJaguar::GetJaguarType() {
	return mm_type;
}

float RedAlertJaguar::Get() {
	if (IAmStub()) {
		return 0.0;
	} else {
		return GetMyJaguar()->Get();
	}
	
}

void RedAlertJaguar::Set(float value) {
	if (IAmStub()) {
		// NOP
	} else {
		GetMyJaguar()->Set(value);
	}
}

void RedAlertJaguar::PIDWrite(float output) {
	if (IAmStub()) {
		// NOP
	} else {
		GetMyJaguar()->PIDWrite(output);
	}
}

void RedAlertJaguar::SetPositionReference(CANJaguar::PositionReference reference)
{
	if (IAmCan()) {
		m_can_ptr->SetPositionReference(reference);
	}
}

CANJaguar::PositionReference RedAlertJaguar::GetPositionReference()
{
	if (IAmCan()) {
		return m_can_ptr->GetPositionReference();
	} else {
		return CANJaguar::kPosRef_Encoder; // ?
	}
}

void RedAlertJaguar::SetPID(double p, double i, double d)
{
	if (IAmCan()) {
		m_can_ptr->SetPID(p,i,d);
	}
}

double RedAlertJaguar::GetP() 
{
	if (IAmCan()) {
		return m_can_ptr->GetP();
	} else
		return 0;
}

double RedAlertJaguar::GetI()
{
	if (IAmCan()) {
		return m_can_ptr->GetI();
	}
	return 0;
}

double RedAlertJaguar::GetD()
{
	if (IAmCan()) {
		return m_can_ptr->GetD();
	} else return 0;
}

void RedAlertJaguar::EnableControl(double encoderInitialPosition)
{
	if (IAmCan()) {
		m_can_ptr->EnableControl(encoderInitialPosition);
	} else {
		// nOP;
	}
}

void RedAlertJaguar::DisableControl()
{
	if (IAmCan()) {
		m_can_ptr->DisableControl();
	}
}

float RedAlertJaguar::GetBusVoltage()
{
	if (IAmCan()) {
		return m_can_ptr->GetBusVoltage();
	} else return 0.0; 
}

float RedAlertJaguar::GetOutputVoltage()
{
	if (IAmCan()) {
		return m_can_ptr->GetOutputCurrent();
	} else return 0;
}
float RedAlertJaguar::GetOutputCurrent()
{
	if (IAmCan()) {
		return m_can_ptr->GetOutputCurrent();
	} else return 0;
}

float RedAlertJaguar::GetTemperature()
{
	if (IAmCan()) {
		return m_can_ptr->GetTemperature();
	}
	return 0;
}

double RedAlertJaguar::GetPosition()
{
	if (IAmCan()) {
		return m_can_ptr->GetPosition();
	}
	return 0;
}

double RedAlertJaguar::GetSpeed()
{
	if (IAmCan()) {
		return m_can_ptr->GetSpeed();
	}
	return 0;
}

// TODO: Determine safe values for these if the motor does not exist.
bool RedAlertJaguar::GetForwardLimitOK()
{
	if (IAmCan()) {
		return m_can_ptr->GetForwardLimitOK();
	}
	return false;
}

bool RedAlertJaguar::GetReverseLimitOK()
{
	if (IAmCan()) {
		return m_can_ptr->GetReverseLimitOK();
	}
	return false;
}

UINT16 RedAlertJaguar::GetFaults()
{
	if (IAmCan()) {
		return m_can_ptr->GetFaults();
	} else return 0;
}

bool RedAlertJaguar::GetPowerCycled()
{
	if (IAmCan()) {
		return m_can_ptr->GetPowerCycled();
	} else return false;
}

void RedAlertJaguar::SetVoltageRampRate(double rampRate)
{
	if (IAmCan()) {
		m_can_ptr->SetVoltageRampRate(rampRate);
	}
}

UINT32 RedAlertJaguar::GetFirmwareVersion()
{
	if (IAmCan()) {
		return m_can_ptr->GetFirmwareVersion();
	} else return COMP_FIRM_VERSION;
}

UINT8 RedAlertJaguar::GetHardwareVersion()
{
	if (IAmCan()) {
		return m_can_ptr->GetHardwareVersion();
	} else	return 0;
	
}

void RedAlertJaguar::ConfigNeutralMode(CANJaguar::NeutralMode mode)
{
	if (IAmCan()) {
		m_can_ptr->ConfigNeutralMode(mode);
	}
}

void RedAlertJaguar::ConfigEncoderCodesPerRev(UINT16 codesPerRev)
{
	if (IAmCan()) {
		m_can_ptr->ConfigEncoderCodesPerRev(codesPerRev);
	}
}

void RedAlertJaguar::ConfigPotentiometerTurns(UINT16 turns)
{
	if (IAmCan()) {
		m_can_ptr->ConfigPotentiometerTurns(turns);
	}
}

void RedAlertJaguar::ConfigSoftPositionLimits(double forwardLimitPosition,double reverseLimitPosition)
{
	if (IAmCan()) {
		m_can_ptr->ConfigSoftPositionLimits(forwardLimitPosition, reverseLimitPosition);
	}
}

void RedAlertJaguar::DisableSoftPositionLimits()
{
	if (IAmCan()) {
		m_can_ptr->DisableSoftPositionLimits();
	}
}

void RedAlertJaguar::ConfigMaxOutputVoltage(double voltage)
{
	if (IAmCan()) {
		m_can_ptr->ConfigMaxOutputVoltage(voltage);
	}
}

void RedAlertJaguar::ConfigFaultTime(float faultTime)
{
	if (IAmCan()) {
		m_can_ptr->ConfigFaultTime(faultTime);
	}
}

#endif