AnalogChannel.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 "AnalogChannel.h"
#include "AnalogModule.h"
#include "NetworkCommunication/UsageReporting.h"
#include "Resource.h"
#include "WPIErrors.h"
#include "LiveWindow/LiveWindow.h"

static Resource *channels = NULL;

const uint8_t AnalogChannel::kAccumulatorModuleNumber;
const uint32_t AnalogChannel::kAccumulatorNumChannels;
const uint32_t AnalogChannel::kAccumulatorChannels[] = {1, 2};

void AnalogChannel::InitChannel(uint8_t moduleNumber, uint32_t channel)
{
        m_table = NULL;
        char buf[64];
        Resource::CreateResourceObject(&channels, kAnalogModules * kAnalogChannels);
        if (!CheckAnalogModule(moduleNumber))
        {
                snprintf(buf, 64, "Analog Module %d", moduleNumber);
                wpi_setWPIErrorWithContext(ModuleIndexOutOfRange, buf);
                return;
        }
        if (!CheckAnalogChannel(channel))
        {
                snprintf(buf, 64, "Analog Channel %d", channel);
                wpi_setWPIErrorWithContext(ChannelIndexOutOfRange, buf);
                return;
        }

        snprintf(buf, 64, "Analog Input %d (Module: %d)", channel, moduleNumber);
        if (channels->Allocate((moduleNumber - 1) * kAnalogChannels + channel - 1, buf) == ~0ul)
        {
                CloneError(channels);
                return;
        }
        m_channel = channel;
        m_module = AnalogModule::GetInstance(moduleNumber);
        if (IsAccumulatorChannel())
        {
                tRioStatusCode localStatus = NiFpga_Status_Success;
                m_accumulator = tAccumulator::create(channel - 1, &localStatus);
                wpi_setError(localStatus);
                m_accumulatorOffset=0;
        }
        else
        {
                m_accumulator = NULL;
        }
        m_shouldUseVoltageForPID = false;
        LiveWindow::GetInstance()->AddSensor("AnalogChannel",channel, GetModuleNumber(), this);
        nUsageReporting::report(nUsageReporting::kResourceType_AnalogChannel, channel, GetModuleNumber() - 1);
}

AnalogChannel::AnalogChannel(uint8_t moduleNumber, uint32_t channel)
{
        InitChannel(moduleNumber, channel);
}

AnalogChannel::AnalogChannel(uint32_t channel)
{
        InitChannel(GetDefaultAnalogModule(), channel);
}

AnalogChannel::~AnalogChannel()
{
        channels->Free((m_module->GetNumber() - 1) * kAnalogChannels + m_channel - 1);
}

AnalogModule *AnalogChannel::GetModule()
{
        if (StatusIsFatal()) return NULL;
        return m_module;
}

int16_t AnalogChannel::GetValue()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetValue(m_channel);
}

int32_t AnalogChannel::GetAverageValue()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetAverageValue(m_channel);
}

float AnalogChannel::GetVoltage()
{
        if (StatusIsFatal()) return 0.0f;
        return m_module->GetVoltage(m_channel);
}

float AnalogChannel::GetAverageVoltage()
{
        if (StatusIsFatal()) return 0.0f;
        return m_module->GetAverageVoltage(m_channel);
}

uint32_t AnalogChannel::GetLSBWeight()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetLSBWeight(m_channel);
}

int32_t AnalogChannel::GetOffset()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetOffset(m_channel);
}

uint32_t AnalogChannel::GetChannel()
{
        if (StatusIsFatal()) return 0;
        return m_channel;
}

uint8_t AnalogChannel::GetModuleNumber()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetNumber();
}

void AnalogChannel::SetAverageBits(uint32_t bits)
{
        if (StatusIsFatal()) return;
        m_module->SetAverageBits(m_channel, bits);
}

uint32_t AnalogChannel::GetAverageBits()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetAverageBits(m_channel);
}

void AnalogChannel::SetOversampleBits(uint32_t bits)
{
        if (StatusIsFatal()) return;
        m_module->SetOversampleBits(m_channel, bits);
}

uint32_t AnalogChannel::GetOversampleBits()
{
        if (StatusIsFatal()) return 0;
        return m_module->GetOversampleBits(m_channel);
}

bool AnalogChannel::IsAccumulatorChannel()
{
        if (StatusIsFatal()) return false;
        if(m_module->GetNumber() != kAccumulatorModuleNumber) return false;
        for (uint32_t i=0; i<kAccumulatorNumChannels; i++)
        {
                if (m_channel == kAccumulatorChannels[i]) return true;
        }
        return false;
}

void AnalogChannel::InitAccumulator()
{
        if (StatusIsFatal()) return;
        m_accumulatorOffset = 0;
        SetAccumulatorCenter(0);
        ResetAccumulator();
}


void AnalogChannel::SetAccumulatorInitialValue(INT64 initialValue)
{
        if (StatusIsFatal()) return;
        m_accumulatorOffset = initialValue;
}

void AnalogChannel::ResetAccumulator()
{
        if (StatusIsFatal()) return;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return;
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_accumulator->strobeReset(&localStatus);
        wpi_setError(localStatus);
}

void AnalogChannel::SetAccumulatorCenter(int32_t center)
{
        if (StatusIsFatal()) return;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return;
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_accumulator->writeCenter(center, &localStatus);
        wpi_setError(localStatus);
}

void AnalogChannel::SetAccumulatorDeadband(int32_t deadband)
{
        if (StatusIsFatal()) return;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return;
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_accumulator->writeDeadband(deadband, &localStatus);
        wpi_setError(localStatus);
}

INT64 AnalogChannel::GetAccumulatorValue()
{
        if (StatusIsFatal()) return 0;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return 0;
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        INT64 value = m_accumulator->readOutput_Value(&localStatus) + m_accumulatorOffset;
        wpi_setError(localStatus);
        return value;
}

uint32_t AnalogChannel::GetAccumulatorCount()
{
        if (StatusIsFatal()) return 0;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return 0;
        }
        tRioStatusCode localStatus = NiFpga_Status_Success;
        uint32_t count = m_accumulator->readOutput_Count(&localStatus);
        wpi_setError(localStatus);
        return count;
}


void AnalogChannel::GetAccumulatorOutput(INT64 *value, uint32_t *count)
{
        if (StatusIsFatal()) return;
        if (m_accumulator == NULL)
        {
                wpi_setWPIError(NullParameter);
                return;
        }
        if (value == NULL || count == NULL)
        {
                wpi_setWPIError(NullParameter);
                return;
        }

        tRioStatusCode localStatus = NiFpga_Status_Success;
        tAccumulator::tOutput output = m_accumulator->readOutput(&localStatus);
        *value = output.Value + m_accumulatorOffset;
        *count = output.Count;
        wpi_setError(localStatus);
}

void AnalogChannel::SetVoltageForPID(bool shouldUseVoltageForPID) {
        m_shouldUseVoltageForPID = shouldUseVoltageForPID;
}

double AnalogChannel::PIDGet() 
{
        if (StatusIsFatal()) return 0.0;
        if (m_shouldUseVoltageForPID) {
                return GetAverageVoltage();
        } else {
                return GetAverageValue();
        }
}

void AnalogChannel::UpdateTable() {
        if (m_table != NULL) {
                m_table->PutNumber("Value", GetAverageVoltage());
        }
}

void AnalogChannel::StartLiveWindowMode() {
        
}

void AnalogChannel::StopLiveWindowMode() {
        
}

std::string AnalogChannel::GetSmartDashboardType() {
        return "Analog Input";
}

void AnalogChannel::InitTable(ITable *subTable) {
        m_table = subTable;
        UpdateTable();
}

ITable * AnalogChannel::GetTable() {
        return m_table;
}