Analog.cpp

Go to the documentation of this file.

#include "Analog.h"

namespace Devices
{
        int CCONV Analog::AttachHandler(CPhidgetHandle IFK, void* usrptr)
        {
                Analog* analog = static_cast<Analog*>(usrptr);

                int serialNo;
                const char* name;

                CPhidget_getDeviceName(IFK, &name);
                CPhidget_getSerialNumber(IFK, &serialNo);

                if (analog->config->serialno == -1)
                        analog->config->serialno = serialNo;

                char msg[99];
                sprintf_s(msg, 99, "Analog::AttachHandler %s (%i) attached!", name, serialNo);
                analog->logger->Log(msg);
                return 0;
        }

        int CCONV Analog::DetachHandler(CPhidgetHandle IFK, void* usrptr)
        {
                Analog* analog = static_cast<Analog*>(usrptr);

                int serialNo;
                const char* name;

                CPhidget_getDeviceName(IFK, &name);
                CPhidget_getSerialNumber(IFK, &serialNo);

                char msg[99];
                sprintf_s(msg, 99, "Analog::DetachHandler %s (%i) detached!", name, serialNo);
                analog->logger->Log(msg, Logger::Error);

                return 0;
        }

        int CCONV Analog::ErrorHandler(CPhidgetHandle IFK, void* usrptr, int ErrorCode, const char* unknown)
        {
                Analog* analog = static_cast<Analog*>(usrptr);
                char msg[99];
                sprintf_s(msg, 99, "Analog::ErrorHandler Error handled. %s", unknown);
                analog->logger->Log(msg, Logger::Error, ErrorCode);
                return 0;
        }

        //Display the properties of the attached phidget to the screen.  We will be displaying the name, serial number and version of the attached device.
        //Will also display the number of inputs, outputs, and analog inputs on the interface kit as well as the state of the ratiometric flag
        //and the current analog sensor sensitivity.
        int Analog::display_properties(CPhidgetAnalogHandle phid) const
        {
                int serialNo, version, numAnalog;
                double max, min;
                const char* ptr;

                CPhidget_getDeviceType(reinterpret_cast<CPhidgetHandle>(phid), &ptr);
                CPhidget_getSerialNumber(reinterpret_cast<CPhidgetHandle>(phid), &serialNo);
                CPhidget_getDeviceVersion(reinterpret_cast<CPhidgetHandle>(phid), &version);
                CPhidgetAnalog_getOutputCount(phid, &numAnalog);
                CPhidgetAnalog_getVoltageMax(phid, 0, &max);
                CPhidgetAnalog_getVoltageMin(phid, 0, &min);

                char msg[99];
                sprintf_s(msg, 99, "Analog::display_properties Type: %s", ptr);
                logger->Log(msg);
                sprintf_s(msg, 99, "Analog::display_properties Serial Number: %i", serialNo);
                logger->Log(msg);
                sprintf_s(msg, 99, "Analog::display_properties Version: %i", version);
                logger->Log(msg);
                sprintf_s(msg, 99, "Analog::display_properties Analog Outputs: %d", numAnalog);
                logger->Log(msg);
                sprintf_s(msg, 99, "Analog::display_properties Maximum Output: +%0.1lfV", max);
                logger->Log(msg);
                sprintf_s(msg, 99, "Analog::display_properties Minimum Output: %0.1lfV", min);
                logger->Log(msg);

                return 0;
        }

        void Analog::Initialize(Logger* prmLogger, AnalogConfig* prmConfig, Bus* prmBus)
        {
                logger = prmLogger;
                config = prmConfig;
                bus = prmBus;

                int result;
                const char* err;

                //Declare an InterfaceKit handle
                ifKit = nullptr;

                //create the InterfaceKit object
                CPhidgetAnalog_create(&ifKit);

                //Set the handlers to be run when the device is plugged in or opened from software, unplugged or closed from software, or generates an error.
                CPhidget_set_OnAttach_Handler(reinterpret_cast<CPhidgetHandle>(ifKit), AttachHandler, this);
                CPhidget_set_OnDetach_Handler(reinterpret_cast<CPhidgetHandle>(ifKit), DetachHandler, this);
                CPhidget_set_OnError_Handler(reinterpret_cast<CPhidgetHandle>(ifKit), ErrorHandler, this);

                //open the interfacekit for device connections
                CPhidget_open(reinterpret_cast<CPhidgetHandle>(ifKit), config->serialno);

                //get the program to wait for an interface kit device to be attached
                logger->Log("Analog::ctor Waiting for analog to be attached....");
                result = CPhidget_waitForAttachment(reinterpret_cast<CPhidgetHandle>(ifKit), 5000);
                if (result)
                {
                        CPhidget_getErrorDescription(result, &err);
                        char msg[99];
                        sprintf_s(msg, 99, "Analog::ctor Problem waiting for attachment of %i: %s", config->serialno, err);
                        logger->Log(msg, Logger::Fatal);
                        config->enable = false;
                        return;
                }

                for (UINT i = 0; i < config->channels.size(); i++)
                {
                        if (config->channels[i].defined)
                        {
                                int enabled;
                                CPhidgetAnalog_getEnabled(ifKit, i, &enabled);
                                if (enabled == 1)
                                {
                                        CPhidgetAnalog_getVoltage(ifKit, i, &config->channels[i].currentValue);
                                }
                                else
                                {
                                        CPhidgetAnalog_setVoltage(ifKit, i, 0.0);
                                        config->channels[i].currentValue = 0.0;
                                        CPhidgetAnalog_setEnabled(ifKit, i, PTRUE);
                                }
                        }
                        else
                        {
                                CPhidgetAnalog_setEnabled(ifKit, i, PFALSE);
                        }
                }

                // Log the properties of the attached interface kit device
                display_properties(ifKit);
        }

        void Analog::Destroy() const
        {
                logger->Log("Analog::Destroy...");
                CPhidget_close(reinterpret_cast<CPhidgetHandle>(ifKit));
                CPhidget_delete(reinterpret_cast<CPhidgetHandle>(ifKit));
                config->enable = false;
        }

        void Analog::FrameMove() const
        {
                if (!config->enable) return;

                for (UINT i = 0; i < config->channels.size(); i++)
                {
                        if (config->channels[i].defined)
                        {
                                double busValue;
                                if (config->channels[i].trigger == "Back Right Bellow")
                                        busValue = bus->PlatformBackRightBellow;
                                else if (config->channels[i].trigger == "Back Left Bellow")
                                        busValue = bus->PlatformBackLeftBellow;
                                else if (config->channels[i].trigger == "Front Right Bellow")
                                        busValue = bus->PlatformFrontRightBellow;
                                else if (config->channels[i].trigger == "Front Left Bellow")
                                        busValue = bus->PlatformFrontLeftBellow;
                                //else if (config->channels[i].trigger == "Avionics Blower Motor")
                                //      busValue = bus->AvionicsBlowerMotor;
                                else
                                {
                                        config->channels[i].defined = false;
                                        char msg[99];
                                        sprintf_s(msg, 99, "Analog::FrameMove Undefined analog channel (index %i) triggered: %s (%i)", i, config->channels[i].trigger.c_str(), config->serialno);
                                        logger->Log(msg, Logger::Error);
                                        this->Destroy();
                                        return;
                                }

                                //if (config->channels[i].currentValue != busValue)
                                {
                                        CPhidgetAnalog_setVoltage(ifKit, i, busValue);
                                        config->channels[i].currentValue = busValue;
                                }
                        }
                }
        }
}