InterfaceKit.cpp

Go to the documentation of this file.

#include "InterfaceKit.h"

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

                int serialNo;
                const char* name;

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

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

                char msg[99];
                if (interfaceKit->wasDetached)
                {
                        interfaceKit->wasDetached = false;
                        sprintf_s(msg, 99, "InterfaceKit::AttachHandler %s (%s) reattached!", name, interfaceKit->config->friendlyName.c_str());
                        interfaceKit->logger->Log(msg, Logger::Error);
                }
                else
                {
                        sprintf_s(msg, 99, "InterfaceKit::AttachHandler %s (%s) attached!", name, interfaceKit->config->friendlyName.c_str());
                        interfaceKit->logger->Log(msg);
                }

                interfaceKit->attached = true;

                return 0;
        }

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

                int serialNo;
                const char* name;

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

                char msg[99];
                sprintf_s(msg, 99, "InterfaceKit::DetachHandler %s (%s) detached!", name, interfaceKit->config->friendlyName.c_str());
                interfaceKit->logger->Log(msg, Logger::Error);

                for (UINT i = 0; i < interfaceKit->config->sensors.size(); i++)
                {
                        SensorChangeHandler(reinterpret_cast<CPhidgetInterfaceKitHandle>(IFK), usrptr, i, -1);
                }
                for (UINT i = 0; i < interfaceKit->config->inputs.size(); i++)
                {
                        InputChangeHandler(reinterpret_cast<CPhidgetInterfaceKitHandle>(IFK), usrptr, i, -1);
                }

                interfaceKit->attached = false;
                interfaceKit->wasDetached = true;

                return 0;
        }

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

        //callback that will run if an input changes.
        //Index - Index of the input that generated the event, State - boolean (0 or 1) representing the input state (on or off), -1 means no signal!
        int CCONV InterfaceKit::InputChangeHandler(CPhidgetInterfaceKitHandle IFK, void* usrptr, int Index, int State)
        {
                InterfaceKit* interfaceKit = static_cast<InterfaceKit*>(usrptr);
                InterfaceKitConfig::Input input = interfaceKit->config->inputs.at(Index);

                if (!input.defined)
                {
                        //                      char msg[99];
                        //              sprintf_s(msg, 99, "InterfaceKit::InputChangeHandler Received digital data for undefined index: %d (%d)", Index, State);
                        //      interfaceKit->logger->Log(msg, Logger::Warn);
                }
                else
                {
                        if (input.name == "Component")
                        {
                                char msg[99];
                                sprintf_s(msg, 99, "InterfaceKit::InputChangeHandler Index %i: %i", input.name.c_str(), Index, State);
                                interfaceKit->logger->Log(msg);

                                if (!input.ptrFloat)
                                        input.ptrFloat = interfaceKit->bus->GetComponentSetStatePtr(input.guid);
                                if (!input.ptrFault)
                                        input.ptrFault = interfaceKit->bus->GetComponentFaultStatePtr(input.guid);

                                if (State != 0 && State != 1)
                                {
                                        *input.ptrFloat = -999.0f;
                                        *input.ptrFault = Systems::Fault::NoSignal;
                                }
                                else
                                {
                                        *input.ptrFloat = static_cast<float>(State);
                                        *input.ptrFault = Systems::Fault::None;
                                }
                        }
                        else
                        {
                                char msg[99];
                                sprintf_s(msg, 99, "InterfaceKit::InputChangeHandler %s (%i): %i", input.name.c_str(), Index, State);
                                interfaceKit->logger->Log(msg);

                                if (State == 1)
                                {
                                        Command command;
                                        command.name = input.name;
                                        interfaceKit->bus->commandStream.push_back(command);

                                        sprintf_s(msg, 99, "InterfaceKit::InputChangeHandler: Added command: %s", command.name.c_str());
                                        interfaceKit->logger->Log(msg);
                                }
                        }
                }

                return 0;
        }

        //callback that will run if an output changes.
        //Index - Index of the output that generated the event, State - boolean (0 or 1) representing the output state (on or off)
        /*int CCONV InterfaceKit::OutputChangeHandler(CPhidgetInterfaceKitHandle IFK, void *usrptr, int Index, int State)
        {
        InterfaceKit* interfaceKit = (InterfaceKit*)usrptr;
        char msg[99];
        sprintf_s(msg, 99, "InterfaceKit::OutputChangeHandler Index: %d  State: %d", Index, State);
        interfaceKit->logger->Log(msg);
        return 0;
        }*/

        //callback that will run if the sensor value changes by more than the OnSensorChange trigger.
        //Index - Index of the sensor that generated the event, Value - the sensor read value
        int CCONV InterfaceKit::SensorChangeHandler(CPhidgetInterfaceKitHandle IFK, void* usrptr, int Index, int Value)
        {
                InterfaceKit* interfaceKit = static_cast<InterfaceKit*>(usrptr);
                InterfaceKitConfig::Sensor sensor = interfaceKit->config->sensors.at(Index);

                if (!sensor.defined)
                {
                        //                      char msg[99];
                        //              sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler Received sensor data for undefined index: %d (%d)", Index, Value);
                        //      interfaceKit->logger->Log(msg, Logger::Warn);
                }
                else
                {
                        if (!sensor.ptrFloat)
                                sensor.ptrFloat = interfaceKit->bus->GetComponentSetStatePtr(sensor.guid);
                        if (!sensor.ptrFault)
                                sensor.ptrFault = interfaceKit->bus->GetComponentFaultStatePtr(sensor.guid);

#pragma region // phidgets precision temperature sensor

                        if (sensor.type == "1124_0")
                        {
                                if (Value == -1)
                                {
                                        *sensor.ptrFault = Systems::Fault::NoSignal;
                                        *sensor.ptrFloat = -1.0f;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): NO SIGNAL", sensor.guid.c_str(), Index);
                                        interfaceKit->logger->Log(msg);
                                }
                                else
                                {
                                        float celciusTemp = (static_cast<float>(Value) * 0.2222f) - 61.111f;
                                        if (sensor.inverse) celciusTemp = -celciusTemp;
                                        celciusTemp += sensor.bias;
                                        *sensor.ptrFault = Systems::Fault::None;
                                        *sensor.ptrFloat = celciusTemp;
                                        float farenheitTemp = celciusTemp * 9.0f / 5.0f + 32.0f;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): %.1f°C  %.1f°F", sensor.guid.c_str(), Index, celciusTemp, farenheitTemp);
                                        interfaceKit->logger->Log(msg);
                                }
                        }
#pragma endregion
#pragma region // 20 Amp Current Sensor DC Current (DC Amps)
                        else if (sensor.type == "1119_0" && sensor.subtype == "DC")
                        {
                                if (Value == -1)
                                {
                                        *sensor.ptrFault = Systems::Fault::NoSignal;
                                        *sensor.ptrFloat = -1.0f;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): NO SIGNAL", sensor.guid.c_str(), Index);
                                        interfaceKit->logger->Log(msg);
                                }
                                else
                                {
                                        float dcAmps = static_cast<float>(Value) / 20.0f - 25.0f;
                                        if (sensor.inverse) dcAmps = -dcAmps;
                                        dcAmps += sensor.bias;
                                        *sensor.ptrFault = Systems::Fault::None;
                                        *sensor.ptrFloat = dcAmps;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): %.1f A (%.1f A)", sensor.guid.c_str(), Index, dcAmps, static_cast<float>(Value) / 20.0f - 25.0f);
                                        //interfaceKit->logger->Log(msg);
                                }
                        }
#pragma endregion
#pragma region // 200 PSI pressure sensor Custom0
                        else if (sensor.type == "Custom0")
                        {
                                if (Value == -1)
                                {
                                        *sensor.ptrFault = Systems::Fault::NoSignal;
                                        *sensor.ptrFloat = -1.0f;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): NO SIGNAL", sensor.guid.c_str(), Index);
                                        interfaceKit->logger->Log(msg);
                                }
                                else
                                {
                                        // sensor value is always 0-1000 for 0V to 5V
                                        // for the sensor I bought on ebay at 0PSI at 0.5V, 200PSI at 4.5V
                                        // so 0PSI is 0.5V is 100.0f = 0.0 PSI
                                        // so 100 PSI is 2.5V is 500.0f = 100 PSI
                                        float psi = (static_cast<float>(Value) - 100.0f) / 800.0f * 200.0f;
                                        if (sensor.inverse) psi = -psi;
                                        psi += sensor.bias;
                                        *sensor.ptrFault = Systems::Fault::None;
                                        *sensor.ptrFloat = psi;
                                        //char msg[99];
                                        //sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): %.1f PSI (%.1f)", sensor.guid.c_str(), Index, dcAmps, (float)Value);
                                        //interfaceKit->logger->Log(msg);
                                }
                        }
#pragma endregion
#pragma region // Vibration sensor
                        else if (sensor.type == "1104_0")
                        {
                                if (Value == -1)
                                {
                                        *sensor.ptrFault = Systems::Fault::NoSignal;
                                        *sensor.ptrFloat = -1.0f;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): NO SIGNAL", sensor.guid.c_str(), Index);
                                        interfaceKit->logger->Log(msg);
                                }
                                else
                                {
                                        float mils = (static_cast<float>(Value)-500.0f) / 10.0f; // -50 to 50?
                                        if (sensor.inverse) mils = -mils;
                                        mils += sensor.bias;
                                        *sensor.ptrFault = Systems::Fault::None;
                                        *sensor.ptrFloat = mils;
                                        char msg[99];
                                        sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler %s (%d): %.1f", sensor.guid.c_str(), Index, mils);
                                }
                        }
#pragma endregion
                        else
                        {
                                *sensor.ptrFault = Systems::Fault::NoSignal;
                                *sensor.ptrFloat = -1.0f;
                                char msg[99];
                                sprintf_s(msg, 99, "InterfaceKit::SensorChangeHandler Unknown sensor type \"%s\" at index: %d (%d)", sensor.type, Index, Value);
                                interfaceKit->logger->Log(msg, Logger::Warn);
                        }
                }

                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 InterfaceKit::display_properties(CPhidgetInterfaceKitHandle phid) const
        {
                int serialNo, version, numInputs, numOutputs, numSensors, triggerVal, ratiometric = 0, i;
                const char* ptr;

                CPhidget_getDeviceType(reinterpret_cast<CPhidgetHandle>(phid), &ptr);
                CPhidget_getSerialNumber(reinterpret_cast<CPhidgetHandle>(phid), &serialNo);
                CPhidget_getDeviceVersion(reinterpret_cast<CPhidgetHandle>(phid), &version);

                CPhidgetInterfaceKit_getInputCount(phid, &numInputs);
                CPhidgetInterfaceKit_getOutputCount(phid, &numOutputs);
                CPhidgetInterfaceKit_getSensorCount(phid, &numSensors);
                if (numSensors)
                        CPhidgetInterfaceKit_getRatiometric(phid, &ratiometric);

                char msg[99];
                sprintf_s(msg, 99, "InterfaceKit::display_properties Type: %s", ptr);
                logger->Log(msg);
                sprintf_s(msg, 99, "InterfaceKit::display_properties Serial Number: %i", serialNo);
                logger->Log(msg);
                sprintf_s(msg, 99, "InterfaceKit::display_properties Version: %i", version);
                logger->Log(msg);
                sprintf_s(msg, 99, "InterfaceKit::display_properties Digital Inputs: %d", numInputs);
                logger->Log(msg);
                sprintf_s(msg, 99, "InterfaceKit::display_properties Digital Outputs: %d", numOutputs);
                logger->Log(msg);
                sprintf_s(msg, 99, "InterfaceKit::display_properties Sensors: %d", numSensors);
                logger->Log(msg);

                for (i = 0; i < numSensors; i++)
                {
                        CPhidgetInterfaceKit_getSensorChangeTrigger(phid, i, &triggerVal);

                        sprintf_s(msg, 99, "InterfaceKit::display_properties Sensor#: %d > Sensitivity Trigger: %d", i, triggerVal);
                        logger->Log(msg);
                }

                if (numSensors)
                {
                        sprintf_s(msg, 99, "InterfaceKit::display_properties Ratiometric: %d", ratiometric);
                        logger->Log(msg);
                }

                return 0;
        }

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

                int result;
                const char* err;

                //Declare an InterfaceKit handle
                ifKit = nullptr;

                //create the InterfaceKit object
                CPhidgetInterfaceKit_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);

                //Registers a callback that will run if an input changes.
                //Requires the handle for the Phidget, the function that will be called, and an arbitrary pointer that will be supplied to the callback function (may be NULL).
                CPhidgetInterfaceKit_set_OnInputChange_Handler(ifKit, InputChangeHandler, this);

                //Registers a callback that will run if the sensor value changes by more than the OnSensorChange trigger.
                //Requires the handle for the IntefaceKit, the function that will be called, and an arbitrary pointer that will be supplied to the callback function (may be NULL).
                CPhidgetInterfaceKit_set_OnSensorChange_Handler(ifKit, SensorChangeHandler, this);

                //Registers a callback that will run if an output changes.
                //Requires the handle for the Phidget, the function that will be called, and an arbitrary pointer that will be supplied to the callback function (may be NULL).
                //CPhidgetInterfaceKit_set_OnOutputChange_Handler(ifKit, OutputChangeHandler, 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
                char msg[99];
                sprintf_s(msg, 99, "InterfaceKit::ctor Waiting for interface kit %i to be attached...", config->serialno);
                logger->Log(msg);
                result = CPhidget_waitForAttachment(reinterpret_cast<CPhidgetHandle>(ifKit), 5000);
                if (result)
                {
                        CPhidget_getErrorDescription(result, &err);
                        sprintf_s(msg, 99, "InterfaceKit::ctor Problem waiting for attachment of %i: %s", config->serialno, err);
                        logger->Log(msg, Logger::Fatal);
                        config->enable = false;
                        return;
                }

                CPhidgetInterfaceKit_setRatiometric(ifKit, config->ratiometric ? 1 : 0);
                for (UINT i = 0; i < config->sensors.size(); i++)
                {
                        if (config->sensors.at(i).defined)
                        {
                                CPhidgetInterfaceKit_setSensorChangeTrigger(ifKit, i, config->sensors.at(i).sensitivity); // integral values update
                        }
                }

                for (UINT i = 0; i < config->outputs.size(); i++)
                {
                        if (config->outputs.at(i).defined && config->outputs.at(i).trigger == "Component")
                        {
                                config->outputs.at(i).busCurrentState = bus->GetComponentCurrentStatePtr(config->outputs.at(i).guid);
                        }
                }

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

        void InterfaceKit::Destroy() const
        {
                logger->Log("InterfaceKit::Destroy...");
                CPhidget_close(reinterpret_cast<CPhidgetHandle>(ifKit));
                CPhidget_delete(reinterpret_cast<CPhidgetHandle>(ifKit));
        }

        void InterfaceKit::FrameMove() const
        {
                if (!attached)
                        return;

#pragma region Command Stream
                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command command = bus->commandStream.at(i);
                        if (command.delay != 0.0f) continue;

                        for (UINT j = 0; j < config->outputs.size(); j++)
                        {
                                if (!config->outputs.at(j).defined) continue;
                                if (config->outputs.at(j).trigger == "Component") continue;

                                if (command.name == config->outputs.at(j).trigger)
                                {
                                        char msg[199];
                                        sprintf_s(msg, 199, "InterfaceKit::FrameMove Sending digital output signal %i to index %i!", command.ivalue, j);
                                        logger->Log(msg);
                                        try
                                        {
                                                int result = CPhidgetInterfaceKit_setOutputState(ifKit, j, command.ivalue);
                                                if (result)
                                                {
                                                        const char* err;
                                                        CPhidget_getErrorDescription(result, &err);
                                                        sprintf_s(msg, 199, "InterfaceKit::FrameMove Problem sending digital output signal: %s (%i)", err, config->serialno);
                                                        logger->Log(msg, Logger::Error, result);
                                                }
                                        }
                                        catch (...)
                                        {
                                                logger->Log("InterfaceKit::FrameMove Exception raised and caught!", Logger::Error);
                                        }

                                        bus->commandStream.erase(bus->commandStream.begin() + i);
                                        break;
                                }
                        }
                }
#pragma endregion

#pragma region Components
                for (UINT j = 0; j < config->outputs.size(); j++)
                {
                        if (!config->outputs.at(j).defined) continue;
                        if (config->outputs.at(j).trigger == "Component")
                        {
                                bool currentState = *config->outputs.at(j).busCurrentState > 0.5f;
                                if (!config->outputs.at(j).internalState.is_set() || config->outputs.at(j).internalState.get() != currentState)
                                {
                                        config->outputs.at(j).internalState = currentState;
                                        int ivalue = currentState ? 1 : 0;
                                        char msg[199];
                                        sprintf_s(msg, 199, "InterfaceKit::FrameMove Sending digital output signal %i to index %i!", ivalue, j);
                                        logger->Log(msg);
                                        try
                                        {
                                                int result = CPhidgetInterfaceKit_setOutputState(ifKit, j, ivalue);
                                                if (result)
                                                {
                                                        const char* err;
                                                        CPhidget_getErrorDescription(result, &err);
                                                        sprintf_s(msg, 199, "InterfaceKit::FrameMove Problem sending digital output signal: %s (%i)", err, config->serialno);
                                                        logger->Log(msg, Logger::Error, result);
                                                }
                                        }
                                        catch (...)
                                        {
                                                logger->Log("InterfaceKit::FrameMove Exception raised and caught!", Logger::Error);
                                        }
                                }
                        }
                }
#pragma endregion
        }
}