syndilights/open-lighting-architecture/ola-0.8.4/common/rdm/RDMHelper.cpp

920 lines
26 KiB
C++
Raw Normal View History

2010-10-31 17:32:25 +01:00
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* RDMHelper.cpp
* Various misc RDM functions.
* Copyright (C) 2010 Simon Newton
*
* At some point we may want to localize this file.
*/
#include <sstream>
#include <string>
#include "ola/rdm/RDMHelper.h"
namespace ola {
namespace rdm {
using std::string;
using std::stringstream;
/**
* Convert a uint8_t representing a lamp mode to a human-readable string.
* @param type the lamp mode value
*/
string DataTypeToString(uint8_t type) {
switch (type) {
case DS_NOT_DEFINED:
return "Not defined";
case DS_BIT_FIELD:
return "Bit field";
case DS_ASCII:
return "ASCII";
case DS_UNSIGNED_BYTE:
return "uint8";
case DS_SIGNED_BYTE:
return "int8";
case DS_UNSIGNED_WORD:
return "uint16";
case DS_SIGNED_WORD:
return "int16";
case DS_UNSIGNED_DWORD:
return "uint32 ";
case DS_SIGNED_DWORD:
return "int32 ";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(type);
return str.str();
}
}
/**
* Convert a uint8_t representing a lamp mode to a human-readable string.
* @param lamp_mode the lamp mode value
*/
string LampModeToString(uint8_t lamp_mode) {
switch (lamp_mode) {
case LAMP_ON_MODE_OFF:
return "Off";
case LAMP_ON_MODE_DMX:
return "DMX";
case LAMP_ON_MODE_ON:
return "On";
case LAMP_ON_MODE_AFTER_CAL:
return "On after calibration";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(lamp_mode);
return str.str();
}
}
/**
* Convert a uint8_t representing a lamp mode to a human-readable string.
* @param lamp_state the lamp mode value
*/
string LampStateToString(uint8_t lamp_state) {
switch (lamp_state) {
case LAMP_OFF:
return "Off";
case LAMP_ON:
return "On";
case LAMP_STRIKE:
return "Strike";
case LAMP_STANDBY:
return "Standby";
case LAMP_NOT_PRESENT:
return "Lamp not present";
case LAMP_ERROR:
return "Error";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(lamp_state);
return str.str();
}
}
/**
* Convert a uint16_t representing a nack reason to a human-readable string.
* @param reason the nack reason value
*/
string NackReasonToString(uint16_t reason) {
switch (reason) {
case NR_UNKNOWN_PID:
return "Unknown PID";
case NR_FORMAT_ERROR:
return "Format error";
case NR_HARDWARE_FAULT:
return "Hardware fault";
case NR_PROXY_REJECT:
return "Proxy reject";
case NR_WRITE_PROTECT:
return "Write protect";
case NR_UNSUPPORTED_COMMAND_CLASS:
return "Unsupported command class";
case NR_DATA_OUT_OF_RANGE:
return "Data out of range";
case NR_BUFFER_FULL:
return "Buffer full";
case NR_PACKET_SIZE_UNSUPPORTED:
return "Packet size unsupported";
case NR_SUB_DEVICE_OUT_OF_RANGE:
return "Sub device out of range";
default:
stringstream str;
str << "Unknown, was " << reason;
return str.str();
}
}
/**
* Convert a uint8_t representing a power state to a human-readable string.
* @param power_state the power state value
*/
string PowerStateToString(uint8_t power_state) {
switch (power_state) {
case POWER_STATE_FULL_OFF:
return "Full Off";
case POWER_STATE_SHUTDOWN:
return "Shutdown";
case POWER_STATE_STANDBY:
return "Standby";
case POWER_STATE_NORMAL:
return "Normal";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(power_state);
return str.str();
}
}
/**
* Safely convert a uint8_t to a rdm_power_state
*/
bool UIntToPowerState(uint8_t state, rdm_power_state *power_state) {
switch (state) {
case POWER_STATE_FULL_OFF:
*power_state = POWER_STATE_FULL_OFF;
return true;
case POWER_STATE_SHUTDOWN:
*power_state = POWER_STATE_SHUTDOWN;
return true;
case POWER_STATE_STANDBY:
*power_state = POWER_STATE_STANDBY;
return true;
case POWER_STATE_NORMAL:
*power_state = POWER_STATE_NORMAL;
return true;
default:
return false;
}
}
/**
* Convert a uint8 representing a prefix to a human-readable string.
* @param prefix the prefix value
*/
string PrefixToString(uint8_t prefix) {
switch (prefix) {
case PREFIX_NONE:
return "";
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_TERRA:
return "Terra";
case PREFIX_PETA:
return "Peta";
case PREFIX_EXA:
return "Exa";
case PREFIX_ZETTA:
return "Zetta";
case PREFIX_YOTTA:
return "Yotta";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(prefix);
return str.str();
}
}
/**
* Convert a uint16_t representing a product category to a human-readable
* string.
* @param category the product category value
*/
string ProductCategoryToString(uint16_t category) {
switch (category) {
case PRODUCT_CATEGORY_NOT_DECLARED:
return "Not declared";
case PRODUCT_CATEGORY_FIXTURE:
return "Fixture";
case PRODUCT_CATEGORY_FIXTURE_FIXED:
return "Fixed fixture";
case PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE:
return "Moving yoke fixture";
case PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR:
return "Moving mirror fixture";
case PRODUCT_CATEGORY_FIXTURE_OTHER:
return "Fixture other";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY:
return "Fixture accessory";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR:
return "Fixture accessory color";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE:
return "Fixture accessory yoke";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR:
return "Fixture accessory mirror";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT:
return "Fixture accessory effect";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM:
return "Fixture accessory beam";
case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER:
return "Fixture accessory other";
case PRODUCT_CATEGORY_PROJECTOR:
return "Projector";
case PRODUCT_CATEGORY_PROJECTOR_FIXED:
return "Projector fixed";
case PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE:
return "Projector moving yoke";
case PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR:
return "Projector moving mirror";
case PRODUCT_CATEGORY_PROJECTOR_OTHER:
return "Projector other";
case PRODUCT_CATEGORY_ATMOSPHERIC:
return "Atmospheric";
case PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT:
return "Atmospheric effect";
case PRODUCT_CATEGORY_ATMOSPHERIC_PYRO:
return "Atmospheric pyro";
case PRODUCT_CATEGORY_ATMOSPHERIC_OTHER:
return "Atmospheric other";
case PRODUCT_CATEGORY_DIMMER:
return "Dimmer";
case PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT:
return "Dimmer AC incandescent";
case PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT:
return "Dimmer AC fluorescent";
case PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE:
return "Dimmer AC cold cathode";
case PRODUCT_CATEGORY_DIMMER_AC_NONDIM:
return "Dimmer AC no dim";
case PRODUCT_CATEGORY_DIMMER_AC_ELV:
return "Dimmer AC ELV";
case PRODUCT_CATEGORY_DIMMER_AC_OTHER:
return "Dimmer AC other";
case PRODUCT_CATEGORY_DIMMER_DC_LEVEL:
return "Dimmer DC level";
case PRODUCT_CATEGORY_DIMMER_DC_PWM:
return "Dimmer DC PWM";
case PRODUCT_CATEGORY_DIMMER_CS_LED:
return "Dimmer DC led";
case PRODUCT_CATEGORY_DIMMER_OTHER:
return "Dimmer other";
case PRODUCT_CATEGORY_POWER:
return "Power";
case PRODUCT_CATEGORY_POWER_CONTROL:
return "Power control";
case PRODUCT_CATEGORY_POWER_SOURCE:
return "Power source";
case PRODUCT_CATEGORY_POWER_OTHER:
return "Power other";
case PRODUCT_CATEGORY_SCENIC:
return "Scenic";
case PRODUCT_CATEGORY_SCENIC_DRIVE:
return "Scenic drive";
case PRODUCT_CATEGORY_SCENIC_OTHER:
return "Scenic other";
case PRODUCT_CATEGORY_DATA:
return "Data";
case PRODUCT_CATEGORY_DATA_DISTRIBUTION:
return "Data distribution";
case PRODUCT_CATEGORY_DATA_CONVERSION:
return "Data conversion";
case PRODUCT_CATEGORY_DATA_OTHER:
return "Data other";
case PRODUCT_CATEGORY_AV:
return "A/V";
case PRODUCT_CATEGORY_AV_AUDIO:
return "A/V audio";
case PRODUCT_CATEGORY_AV_VIDEO:
return "A/V video";
case PRODUCT_CATEGORY_AV_OTHER:
return "AV other";
case PRODUCT_CATEGORY_MONITOR:
return "monitor";
case PRODUCT_CATEGORY_MONITOR_ACLINEPOWER:
return "AC line power monitor";
case PRODUCT_CATEGORY_MONITOR_DCPOWER:
return "DC power monitor";
case PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL:
return "Environmental monitor";
case PRODUCT_CATEGORY_MONITOR_OTHER:
return "Other monitor";
case PRODUCT_CATEGORY_CONTROL:
return "Control";
case PRODUCT_CATEGORY_CONTROL_CONTROLLER:
return "Controller";
case PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE:
return "Backup device";
case PRODUCT_CATEGORY_CONTROL_OTHER:
return "Other control";
case PRODUCT_CATEGORY_TEST:
return "Test";
case PRODUCT_CATEGORY_TEST_EQUIPMENT:
return "Test equipment";
case PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER:
return "Test equipment other";
case PRODUCT_CATEGORY_OTHER:
return "Other";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(category);
return str.str();
}
}
/**
* Convert a uint16_t representing a product detail to a human-readable string.
* @param detail the product detail value.
*/
string ProductDetailToString(uint16_t detail) {
switch (detail) {
case PRODUCT_DETAIL_NOT_DECLARED:
return "Not declared";
case PRODUCT_DETAIL_ARC:
return "Arc Lamp";
case PRODUCT_DETAIL_METAL_HALIDE:
return "Metal Halide Lamp";
case PRODUCT_DETAIL_INCANDESCENT:
return "Incandescent Lamp";
case PRODUCT_DETAIL_LED:
return "LED";
case PRODUCT_DETAIL_FLUROESCENT:
return "Fluroescent";
case PRODUCT_DETAIL_COLDCATHODE:
return "Cold Cathode";
case PRODUCT_DETAIL_ELECTROLUMINESCENT:
return "Electro-luminescent";
case PRODUCT_DETAIL_LASER:
return "Lase";
case PRODUCT_DETAIL_FLASHTUBE:
return "Flash Tube";
case PRODUCT_DETAIL_COLORSCROLLER:
return "Color Scroller";
case PRODUCT_DETAIL_COLORWHEEL:
return "Color Wheel";
case PRODUCT_DETAIL_COLORCHANGE:
return "Color Changer (Semaphore or other type)";
case PRODUCT_DETAIL_IRIS_DOUSER:
return "Iris";
case PRODUCT_DETAIL_DIMMING_SHUTTER:
return "Dimming Shuttle";
case PRODUCT_DETAIL_PROFILE_SHUTTER:
return "Profile Shuttle";
case PRODUCT_DETAIL_BARNDOOR_SHUTTER:
return "Barndoor Shuttle";
case PRODUCT_DETAIL_EFFECTS_DISC:
return "Effects Disc";
case PRODUCT_DETAIL_GOBO_ROTATOR:
return "Gobo Rotator";
case PRODUCT_DETAIL_VIDEO:
return "Video";
case PRODUCT_DETAIL_SLIDE:
return "Slide";
case PRODUCT_DETAIL_FILM:
return "Film";
case PRODUCT_DETAIL_OILWHEEL:
return "Oil Wheel";
case PRODUCT_DETAIL_LCDGATE:
return "LCD Gate";
case PRODUCT_DETAIL_FOGGER_GLYCOL:
return "Fogger, Glycol";
case PRODUCT_DETAIL_FOGGER_MINERALOIL:
return "Fogger, Mineral Oil";
case PRODUCT_DETAIL_FOGGER_WATER:
return "Fogger, Water";
case PRODUCT_DETAIL_CO2:
return "Dry Ice/ Carbon Dioxide Device";
case PRODUCT_DETAIL_LN2:
return "Nitrogen based";
case PRODUCT_DETAIL_BUBBLE:
return "Bubble or Foam Machine";
case PRODUCT_DETAIL_FLAME_PROPANE:
return "Propane Flame";
case PRODUCT_DETAIL_FLAME_OTHER:
return "Other Flame";
case PRODUCT_DETAIL_OLEFACTORY_STIMULATOR:
return "Scents";
case PRODUCT_DETAIL_SNOW:
return "Snow Machine";
case PRODUCT_DETAIL_WATER_JET:
return "Water Jet";
case PRODUCT_DETAIL_WIND:
return "Wind Machine";
case PRODUCT_DETAIL_CONFETTI:
return "Confetti Machine";
case PRODUCT_DETAIL_HAZARD:
return "Hazard (Any form of pyrotechnic control or device.)";
case PRODUCT_DETAIL_PHASE_CONTROL:
return "Phase Control";
case PRODUCT_DETAIL_REVERSE_PHASE_CONTROL:
return "Phase Angle";
case PRODUCT_DETAIL_SINE:
return "Sine";
case PRODUCT_DETAIL_PWM:
return "PWM";
case PRODUCT_DETAIL_DC:
return "DC";
case PRODUCT_DETAIL_HFBALLAST:
return "HF Ballast";
case PRODUCT_DETAIL_HFHV_NEONBALLAST:
return "HFHV Neon/Argon";
case PRODUCT_DETAIL_HFHV_EL:
return "HFHV Electroluminscent";
case PRODUCT_DETAIL_MHR_BALLAST:
return "Metal Halide Ballast";
case PRODUCT_DETAIL_BITANGLE_MODULATION:
return "Bit Angle Modulation";
case PRODUCT_DETAIL_FREQUENCY_MODULATION:
return "Frequency Modulation";
case PRODUCT_DETAIL_HIGHFREQUENCY_12V:
return "High Frequency 12V";
case PRODUCT_DETAIL_RELAY_MECHANICAL:
return "Mechanical Relay";
case PRODUCT_DETAIL_RELAY_ELECTRONIC:
return "Electronic Relay";
case PRODUCT_DETAIL_SWITCH_ELECTRONIC:
return "Electronic Switch";
case PRODUCT_DETAIL_CONTACTOR:
return "Contactor";
case PRODUCT_DETAIL_MIRRORBALL_ROTATOR:
return "Mirror Ball Rotator";
case PRODUCT_DETAIL_OTHER_ROTATOR:
return "Other Rotator";
case PRODUCT_DETAIL_KABUKI_DROP:
return "Kabuki Drop";
case PRODUCT_DETAIL_CURTAIN:
return "Curtain";
case PRODUCT_DETAIL_LINESET:
return "Line Set";
case PRODUCT_DETAIL_MOTOR_CONTROL:
return "Motor Control";
case PRODUCT_DETAIL_DAMPER_CONTROL:
return "Damper Control";
case PRODUCT_DETAIL_SPLITTER:
return "Splitter";
case PRODUCT_DETAIL_ETHERNET_NODE:
return "Ethernet Node";
case PRODUCT_DETAIL_MERGE:
return "DMX512 Merger";
case PRODUCT_DETAIL_DATAPATCH:
return "Data Patch";
case PRODUCT_DETAIL_WIRELESS_LINK:
return "Wireless link";
case PRODUCT_DETAIL_PROTOCOL_CONVERTOR:
return "Protocol Convertor";
case PRODUCT_DETAIL_ANALOG_DEMULTIPLEX:
return "DMX512 to DC Voltage";
case PRODUCT_DETAIL_ANALOG_MULTIPLEX:
return "DC Voltage to DMX512";
case PRODUCT_DETAIL_SWITCH_PANEL:
return "Switch Panel";
case PRODUCT_DETAIL_ROUTER:
return "Router";
case PRODUCT_DETAIL_FADER:
return "Fader, Single Channel";
case PRODUCT_DETAIL_MIXER:
return "Mixer, Multi Channel";
case PRODUCT_DETAIL_CHANGEOVER_MANUAL:
return "Manual Changeover";
case PRODUCT_DETAIL_CHANGEOVER_AUTO:
return "Auto Changeover";
case PRODUCT_DETAIL_TEST:
return "Test Device";
case PRODUCT_DETAIL_GFI_RCD:
return "GFI / RCD Device";
case PRODUCT_DETAIL_BATTERY:
return "Battery";
case PRODUCT_DETAIL_CONTROLLABLE_BREAKER:
return "Controllable Breaker";
case PRODUCT_DETAIL_OTHER:
return "Other Device";
default:
stringstream str;
str << "Unknown, was " << detail;
return str.str();
}
}
/**
* Convert a uint8_t representing a sensor type to a human-readable string.
* @param type the sensor type value
*/
string SensorTypeToString(uint8_t type) {
switch (type) {
case SENSOR_TEMPERATURE:
return "Temperature";
case SENSOR_VOLTAGE:
return "Voltage";
case SENSOR_CURRENT:
return "Current";
case SENSOR_FREQUENCY:
return "Frequency";
case SENSOR_RESISTANCE:
return "Resistance";
case SENSOR_POWER:
return "Power";
case SENSOR_MASS:
return "Mass";
case SENSOR_LENGTH:
return "Length";
case SENSOR_AREA:
return "Area";
case SENSOR_VOLUME:
return "Volume";
case SENSOR_DENSITY:
return "Density";
case SENSOR_VELOCITY:
return "Velocity";
case SENSOR_ACCELERATION:
return "Acceleration";
case SENSOR_FORCE:
return "Force";
case SENSOR_ENERGY:
return "Energy";
case SENSOR_PRESSURE:
return "Pressure";
case SENSOR_TIME:
return "Time";
case SENSOR_ANGLE:
return "Angle";
case SENSOR_POSITION_X:
return "Position X";
case SENSOR_POSITION_Y:
return "Position Y";
case SENSOR_POSITION_Z:
return "Position Z";
case SENSOR_ANGULAR_VELOCITY:
return "Angular velocity";
case SENSOR_LUMINOUS_INTENSITY:
return "Luminous intensity";
case SENSOR_LUMINOUS_FLUX:
return "Luminous flux";
case SENSOR_ILLUMINANCE:
return "Illuminance";
case SENSOR_CHROMINANCE_RED:
return "Chrominance red";
case SENSOR_CHROMINANCE_GREEN:
return "Chrominance green";
case SENSOR_CHROMINANCE_BLUE:
return "Chrominance blue";
case SENSOR_CONTACTS:
return "Contacts";
case SENSOR_MEMORY:
return "Memory";
case SENSOR_ITEMS:
return "Items";
case SENSOR_HUMIDITY:
return "Humidity";
case SENSOR_COUNTER_16BIT:
return "16 bith counter";
case SENSOR_OTHER:
return "Other";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(type);
return str.str();
}
}
/**
* Convert a uint16_t representing a slot type to a human-readable string.
* @param slot_type the type of the slot.
* @param slot_label the label for the slot.
*/
string SlotInfoToString(uint8_t slot_type, uint16_t slot_label) {
if (slot_type == ST_PRIMARY) {
switch (slot_label) {
case SD_INTENSITY:
return "Primary, intensity";
case SD_INTENSITY_MASTER:
return "Primary, intensity master";
case SD_PAN:
return "Primary, pan";
case SD_TILT:
return "Primary, tilt";
case SD_COLOR_WHEEL:
return "Primary, color wheel";
case SD_COLOR_SUB_CYAN:
return "Primary, subtractive cyan";
case SD_COLOR_SUB_YELLOW:
return "Primary, subtractive yellow";
case SD_COLOR_SUB_MAGENTA:
return "Primary, subtractive magenta";
case SD_COLOR_ADD_RED:
return "Primary, additive red";
case SD_COLOR_ADD_GREEN:
return "Primary, additive green";
case SD_COLOR_ADD_BLUE:
return "Primary, additive blue";
case SD_COLOR_CORRECTION:
return "Primary, color correction";
case SD_COLOR_SCROLL:
return "Primary, scroll";
case SD_COLOR_SEMAPHORE:
return "Primary, color semaphone";
case SD_STATIC_GOBO_WHEEL:
return "Primary, static gobo wheel";
case SD_ROTO_GOBO_WHEEL:
return "Primary, gobo wheel";
case SD_PRISM_WHEEL:
return "Primary, prism wheel";
case SD_EFFECTS_WHEEL:
return "Primary, effects wheel";
case SD_BEAM_SIZE_IRIS:
return "Primary, iris size";
case SD_EDGE:
return "Primary, edge";
case SD_FROST:
return "Primary, frost";
case SD_STROBE:
return "Primary, strobe";
case SD_ZOOM:
return "Primary, zoom";
case SD_FRAMING_SHUTTER:
return "Primary, framing shutter";
case SD_SHUTTER_ROTATE:
return "Primary, shuttle rotate";
case SD_DOUSER:
return "Primary, douser";
case SD_BARN_DOOR:
return "Primary, barn door";
case SD_LAMP_CONTROL:
return "Primary, lamp control";
case SD_FIXTURE_CONTROL:
return "Primary, fixture control";
case SD_FIXTURE_SPEED:
return "Primary, fixture speed";
case SD_MACRO:
return "Primary, macro";
case SD_UNDEFINED:
return "Primary, undefined";
default:
stringstream str;
str << "Primary unknown, was " << slot_label;
return str.str();
}
} else {
stringstream str;
switch (slot_type) {
case ST_SEC_FINE:
str << "fine control for slot " << slot_label;
break;
case ST_SEC_TIMING:
str << "timing control for slot " << slot_label;
break;
case ST_SEC_SPEED:
str << "speed control for slot " << slot_label;
break;
case ST_SEC_CONTROL:
str << "mode control for slot " << slot_label;
break;
case ST_SEC_INDEX:
str << "index control for slot " << slot_label;
break;
case ST_SEC_ROTATION:
str << "rotation speed control for slot " << slot_label;
break;
case ST_SEC_INDEX_ROTATE:
str << "rotation index control for slot " << slot_label;
break;
case ST_SEC_UNDEFINED:
str << "undefined for slot " << slot_label;
break;
default:
str << "unknown for slot " << slot_label;
}
return str.str();
}
}
/**
* Convert a uint16_t representing a status message to a human-readable string.
* @param message_id the status message value
*/
string StatusMessageIdToString(uint16_t message_id) {
switch (message_id) {
case STS_CAL_FAIL:
return "Failed calibration";
case STS_SENS_NOT_FOUND:
return "sensor not found";
case STS_SENS_ALWAYS_ON:
return "sensor always on";
case STS_LAMP_DOUSED:
return "sensor lamp doused";
case STS_LAMP_STRIKE:
return "sensor lamp failed to strike";
case STS_OVERTEMP:
return "over temp";
case STS_UNDERTEMP:
return "under temp";
case STS_SENS_OUT_RANGE:
return "sensor out of range";
case STS_OVERVOLTAGE_PHASE:
return "phase over voltage";
case STS_UNDERVOLTAGE_PHASE:
return "phase under voltage";
case STS_OVERCURRENT:
return "over current";
case STS_UNDERCURRENT:
return "under current";
case STS_PHASE:
return "out of phase";
case STS_PHASE_ERROR:
return "phase error";
case STS_AMPS:
return "amps";
case STS_VOLTS:
return "volts";
case STS_DIMSLOT_OCCUPIED:
return "no dimmer";
case STS_BREAKER_TRIP:
return "breaker tripped";
case STS_WATTS:
return "watts";
case STS_DIM_FAILURE:
return "dimmer failure";
case STS_DIM_PANIC:
return "dimmer panic mode";
case STS_READY:
return "ready";
case STS_NOT_READY:
return "not ready";
case STS_LOW_FLUID:
return "low fluid";
default:
stringstream str;
str << "Unknown, was " << message_id;
return str.str();
}
}
/**
* Convert a uint8_t representing a status type to a human-readable string.
* @param status_type the status type value
*/
string StatusTypeToString(uint8_t status_type) {
switch (status_type) {
case STATUS_NONE:
return "None";
case STATUS_GET_LAST_MESSAGE:
return "Get last messages";
case STATUS_ADVISORY:
return "Advisory";
case STATUS_WARNING:
return "Warning";
case STATUS_ERROR:
return "Error";
case STATUS_ADVISORY_CLEARED:
return "Advisory cleared";
case STATUS_WARNING_CLEARED:
return "Warning cleared";
case STATUS_ERROR_CLEARED:
return "Error cleared";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(status_type);
return str.str();
}
}
/**
* Convert a uint8_t representing a unit to a human-readable string.
* @param unit the unit value
*/
string UnitToString(uint8_t unit) {
switch (unit) {
case UNITS_NONE:
return "none";
case UNITS_CENTIGRADE:
return "degrees C";
case UNITS_VOLTS_DC:
return "Volts (DC)";
case UNITS_VOLTS_AC_PEAK:
return "Volts (AC Peak)";
case UNITS_VOLTS_AC_RMS:
return "Volts (AC RMS)";
case UNITS_AMPERE_DC:
return "Amps (DC)";
case UNITS_AMPERE_AC_PEAK:
return "Amps (AC Peak)";
case UNITS_AMPERE_AC_RMS:
return "Amps (AC RMS)";
case UNITS_HERTZ:
return "Hz";
case UNITS_OHM:
return "ohms";
case UNITS_WATT:
return "W";
case UNITS_KILOGRAM:
return "kg";
case UNITS_METERS:
return "m";
case UNITS_METERS_SQUARED:
return "m^2";
case UNITS_METERS_CUBED:
return "m^3";
case UNITS_KILOGRAMMES_PER_METER_CUBED:
return "kg/m^3";
case UNITS_METERS_PER_SECOND:
return "m/s";
case UNITS_METERS_PER_SECOND_SQUARED:
return "m/s^2";
case UNITS_NEWTON:
return "newton";
case UNITS_JOULE:
return "joule";
case UNITS_PASCAL:
return "pascal";
case UNITS_SECOND:
return "second";
case UNITS_DEGREE:
return "degree";
case UNITS_STERADIAN:
return "steradian";
case UNITS_CANDELA:
return "candela";
case UNITS_LUMEN:
return "lumen";
case UNITS_LUX:
return "lux";
case UNITS_IRE:
return "ire";
case UNITS_BYTE:
return "bytes";
default:
stringstream str;
str << "Unknown, was " << static_cast<int>(unit);
return str.str();
}
}
} // rdm
} // ola