Encoder.cpp

Go to the documentation of this file.

/*
2015-03-22 10:57:14.151 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 216 rpos: 1 pos: 229
2015-03-22 10:57:14.166 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 19 rpos: 1 pos: 230
2015-03-22 10:57:14.215 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 38 rpos: 1 pos: 231
2015-03-22 10:57:14.454 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 236 rpos: 1 pos: 232
2015-03-22 10:57:14.519 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 69 rpos: 1 pos: 233
2015-03-22 10:57:14.550 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 25 rpos: 1 pos: 234
2015-03-22 10:57:14.603 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 51 rpos: 1 pos: 235
2015-03-22 10:57:14.615 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 23 rpos: 1 pos: 236
2015-03-22 10:57:15.080 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 441 rpos: 1 pos: 237
2015-03-22 10:57:15.094 Warning: Encoder::PositionChangeHandler Received encoder data for undefined index: 0 time: 29 rpos: 1 pos: 238
2015-03-22 10:57:15.190 Warning: InterfaceKit::InputChangeHandler Received digital data for undefined index: 0 (1)
2015-03-22 10:57:15.511 Warning: InterfaceKit::InputChangeHandler Received digital data for undefined index: 0 (0)
*/

#include "Encoder.h"

namespace Devices
{
        int CCONV Encoder::AttachHandler(CPhidgetHandle IFK, void* usrptr)
        {
                Encoder* interfaceKit = static_cast<Encoder*>(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, "Encoder::AttachHandler %s (%s) reattached!", name, interfaceKit->config->friendlyName.c_str());
                        interfaceKit->logger->Log(msg, Logger::Error);
                }
                else
                {
                        sprintf_s(msg, 99, "Encoder::AttachHandler %s (%s) attached!", name, interfaceKit->config->friendlyName.c_str());
                        interfaceKit->logger->Log(msg);
                }

                interfaceKit->attached = true;

                return 0;
        }

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

                int serialNo;
                const char* name;

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

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

                //PositionChangeHandler((CPhidgetEncoderHandle)IFK, usrptr, 0, 0, 0);
                //InputChangeHandler((CPhidgetEncoderHandle)IFK, usrptr, 0, -1);

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

                return 0;
        }

        int CCONV Encoder::ErrorHandler(CPhidgetHandle IFK, void* usrptr, int ErrorCode, const char* unknown)
        {
                Encoder* interfaceKit = static_cast<Encoder*>(usrptr);
                char msg[99];
                sprintf_s(msg, 99, "Encoder::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 Encoder::InputChangeHandler(CPhidgetEncoderHandle IFK, void* usrptr, int Index, int State)
        {
                Encoder* interfaceKit = static_cast<Encoder*>(usrptr);

                char msg[99];
                sprintf_s(msg, 99, "Encoder::InputChangeHandler Received digital data for undefined index: %d (%d)", Index, State);
                interfaceKit->logger->Log(msg, Logger::Warn);

                /*
                EncoderConfig::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")
                        {
                                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 = (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;
                                        //command.ivalue = State;
                                        interfaceKit->bus->commandStream.push_back(command);

                                        sprintf_s(msg, 99, "InterfaceKit::InputChangeHandler: Added command: %s (%i)", command.name.c_str(), 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 Encoder::PositionChangeHandler(CPhidgetEncoderHandle IFK, void* usrptr, int Index, int Time, int RelativePosition)
        {
                int Position;
                CPhidgetEncoder_getPosition(IFK, Index, &Position);

                Encoder* interfaceKit = static_cast<Encoder*>(usrptr);

                char msg[199];
                sprintf_s(msg, 199, "Encoder::PositionChangeHandler Received encoder data for undefined index: %d time: %d rpos: %d pos: %d", Index, Time, RelativePosition, Position);
                interfaceKit->logger->Log(msg, Logger::Warn);

                /*
                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 = ((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 = (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, (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 dcAmps = ((float)Value - 100.0f) / 800.0f * 200.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 PSI (%.1f)", sensor.guid.c_str(), Index, dcAmps, (float)Value);
                                        interfaceKit->logger->Log(msg);
                                }
                        }
#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;
        }


        int Encoder::display_properties(CPhidgetEncoderHandle phid) const
        {
                int serialNo, version, numInputs, numEncoders;
                const char* ptr;

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

                CPhidgetEncoder_getInputCount(phid, &numInputs);
                CPhidgetEncoder_getEncoderCount(phid, &numEncoders);

                char msg[99];
                sprintf_s(msg, 99, "Encoder::display_properties Type: %s", ptr);
                logger->Log(msg);
                sprintf_s(msg, 99, "Encoder::display_properties Serial Number: %i", serialNo);
                logger->Log(msg);
                sprintf_s(msg, 99, "Encoder::display_properties Version: %i", version);
                logger->Log(msg);
                sprintf_s(msg, 99, "Encoder::display_properties Digital Inputs: %d", numInputs);
                logger->Log(msg);
                sprintf_s(msg, 99, "Encoder::display_properties Encoders: %d", numEncoders);
                logger->Log(msg);

                return 0;
        }

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

                int result;
                const char* err;

                //Declare an InterfaceKit handle
                ifKit = nullptr;

                //create the InterfaceKit object
                CPhidgetEncoder_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).
                CPhidgetEncoder_set_OnInputChange_Handler(ifKit, InputChangeHandler, this);

                //Registers a callback that will run if the encoder changes.
                //Requires the handle for the Encoder, the function that will be called, and an arbitrary pointer that will be supplied to the callback function (may be NULL).
                CPhidgetEncoder_set_OnPositionChange_Handler(ifKit, PositionChangeHandler, this);

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

                //get the program to wait for an encoder device to be attached
                char msg[99];
                sprintf_s(msg, 99, "Encoder::ctor Waiting for encoder %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, "Encoder::ctor Problem waiting for attachment of %i: %s", config->serialno, err);
                        logger->Log(msg, Logger::Fatal);
                        config->enable = false;
                        return;
                }

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

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