2021-08-07 16:27:09 -04:00
|
|
|
|
/*
|
|
|
|
|
rdm.cpp
|
|
|
|
|
|
|
|
|
|
Copyright (c) 2021 Kevin Matz (kevin.matz@gmail.com)
|
|
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
|
|
|
copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
|
SOFTWARE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "rdm.h"
|
2023-05-02 12:59:26 -04:00
|
|
|
|
#include "E1.37-1.h"
|
|
|
|
|
#include "E1.37-2.h"
|
|
|
|
|
#include "E1.37-7.h"
|
2021-08-07 16:27:09 -04:00
|
|
|
|
|
|
|
|
|
namespace RDM {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief ProductCategoryDescription
|
|
|
|
|
* @param PRODUCT_CATEGORY
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string ProductCategoryDescription(const uint16_t PRODUCT_CATEGORY)
|
|
|
|
|
{
|
|
|
|
|
switch (PRODUCT_CATEGORY) {
|
|
|
|
|
case PRODUCT_CATEGORY_NOT_DECLARED:
|
|
|
|
|
return std::string("Undeclard");
|
|
|
|
|
/// Fixtures – intended as source of illumination
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE:
|
|
|
|
|
return std::string("Fixture");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_FIXED:
|
|
|
|
|
return std::string("Fixed Fixture");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE:
|
|
|
|
|
return std::string("Moving Yoke Fixture");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR:
|
|
|
|
|
return std::string("Moving Mirror Fixture");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_OTHER:
|
|
|
|
|
return std::string("Fixture (Other)");
|
|
|
|
|
/// Fixture Accessories – add-ons to fixtures or projectors
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY:
|
|
|
|
|
return std::string("Fixture Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR:
|
|
|
|
|
return std::string("Color Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE:
|
|
|
|
|
return std::string("Yoke Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR:
|
|
|
|
|
return std::string("Mirror Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT:
|
|
|
|
|
return std::string("Effect Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM:
|
|
|
|
|
return std::string("Beam Accessory");
|
|
|
|
|
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER:
|
|
|
|
|
return std::string("Fixture Accessory (Other)");
|
|
|
|
|
/// Projectors - light source capable of producing realistic images from another media
|
|
|
|
|
case PRODUCT_CATEGORY_PROJECTOR:
|
|
|
|
|
return std::string("Projector");
|
|
|
|
|
case PRODUCT_CATEGORY_PROJECTOR_FIXED:
|
|
|
|
|
return std::string("Fixed Projector");
|
|
|
|
|
case PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE:
|
|
|
|
|
return std::string("Moving Yoke Projector");
|
|
|
|
|
case PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR:
|
|
|
|
|
return std::string("Moving Mirror Projector");
|
|
|
|
|
case PRODUCT_CATEGORY_PROJECTOR_OTHER:
|
|
|
|
|
return std::string("Projector (Other)");
|
|
|
|
|
/// Atmospheric Effect – earth/wind/fire
|
|
|
|
|
case PRODUCT_CATEGORY_ATMOSPHERIC:
|
|
|
|
|
return std::string("Atmospheric");
|
|
|
|
|
case PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT:
|
|
|
|
|
return std::string("Atomospheric Effect");
|
|
|
|
|
case PRODUCT_CATEGORY_ATMOSPHERIC_PYRO:
|
|
|
|
|
return std::string("Pyro");
|
|
|
|
|
case PRODUCT_CATEGORY_ATMOSPHERIC_OTHER:
|
|
|
|
|
return std::string("Atmospheric (other)");
|
|
|
|
|
/// Intensity Control (specifically Dimming equipment)
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER:
|
|
|
|
|
return std::string("Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT:
|
|
|
|
|
return std::string("AC Incandescent Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT:
|
|
|
|
|
return std::string("AC Flourescent Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE:
|
|
|
|
|
return std::string("AC Cold Cathode Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_NONDIM:
|
|
|
|
|
return std::string("AC Non-Dim");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_ELV:
|
|
|
|
|
return std::string("AC Low-Voltage Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_AC_OTHER:
|
|
|
|
|
return std::string("AC Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_DC_LEVEL:
|
|
|
|
|
return std::string("DC Level Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_DC_PWM:
|
|
|
|
|
return std::string("DC PWM Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_CS_LED:
|
|
|
|
|
return std::string("LED Dimmer");
|
|
|
|
|
case PRODUCT_CATEGORY_DIMMER_OTHER:
|
|
|
|
|
return std::string("Dimmer (other)");
|
|
|
|
|
/// Power Control (other than Dimming equipment)
|
|
|
|
|
case PRODUCT_CATEGORY_POWER:
|
|
|
|
|
return std::string("Power");
|
|
|
|
|
case PRODUCT_CATEGORY_POWER_CONTROL:
|
|
|
|
|
return std::string("Power Control");
|
|
|
|
|
case PRODUCT_CATEGORY_POWER_SOURCE:
|
|
|
|
|
return std::string("Power Source");
|
|
|
|
|
case PRODUCT_CATEGORY_POWER_OTHER:
|
|
|
|
|
return std::string("Power (other)");
|
|
|
|
|
/// Scenic Drive – including motorized effects unrelated to light source.
|
|
|
|
|
case PRODUCT_CATEGORY_SCENIC:
|
|
|
|
|
return std::string("Scenic");
|
|
|
|
|
case PRODUCT_CATEGORY_SCENIC_DRIVE:
|
|
|
|
|
return std::string("Scenic Drive");
|
|
|
|
|
case PRODUCT_CATEGORY_SCENIC_OTHER:
|
|
|
|
|
return std::string("Scenic (Other)");
|
|
|
|
|
/// DMX Infrastructure, conversion and interfaces
|
|
|
|
|
case PRODUCT_CATEGORY_DATA:
|
|
|
|
|
return std::string("Data");
|
|
|
|
|
case PRODUCT_CATEGORY_DATA_DISTRIBUTION:
|
|
|
|
|
return std::string("Data Distribution");
|
|
|
|
|
case PRODUCT_CATEGORY_DATA_CONVERSION:
|
|
|
|
|
return std::string("Data Converter");
|
|
|
|
|
case PRODUCT_CATEGORY_DATA_OTHER:
|
|
|
|
|
return std::string("Data (Other)");
|
|
|
|
|
/// Audio-Visual Equipment
|
|
|
|
|
case PRODUCT_CATEGORY_AV:
|
|
|
|
|
return std::string("AV");
|
|
|
|
|
case PRODUCT_CATEGORY_AV_AUDIO:
|
|
|
|
|
return std::string("Audio Controller or Device");
|
|
|
|
|
case PRODUCT_CATEGORY_AV_VIDEO:
|
|
|
|
|
return std::string("Video Controller or Display Device");
|
|
|
|
|
case PRODUCT_CATEGORY_AV_OTHER:
|
|
|
|
|
return std::string("AV (Other)");
|
|
|
|
|
/// Parameter Monitoring Equipment
|
|
|
|
|
case PRODUCT_CATEGORY_MONITOR:
|
|
|
|
|
return std::string("Monitor");
|
|
|
|
|
case PRODUCT_CATEGORY_MONITOR_ACLINEPOWER:
|
|
|
|
|
return std::string("AC Line-power Monitor");
|
|
|
|
|
case PRODUCT_CATEGORY_MONITOR_DCPOWER:
|
|
|
|
|
return std::string("DC Power Monitor");
|
|
|
|
|
case PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL:
|
|
|
|
|
return std::string("Environmental Monitor");
|
|
|
|
|
case PRODUCT_CATEGORY_MONITOR_OTHER:
|
|
|
|
|
return std::string("Monitor (Other)");
|
|
|
|
|
/// Controllers, Backup devices
|
|
|
|
|
case PRODUCT_CATEGORY_CONTROL:
|
|
|
|
|
return std::string("Control");
|
|
|
|
|
case PRODUCT_CATEGORY_CONTROL_CONTROLLER:
|
|
|
|
|
return std::string("Controller");
|
|
|
|
|
case PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE:
|
|
|
|
|
return std::string("Controller-Backup");
|
|
|
|
|
case PRODUCT_CATEGORY_CONTROL_OTHER:
|
|
|
|
|
return std::string("Control (Other)");
|
|
|
|
|
/// Test Equipment
|
|
|
|
|
case PRODUCT_CATEGORY_TEST:
|
|
|
|
|
return std::string("Test");
|
|
|
|
|
case PRODUCT_CATEGORY_TEST_EQUIPMENT:
|
|
|
|
|
return std::string("Test Equipment");
|
|
|
|
|
case PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER:
|
|
|
|
|
return std::string("Test-Other");
|
|
|
|
|
/// Miscellaneous
|
|
|
|
|
case PRODUCT_CATEGORY_OTHER:
|
|
|
|
|
return std::string("Other");
|
|
|
|
|
default:
|
|
|
|
|
return std::string("Unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief ProductDetailDescription
|
|
|
|
|
* @param PRODUCT_DETAIL
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
2021-08-25 17:20:33 -04:00
|
|
|
|
std::string ProductDetailDescription(const uint16_t PRODUCT_DETAIL)
|
2021-08-07 16:27:09 -04:00
|
|
|
|
{
|
|
|
|
|
switch (PRODUCT_DETAIL) {
|
|
|
|
|
case PRODUCT_DETAIL_NOT_DECLARED:
|
|
|
|
|
return std::string("Undeclared");
|
|
|
|
|
/// Generally applied to fixtures
|
|
|
|
|
case PRODUCT_DETAIL_ARC:
|
|
|
|
|
return std::string("Arc");
|
|
|
|
|
case PRODUCT_DETAIL_METAL_HALIDE:
|
|
|
|
|
return std::string("Metal Halide");
|
|
|
|
|
case PRODUCT_DETAIL_INCANDESCENT:
|
|
|
|
|
return std::string("Incandescent");
|
|
|
|
|
case PRODUCT_DETAIL_LED:
|
|
|
|
|
return std::string("LED");
|
|
|
|
|
case PRODUCT_DETAIL_FLUROESCENT:
|
|
|
|
|
return std::string("Flouroescent");
|
|
|
|
|
case PRODUCT_DETAIL_COLDCATHODE:
|
|
|
|
|
return std::string("Cold Cathode");
|
|
|
|
|
case PRODUCT_DETAIL_ELECTROLUMINESCENT:
|
|
|
|
|
return std::string("Eloctroluminescent");
|
|
|
|
|
case PRODUCT_DETAIL_LASER:
|
|
|
|
|
return std::string("Laser");
|
|
|
|
|
case PRODUCT_DETAIL_FLASHTUBE:
|
|
|
|
|
return std::string("Flash Tube");
|
|
|
|
|
/// Generally applied to fixture accessories
|
|
|
|
|
case PRODUCT_DETAIL_COLORSCROLLER:
|
|
|
|
|
return std::string("Color Scroll");
|
|
|
|
|
case PRODUCT_DETAIL_COLORWHEEL:
|
|
|
|
|
return std::string("Color Wheel");
|
|
|
|
|
case PRODUCT_DETAIL_COLORCHANGE:
|
|
|
|
|
return std::string("Color Change");
|
|
|
|
|
case PRODUCT_DETAIL_IRIS_DOUSER:
|
|
|
|
|
return std::string("Iris");
|
|
|
|
|
case PRODUCT_DETAIL_DIMMING_SHUTTER:
|
|
|
|
|
return std::string("Dimming Shutter");
|
|
|
|
|
case PRODUCT_DETAIL_PROFILE_SHUTTER:
|
|
|
|
|
return std::string("Profile Shutter");
|
|
|
|
|
case PRODUCT_DETAIL_BARNDOOR_SHUTTER:
|
|
|
|
|
return std::string("Barndoor");
|
|
|
|
|
case PRODUCT_DETAIL_EFFECTS_DISC:
|
|
|
|
|
return std::string("Effects Disc");
|
|
|
|
|
case PRODUCT_DETAIL_GOBO_ROTATOR:
|
|
|
|
|
return std::string("Gobo Rotator");
|
|
|
|
|
/// Generally applied to Projectors
|
|
|
|
|
case PRODUCT_DETAIL_VIDEO:
|
|
|
|
|
return std::string("Video");
|
|
|
|
|
case PRODUCT_DETAIL_SLIDE:
|
|
|
|
|
return std::string("Slide");
|
|
|
|
|
case PRODUCT_DETAIL_FILM:
|
|
|
|
|
return std::string("Film");
|
|
|
|
|
case PRODUCT_DETAIL_OILWHEEL:
|
|
|
|
|
return std::string("Oil Wheel");
|
|
|
|
|
case PRODUCT_DETAIL_LCDGATE:
|
|
|
|
|
return std::string("LCD Gate");
|
|
|
|
|
/// Generally applied to Atmospheric Effects
|
|
|
|
|
case PRODUCT_DETAIL_FOGGER_GLYCOL:
|
|
|
|
|
return std::string("Fogger (glycol)");
|
|
|
|
|
case PRODUCT_DETAIL_FOGGER_MINERALOIL:
|
|
|
|
|
return std::string("Fogger (mineral oil)");
|
|
|
|
|
case PRODUCT_DETAIL_FOGGER_WATER:
|
|
|
|
|
return std::string("Fogger (water)");
|
|
|
|
|
case PRODUCT_DETAIL_C02:
|
|
|
|
|
return std::string("Carbon Dioxide");
|
|
|
|
|
case PRODUCT_DETAIL_LN2:
|
|
|
|
|
return std::string("Liquid Nitrogen");
|
|
|
|
|
case PRODUCT_DETAIL_BUBBLE:
|
|
|
|
|
return std::string("Bubble");
|
|
|
|
|
case PRODUCT_DETAIL_FLAME_PROPANE:
|
|
|
|
|
return std::string("Flame (other)");
|
|
|
|
|
case PRODUCT_DETAIL_FLAME_OTHER:
|
|
|
|
|
return std::string("");
|
|
|
|
|
case PRODUCT_DETAIL_OLEFACTORY_STIMULATOR:
|
|
|
|
|
return std::string("Olefactory Stimulator");
|
|
|
|
|
case PRODUCT_DETAIL_SNOW:
|
|
|
|
|
return std::string("Snow");
|
|
|
|
|
case PRODUCT_DETAIL_WATER_JET:
|
|
|
|
|
return std::string("Water Jet");
|
|
|
|
|
case PRODUCT_DETAIL_WIND:
|
|
|
|
|
return std::string("Wind");
|
|
|
|
|
case PRODUCT_DETAIL_CONFETTI:
|
|
|
|
|
return std::string("Confetti");
|
|
|
|
|
case PRODUCT_DETAIL_HAZARD:
|
|
|
|
|
return std::string("Hazard");
|
|
|
|
|
/// Generally applied to Dimmers/Power controllers
|
|
|
|
|
case PRODUCT_DETAIL_PHASE_CONTROL:
|
|
|
|
|
return std::string("Phase Control");
|
|
|
|
|
case PRODUCT_DETAIL_REVERSE_PHASE_CONTROL:
|
|
|
|
|
return std::string("Reverse Phase Control");
|
|
|
|
|
case PRODUCT_DETAIL_SINE:
|
|
|
|
|
return std::string("Sine");
|
|
|
|
|
case PRODUCT_DETAIL_PWM:
|
|
|
|
|
return std::string("PWM");
|
|
|
|
|
case PRODUCT_DETAIL_DC:
|
|
|
|
|
return std::string("DC");
|
|
|
|
|
case PRODUCT_DETAIL_HFBALLAST:
|
|
|
|
|
return std::string("High-Frequency Ballast");
|
|
|
|
|
case PRODUCT_DETAIL_HFHV_NEONBALLAST:
|
|
|
|
|
return std::string("High-Frequency/High-Voltage Neon");
|
|
|
|
|
case PRODUCT_DETAIL_HFHV_EL:
|
|
|
|
|
return std::string("High-Frequency/High-Voltage EL");
|
|
|
|
|
case PRODUCT_DETAIL_MHR_BALLAST:
|
|
|
|
|
return std::string("MHR Ballast");
|
|
|
|
|
case PRODUCT_DETAIL_BITANGLE_MODULATION:
|
|
|
|
|
return std::string("Bitangle Modulation");
|
|
|
|
|
case PRODUCT_DETAIL_FREQUENCY_MODULATION:
|
|
|
|
|
return std::string("Frequency Modulation");
|
|
|
|
|
case PRODUCT_DETAIL_HIGHFREQUENCY_12V:
|
|
|
|
|
return std::string("High Frequency 12v");
|
|
|
|
|
case PRODUCT_DETAIL_RELAY_MECHANICAL:
|
|
|
|
|
return std::string("Mechanical Relay");
|
|
|
|
|
case PRODUCT_DETAIL_RELAY_ELECTRONIC:
|
|
|
|
|
return std::string("Electronic Relay");
|
|
|
|
|
case PRODUCT_DETAIL_SWITCH_ELECTRONIC:
|
|
|
|
|
return std::string("Electronic Switch");
|
|
|
|
|
case PRODUCT_DETAIL_CONTACTOR:
|
|
|
|
|
return std::string("Contactor");
|
|
|
|
|
/// Generally applied to Scenic drive
|
|
|
|
|
case PRODUCT_DETAIL_MIRRORBALL_ROTATOR:
|
|
|
|
|
return std::string("Mirroball Rotator");
|
|
|
|
|
case PRODUCT_DETAIL_OTHER_ROTATOR:
|
|
|
|
|
return std::string("Rotator (other)");
|
|
|
|
|
case PRODUCT_DETAIL_KABUKI_DROP:
|
|
|
|
|
return std::string("Kabuki Drop");
|
|
|
|
|
case PRODUCT_DETAIL_CURTAIN:
|
|
|
|
|
return std::string("Curtain");
|
|
|
|
|
case PRODUCT_DETAIL_LINESET:
|
|
|
|
|
return std::string("Lineset");
|
|
|
|
|
case PRODUCT_DETAIL_MOTOR_CONTROL:
|
|
|
|
|
return std::string("Motor Control");
|
|
|
|
|
case PRODUCT_DETAIL_DAMPER_CONTROL:
|
|
|
|
|
return std::string("Damper Control");
|
|
|
|
|
/// Generally applied to Data Distribution
|
|
|
|
|
case PRODUCT_DETAIL_SPLITTER:
|
|
|
|
|
return std::string("Splitter");
|
|
|
|
|
case PRODUCT_DETAIL_ETHERNET_NODE:
|
|
|
|
|
return std::string("Ethernet Node");
|
|
|
|
|
case PRODUCT_DETAIL_MERGE:
|
|
|
|
|
return std::string("Merge");
|
|
|
|
|
case PRODUCT_DETAIL_DATAPATCH:
|
|
|
|
|
return std::string("Data Patch");
|
|
|
|
|
case PRODUCT_DETAIL_WIRELESS_LINK:
|
|
|
|
|
return std::string("Wireless Link");
|
|
|
|
|
/// Generally applied to Data Conversion and Interfaces
|
|
|
|
|
case PRODUCT_DETAIL_PROTOCOL_CONVERTOR:
|
|
|
|
|
return std::string("Protocl Convertor");
|
|
|
|
|
case PRODUCT_DETAIL_ANALOG_DEMULTIPLEX:
|
|
|
|
|
return std::string("Analog De-multiplex");
|
|
|
|
|
case PRODUCT_DETAIL_ANALOG_MULTIPLEX:
|
|
|
|
|
return std::string("Analog Multiplex");
|
|
|
|
|
case PRODUCT_DETAIL_SWITCH_PANEL:
|
|
|
|
|
return std::string("Switch Panel");
|
|
|
|
|
/// Generally applied to Audio or Video (AV) devices
|
|
|
|
|
case PRODUCT_DETAIL_ROUTER:
|
|
|
|
|
return std::string("Router");
|
|
|
|
|
case PRODUCT_DETAIL_FADER:
|
|
|
|
|
return std::string("Fader");
|
|
|
|
|
case PRODUCT_DETAIL_MIXER:
|
|
|
|
|
return std::string("Mixer");
|
|
|
|
|
/// Generally applied to Controllers, Backup devices and Test Equipment
|
|
|
|
|
case PRODUCT_DETAIL_CHANGEOVER_MANUAL:
|
|
|
|
|
return std::string("Manual Changeover");
|
|
|
|
|
case PRODUCT_DETAIL_CHANGEOVER_AUTO:
|
|
|
|
|
return std::string("Auto Changeover");
|
|
|
|
|
case PRODUCT_DETAIL_TEST:
|
|
|
|
|
return std::string("TEST");
|
|
|
|
|
/// Could be applied to any category
|
|
|
|
|
case PRODUCT_DETAIL_GFI_RCD:
|
|
|
|
|
return std::string("GFI RCD");
|
|
|
|
|
case PRODUCT_DETAIL_BATTERY:
|
|
|
|
|
return std::string("Battery");
|
|
|
|
|
case PRODUCT_DETAIL_CONTROLLABLE_BREAKER:
|
|
|
|
|
return std::string("Controllable Breaker");
|
|
|
|
|
/// for where the Manufacturer believes that none of the defined details apply.
|
|
|
|
|
case PRODUCT_DETAIL_OTHER:
|
|
|
|
|
return std::string("Other");
|
|
|
|
|
default:
|
|
|
|
|
return std::string("Unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2021-08-08 17:25:41 -04:00
|
|
|
|
/**
|
|
|
|
|
* @brief NackReasonDescription
|
|
|
|
|
* @param NR
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string NackReasonDescription(const uint16_t NR)
|
|
|
|
|
{
|
|
|
|
|
switch (NR) {
|
|
|
|
|
case NR_UNKNOWN_PID:
|
|
|
|
|
return std::string("The responder cannot comply with request because the message is not implemented in responder.");
|
|
|
|
|
case NR_FORMAT_ERROR:
|
|
|
|
|
return std::string("The responder cannot interpret request as controller data was not formatted correctly.");
|
|
|
|
|
case NR_HARDWARE_FAULT:
|
|
|
|
|
return std::string("The responder cannot comply due to an internal hardware fault.");
|
|
|
|
|
case NR_PROXY_REJECT:
|
|
|
|
|
return std::string("Proxy is not the RDM line master and cannot comply with message.");
|
|
|
|
|
case NR_WRITE_PROTECT:
|
|
|
|
|
return std::string("SET Command normally allowed but being blocked currently.");
|
|
|
|
|
case NR_UNSUPPORTED_COMMAND_CLASS:
|
|
|
|
|
return std::string("Not valid for Command Class attempted.");
|
|
|
|
|
case NR_DATA_OUT_OF_RANGE:
|
|
|
|
|
return std::string("Value for given Parameter out of allowable range or not supported.");
|
|
|
|
|
case NR_BUFFER_FULL:
|
|
|
|
|
return std::string("Buffer or Queue space currently has no free space to store data.");
|
|
|
|
|
case NR_PACKET_SIZE_UNSUPPORTED:
|
|
|
|
|
return std::string("Incoming message exceeds buffer capacity.");
|
|
|
|
|
case NR_SUB_DEVICE_OUT_OF_RANGE:
|
|
|
|
|
return std::string("Sub-Device is out of range or unknown.");
|
|
|
|
|
case NR_PROXY_BUFFER_FULL:
|
|
|
|
|
return std::string("The proxy buffer is full and can not store any more Queued Message or Status Message responses.");
|
|
|
|
|
case NR_ACTION_NOT_SUPPORTED: //!< from E1.37-7
|
|
|
|
|
return std::string("The specified action is not supported.");
|
|
|
|
|
case NR_ENDPOINT_NUMBER_INVALID: //!< from E1.37-7
|
|
|
|
|
return std::string("The specified endpoint is invalid.");
|
|
|
|
|
case NR_INVALID_ENDPOINT_MODE: //!< from E1.37-7
|
|
|
|
|
return std::string("The specified endpoint is in an invalid Endpoint Mode for the requested action.");
|
|
|
|
|
case NR_UNKNOWN_UID: //!< from E1.37-7
|
|
|
|
|
return std::string("The specified UID is not recognized.");
|
|
|
|
|
default:
|
|
|
|
|
return std::string("Unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-12 00:31:00 -04:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief StatusMessageDescription
|
|
|
|
|
* @param status
|
2023-05-02 13:01:33 -04:00
|
|
|
|
* @param data1
|
|
|
|
|
* @param data2
|
|
|
|
|
* @param label
|
2021-08-12 00:31:00 -04:00
|
|
|
|
* @return
|
2023-05-02 13:01:33 -04:00
|
|
|
|
*
|
|
|
|
|
* %d Decimal Number -- as decimal number
|
|
|
|
|
* %x Hexadecimal Number -- as hexadecimal number
|
|
|
|
|
* %L Slot Label Code -- as text description of Slot Label Code
|
2021-08-12 00:31:00 -04:00
|
|
|
|
*/
|
2023-05-02 13:01:33 -04:00
|
|
|
|
std::string StatusMessageDescription(uint16_t status, std::string label, int data1, int data2)
|
2021-08-12 00:31:00 -04:00
|
|
|
|
{
|
|
|
|
|
switch (status) {
|
|
|
|
|
case STS_CAL_FAIL:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" failed calibration";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_SENS_NOT_FOUND:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" sensor not found";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_SENS_ALWAYS_ON:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" sensor always on";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_LAMP_DOUSED:
|
|
|
|
|
return "Lamp doused";
|
|
|
|
|
case STS_LAMP_STRIKE:
|
|
|
|
|
return "Lamp failed to strike";
|
|
|
|
|
case STS_OVERTEMP:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Sensor "+std::to_string(data1)+" over temp at "+std::to_string(data2)+" °C";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_UNDERTEMP:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Sensor "+std::to_string(data1)+" under temp at "+std::to_string(data2)+" °C";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_SENS_OUT_RANGE:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Sensor "+std::to_string(data1)+" out of range";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_OVERVOLTAGE_PHASE:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" over voltage at "+std::to_string(data2)+" V.";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_UNDERVOLTAGE_PHASE:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" under voltage at "+std::to_string(data2)+" V.";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_OVERCURRENT:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" over current at "+std::to_string(data2)+" A.";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_UNDERCURRENT:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" under current at "+std::to_string(data2)+" A.";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_PHASE:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" is at "+std::to_string(data2)+"°";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_PHASE_ERROR:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return "Phase "+std::to_string(data1)+" Error.";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_AMPS:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return std::to_string(data1)+" Amps";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_VOLTS:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return std::to_string(data1)+" Volts";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_DIMSLOT_OCCUPIED:
|
|
|
|
|
return "No Dimmer";
|
|
|
|
|
case STS_BREAKER_TRIP:
|
|
|
|
|
return "Tripped Breaker";
|
|
|
|
|
case STS_WATTS:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return std::to_string(data1)+" Watts";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_DIM_FAILURE:
|
|
|
|
|
return "Dimmer Failure";
|
|
|
|
|
case STS_DIM_PANIC:
|
|
|
|
|
return "Panic Mode";
|
|
|
|
|
case STS_READY:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" ready";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_NOT_READY:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" not ready";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
case STS_LOW_FLUID:
|
2023-05-02 13:01:33 -04:00
|
|
|
|
return label+" low fluid";
|
2021-08-12 00:31:00 -04:00
|
|
|
|
default:
|
|
|
|
|
return std::string();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-02 12:59:26 -04:00
|
|
|
|
|
2023-05-02 13:01:33 -04:00
|
|
|
|
/**
|
|
|
|
|
* @brief SiUnitName
|
|
|
|
|
* @param unit
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiUnitName(const uint8_t unit)
|
|
|
|
|
{
|
|
|
|
|
switch (unit) {
|
|
|
|
|
case UNITS_CENTIGRADE:
|
|
|
|
|
return "Centigrade";
|
|
|
|
|
case UNITS_VOLTS_DC:
|
|
|
|
|
return "DC Volts";
|
|
|
|
|
case UNITS_VOLTS_AC_PEAK:
|
|
|
|
|
return "Peak AC Volts";
|
|
|
|
|
case UNITS_VOLTS_AC_RMS:
|
|
|
|
|
return "RMS AC Volts";
|
|
|
|
|
case UNITS_AMPERE_DC:
|
|
|
|
|
return "DC Amps";
|
|
|
|
|
case UNITS_AMPERE_AC_PEAK:
|
|
|
|
|
return "Peak AC Amps";
|
|
|
|
|
case UNITS_AMPERE_AC_RMS:
|
|
|
|
|
return "RMS AC Amps";
|
|
|
|
|
case UNITS_HERTZ:
|
|
|
|
|
return "Hertz";
|
|
|
|
|
case UNITS_OHM:
|
|
|
|
|
return "Ohms";
|
|
|
|
|
case UNITS_WATT:
|
|
|
|
|
return "Watts";
|
|
|
|
|
case UNITS_KILOGRAM:
|
|
|
|
|
return "kilograms";
|
|
|
|
|
case UNITS_METERS:
|
|
|
|
|
return "meters";
|
|
|
|
|
case UNITS_METERS_SQUARED:
|
|
|
|
|
return "square meters";
|
|
|
|
|
case UNITS_METERS_CUBED:
|
|
|
|
|
return "cubic meters";
|
|
|
|
|
case UNITS_KILOGRAMES_PER_METER_CUBED:
|
|
|
|
|
return "kilograms per cubic meter";
|
|
|
|
|
case UNITS_METERS_PER_SECOND:
|
|
|
|
|
return "meters per second";
|
|
|
|
|
case UNITS_METERS_PER_SECOND_SQUARED:
|
|
|
|
|
return "meters per second sqared";
|
|
|
|
|
case UNITS_NEWTON:
|
|
|
|
|
return "Newtons";
|
|
|
|
|
case UNITS_JOULE:
|
|
|
|
|
return "Joules";
|
|
|
|
|
case UNITS_PASCAL:
|
|
|
|
|
return "Pascals";
|
|
|
|
|
case UNITS_SECOND:
|
|
|
|
|
return "seconds";
|
|
|
|
|
case UNITS_DEGREE:
|
|
|
|
|
return "degrees";
|
|
|
|
|
case UNITS_STERADIAN:
|
|
|
|
|
return "streradians";
|
|
|
|
|
case UNITS_CANDELA:
|
|
|
|
|
return "candelas";
|
|
|
|
|
case UNITS_LUMEN:
|
|
|
|
|
return "lumen";
|
|
|
|
|
case UNITS_LUX:
|
|
|
|
|
return "lux";
|
|
|
|
|
case UNITS_IRE:
|
|
|
|
|
return "IRE";
|
|
|
|
|
case UNITS_BYTE:
|
|
|
|
|
return "byte";
|
|
|
|
|
default:
|
|
|
|
|
return std::string();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiUnitSymbol
|
|
|
|
|
* @param unit
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiUnitSymbol(const uint8_t unit)
|
|
|
|
|
{
|
|
|
|
|
switch (unit) {
|
|
|
|
|
case UNITS_CENTIGRADE:
|
|
|
|
|
return "°C";
|
|
|
|
|
case UNITS_VOLTS_DC:
|
|
|
|
|
return "Vᵈᶜ";
|
|
|
|
|
case UNITS_VOLTS_AC_PEAK:
|
|
|
|
|
return "Vᵖᵉᵃᵏ";
|
|
|
|
|
case UNITS_VOLTS_AC_RMS:
|
|
|
|
|
return "Vʳᵐˢ";
|
|
|
|
|
case UNITS_AMPERE_DC:
|
|
|
|
|
return "Aᵈᶜ";
|
|
|
|
|
case UNITS_AMPERE_AC_PEAK:
|
|
|
|
|
return "Aᵖᵉᵃᵏ";
|
|
|
|
|
case UNITS_AMPERE_AC_RMS:
|
|
|
|
|
return "Aʳᵐˢ";
|
|
|
|
|
case UNITS_HERTZ:
|
|
|
|
|
return "Hz";
|
|
|
|
|
case UNITS_OHM:
|
|
|
|
|
return "Ω";
|
|
|
|
|
case UNITS_WATT:
|
|
|
|
|
return "W";
|
|
|
|
|
case UNITS_KILOGRAM:
|
|
|
|
|
return "kg";
|
|
|
|
|
case UNITS_METERS:
|
|
|
|
|
return "m";
|
|
|
|
|
case UNITS_METERS_SQUARED:
|
|
|
|
|
return "m²";
|
|
|
|
|
case UNITS_METERS_CUBED:
|
|
|
|
|
return "m³";
|
|
|
|
|
case UNITS_KILOGRAMES_PER_METER_CUBED:
|
|
|
|
|
return "kg/m³";
|
|
|
|
|
case UNITS_METERS_PER_SECOND:
|
|
|
|
|
return "m/s";
|
|
|
|
|
case UNITS_METERS_PER_SECOND_SQUARED:
|
|
|
|
|
return "m/s²";
|
|
|
|
|
case UNITS_NEWTON:
|
|
|
|
|
return "N";
|
|
|
|
|
case UNITS_JOULE:
|
|
|
|
|
return "J";
|
|
|
|
|
case UNITS_PASCAL:
|
|
|
|
|
return "σ";
|
|
|
|
|
case UNITS_SECOND:
|
|
|
|
|
return "s";
|
|
|
|
|
case UNITS_DEGREE:
|
|
|
|
|
return "°";
|
|
|
|
|
case UNITS_STERADIAN:
|
|
|
|
|
return "Ω";
|
|
|
|
|
case UNITS_CANDELA:
|
|
|
|
|
return "Ιᵥ";
|
|
|
|
|
case UNITS_LUMEN:
|
|
|
|
|
return "Φᵥ";
|
|
|
|
|
case UNITS_LUX:
|
|
|
|
|
return "lx";
|
|
|
|
|
case UNITS_IRE:
|
|
|
|
|
return "IRE";
|
|
|
|
|
case UNITS_BYTE:
|
|
|
|
|
return "B";
|
|
|
|
|
default:
|
|
|
|
|
return std::string();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiUnitSymbolASCII
|
|
|
|
|
* @param unit
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiUnitSymbolASCII(const uint8_t unit)
|
|
|
|
|
{
|
|
|
|
|
switch (unit) {
|
|
|
|
|
case UNITS_CENTIGRADE:
|
|
|
|
|
return "deg(C)";
|
|
|
|
|
case UNITS_VOLTS_DC:
|
|
|
|
|
return "V(dc)";
|
|
|
|
|
case UNITS_VOLTS_AC_PEAK:
|
|
|
|
|
return "V(peak)";
|
|
|
|
|
case UNITS_VOLTS_AC_RMS:
|
|
|
|
|
return "V(rms)";
|
|
|
|
|
case UNITS_AMPERE_DC:
|
|
|
|
|
return "A(dc)";
|
|
|
|
|
case UNITS_AMPERE_AC_PEAK:
|
|
|
|
|
return "A(peak)";
|
|
|
|
|
case UNITS_AMPERE_AC_RMS:
|
|
|
|
|
return "A(rms)";
|
|
|
|
|
case UNITS_OHM:
|
|
|
|
|
return "Ohm";
|
|
|
|
|
case UNITS_METERS_SQUARED:
|
|
|
|
|
return "m^2";
|
|
|
|
|
case UNITS_METERS_CUBED:
|
|
|
|
|
return "m^3";
|
|
|
|
|
case UNITS_KILOGRAMES_PER_METER_CUBED:
|
|
|
|
|
return "kg/m^3";
|
|
|
|
|
case UNITS_METERS_PER_SECOND_SQUARED:
|
|
|
|
|
return "m/s^2";
|
|
|
|
|
case UNITS_PASCAL:
|
|
|
|
|
return "Pa";
|
|
|
|
|
case UNITS_DEGREE:
|
|
|
|
|
return "deg";
|
|
|
|
|
case UNITS_STERADIAN:
|
|
|
|
|
return "sr";
|
|
|
|
|
case UNITS_CANDELA:
|
|
|
|
|
return "cd";
|
|
|
|
|
case UNITS_LUMEN:
|
|
|
|
|
return "lm";
|
|
|
|
|
default:
|
|
|
|
|
return SiUnitSymbol(unit);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiPrefixName
|
|
|
|
|
* @param prefix
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiPrefixName(const uint8_t prefix)
|
|
|
|
|
{
|
|
|
|
|
switch (prefix) {
|
|
|
|
|
case PREFIX_DECI:
|
|
|
|
|
return "deci";
|
|
|
|
|
case PREFIX_CENTI:
|
|
|
|
|
return "centi";
|
|
|
|
|
case PREFIX_MILLI:
|
|
|
|
|
return "milli";
|
|
|
|
|
case PREFIX_MICRO:
|
|
|
|
|
return "micro";
|
|
|
|
|
case PREFIX_NANO:
|
|
|
|
|
return "nano";
|
|
|
|
|
case PREFIX_PICO:
|
|
|
|
|
return "pico";
|
|
|
|
|
case PREFIX_FEMPTO:
|
|
|
|
|
return "fempto";
|
|
|
|
|
case PREFIX_ATTO:
|
|
|
|
|
return "atto";
|
|
|
|
|
case PREFIX_ZEPTO:
|
|
|
|
|
return "zepto";
|
|
|
|
|
case PREFIX_YOCTO:
|
|
|
|
|
return "yocto";
|
|
|
|
|
case PREFIX_DECA:
|
|
|
|
|
return "deca";
|
|
|
|
|
case PREFIX_HECTO:
|
|
|
|
|
return "hecto";
|
|
|
|
|
case PREFIX_KILO:
|
|
|
|
|
return "kilo";
|
|
|
|
|
case PREFIX_MEGA:
|
|
|
|
|
return "mega";
|
|
|
|
|
case PREFIX_GIGA:
|
|
|
|
|
return "giga";
|
|
|
|
|
case PREFIX_TERA:
|
|
|
|
|
return "tera";
|
|
|
|
|
case PREFIX_PETA:
|
|
|
|
|
return "peta";
|
|
|
|
|
case PREFIX_EXA:
|
|
|
|
|
return "exa";
|
|
|
|
|
case PREFIX_ZETTA:
|
|
|
|
|
return "zetta";
|
|
|
|
|
case PREFIX_YOTTA:
|
|
|
|
|
return "yotta";
|
|
|
|
|
default:
|
|
|
|
|
return std::string();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiPrefixSymbol
|
|
|
|
|
* @param prefix
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiPrefixSymbol(const uint8_t prefix)
|
|
|
|
|
{
|
|
|
|
|
switch (prefix) {
|
|
|
|
|
case PREFIX_DECI:
|
|
|
|
|
return "d";
|
|
|
|
|
case PREFIX_CENTI:
|
|
|
|
|
return "c";
|
|
|
|
|
case PREFIX_MILLI:
|
|
|
|
|
return "m";
|
|
|
|
|
case PREFIX_MICRO:
|
|
|
|
|
return "μ";
|
|
|
|
|
case PREFIX_NANO:
|
|
|
|
|
return "n";
|
|
|
|
|
case PREFIX_PICO:
|
|
|
|
|
return "p";
|
|
|
|
|
case PREFIX_FEMPTO:
|
|
|
|
|
return "f";
|
|
|
|
|
case PREFIX_ATTO:
|
|
|
|
|
return "a";
|
|
|
|
|
case PREFIX_ZEPTO:
|
|
|
|
|
return "z";
|
|
|
|
|
case PREFIX_YOCTO:
|
|
|
|
|
return "y";
|
|
|
|
|
case PREFIX_DECA:
|
|
|
|
|
return "da";
|
|
|
|
|
case PREFIX_HECTO:
|
|
|
|
|
return "h";
|
|
|
|
|
case PREFIX_KILO:
|
|
|
|
|
return "k";
|
|
|
|
|
case PREFIX_MEGA:
|
|
|
|
|
return "M";
|
|
|
|
|
case PREFIX_GIGA:
|
|
|
|
|
return "G";
|
|
|
|
|
case PREFIX_TERA:
|
|
|
|
|
return "T";
|
|
|
|
|
case PREFIX_PETA:
|
|
|
|
|
return "P";
|
|
|
|
|
case PREFIX_EXA:
|
|
|
|
|
return "E";
|
|
|
|
|
case PREFIX_ZETTA:
|
|
|
|
|
return "Z";
|
|
|
|
|
case PREFIX_YOTTA:
|
|
|
|
|
return "Y";
|
|
|
|
|
default:
|
|
|
|
|
return std::string();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiPrefixSymbolASCII
|
|
|
|
|
* @param prefix
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
std::string SiPrefixSymbolASCII(const uint8_t prefix)
|
|
|
|
|
{
|
|
|
|
|
switch (prefix) {
|
|
|
|
|
case PREFIX_MICRO:
|
|
|
|
|
return "u";
|
|
|
|
|
default:
|
|
|
|
|
return SiPrefixSymbol(prefix);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief SiPrefixBase10Exponent
|
|
|
|
|
* @param prefix
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
int SiPrefixBase10Exponent(const uint8_t prefix)
|
|
|
|
|
{
|
|
|
|
|
switch (prefix) {
|
|
|
|
|
case PREFIX_NONE:
|
|
|
|
|
return 0;
|
|
|
|
|
case PREFIX_DECI:
|
|
|
|
|
return -1;
|
|
|
|
|
case PREFIX_CENTI:
|
|
|
|
|
return -2;
|
|
|
|
|
case PREFIX_MILLI:
|
|
|
|
|
return -3;
|
|
|
|
|
case PREFIX_MICRO:
|
|
|
|
|
return -6;
|
|
|
|
|
case PREFIX_NANO:
|
|
|
|
|
return -9;
|
|
|
|
|
case PREFIX_PICO:
|
|
|
|
|
return -12;
|
|
|
|
|
case PREFIX_FEMPTO:
|
|
|
|
|
return -15;
|
|
|
|
|
case PREFIX_ATTO:
|
|
|
|
|
return -18;
|
|
|
|
|
case PREFIX_ZEPTO:
|
|
|
|
|
return -21;
|
|
|
|
|
case PREFIX_YOCTO:
|
|
|
|
|
return -24;
|
|
|
|
|
case PREFIX_DECA:
|
|
|
|
|
return 1;
|
|
|
|
|
case PREFIX_HECTO:
|
|
|
|
|
return 2;
|
|
|
|
|
case PREFIX_KILO:
|
|
|
|
|
return 3;
|
|
|
|
|
case PREFIX_MEGA:
|
|
|
|
|
return 6;
|
|
|
|
|
case PREFIX_GIGA:
|
|
|
|
|
return 9;
|
|
|
|
|
case PREFIX_TERA:
|
|
|
|
|
return 12;
|
|
|
|
|
case PREFIX_PETA:
|
|
|
|
|
return 15;
|
|
|
|
|
case PREFIX_EXA:
|
|
|
|
|
return 18;
|
|
|
|
|
case PREFIX_ZETTA:
|
|
|
|
|
return 21;
|
|
|
|
|
case PREFIX_YOTTA:
|
|
|
|
|
return 24;
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2023-05-02 12:59:26 -04:00
|
|
|
|
/**
|
|
|
|
|
* @brief StandardDescription
|
|
|
|
|
* @param pid
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
const ParameterDescription StandardDescription(const PID pid)
|
|
|
|
|
{
|
|
|
|
|
for (const auto &description : PIDs)
|
|
|
|
|
if (description->pid == pid)
|
|
|
|
|
return *description;
|
|
|
|
|
|
|
|
|
|
for (const auto &description : PIDs_E137_1)
|
|
|
|
|
if (description->pid == pid)
|
|
|
|
|
return *description;
|
|
|
|
|
|
|
|
|
|
for (const auto &description : PIDs_E137_2)
|
|
|
|
|
if (description->pid == pid)
|
|
|
|
|
return *description;
|
|
|
|
|
|
|
|
|
|
for (const auto &description : PIDs_E137_7)
|
|
|
|
|
if (description->pid == pid)
|
|
|
|
|
return *description;
|
|
|
|
|
|
|
|
|
|
return ParameterDescription();
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-07 16:27:09 -04:00
|
|
|
|
} // namespace RDM
|