diff --git a/radio/src/audio.cpp b/radio/src/audio.cpp index c8fbc65bf..f53eaf409 100644 --- a/radio/src/audio.cpp +++ b/radio/src/audio.cpp @@ -637,7 +637,7 @@ int WavContext::mixBuffer(AudioBuffer *buffer, int volume, unsigned int fade) } #endif -const unsigned int toneVolumes[] = { 10, 8, 6, 4, 2 }; +const uint8_t toneVolumes[] = { 10, 8, 6, 4, 2 }; inline float evalVolumeRatio(int freq, int volume) { float result = toneVolumes[2+volume]; diff --git a/radio/src/storage/yaml/yaml_datastructs_funcs.cpp b/radio/src/storage/yaml/yaml_datastructs_funcs.cpp index ea5bc9b6b..33d88b46a 100644 --- a/radio/src/storage/yaml/yaml_datastructs_funcs.cpp +++ b/radio/src/storage/yaml/yaml_datastructs_funcs.cpp @@ -2162,7 +2162,7 @@ static void r_serialMode(void* user, uint8_t* data, uint32_t bitoffs, auto tw = reinterpret_cast(user); auto node = tw->getAttr(); - if (!node || node->tag_len < 4) return; + if (!node || node->tag_len() < 4) return; uint8_t port_nr; if (node->tag[3] == 'S') diff --git a/radio/src/storage/yaml/yaml_node.h b/radio/src/storage/yaml/yaml_node.h index 1eed24cb1..c5a43a7d0 100644 --- a/radio/src/storage/yaml/yaml_node.h +++ b/radio/src/storage/yaml/yaml_node.h @@ -74,18 +74,15 @@ struct YamlNode typedef bool (*cust_write_func)(void* user, uint8_t* data, uint32_t bitoffs, yaml_writer_func wf, void* opaque); - uint8_t type; - uint32_t size; // bits - uint8_t tag_len; + uint16_t size; // bits + uint8_t type:4; + uint16_t elmts:12; // maximum number of array elements const char* tag; union { struct { const YamlNode* child; union { - struct { - is_active_func is_active; - uint16_t elmts; // maximum number of elements - } _a; + is_active_func is_active; select_member_func select_member; } u; } _array; @@ -109,105 +106,108 @@ struct YamlNode cust_write_func write; } _cust_attr; } u; + + uint8_t tag_len() const { return tag ? strlen(tag) : 0; } }; #if !defined(_MSC_VER) + #define YAML_TAG(str) \ - .tag_len=(sizeof(str)-1), .tag=(str) + .tag=(str) #define YAML_IDX \ - { .type=YDT_IDX, .size=0, YAML_TAG("idx") } + { .size=0, .type=YDT_IDX, 0, YAML_TAG("idx") } #define YAML_IDX_CUST(tag, f_read, f_write) \ - { .type=YDT_IDX, .size=0, YAML_TAG(tag), .u={._cust_idx={.read=(f_read), .write=(f_write) }} } + { .size=0, .type=YDT_IDX, 0, YAML_TAG(tag), .u={._cust_idx={.read=(f_read), .write=(f_write) }} } #define YAML_SIGNED(tag, bits) \ - { .type=YDT_SIGNED, .size=(bits), YAML_TAG(tag) } + { .size=(bits), .type=YDT_SIGNED, 0, YAML_TAG(tag) } #define YAML_UNSIGNED(tag, bits) \ - { .type=YDT_UNSIGNED, .size=(bits), YAML_TAG(tag) } + { .size=(bits), .type=YDT_UNSIGNED, 0, YAML_TAG(tag) } #define YAML_SIGNED_CUST(tag, bits, f_cust_to_uint, f_uint_to_cust) \ - { .type=YDT_SIGNED, .size=(bits), YAML_TAG(tag), .u={._cust={ .cust_to_uint=f_cust_to_uint, .uint_to_cust=f_uint_to_cust }} } + { .size=(bits), .type=YDT_SIGNED, 0, YAML_TAG(tag), .u={._cust={ .cust_to_uint=f_cust_to_uint, .uint_to_cust=f_uint_to_cust }} } #define YAML_UNSIGNED_CUST(tag, bits, f_cust_to_uint, f_uint_to_cust) \ - { .type=YDT_UNSIGNED, .size=(bits), YAML_TAG(tag), .u={._cust={ .cust_to_uint=f_cust_to_uint, .uint_to_cust=f_uint_to_cust }} } + { .size=(bits), .type=YDT_UNSIGNED, 0, YAML_TAG(tag), .u={._cust={ .cust_to_uint=f_cust_to_uint, .uint_to_cust=f_uint_to_cust }} } #define YAML_STRING(tag, max_len) \ - { .type=YDT_STRING, .size=((max_len)<<3), YAML_TAG(tag) } + { .size=((max_len)<<3), .type=YDT_STRING, 0, YAML_TAG(tag) } #define YAML_STRUCT(tag, bits, nodes, f_is_active) \ - { .type=YDT_ARRAY, .size=(bits), YAML_TAG(tag), .u={._array={ .child=(nodes), .u={ ._a={.is_active=(f_is_active), .elmts=1 }}}} } + { .size=(bits), .type=YDT_ARRAY, .elmts=1, YAML_TAG(tag), .u={._array={ .child=(nodes), .u={.is_active=(f_is_active)}}} } #define YAML_ARRAY(tag, bits, max_elmts, nodes, f_is_active) \ - { .type=YDT_ARRAY, .size=(bits), YAML_TAG(tag), .u={._array={ .child=(nodes), .u={ ._a={.is_active=(f_is_active), .elmts=(max_elmts) }}}} } + { .size=(bits), .type=YDT_ARRAY, .elmts=(max_elmts), YAML_TAG(tag), .u={._array={ .child=(nodes), .u={.is_active=(f_is_active)}}} } #define YAML_ENUM(tag, bits, id_strs) \ - { .type=YDT_ENUM, .size=(bits), YAML_TAG(tag), .u={._enum={ .choices=(id_strs) }} } + { .size=(bits), .type=YDT_ENUM, 0, YAML_TAG(tag), .u={._enum={ .choices=(id_strs) }} } #define YAML_UNION(tag, bits, nodes, f_sel_m) \ - { .type=YDT_UNION, .size=(bits), YAML_TAG(tag), .u={._array={ .child=(nodes), .u={.select_member=(f_sel_m) }}} } + { .size=(bits), .type=YDT_UNION, 0, YAML_TAG(tag), .u={._array={ .child=(nodes), .u={.select_member=(f_sel_m) }}} } #define YAML_PADDING(bits) \ - { .type=YDT_PADDING, .size=(bits) } + { .size=(bits), .type=YDT_PADDING } #define YAML_CUSTOM(tag, f_read, f_write) \ - { .type=YDT_CUSTOM, .size=0, YAML_TAG(tag), .u={._cust_attr={.read=(f_read), .write=(f_write) }} } + { .size=0, .type=YDT_CUSTOM, 0, YAML_TAG(tag), .u={._cust_attr={.read=(f_read), .write=(f_write) }} } #define YAML_END \ - { .type=YDT_NONE } + { .size=0, .type=YDT_NONE } #define YAML_ROOT(nodes) \ - { .type=YDT_ARRAY, .size=0, .tag_len=0, .tag=NULL, \ + { .size=0, .type=YDT_ARRAY, .elmts=1, .tag=NULL, \ .u={ \ ._array={ .child=(nodes), \ - .u={._a={.is_active=NULL, .elmts=1 }} \ + .u={.is_active=NULL} \ }} \ } #else // MSVC++ compat #define YAML_TAG(str) \ - (sizeof(str)-1), (str) + (str) #define YAML_IDX \ - { YDT_IDX , 0, YAML_TAG("idx") } + { 0, YDT_IDX, 0, YAML_TAG("idx") } #define YAML_SIGNED(tag, bits) \ - { YDT_SIGNED, (bits), YAML_TAG(tag) } + { (bits), YDT_SIGNED, 0, YAML_TAG(tag) } #define YAML_UNSIGNED(tag, bits) \ - { YDT_UNSIGNED, (bits), YAML_TAG(tag) } + { (bits), YDT_UNSIGNED, 0, YAML_TAG(tag) } #define YAML_SIGNED_CUST(tag, bits, f_cust_to_uint, f_uint_to_cust) \ - { YDT_SIGNED, (bits), YAML_TAG(tag), {{ (const YamlNode*)f_cust_to_uint, {{ (YamlNode::is_active_func)f_uint_to_cust, 0 }}}} } + { (bits), YDT_SIGNED, 0, YAML_TAG(tag), {{ (const YamlNode*)f_cust_to_uint, {{ (YamlNode::is_active_func)f_uint_to_cust, 0 }}}} } #define YAML_UNSIGNED_CUST(tag, bits, f_cust_to_uint, f_uint_to_cust) \ - { YDT_UNSIGNED, (bits), YAML_TAG(tag), {{ (const YamlNode*)f_cust_to_uint, {{ (YamlNode::is_active_func)f_uint_to_cust, 0}}}} } + { (bits), YDT_UNSIGNED, 0, YAML_TAG(tag), {{ (const YamlNode*)f_cust_to_uint, {{ (YamlNode::is_active_func)f_uint_to_cust, 0}}}} } #define YAML_STRING(tag, max_len) \ - { YDT_STRING, ((max_len)<<3), YAML_TAG(tag) } + { ((max_len)<<3), YDT_STRING, 0, YAML_TAG(tag) } #define YAML_STRUCT(tag, bits, nodes, f_is_active) \ - { YDT_ARRAY, (bits), YAML_TAG(tag), {{ (nodes), {{ (f_is_active), 1 }}}} } + { (bits), YDT_ARRAY, 1, YAML_TAG(tag), {{ (nodes), {{ (f_is_active) }}}} } #define YAML_ARRAY(tag, bits, max_elmts, nodes, f_is_active) \ - { YDT_ARRAY, (bits), YAML_TAG(tag), {{ (nodes), {{ (f_is_active), (max_elmts) }}}} } + { (bits), YDT_ARRAY, (max_elmts), YAML_TAG(tag), {{ (nodes), {{ (f_is_active) }}}} } #define YAML_ENUM(tag, bits, id_strs) \ - { YDT_ENUM, (bits), YAML_TAG(tag), {{ (const YamlNode*)(id_strs) }} } + { (bits), YDT_ENUM, 0, YAML_TAG(tag), {{ (const YamlNode*)(id_strs) }} } #define YAML_UNION(tag, bits, nodes, f_sel_m) \ - { YDT_UNION, (bits), YAML_TAG(tag), {{ (nodes), {{ (YamlNode::is_active_func)(f_sel_m), 0 }}}} } + { (bits), YDT_UNION, 0, YAML_TAG(tag), {{ (nodes), {{ (YamlNode::is_active_func)(f_sel_m) }}}} } #define YAML_PADDING(bits) \ - { YDT_PADDING, (bits) } + { (bits), YDT_PADDING } #define YAML_END \ - { YDT_NONE } + { 0, YDT_NONE } #define YAML_ROOT(nodes) \ - { YDT_ARRAY, 0, 0, NULL, {{ (nodes), {{ NULL, 1 }}}} } + { 0, YDT_ARRAY, 1, NULL, {{ (nodes), {{ NULL }}}} } #endif diff --git a/radio/src/storage/yaml/yaml_tree_walker.cpp b/radio/src/storage/yaml/yaml_tree_walker.cpp index 235bf68bd..d13c7422b 100644 --- a/radio/src/storage/yaml/yaml_tree_walker.cpp +++ b/radio/src/storage/yaml/yaml_tree_walker.cpp @@ -19,14 +19,14 @@ * GNU General Public License for more details. */ +#include + #include "debug.h" #include "yaml_node.h" #include "yaml_bits.h" #include "yaml_tree_walker.h" #include "yaml_parser.h" -#include - #define MIN(a,b) (a < b ? a : b) static void copy_string(char* dst, uint16_t dst_len, const char* src, @@ -146,7 +146,7 @@ static bool yaml_output_attr(void* user, uint8_t* ptr, uint32_t bit_ofs, if (node->type == YDT_CUSTOM && !node->u._cust_attr.write) return true; // output tag - if (!wf(opaque, node->tag, node->tag_len)) return false; + if (!wf(opaque, node->tag, node->tag_len())) return false; if (!wf(opaque, ": ", 2)) return false; @@ -268,7 +268,7 @@ bool YamlTreeWalker::findNode(const char* tag, uint8_t tag_len) while(attr && attr->type != YDT_NONE) { - if ((tag_len == attr->tag_len) + if ((tag_len == attr->tag_len()) && !strncmp(tag, attr->tag, tag_len)) { return true; // attribute found! } @@ -312,7 +312,7 @@ bool YamlTreeWalker::toChild() bool is_array = false; if (attr->type == YDT_ARRAY - && attr->u._array.u._a.elmts > 1) { + && attr->elmts > 1) { is_array = true; } @@ -333,7 +333,7 @@ bool YamlTreeWalker::toChild() if (!attr) return false; - if ((attr->type == YDT_UNION) && (attr->tag_len == 0)) { + if ((attr->type == YDT_UNION) && (attr->tag_len() == 0)) { toChild(); anon_union++; } @@ -359,7 +359,7 @@ bool YamlTreeWalker::toNextElmt() setElmts(0); } - if (getElmts() < node->u._array.u._a.elmts - 1) { + if (getElmts() < node->elmts - 1) { incElmts(); rewind(); } else { @@ -388,8 +388,8 @@ bool YamlTreeWalker::isElmtEmpty(uint8_t* data) + getLevelOfs(); // assume structs aligned on 8bit boundaries - if (node->u._array.u._a.is_active) - return !node->u._array.u._a.is_active(this, data, bit_ofs); + if (node->u._array.u.is_active) + return !node->u._array.u.is_active(this, data, bit_ofs); return yaml_is_zero(data, bit_ofs, node->size); } @@ -417,7 +417,7 @@ void YamlTreeWalker::toNextAttr() uint32_t attr_bit_ofs = getAttrOfs(); if (attr->type == YDT_ARRAY) - attr_bit_ofs += ((uint32_t)attr->u._array.u._a.elmts * attr->size); + attr_bit_ofs += ((uint32_t)attr->elmts * attr->size); else attr_bit_ofs += attr->size; @@ -428,7 +428,7 @@ void YamlTreeWalker::toNextAttr() // anonymous union handling attr = getAttr(); - if ((attr->type == YDT_UNION) && (attr->tag_len == 0)) { + if ((attr->type == YDT_UNION) && (strlen(attr->tag) == 0)) { toChild(); anon_union++; } @@ -457,7 +457,7 @@ void YamlTreeWalker::setAttrValue(char* buf, uint16_t len) i = yaml_str2uint(buf, len); const YamlNode* node = getNode(); - if (i < node->u._array.u._a.elmts) { + if (i < node->elmts) { setElmts(i); rewind(); } else { diff --git a/radio/src/telemetry/crossfire.cpp b/radio/src/telemetry/crossfire.cpp index 15347a286..c0320a1b4 100644 --- a/radio/src/telemetry/crossfire.cpp +++ b/radio/src/telemetry/crossfire.cpp @@ -23,39 +23,41 @@ #include "opentx.h" +#define CS(id,subId,name,unit,precision) {id,subId,unit,precision,name} + const CrossfireSensor crossfireSensors[] = { - {LINK_ID, 0, STR_SENSOR_RX_RSSI1, UNIT_DB, 0}, - {LINK_ID, 1, STR_SENSOR_RX_RSSI2, UNIT_DB, 0}, - {LINK_ID, 2, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0}, - {LINK_ID, 3, STR_SENSOR_RX_SNR, UNIT_DB, 0}, - {LINK_ID, 4, STR_SENSOR_ANTENNA, UNIT_RAW, 0}, - {LINK_ID, 5, STR_SENSOR_RF_MODE, UNIT_RAW, 0}, - {LINK_ID, 6, STR_SENSOR_TX_POWER, UNIT_MILLIWATTS, 0}, - {LINK_ID, 7, STR_SENSOR_TX_RSSI, UNIT_DB, 0}, - {LINK_ID, 8, STR_SENSOR_TX_QUALITY, UNIT_PERCENT, 0}, - {LINK_ID, 9, STR_SENSOR_TX_SNR, UNIT_DB, 0}, - {LINK_RX_ID, 0, STR_SENSOR_RX_RSSI_PERC, UNIT_PERCENT, 0}, - {LINK_RX_ID, 1, STR_SENSOR_RX_RF_POWER, UNIT_DBM, 0}, - {LINK_TX_ID, 0, STR_SENSOR_TX_RSSI_PERC, UNIT_PERCENT, 0}, - {LINK_TX_ID, 1, STR_SENSOR_TX_POWER, UNIT_DBM, 0}, - {LINK_TX_ID, 2, STR_SENSOR_TX_FPS, UNIT_HERTZ, 0}, - {BATTERY_ID, 0, STR_SENSOR_BATT, UNIT_VOLTS, 1}, - {BATTERY_ID, 1, STR_SENSOR_CURR, UNIT_AMPS, 1}, - {BATTERY_ID, 2, STR_SENSOR_CAPACITY, UNIT_MAH, 0}, - {BATTERY_ID, 3, STR_SENSOR_BATT_PERCENT, UNIT_PERCENT, 0}, - {GPS_ID, 0, STR_SENSOR_GPS, UNIT_GPS_LATITUDE, 0}, - {GPS_ID, 0, STR_SENSOR_GPS, UNIT_GPS_LONGITUDE, 0}, - {GPS_ID, 2, STR_SENSOR_GSPD, UNIT_KMH, 1}, - {GPS_ID, 3, STR_SENSOR_HDG, UNIT_DEGREE, 2}, - {GPS_ID, 4, STR_SENSOR_ALT, UNIT_METERS, 0}, - {GPS_ID, 5, STR_SENSOR_SATELLITES, UNIT_RAW, 0}, - {ATTITUDE_ID, 0, STR_SENSOR_PITCH, UNIT_RADIANS, 3}, - {ATTITUDE_ID, 1, STR_SENSOR_ROLL, UNIT_RADIANS, 3}, - {ATTITUDE_ID, 2, STR_SENSOR_YAW, UNIT_RADIANS, 3}, - {FLIGHT_MODE_ID, 0, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0}, - {CF_VARIO_ID, 0, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2}, - {BARO_ALT_ID, 0, STR_SENSOR_ALT, UNIT_METERS, 2}, - {0, 0, "UNKNOWN", UNIT_RAW, 0}, + CS(LINK_ID, 0, STR_SENSOR_RX_RSSI1, UNIT_DB, 0), + CS(LINK_ID, 1, STR_SENSOR_RX_RSSI2, UNIT_DB, 0), + CS(LINK_ID, 2, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0), + CS(LINK_ID, 3, STR_SENSOR_RX_SNR, UNIT_DB, 0), + CS(LINK_ID, 4, STR_SENSOR_ANTENNA, UNIT_RAW, 0), + CS(LINK_ID, 5, STR_SENSOR_RF_MODE, UNIT_RAW, 0), + CS(LINK_ID, 6, STR_SENSOR_TX_POWER, UNIT_MILLIWATTS, 0), + CS(LINK_ID, 7, STR_SENSOR_TX_RSSI, UNIT_DB, 0), + CS(LINK_ID, 8, STR_SENSOR_TX_QUALITY, UNIT_PERCENT, 0), + CS(LINK_ID, 9, STR_SENSOR_TX_SNR, UNIT_DB, 0), + CS(LINK_RX_ID, 0, STR_SENSOR_RX_RSSI_PERC, UNIT_PERCENT, 0), + CS(LINK_RX_ID, 1, STR_SENSOR_RX_RF_POWER, UNIT_DBM, 0), + CS(LINK_TX_ID, 0, STR_SENSOR_TX_RSSI_PERC, UNIT_PERCENT, 0), + CS(LINK_TX_ID, 1, STR_SENSOR_TX_POWER, UNIT_DBM, 0), + CS(LINK_TX_ID, 2, STR_SENSOR_TX_FPS, UNIT_HERTZ, 0), + CS(BATTERY_ID, 0, STR_SENSOR_BATT, UNIT_VOLTS, 1), + CS(BATTERY_ID, 1, STR_SENSOR_CURR, UNIT_AMPS, 1), + CS(BATTERY_ID, 2, STR_SENSOR_CAPACITY, UNIT_MAH, 0), + CS(BATTERY_ID, 3, STR_SENSOR_BATT_PERCENT, UNIT_PERCENT, 0), + CS(GPS_ID, 0, STR_SENSOR_GPS, UNIT_GPS_LATITUDE, 0), + CS(GPS_ID, 0, STR_SENSOR_GPS, UNIT_GPS_LONGITUDE, 0), + CS(GPS_ID, 2, STR_SENSOR_GSPD, UNIT_KMH, 1), + CS(GPS_ID, 3, STR_SENSOR_HDG, UNIT_DEGREE, 2), + CS(GPS_ID, 4, STR_SENSOR_ALT, UNIT_METERS, 0), + CS(GPS_ID, 5, STR_SENSOR_SATELLITES, UNIT_RAW, 0), + CS(ATTITUDE_ID, 0, STR_SENSOR_PITCH, UNIT_RADIANS, 3), + CS(ATTITUDE_ID, 1, STR_SENSOR_ROLL, UNIT_RADIANS, 3), + CS(ATTITUDE_ID, 2, STR_SENSOR_YAW, UNIT_RADIANS, 3), + CS(FLIGHT_MODE_ID, 0, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0), + CS(CF_VARIO_ID, 0, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2), + CS(BARO_ALT_ID, 0, STR_SENSOR_ALT, UNIT_METERS, 2), + CS(0, 0, "UNKNOWN", UNIT_RAW, 0), }; const CrossfireSensor & getCrossfireSensor(uint8_t id, uint8_t subId) diff --git a/radio/src/telemetry/crossfire.h b/radio/src/telemetry/crossfire.h index 957ffb767..77e4d8889 100644 --- a/radio/src/telemetry/crossfire.h +++ b/radio/src/telemetry/crossfire.h @@ -54,9 +54,9 @@ struct CrossfireSensor { const uint8_t id; const uint8_t subId; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; enum CrossfireSensorIndexes { diff --git a/radio/src/telemetry/flysky_ibus.cpp b/radio/src/telemetry/flysky_ibus.cpp index de03fa88d..296562ac8 100644 --- a/radio/src/telemetry/flysky_ibus.cpp +++ b/radio/src/telemetry/flysky_ibus.cpp @@ -37,9 +37,9 @@ struct FlySkySensor { const uint16_t type; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; // telemetry sensors type @@ -144,59 +144,60 @@ enum AFHDS2A_ID_END = 0xFF, }; +#define FS(type,name,unit,precision) {type,unit,precision,name} const FlySkySensor flySkySensors[] = { // flysky start - { SENSOR_TYPE_RX_VOL, STR_SENSOR_A1, UNIT_VOLTS, 2 }, // RX Voltage (remapped, really 0x0) - { SENSOR_TYPE_TEMPERATURE, STR_SENSOR_TEMP1, UNIT_CELSIUS, 1 }, // Temperature - { SENSOR_TYPE_MOT, STR_SENSOR_RPM, UNIT_RAW, 0 }, // RPM - { SENSOR_TYPE_EXT_VOL, STR_SENSOR_A3, UNIT_VOLTS, 2 }, // External voltage - { SENSOR_TYPE_BVD, "BVD", UNIT_VOLTS, 2 }, // BVD - { SENSOR_TYPE_GYROSCOPE_1_AXIS, STR_SENSOR_CELLS, UNIT_DEGREE, 1 }, // - { SENSOR_TYPE_PRES, STR_SENSOR_PRES, UNIT_RAW, 2 }, // 4 bytes In fact Temperature + Pressure -> Altitude - { SENSOR_TYPE_ALT, STR_SENSOR_ALT, UNIT_METERS, 2 }, - { SENSOR_TYPE_RF_MODULE_TEMP, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 }, // 1 bytes temperature - { SENSOR_TYPE_RF_MODULE_VOL, STR_SENSOR_TXV, UNIT_VOLTS, 2 }, // 2 bytes voltage - { SENSOR_TYPE_RF_MODULE_POWER, STR_SENSOR_TX_POWER, UNIT_DBM, 0 }, // 2 bytes DBM -// { SENSOR_TYPE_RF_MODULE_RAW, STR_SENSOR_TX_POWER, UNIT_RAW, 0 }, // 2 bytes DBM - { SENSOR_TYPE_TX_V, STR_SENSOR_TXV, UNIT_VOLTS, 2 }, // TX Voltage - { SENSOR_TYPE_RX_SNR, STR_SENSOR_RX_SNR, UNIT_DB, 0 }, // RX SNR - { SENSOR_TYPE_RX_NOISE, STR_SENSOR_RX_NOISE, UNIT_DBM, 0 }, // RX Noise - { SENSOR_TYPE_RX_RSSI, STR_SENSOR_RSSI, UNIT_DBM, 0 }, // RX RSSI (0xfc) - { SENSOR_TYPE_RX_ERR_RATE, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0 }, // RX error rate + FS( SENSOR_TYPE_RX_VOL, STR_SENSOR_A1, UNIT_VOLTS, 2 ), // RX Voltage (remapped, really 0x0) + FS( SENSOR_TYPE_TEMPERATURE, STR_SENSOR_TEMP1, UNIT_CELSIUS, 1 ), // Temperature + FS( SENSOR_TYPE_MOT, STR_SENSOR_RPM, UNIT_RAW, 0 ), // RPM + FS( SENSOR_TYPE_EXT_VOL, STR_SENSOR_A3, UNIT_VOLTS, 2 ), // External voltage + FS( SENSOR_TYPE_BVD, "BVD", UNIT_VOLTS, 2 ), // BVD + FS( SENSOR_TYPE_GYROSCOPE_1_AXIS, STR_SENSOR_CELLS, UNIT_DEGREE, 1 ), // + FS( SENSOR_TYPE_PRES, STR_SENSOR_PRES, UNIT_RAW, 2 ), // 4 bytes In fact Temperature + Pressure -> Altitude + FS( SENSOR_TYPE_ALT, STR_SENSOR_ALT, UNIT_METERS, 2 ), + FS( SENSOR_TYPE_RF_MODULE_TEMP, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 ), // 1 bytes temperature + FS( SENSOR_TYPE_RF_MODULE_VOL, STR_SENSOR_TXV, UNIT_VOLTS, 2 ), // 2 bytes voltage + FS( SENSOR_TYPE_RF_MODULE_POWER, STR_SENSOR_TX_POWER, UNIT_DBM, 0 ), // 2 bytes DBM +// FS( SENSOR_TYPE_RF_MODULE_RAW, STR_SENSOR_TX_POWER, UNIT_RAW, 0 ), // 2 bytes DBM + FS( SENSOR_TYPE_TX_V, STR_SENSOR_TXV, UNIT_VOLTS, 2 ), // TX Voltage + FS( SENSOR_TYPE_RX_SNR, STR_SENSOR_RX_SNR, UNIT_DB, 0 ), // RX SNR + FS( SENSOR_TYPE_RX_NOISE, STR_SENSOR_RX_NOISE, UNIT_DBM, 0 ), // RX Noise + FS( SENSOR_TYPE_RX_RSSI, STR_SENSOR_RSSI, UNIT_DBM, 0 ), // RX RSSI (0xfc) + FS( SENSOR_TYPE_RX_ERR_RATE, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0 ), // RX error rate //////////////////////////////////////////////////////////////// - { AFHDS2A_ID_BAT_CURR, STR_SENSOR_CURR, UNIT_AMPS, 2 }, // battery current A * 100 - { AFHDS2A_ID_FUEL, STR_SENSOR_CAPACITY, UNIT_RAW, 0 }, // remaining battery percentage / mah drawn otherwise or fuel level no unit! - { AFHDS2A_ID_RPM, STR_SENSOR_RPM, UNIT_RAW, 0 }, // throttle value / battery capacity - { AFHDS2A_ID_CMP_HEAD, STR_SENSOR_HDG, UNIT_DEGREE, 0 }, // Heading 0..360 deg, 0=north 2bytes - { AFHDS2A_ID_CLIMB_RATE, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 - { AFHDS2A_ID_COG, STR_SENSOR_HDG, UNIT_DEGREE, 2 }, // 2 bytes Course over ground(NOT heading, but direction of movement) in degrees * 100, 0.0..359.99 degrees. unknown max uint - { AFHDS2A_ID_GPS_STATUS, STR_SENSOR_SATELLITES, UNIT_RAW, 0 }, // 2 bytes - { AFHDS2A_ID_ACC_X, STR_SENSOR_ACCX, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 signed - { AFHDS2A_ID_ACC_Y, STR_SENSOR_ACCY, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 signed - { AFHDS2A_ID_ACC_Z, STR_SENSOR_ACCZ, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 signed - { AFHDS2A_ID_ROLL, STR_SENSOR_ROLL, UNIT_DEGREE, 2 }, // 2 bytes deg *100 signed - { AFHDS2A_ID_PITCH, STR_SENSOR_PITCH, UNIT_DEGREE, 2 }, // 2 bytes deg *100 signed - { AFHDS2A_ID_YAW, STR_SENSOR_YAW, UNIT_DEGREE, 2 }, // 2 bytes deg *100 signed - { AFHDS2A_ID_VERTICAL_SPEED, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 - { AFHDS2A_ID_GROUND_SPEED, STR_SENSOR_GSPD, UNIT_METERS_PER_SECOND, 2 }, // 2 bytes m/s *100 different unit than build-in sensor - { AFHDS2A_ID_GPS_DIST, STR_SENSOR_DIST, UNIT_METERS, 0 }, // 2 bytes dist from home m unsigned - { AFHDS2A_ID_ARMED, STR_SENSOR_ARM, UNIT_RAW, 0 }, // 2 bytes - { AFHDS2A_ID_FLIGHT_MODE, STR_SENSOR_FLIGHT_MODE, UNIT_RAW, 0 }, // 2 bytes index - { SENSOR_TYPE_PRES | 0x100, STR_SENSOR_TEMP2, UNIT_CELSIUS, 1 }, // 2 bytes Temperature - { AFHDS2A_ID_ODO1, STR_SENSOR_ODO1, UNIT_METERS, 2 }, // 2 bytes Odometer1 -- some magic with 330 needed - { AFHDS2A_ID_ODO2, STR_SENSOR_ODO2, UNIT_METERS, 2 }, // 2 bytes Odometer2 -- some magic with 330 needed - { AFHDS2A_ID_SPE, STR_SENSOR_ASPD, UNIT_KMH, 2 }, // 2 bytes Speed km/h -- some magic with 330 needed - { AFHDS2A_ID_GPS_LAT, STR_SENSOR_GPS, UNIT_RAW, 0 }, // 4 bytes signed WGS84 in degrees * 1E7 - { AFHDS2A_ID_GPS_LON, STR_SENSOR_GPS, UNIT_RAW, 0 }, // 4 bytes signed WGS84 in degrees * 1E7 - { AFHDS2A_ID_GPS_ALT, STR_SENSOR_GPSALT, UNIT_METERS, 2 }, // 4 bytes signed GPS alt m*100 - { AFHDS2A_ID_ALT, STR_SENSOR_ALT, UNIT_METERS, 2 }, // 4 bytes signed Alt m*100 - { AFHDS2A_ID_RX_SIG_AFHDS3, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0 }, // RX error rate - { AFHDS2A_ID_RX_SNR_AFHDS3, STR_SENSOR_RX_SNR, UNIT_DB, 1 }, // RX SNR - { AFHDS2A_ID_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_DBM, 0 }, // Pseudo sensor for TRSSI + FS( AFHDS2A_ID_BAT_CURR, STR_SENSOR_CURR, UNIT_AMPS, 2 ), // battery current A * 100 + FS( AFHDS2A_ID_FUEL, STR_SENSOR_CAPACITY, UNIT_RAW, 0 ), // remaining battery percentage / mah drawn otherwise or fuel level no unit! + FS( AFHDS2A_ID_RPM, STR_SENSOR_RPM, UNIT_RAW, 0 ), // throttle value / battery capacity + FS( AFHDS2A_ID_CMP_HEAD, STR_SENSOR_HDG, UNIT_DEGREE, 0 ), // Heading 0..360 deg, 0=north 2bytes + FS( AFHDS2A_ID_CLIMB_RATE, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 + FS( AFHDS2A_ID_COG, STR_SENSOR_HDG, UNIT_DEGREE, 2 ), // 2 bytes Course over ground(NOT heading, but direction of movement) in degrees * 100, 0.0..359.99 degrees. unknown max uint + FS( AFHDS2A_ID_GPS_STATUS, STR_SENSOR_SATELLITES, UNIT_RAW, 0 ), // 2 bytes + FS( AFHDS2A_ID_ACC_X, STR_SENSOR_ACCX, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 signed + FS( AFHDS2A_ID_ACC_Y, STR_SENSOR_ACCY, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 signed + FS( AFHDS2A_ID_ACC_Z, STR_SENSOR_ACCZ, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 signed + FS( AFHDS2A_ID_ROLL, STR_SENSOR_ROLL, UNIT_DEGREE, 2 ), // 2 bytes deg *100 signed + FS( AFHDS2A_ID_PITCH, STR_SENSOR_PITCH, UNIT_DEGREE, 2 ), // 2 bytes deg *100 signed + FS( AFHDS2A_ID_YAW, STR_SENSOR_YAW, UNIT_DEGREE, 2 ), // 2 bytes deg *100 signed + FS( AFHDS2A_ID_VERTICAL_SPEED, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 + FS( AFHDS2A_ID_GROUND_SPEED, STR_SENSOR_GSPD, UNIT_METERS_PER_SECOND, 2 ), // 2 bytes m/s *100 different unit than build-in sensor + FS( AFHDS2A_ID_GPS_DIST, STR_SENSOR_DIST, UNIT_METERS, 0 ), // 2 bytes dist from home m unsigned + FS( AFHDS2A_ID_ARMED, STR_SENSOR_ARM, UNIT_RAW, 0 ), // 2 bytes + FS( AFHDS2A_ID_FLIGHT_MODE, STR_SENSOR_FLIGHT_MODE, UNIT_RAW, 0 ), // 2 bytes index + FS( SENSOR_TYPE_PRES | 0x100, STR_SENSOR_TEMP2, UNIT_CELSIUS, 1 ), // 2 bytes Temperature + FS( AFHDS2A_ID_ODO1, STR_SENSOR_ODO1, UNIT_METERS, 2 ), // 2 bytes Odometer1 -- some magic with 330 needed + FS( AFHDS2A_ID_ODO2, STR_SENSOR_ODO2, UNIT_METERS, 2 ), // 2 bytes Odometer2 -- some magic with 330 needed + FS( AFHDS2A_ID_SPE, STR_SENSOR_ASPD, UNIT_KMH, 2 ), // 2 bytes Speed km/h -- some magic with 330 needed + FS( AFHDS2A_ID_GPS_LAT, STR_SENSOR_GPS, UNIT_RAW, 0 ), // 4 bytes signed WGS84 in degrees * 1E7 + FS( AFHDS2A_ID_GPS_LON, STR_SENSOR_GPS, UNIT_RAW, 0 ), // 4 bytes signed WGS84 in degrees * 1E7 + FS( AFHDS2A_ID_GPS_ALT, STR_SENSOR_GPSALT, UNIT_METERS, 2 ), // 4 bytes signed GPS alt m*100 + FS( AFHDS2A_ID_ALT, STR_SENSOR_ALT, UNIT_METERS, 2 ), // 4 bytes signed Alt m*100 + FS( AFHDS2A_ID_RX_SIG_AFHDS3, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0 ), // RX error rate + FS( AFHDS2A_ID_RX_SNR_AFHDS3, STR_SENSOR_RX_SNR, UNIT_DB, 1 ), // RX SNR + FS( AFHDS2A_ID_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_DBM, 0 ), // Pseudo sensor for TRSSI - { 0x00, NULL, UNIT_RAW, 0 }, // sentinel + FS( 0x00, NULL, UNIT_RAW, 0 ), // sentinel }; int32_t getALT(uint32_t value); diff --git a/radio/src/telemetry/frsky_d.cpp b/radio/src/telemetry/frsky_d.cpp index 35cbd5fd7..59cf1e590 100644 --- a/radio/src/telemetry/frsky_d.cpp +++ b/radio/src/telemetry/frsky_d.cpp @@ -101,34 +101,36 @@ void frskyDProcessPacket(uint8_t module, const uint8_t *packet, uint8_t len) struct FrSkyDSensor { const uint8_t id; - const char * name; const TelemetryUnit unit; const uint8_t prec; + const char * name; }; +#define FS(id,name,unit,prec) {id,unit,prec,name} + const FrSkyDSensor frskyDSensors[] = { - { D_RSSI_ID, STR_SENSOR_RSSI, UNIT_RAW, 0 }, - { D_A1_ID, STR_SENSOR_A1, UNIT_VOLTS, 1 }, - { D_A2_ID, STR_SENSOR_A2, UNIT_VOLTS, 1 }, - { RPM_ID, STR_SENSOR_RPM, UNIT_RPMS, 0 }, - { FUEL_ID, STR_SENSOR_FUEL, UNIT_PERCENT, 0 }, - { TEMP1_ID, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0 }, - { TEMP2_ID, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 }, - { CURRENT_ID, STR_SENSOR_CURR, UNIT_AMPS, 1 }, - { ACCEL_X_ID, STR_SENSOR_ACCX, UNIT_G, 3 }, - { ACCEL_Y_ID, STR_SENSOR_ACCY, UNIT_G, 3 }, - { ACCEL_Z_ID, STR_SENSOR_ACCZ, UNIT_G, 3 }, - { VARIO_ID, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 }, - { VFAS_ID, STR_SENSOR_VFAS, UNIT_VOLTS, 2 }, - { BARO_ALT_AP_ID, STR_SENSOR_ALT, UNIT_METERS, 1 }, // we map hi precision vario into PREC1! - { VOLTS_AP_ID, STR_SENSOR_VFAS, UNIT_VOLTS, 2 }, - { GPS_SPEED_BP_ID, STR_SENSOR_GSPD, UNIT_KTS, 0 }, - { GPS_COURS_BP_ID, STR_SENSOR_HDG, UNIT_DEGREE, 0 }, - { VOLTS_ID, STR_SENSOR_CELLS, UNIT_CELLS, 2 }, - { GPS_ALT_BP_ID, STR_SENSOR_GPSALT, UNIT_METERS, 0 }, - { GPS_HOUR_MIN_ID, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 0 }, - { GPS_LAT_AP_ID, STR_SENSOR_GPS, UNIT_GPS, 0 }, - { 0, NULL, UNIT_RAW, 0 } // sentinel + FS( D_RSSI_ID, STR_SENSOR_RSSI, UNIT_RAW, 0 ), + FS( D_A1_ID, STR_SENSOR_A1, UNIT_VOLTS, 1 ), + FS( D_A2_ID, STR_SENSOR_A2, UNIT_VOLTS, 1 ), + FS( RPM_ID, STR_SENSOR_RPM, UNIT_RPMS, 0 ), + FS( FUEL_ID, STR_SENSOR_FUEL, UNIT_PERCENT, 0 ), + FS( TEMP1_ID, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0 ), + FS( TEMP2_ID, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 ), + FS( CURRENT_ID, STR_SENSOR_CURR, UNIT_AMPS, 1 ), + FS( ACCEL_X_ID, STR_SENSOR_ACCX, UNIT_G, 3 ), + FS( ACCEL_Y_ID, STR_SENSOR_ACCY, UNIT_G, 3 ), + FS( ACCEL_Z_ID, STR_SENSOR_ACCZ, UNIT_G, 3 ), + FS( VARIO_ID, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 ), + FS( VFAS_ID, STR_SENSOR_VFAS, UNIT_VOLTS, 2 ), + FS( BARO_ALT_AP_ID, STR_SENSOR_ALT, UNIT_METERS, 1 ), // we map hi precision vario into PREC1! + FS( VOLTS_AP_ID, STR_SENSOR_VFAS, UNIT_VOLTS, 2 ), + FS( GPS_SPEED_BP_ID, STR_SENSOR_GSPD, UNIT_KTS, 0 ), + FS( GPS_COURS_BP_ID, STR_SENSOR_HDG, UNIT_DEGREE, 0 ), + FS( VOLTS_ID, STR_SENSOR_CELLS, UNIT_CELLS, 2 ), + FS( GPS_ALT_BP_ID, STR_SENSOR_GPSALT, UNIT_METERS, 0 ), + FS( GPS_HOUR_MIN_ID, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 0 ), + FS( GPS_LAT_AP_ID, STR_SENSOR_GPS, UNIT_GPS, 0 ), + FS( 0, NULL, UNIT_RAW, 0 ) // sentinel }; const FrSkyDSensor * getFrSkyDSensor(uint8_t id) diff --git a/radio/src/telemetry/frsky_sport.cpp b/radio/src/telemetry/frsky_sport.cpp index df5ee5e61..a5bcdb353 100644 --- a/radio/src/telemetry/frsky_sport.cpp +++ b/radio/src/telemetry/frsky_sport.cpp @@ -23,89 +23,91 @@ struct FrSkySportSensor { const uint16_t firstId; - const uint16_t lastId; - const uint8_t subId; + const uint8_t idCnt:6; + const uint8_t subId:2; + const uint8_t prec:2; + const TelemetryUnit unit:6; const char * name; - const TelemetryUnit unit; - const uint8_t prec; }; +#define FS(firstId,lastId,subId,name,unit,prec) {firstId,lastId-firstId,subId,prec,unit,name} + const FrSkySportSensor sportSensors[] = { - { VALID_FRAME_RATE_ID, VALID_FRAME_RATE_ID, 0, STR_SENSOR_VFR, UNIT_PERCENT, 0 }, - { RSSI_ID, RSSI_ID, 0, STR_SENSOR_RSSI, UNIT_DB, 0 }, + FS( VALID_FRAME_RATE_ID, VALID_FRAME_RATE_ID, 0, STR_SENSOR_VFR, UNIT_PERCENT, 0 ), + FS( RSSI_ID, RSSI_ID, 0, STR_SENSOR_RSSI, UNIT_DB, 0 ), #if defined(MULTIMODULE) - { TX_RSSI_ID, TX_RSSI_ID, 0, STR_SENSOR_TX_RSSI , UNIT_DB , 0 }, - { TX_LQI_ID , TX_LQI_ID, 0, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0 }, + FS( TX_RSSI_ID, TX_RSSI_ID, 0, STR_SENSOR_TX_RSSI , UNIT_DB , 0 ), + FS( TX_LQI_ID , TX_LQI_ID, 0, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0 ), #endif - { ADC1_ID, ADC1_ID, 0, STR_SENSOR_A1, UNIT_VOLTS, 1 }, - { ADC2_ID, ADC2_ID, 0, STR_SENSOR_A2, UNIT_VOLTS, 1 }, - { A3_FIRST_ID, A3_LAST_ID, 0, STR_SENSOR_A3, UNIT_VOLTS, 2 }, - { A4_FIRST_ID, A4_LAST_ID, 0, STR_SENSOR_A4, UNIT_VOLTS, 2 }, - { BATT_ID, BATT_ID, 0, STR_SENSOR_BATT, UNIT_VOLTS, 1 }, - { R9_PWR_ID, R9_PWR_ID, 0, STR_SENSOR_R9PW, UNIT_MILLIWATTS, 0 }, - { T1_FIRST_ID, T1_LAST_ID, 0, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0 }, - { T2_FIRST_ID, T2_LAST_ID, 0, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 }, - { RPM_FIRST_ID, RPM_LAST_ID, 0, STR_SENSOR_RPM, UNIT_RPMS, 0 }, - { FUEL_FIRST_ID, FUEL_LAST_ID, 0, STR_SENSOR_FUEL, UNIT_PERCENT, 0 }, - { ALT_FIRST_ID, ALT_LAST_ID, 0, STR_SENSOR_ALT, UNIT_METERS, 2 }, - { VARIO_FIRST_ID, VARIO_LAST_ID, 0, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 }, - { ACCX_FIRST_ID, ACCX_LAST_ID, 0, STR_SENSOR_ACCX, UNIT_G, 3 }, - { ACCY_FIRST_ID, ACCY_LAST_ID, 0, STR_SENSOR_ACCY, UNIT_G, 3 }, - { ACCZ_FIRST_ID, ACCZ_LAST_ID, 0, STR_SENSOR_ACCZ, UNIT_G, 3 }, - { CURR_FIRST_ID, CURR_LAST_ID, 0, STR_SENSOR_CURR, UNIT_AMPS, 1 }, - { VFAS_FIRST_ID, VFAS_LAST_ID, 0, STR_SENSOR_VFAS, UNIT_VOLTS, 2 }, - { AIR_SPEED_FIRST_ID, AIR_SPEED_LAST_ID, 0, STR_SENSOR_ASPD, UNIT_KTS, 1 }, - { GPS_SPEED_FIRST_ID, GPS_SPEED_LAST_ID, 0, STR_SENSOR_GSPD, UNIT_KTS, 3 }, - { CELLS_FIRST_ID, CELLS_LAST_ID, 0, STR_SENSOR_CELLS, UNIT_CELLS, 2 }, - { GPS_ALT_FIRST_ID, GPS_ALT_LAST_ID, 0, STR_SENSOR_GPSALT, UNIT_METERS, 2 }, - { GPS_TIME_DATE_FIRST_ID, GPS_TIME_DATE_LAST_ID, 0, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 0 }, - { GPS_LONG_LATI_FIRST_ID, GPS_LONG_LATI_LAST_ID, 0, STR_SENSOR_GPS, UNIT_GPS, 0 }, - { FUEL_QTY_FIRST_ID, FUEL_QTY_LAST_ID, 0, STR_SENSOR_FUEL, UNIT_MILLILITERS, 2 }, - { GPS_COURS_FIRST_ID, GPS_COURS_LAST_ID, 0, STR_SENSOR_HDG, UNIT_DEGREE, 2 }, - { RBOX_BATT1_FIRST_ID, RBOX_BATT1_LAST_ID, 0, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 3 }, - { RBOX_BATT2_FIRST_ID, RBOX_BATT2_LAST_ID, 0, STR_SENSOR_BATT2_VOLTAGE, UNIT_VOLTS, 3 }, - { RBOX_BATT1_FIRST_ID, RBOX_BATT1_LAST_ID, 1, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2 }, - { RBOX_BATT2_FIRST_ID, RBOX_BATT2_LAST_ID, 1, STR_SENSOR_BATT2_CURRENT, UNIT_AMPS, 2 }, - { RBOX_CNSP_FIRST_ID, RBOX_CNSP_LAST_ID, 0, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0 }, - { RBOX_CNSP_FIRST_ID, RBOX_CNSP_LAST_ID, 1, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0 }, - { RBOX_STATE_FIRST_ID, RBOX_STATE_LAST_ID, 0, STR_SENSOR_CHANS_STATE, UNIT_TEXT, 0 }, - { RBOX_STATE_FIRST_ID, RBOX_STATE_LAST_ID, 1, STR_SENSOR_RB_STATE, UNIT_TEXT, 0 }, - { SD1_FIRST_ID, SD1_LAST_ID, 0, STR_SENSOR_SD1_CHANNEL, UNIT_RAW, 0 }, - { ESC_POWER_FIRST_ID, ESC_POWER_LAST_ID, 0, STR_SENSOR_ESC_VOLTAGE, UNIT_VOLTS, 2 }, - { ESC_POWER_FIRST_ID, ESC_POWER_LAST_ID, 1, STR_SENSOR_ESC_CURRENT, UNIT_AMPS, 2 }, - { ESC_RPM_CONS_FIRST_ID, ESC_RPM_CONS_LAST_ID, 0, STR_SENSOR_ESC_RPM, UNIT_RPMS, 0 }, - { ESC_RPM_CONS_FIRST_ID, ESC_RPM_CONS_LAST_ID, 1, STR_SENSOR_ESC_CONSUMPTION, UNIT_MAH, 0 }, - { ESC_TEMPERATURE_FIRST_ID, ESC_TEMPERATURE_LAST_ID, 0, STR_SENSOR_ESC_TEMP, UNIT_CELSIUS, 0 }, - { GASSUIT_TEMP1_FIRST_ID, GASSUIT_TEMP1_LAST_ID, 0, STR_SENSOR_GASSUIT_TEMP1, UNIT_CELSIUS, 0 }, - { GASSUIT_TEMP2_FIRST_ID, GASSUIT_TEMP2_LAST_ID, 0, STR_SENSOR_GASSUIT_TEMP2, UNIT_CELSIUS, 0 }, - { GASSUIT_SPEED_FIRST_ID, GASSUIT_SPEED_LAST_ID, 0, STR_SENSOR_GASSUIT_RPM, UNIT_RPMS, 0 }, - { GASSUIT_RES_VOL_FIRST_ID, GASSUIT_RES_VOL_LAST_ID, 0, STR_SENSOR_GASSUIT_RES_VOL, UNIT_MILLILITERS, 0 }, - { GASSUIT_RES_PERC_FIRST_ID, GASSUIT_RES_PERC_LAST_ID, 0, STR_SENSOR_GASSUIT_RES_PERC, UNIT_PERCENT, 0 }, - { GASSUIT_FLOW_FIRST_ID, GASSUIT_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 }, - { GASSUIT_MAX_FLOW_FIRST_ID, GASSUIT_MAX_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_MAX_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 }, - { GASSUIT_AVG_FLOW_FIRST_ID, GASSUIT_AVG_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_AVG_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 }, - { SBEC_POWER_FIRST_ID, SBEC_POWER_LAST_ID, 0, STR_SENSOR_SBEC_VOLTAGE, UNIT_VOLTS, 2 }, - { SBEC_POWER_FIRST_ID, SBEC_POWER_LAST_ID, 1, STR_SENSOR_SBEC_CURRENT, UNIT_AMPS, 2 }, - { RB3040_OUTPUT_FIRST_ID, RB3040_OUTPUT_LAST_ID, 0, STR_SENSOR_RB3040_EXTRA_STATE, UNIT_TEXT, 0 }, - { RB3040_CH1_2_FIRST_ID, RB3040_CH1_2_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL1, UNIT_AMPS, 2 }, - { RB3040_CH1_2_FIRST_ID, RB3040_CH1_2_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL2, UNIT_AMPS, 2 }, - { RB3040_CH3_4_FIRST_ID, RB3040_CH3_4_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL3, UNIT_AMPS, 2 }, - { RB3040_CH3_4_FIRST_ID, RB3040_CH3_4_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL4, UNIT_AMPS, 2 }, - { RB3040_CH5_6_FIRST_ID, RB3040_CH5_6_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL5, UNIT_AMPS, 2 }, - { RB3040_CH5_6_FIRST_ID, RB3040_CH5_6_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL6, UNIT_AMPS, 2 }, - { RB3040_CH7_8_FIRST_ID, RB3040_CH7_8_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL7, UNIT_AMPS, 2 }, - { RB3040_CH7_8_FIRST_ID, RB3040_CH7_8_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL8, UNIT_AMPS, 2 }, - { SERVO_FIRST_ID, SERVO_LAST_ID, 0, STR_SENSOR_SERVO_CURRENT, UNIT_AMPS, 1 }, - { SERVO_FIRST_ID, SERVO_LAST_ID, 1, STR_SENSOR_SERVO_VOLTAGE, UNIT_VOLTS, 1 }, - { SERVO_FIRST_ID, SERVO_LAST_ID, 2, STR_SENSOR_SERVO_TEMPERATURE, UNIT_CELSIUS, 0 }, - { SERVO_FIRST_ID, SERVO_LAST_ID, 3, STR_SENSOR_SERVO_STATUS, UNIT_TEXT, 0 }, - { 0, 0, 0, nullptr, UNIT_RAW, 0 } // sentinel + FS( ADC1_ID, ADC1_ID, 0, STR_SENSOR_A1, UNIT_VOLTS, 1 ), + FS( ADC2_ID, ADC2_ID, 0, STR_SENSOR_A2, UNIT_VOLTS, 1 ), + FS( A3_FIRST_ID, A3_LAST_ID, 0, STR_SENSOR_A3, UNIT_VOLTS, 2 ), + FS( A4_FIRST_ID, A4_LAST_ID, 0, STR_SENSOR_A4, UNIT_VOLTS, 2 ), + FS( BATT_ID, BATT_ID, 0, STR_SENSOR_BATT, UNIT_VOLTS, 1 ), + FS( R9_PWR_ID, R9_PWR_ID, 0, STR_SENSOR_R9PW, UNIT_MILLIWATTS, 0 ), + FS( T1_FIRST_ID, T1_LAST_ID, 0, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0 ), + FS( T2_FIRST_ID, T2_LAST_ID, 0, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0 ), + FS( RPM_FIRST_ID, RPM_LAST_ID, 0, STR_SENSOR_RPM, UNIT_RPMS, 0 ), + FS( FUEL_FIRST_ID, FUEL_LAST_ID, 0, STR_SENSOR_FUEL, UNIT_PERCENT, 0 ), + FS( ALT_FIRST_ID, ALT_LAST_ID, 0, STR_SENSOR_ALT, UNIT_METERS, 2 ), + FS( VARIO_FIRST_ID, VARIO_LAST_ID, 0, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 2 ), + FS( ACCX_FIRST_ID, ACCX_LAST_ID, 0, STR_SENSOR_ACCX, UNIT_G, 3 ), + FS( ACCY_FIRST_ID, ACCY_LAST_ID, 0, STR_SENSOR_ACCY, UNIT_G, 3 ), + FS( ACCZ_FIRST_ID, ACCZ_LAST_ID, 0, STR_SENSOR_ACCZ, UNIT_G, 3 ), + FS( CURR_FIRST_ID, CURR_LAST_ID, 0, STR_SENSOR_CURR, UNIT_AMPS, 1 ), + FS( VFAS_FIRST_ID, VFAS_LAST_ID, 0, STR_SENSOR_VFAS, UNIT_VOLTS, 2 ), + FS( AIR_SPEED_FIRST_ID, AIR_SPEED_LAST_ID, 0, STR_SENSOR_ASPD, UNIT_KTS, 1 ), + FS( GPS_SPEED_FIRST_ID, GPS_SPEED_LAST_ID, 0, STR_SENSOR_GSPD, UNIT_KTS, 3 ), + FS( CELLS_FIRST_ID, CELLS_LAST_ID, 0, STR_SENSOR_CELLS, UNIT_CELLS, 2 ), + FS( GPS_ALT_FIRST_ID, GPS_ALT_LAST_ID, 0, STR_SENSOR_GPSALT, UNIT_METERS, 2 ), + FS( GPS_TIME_DATE_FIRST_ID, GPS_TIME_DATE_LAST_ID, 0, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 0 ), + FS( GPS_LONG_LATI_FIRST_ID, GPS_LONG_LATI_LAST_ID, 0, STR_SENSOR_GPS, UNIT_GPS, 0 ), + FS( FUEL_QTY_FIRST_ID, FUEL_QTY_LAST_ID, 0, STR_SENSOR_FUEL, UNIT_MILLILITERS, 2 ), + FS( GPS_COURS_FIRST_ID, GPS_COURS_LAST_ID, 0, STR_SENSOR_HDG, UNIT_DEGREE, 2 ), + FS( RBOX_BATT1_FIRST_ID, RBOX_BATT1_LAST_ID, 0, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 3 ), + FS( RBOX_BATT2_FIRST_ID, RBOX_BATT2_LAST_ID, 0, STR_SENSOR_BATT2_VOLTAGE, UNIT_VOLTS, 3 ), + FS( RBOX_BATT1_FIRST_ID, RBOX_BATT1_LAST_ID, 1, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2 ), + FS( RBOX_BATT2_FIRST_ID, RBOX_BATT2_LAST_ID, 1, STR_SENSOR_BATT2_CURRENT, UNIT_AMPS, 2 ), + FS( RBOX_CNSP_FIRST_ID, RBOX_CNSP_LAST_ID, 0, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0 ), + FS( RBOX_CNSP_FIRST_ID, RBOX_CNSP_LAST_ID, 1, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0 ), + FS( RBOX_STATE_FIRST_ID, RBOX_STATE_LAST_ID, 0, STR_SENSOR_CHANS_STATE, UNIT_TEXT, 0 ), + FS( RBOX_STATE_FIRST_ID, RBOX_STATE_LAST_ID, 1, STR_SENSOR_RB_STATE, UNIT_TEXT, 0 ), + FS( SD1_FIRST_ID, SD1_LAST_ID, 0, STR_SENSOR_SD1_CHANNEL, UNIT_RAW, 0 ), + FS( ESC_POWER_FIRST_ID, ESC_POWER_LAST_ID, 0, STR_SENSOR_ESC_VOLTAGE, UNIT_VOLTS, 2 ), + FS( ESC_POWER_FIRST_ID, ESC_POWER_LAST_ID, 1, STR_SENSOR_ESC_CURRENT, UNIT_AMPS, 2 ), + FS( ESC_RPM_CONS_FIRST_ID, ESC_RPM_CONS_LAST_ID, 0, STR_SENSOR_ESC_RPM, UNIT_RPMS, 0 ), + FS( ESC_RPM_CONS_FIRST_ID, ESC_RPM_CONS_LAST_ID, 1, STR_SENSOR_ESC_CONSUMPTION, UNIT_MAH, 0 ), + FS( ESC_TEMPERATURE_FIRST_ID, ESC_TEMPERATURE_LAST_ID, 0, STR_SENSOR_ESC_TEMP, UNIT_CELSIUS, 0 ), + FS( GASSUIT_TEMP1_FIRST_ID, GASSUIT_TEMP1_LAST_ID, 0, STR_SENSOR_GASSUIT_TEMP1, UNIT_CELSIUS, 0 ), + FS( GASSUIT_TEMP2_FIRST_ID, GASSUIT_TEMP2_LAST_ID, 0, STR_SENSOR_GASSUIT_TEMP2, UNIT_CELSIUS, 0 ), + FS( GASSUIT_SPEED_FIRST_ID, GASSUIT_SPEED_LAST_ID, 0, STR_SENSOR_GASSUIT_RPM, UNIT_RPMS, 0 ), + FS( GASSUIT_RES_VOL_FIRST_ID, GASSUIT_RES_VOL_LAST_ID, 0, STR_SENSOR_GASSUIT_RES_VOL, UNIT_MILLILITERS, 0 ), + FS( GASSUIT_RES_PERC_FIRST_ID, GASSUIT_RES_PERC_LAST_ID, 0, STR_SENSOR_GASSUIT_RES_PERC, UNIT_PERCENT, 0 ), + FS( GASSUIT_FLOW_FIRST_ID, GASSUIT_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 ), + FS( GASSUIT_MAX_FLOW_FIRST_ID, GASSUIT_MAX_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_MAX_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 ), + FS( GASSUIT_AVG_FLOW_FIRST_ID, GASSUIT_AVG_FLOW_LAST_ID, 0, STR_SENSOR_GASSUIT_AVG_FLOW, UNIT_MILLILITERS_PER_MINUTE, 0 ), + FS( SBEC_POWER_FIRST_ID, SBEC_POWER_LAST_ID, 0, STR_SENSOR_SBEC_VOLTAGE, UNIT_VOLTS, 2 ), + FS( SBEC_POWER_FIRST_ID, SBEC_POWER_LAST_ID, 1, STR_SENSOR_SBEC_CURRENT, UNIT_AMPS, 2 ), + FS( RB3040_OUTPUT_FIRST_ID, RB3040_OUTPUT_LAST_ID, 0, STR_SENSOR_RB3040_EXTRA_STATE, UNIT_TEXT, 0 ), + FS( RB3040_CH1_2_FIRST_ID, RB3040_CH1_2_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL1, UNIT_AMPS, 2 ), + FS( RB3040_CH1_2_FIRST_ID, RB3040_CH1_2_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL2, UNIT_AMPS, 2 ), + FS( RB3040_CH3_4_FIRST_ID, RB3040_CH3_4_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL3, UNIT_AMPS, 2 ), + FS( RB3040_CH3_4_FIRST_ID, RB3040_CH3_4_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL4, UNIT_AMPS, 2 ), + FS( RB3040_CH5_6_FIRST_ID, RB3040_CH5_6_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL5, UNIT_AMPS, 2 ), + FS( RB3040_CH5_6_FIRST_ID, RB3040_CH5_6_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL6, UNIT_AMPS, 2 ), + FS( RB3040_CH7_8_FIRST_ID, RB3040_CH7_8_LAST_ID, 0, STR_SENSOR_RB3040_CHANNEL7, UNIT_AMPS, 2 ), + FS( RB3040_CH7_8_FIRST_ID, RB3040_CH7_8_LAST_ID, 1, STR_SENSOR_RB3040_CHANNEL8, UNIT_AMPS, 2 ), + FS( SERVO_FIRST_ID, SERVO_LAST_ID, 0, STR_SENSOR_SERVO_CURRENT, UNIT_AMPS, 1 ), + FS( SERVO_FIRST_ID, SERVO_LAST_ID, 1, STR_SENSOR_SERVO_VOLTAGE, UNIT_VOLTS, 1 ), + FS( SERVO_FIRST_ID, SERVO_LAST_ID, 2, STR_SENSOR_SERVO_TEMPERATURE, UNIT_CELSIUS, 0 ), + FS( SERVO_FIRST_ID, SERVO_LAST_ID, 3, STR_SENSOR_SERVO_STATUS, UNIT_TEXT, 0 ), + FS( 0, 0, 0, nullptr, UNIT_RAW, 0 ) // sentinel }; const FrSkySportSensor * getFrSkySportSensor(uint16_t id, uint8_t subId=0) { for (const FrSkySportSensor * sensor = sportSensors; sensor->firstId; sensor++) { - if (id >= sensor->firstId && id <= sensor->lastId && subId == sensor->subId) { + if (id >= sensor->firstId && id <= (sensor->firstId + sensor->idCnt) && subId == sensor->subId) { return sensor; } } diff --git a/radio/src/telemetry/ghost.cpp b/radio/src/telemetry/ghost.cpp index dd09a8e96..f9f6c6781 100755 --- a/radio/src/telemetry/ghost.cpp +++ b/radio/src/telemetry/ghost.cpp @@ -30,11 +30,13 @@ const char *ghstVtxBandName[GHST_VTX_BAND_COUNT] = { "- - -" , "IRC", "Race", "B struct GhostSensor { const uint16_t id; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; +#define GS(id,name,unit,precision) {id,unit,precision,name} + // telemetry sensors ID enum { @@ -63,32 +65,32 @@ enum }; const GhostSensor ghostSensors[] = { - {GHOST_ID_RX_RSSI, STR_SENSOR_RSSI, UNIT_DB, 0}, - {GHOST_ID_RX_LQ, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0}, - {GHOST_ID_RX_SNR, STR_SENSOR_RX_SNR, UNIT_DB, 0}, + GS(GHOST_ID_RX_RSSI, STR_SENSOR_RSSI, UNIT_DB, 0), + GS(GHOST_ID_RX_LQ, STR_SENSOR_RX_QUALITY, UNIT_PERCENT, 0), + GS(GHOST_ID_RX_SNR, STR_SENSOR_RX_SNR, UNIT_DB, 0), - {GHOST_ID_FRAME_RATE, STR_SENSOR_FRAME_RATE, UNIT_RAW, 0}, - {GHOST_ID_TX_POWER, STR_SENSOR_TX_POWER, UNIT_MILLIWATTS, 0}, - {GHOST_ID_RF_MODE, STR_SENSOR_RF_MODE, UNIT_TEXT, 0}, - {GHOST_ID_TOTAL_LATENCY, STR_SENSOR_TOTAL_LATENCY, UNIT_RAW, 0}, + GS(GHOST_ID_FRAME_RATE, STR_SENSOR_FRAME_RATE, UNIT_RAW, 0), + GS(GHOST_ID_TX_POWER, STR_SENSOR_TX_POWER, UNIT_MILLIWATTS, 0), + GS(GHOST_ID_RF_MODE, STR_SENSOR_RF_MODE, UNIT_TEXT, 0), + GS(GHOST_ID_TOTAL_LATENCY, STR_SENSOR_TOTAL_LATENCY, UNIT_RAW, 0), - {GHOST_ID_VTX_FREQ, STR_SENSOR_VTX_FREQ, UNIT_RAW, 0}, - {GHOST_ID_VTX_POWER, STR_SENSOR_VTX_PWR, UNIT_RAW, 0}, - {GHOST_ID_VTX_CHAN, STR_SENSOR_VTX_CHAN, UNIT_RAW, 0}, - {GHOST_ID_VTX_BAND, STR_SENSOR_VTX_BAND, UNIT_TEXT, 0}, + GS(GHOST_ID_VTX_FREQ, STR_SENSOR_VTX_FREQ, UNIT_RAW, 0), + GS(GHOST_ID_VTX_POWER, STR_SENSOR_VTX_PWR, UNIT_RAW, 0), + GS(GHOST_ID_VTX_CHAN, STR_SENSOR_VTX_CHAN, UNIT_RAW, 0), + GS(GHOST_ID_VTX_BAND, STR_SENSOR_VTX_BAND, UNIT_TEXT, 0), - {GHOST_ID_PACK_VOLTS, STR_SENSOR_BATT, UNIT_VOLTS, 2}, - {GHOST_ID_PACK_AMPS, STR_SENSOR_CURR, UNIT_AMPS, 2}, - {GHOST_ID_PACK_MAH, STR_SENSOR_CAPACITY, UNIT_MAH, 0}, + GS(GHOST_ID_PACK_VOLTS, STR_SENSOR_BATT, UNIT_VOLTS, 2), + GS(GHOST_ID_PACK_AMPS, STR_SENSOR_CURR, UNIT_AMPS, 2), + GS(GHOST_ID_PACK_MAH, STR_SENSOR_CAPACITY, UNIT_MAH, 0), - {GHOST_ID_GPS_LAT, STR_GPS, UNIT_GPS_LATITUDE, 0}, - {GHOST_ID_GPS_LONG, STR_GPS, UNIT_GPS_LONGITUDE, 0}, - {GHOST_ID_GPS_GSPD, STR_SENSOR_GSPD, UNIT_KMH, 1}, - {GHOST_ID_GPS_HDG, STR_SENSOR_HDG, UNIT_DEGREE, 3}, - {GHOST_ID_GPS_ALT, STR_SENSOR_GPSALT, UNIT_METERS, 0}, - {GHOST_ID_GPS_SATS, STR_SENSOR_SATELLITES, UNIT_RAW, 0}, + GS(GHOST_ID_GPS_LAT, STR_GPS, UNIT_GPS_LATITUDE, 0), + GS(GHOST_ID_GPS_LONG, STR_GPS, UNIT_GPS_LONGITUDE, 0), + GS(GHOST_ID_GPS_GSPD, STR_SENSOR_GSPD, UNIT_KMH, 1), + GS(GHOST_ID_GPS_HDG, STR_SENSOR_HDG, UNIT_DEGREE, 3), + GS(GHOST_ID_GPS_ALT, STR_SENSOR_GPSALT, UNIT_METERS, 0), + GS(GHOST_ID_GPS_SATS, STR_SENSOR_SATELLITES, UNIT_RAW, 0), - {0x00, NULL, UNIT_RAW, 0}, + GS(0x00, NULL, UNIT_RAW, 0), }; const GhostSensor *getGhostSensor(uint8_t id) diff --git a/radio/src/telemetry/hitec.cpp b/radio/src/telemetry/hitec.cpp index a52522fd6..1331da6fe 100644 --- a/radio/src/telemetry/hitec.cpp +++ b/radio/src/telemetry/hitec.cpp @@ -104,9 +104,9 @@ data byte 3 -> Alti2L Altitude filtered struct HitecSensor { const uint16_t id; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; // telemetry frames @@ -160,48 +160,50 @@ enum HITEC_ID_TX_LQI = 0xFF01, // Pseudo id outside 1 byte range of Hitec sensors }; +#define HS(id,name,unit,precision) {id,unit,precision,name} + const HitecSensor hitecSensors[] = { //frame 00 - {HITEC_ID_RX_VOLTAGE, STR_SENSOR_BATT, UNIT_VOLTS, 2}, // RX_Batt Voltage + HS(HITEC_ID_RX_VOLTAGE, STR_SENSOR_BATT, UNIT_VOLTS, 2), // RX_Batt Voltage //frame 11 //frame 12 - {HITEC_ID_GPS_LAT_LONG, STR_SENSOR_GPS, UNIT_GPS, 0}, // GPS position + HS(HITEC_ID_GPS_LAT_LONG, STR_SENSOR_GPS, UNIT_GPS, 0), // GPS position //frame 13 - {HITEC_ID_TEMP2, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0}, // Temperature sensor 2 + HS(HITEC_ID_TEMP2, STR_SENSOR_TEMP2, UNIT_CELSIUS, 0), // Temperature sensor 2 //frame 14 - {HITEC_ID_GPS_SPEED, STR_SENSOR_GSPD, UNIT_KMH, 0}, // GPS speed - {HITEC_ID_GPS_ALTITUDE, STR_SENSOR_GPSALT, UNIT_METERS, 0}, // GPS altitude sea level - {HITEC_ID_TEMP1, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0}, // Temperature sensor 1 + HS(HITEC_ID_GPS_SPEED, STR_SENSOR_GSPD, UNIT_KMH, 0), // GPS speed + HS(HITEC_ID_GPS_ALTITUDE, STR_SENSOR_GPSALT, UNIT_METERS, 0), // GPS altitude sea level + HS(HITEC_ID_TEMP1, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0), // Temperature sensor 1 //frame 15 - {HITEC_ID_FUEL, STR_SENSOR_FUEL, UNIT_PERCENT, 0}, // Fuel - {HITEC_ID_RPM1, STR_SENSOR_RPM, UNIT_RPMS, 0}, // RPM1 - {HITEC_ID_RPM2, STR_SENSOR_RPM2, UNIT_RPMS, 0}, // RPM2 + HS(HITEC_ID_FUEL, STR_SENSOR_FUEL, UNIT_PERCENT, 0), // Fuel + HS(HITEC_ID_RPM1, STR_SENSOR_RPM, UNIT_RPMS, 0), // RPM1 + HS(HITEC_ID_RPM2, STR_SENSOR_RPM2, UNIT_RPMS, 0), // RPM2 //frame 16 - {HITEC_ID_GPS_DATETIME, STR_SENSOR_GPS, UNIT_DATETIME, 0}, // GPS date time + HS(HITEC_ID_GPS_DATETIME, STR_SENSOR_GPS, UNIT_DATETIME, 0), // GPS date time //frame 17 - {HITEC_ID_GPS_HEADING, STR_SENSOR_HDG, UNIT_DEGREE, 0}, // GPS Heading - {HITEC_ID_GPS_COUNT, STR_SENSOR_SATELLITES, UNIT_RAW, 0}, // GPS count - {HITEC_ID_TEMP3, STR_SENSOR_TEMP3, UNIT_CELSIUS, 0}, // Temperature sensor 3 - {HITEC_ID_TEMP4, STR_SENSOR_TEMP4, UNIT_CELSIUS, 0}, // Temperature sensor 4 + HS(HITEC_ID_GPS_HEADING, STR_SENSOR_HDG, UNIT_DEGREE, 0), // GPS Heading + HS(HITEC_ID_GPS_COUNT, STR_SENSOR_SATELLITES, UNIT_RAW, 0), // GPS count + HS(HITEC_ID_TEMP3, STR_SENSOR_TEMP3, UNIT_CELSIUS, 0), // Temperature sensor 3 + HS(HITEC_ID_TEMP4, STR_SENSOR_TEMP4, UNIT_CELSIUS, 0), // Temperature sensor 4 //frame 18 - {HITEC_ID_VOLTAGE, STR_SENSOR_A1, UNIT_VOLTS, 1}, // Voltage sensor - {HITEC_ID_AMP, STR_SENSOR_CURR, UNIT_AMPS, 0}, // Amp sensor - {HITEC_ID_C50, STR_SENSOR_C50, UNIT_AMPS, 1}, // Amp sensor C50 - {HITEC_ID_C200, STR_SENSOR_C200, UNIT_AMPS, 0}, // Amp sensor C200 + HS(HITEC_ID_VOLTAGE, STR_SENSOR_A1, UNIT_VOLTS, 1), // Voltage sensor + HS(HITEC_ID_AMP, STR_SENSOR_CURR, UNIT_AMPS, 0), // Amp sensor + HS(HITEC_ID_C50, STR_SENSOR_C50, UNIT_AMPS, 1), // Amp sensor C50 + HS(HITEC_ID_C200, STR_SENSOR_C200, UNIT_AMPS, 0), // Amp sensor C200 //frame 19 - {HITEC_ID_AMP_S1, STR_SENSOR_CURR_SERVO1, UNIT_AMPS, 1}, // Amp sensor - {HITEC_ID_AMP_S2, STR_SENSOR_CURR_SERVO2, UNIT_AMPS, 1}, // Amp sensor - {HITEC_ID_AMP_S3, STR_SENSOR_CURR_SERVO3, UNIT_AMPS, 1}, // Amp sensor - {HITEC_ID_AMP_S4, STR_SENSOR_CURR_SERVO4, UNIT_AMPS, 1}, // Amp sensor + HS(HITEC_ID_AMP_S1, STR_SENSOR_CURR_SERVO1, UNIT_AMPS, 1), // Amp sensor + HS(HITEC_ID_AMP_S2, STR_SENSOR_CURR_SERVO2, UNIT_AMPS, 1), // Amp sensor + HS(HITEC_ID_AMP_S3, STR_SENSOR_CURR_SERVO3, UNIT_AMPS, 1), // Amp sensor + HS(HITEC_ID_AMP_S4, STR_SENSOR_CURR_SERVO4, UNIT_AMPS, 1), // Amp sensor //frame 1A - {HITEC_ID_AIR_SPEED, STR_SENSOR_ASPD, UNIT_KMH, 0}, // Air speed + HS(HITEC_ID_AIR_SPEED, STR_SENSOR_ASPD, UNIT_KMH, 0), // Air speed //frame 1B - {HITEC_ID_VARIO, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1}, // Vario - {HITEC_ID_ALT, STR_SENSOR_ALT, UNIT_METERS, 1}, // Altitude + HS(HITEC_ID_VARIO, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1), // Vario + HS(HITEC_ID_ALT, STR_SENSOR_ALT, UNIT_METERS, 1), // Altitude - {HITEC_ID_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_RAW, 0}, // Pseudo id outside 1 byte range of Hitec sensors - {HITEC_ID_TX_LQI, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0}, // Pseudo id outside 1 byte range of Hitec sensors// Pseudo sensor for TLQI - {0x00, NULL, UNIT_RAW, 0}, // sentinel + HS(HITEC_ID_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_RAW, 0), // Pseudo id outside 1 byte range of Hitec sensors + HS(HITEC_ID_TX_LQI, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0), // Pseudo id outside 1 byte range of Hitec sensors// Pseudo sensor for TLQI + HS(0x00, NULL, UNIT_RAW, 0), // sentinel }; const HitecSensor * getHitecSensor(uint16_t id) diff --git a/radio/src/telemetry/hott.cpp b/radio/src/telemetry/hott.cpp index 1c0ab8785..f37ed4fc9 100644 --- a/radio/src/telemetry/hott.cpp +++ b/radio/src/telemetry/hott.cpp @@ -212,83 +212,85 @@ enum TelemetrySensorID struct HottSensor { const uint16_t id; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; +#define HS(id,name,unit,precision) {id,unit,precision,name} + const HottSensor hottSensors[] = { // TX - { HOTT_ID_TX_RSSI_DL, STR_SENSOR_HOTT_ID_TX_RSSI_DL, UNIT_DB, 0}, // downlink signal strength (rx --> tx as seen by tx) - { HOTT_ID_TX_LQI_DL, STR_SENSOR_HOTT_ID_TX_LQI_DL, UNIT_RAW, 0}, // downlink signal quality (rx --> tx s seen by tx) + HS( HOTT_ID_TX_RSSI_DL, STR_SENSOR_HOTT_ID_TX_RSSI_DL, UNIT_DB, 0), // downlink signal strength (rx --> tx as seen by tx) + HS( HOTT_ID_TX_LQI_DL, STR_SENSOR_HOTT_ID_TX_LQI_DL, UNIT_RAW, 0), // downlink signal quality (rx --> tx s seen by tx) // RX - { HOTT_ID_RX_RSSI_UL, STR_SENSOR_HOTT_ID_RX_RSSI_UL, UNIT_DB, 0 }, // uplink signal strength (tx --> rx as seen by rx) - { HOTT_ID_RX_LQI_UL, STR_SENSOR_HOTT_ID_RX_LQI_UL, UNIT_RAW, 0 }, // uplink signal quality (tx --> rx as seen by rx) - { HOTT_ID_RX_VLT, STR_SENSOR_HOTT_ID_RX_VLT, UNIT_VOLTS, 1 }, // RX battery voltage - { HOTT_ID_RX_TMP, STR_SENSOR_HOTT_ID_RX_TMP, UNIT_CELSIUS, 0 }, // RX temperature - { HOTT_ID_RX_BAT_MIN, STR_SENSOR_HOTT_ID_RX_BAT_MIN, UNIT_VOLTS, 1 }, // RX lowest rx voltage - { HOTT_ID_RX_VPCK, STR_SENSOR_HOTT_ID_RX_VPCK, UNIT_MS, 0 }, // RX VPack - { HOTT_ID_RX_EVENT, STR_SENSOR_HOTT_ID_RX_EVENT, UNIT_RAW, 0 }, // RX event and other devices warnings + HS( HOTT_ID_RX_RSSI_UL, STR_SENSOR_HOTT_ID_RX_RSSI_UL, UNIT_DB, 0 ), // uplink signal strength (tx --> rx as seen by rx) + HS( HOTT_ID_RX_LQI_UL, STR_SENSOR_HOTT_ID_RX_LQI_UL, UNIT_RAW, 0 ), // uplink signal quality (tx --> rx as seen by rx) + HS( HOTT_ID_RX_VLT, STR_SENSOR_HOTT_ID_RX_VLT, UNIT_VOLTS, 1 ), // RX battery voltage + HS( HOTT_ID_RX_TMP, STR_SENSOR_HOTT_ID_RX_TMP, UNIT_CELSIUS, 0 ), // RX temperature + HS( HOTT_ID_RX_BAT_MIN, STR_SENSOR_HOTT_ID_RX_BAT_MIN, UNIT_VOLTS, 1 ), // RX lowest rx voltage + HS( HOTT_ID_RX_VPCK, STR_SENSOR_HOTT_ID_RX_VPCK, UNIT_MS, 0 ), // RX VPack + HS( HOTT_ID_RX_EVENT, STR_SENSOR_HOTT_ID_RX_EVENT, UNIT_RAW, 0 ), // RX event and other devices warnings // Vario - { HOTT_ID_VARIO_ALT, STR_SENSOR_HOTT_ID_VARIO_ALT, UNIT_METERS, 0 }, // Vario altitude - { HOTT_ID_VARIO_VV, STR_SENSOR_HOTT_ID_VARIO_VV, UNIT_METERS_PER_SECOND, 2 }, // Vario vertical velocity - { HOTT_ID_VARIO_HDG, STR_SENSOR_HOTT_ID_VARIO_HDG, UNIT_DEGREE, 0 }, // Vario heading + HS( HOTT_ID_VARIO_ALT, STR_SENSOR_HOTT_ID_VARIO_ALT, UNIT_METERS, 0 ), // Vario altitude + HS( HOTT_ID_VARIO_VV, STR_SENSOR_HOTT_ID_VARIO_VV, UNIT_METERS_PER_SECOND, 2 ), // Vario vertical velocity + HS( HOTT_ID_VARIO_HDG, STR_SENSOR_HOTT_ID_VARIO_HDG, UNIT_DEGREE, 0 ), // Vario heading // GPS - { HOTT_ID_GPS_HDG, STR_SENSOR_HOTT_ID_GPS_HDG, UNIT_DEGREE, 0 }, // GPS heading - { HOTT_ID_GPS_SPEED, STR_SENSOR_HOTT_ID_GPS_SPEED, UNIT_KMH, 0 } , // GPS ground speed - { HOTT_ID_GPS_LL, STR_SENSOR_HOTT_ID_GPS_LL, UNIT_GPS, 0 }, // GPS lat/long - { HOTT_ID_GPS_DST, STR_SENSOR_HOTT_ID_GPS_DST, UNIT_METERS, 0 }, // GPS distance - { HOTT_ID_GPS_ALT, STR_SENSOR_HOTT_ID_GPS_ALT, UNIT_METERS, 0 }, // GPS altitude - { HOTT_ID_GPS_VV, STR_SENSOR_HOTT_ID_GPS_VV, UNIT_METERS_PER_SECOND, 2}, // GPS vertical velocity - { HOTT_ID_GPS_NSATS, STR_SENSOR_HOTT_ID_GPS_NSATS, UNIT_RAW, 0 }, // GPS number of satellites + HS( HOTT_ID_GPS_HDG, STR_SENSOR_HOTT_ID_GPS_HDG, UNIT_DEGREE, 0 ), // GPS heading + HS( HOTT_ID_GPS_SPEED, STR_SENSOR_HOTT_ID_GPS_SPEED, UNIT_KMH, 0 ) , // GPS ground speed + HS( HOTT_ID_GPS_LL, STR_SENSOR_HOTT_ID_GPS_LL, UNIT_GPS, 0 ), // GPS lat/long + HS( HOTT_ID_GPS_DST, STR_SENSOR_HOTT_ID_GPS_DST, UNIT_METERS, 0 ), // GPS distance + HS( HOTT_ID_GPS_ALT, STR_SENSOR_HOTT_ID_GPS_ALT, UNIT_METERS, 0 ), // GPS altitude + HS( HOTT_ID_GPS_VV, STR_SENSOR_HOTT_ID_GPS_VV, UNIT_METERS_PER_SECOND, 2), // GPS vertical velocity + HS( HOTT_ID_GPS_NSATS, STR_SENSOR_HOTT_ID_GPS_NSATS, UNIT_RAW, 0 ), // GPS number of satellites // ESC - { HOTT_ID_ESC_VLT, STR_SENSOR_HOTT_ID_ESC_VLT, UNIT_VOLTS, 1 }, // ESC battery voltage - { HOTT_ID_ESC_CAP, STR_SENSOR_HOTT_ID_ESC_CAP, UNIT_MAH, 0 }, // ESC battery capacity consumed - { HOTT_ID_ESC_TMP, STR_SENSOR_HOTT_ID_ESC_TMP, UNIT_CELSIUS, 0 }, // ESC temperature - { HOTT_ID_ESC_CUR, STR_SENSOR_HOTT_ID_ESC_CUR, UNIT_AMPS, 1 }, // ESC current - { HOTT_ID_ESC_RPM, STR_SENSOR_HOTT_ID_ESC_RPM, UNIT_RPMS, 0 }, // ESC motor rpm - { HOTT_ID_ESC_BEC_VLT, STR_SENSOR_HOTT_ID_ESC_BEC_VLT, UNIT_VOLTS, 1 }, // ESC BEC voltage - { HOTT_ID_ESC_BEC_CUR, STR_SENSOR_HOTT_ID_ESC_BEC_CUR, UNIT_AMPS, 1 }, // ESC BEC current - { HOTT_ID_ESC_BEC_TMP, STR_SENSOR_HOTT_ID_ESC_BEC_TMP, UNIT_CELSIUS, 0 }, // BEC BEC temperature - { HOTT_ID_ESC_MOT_TMP, STR_SENSOR_HOTT_ID_ESC_MOT_TMP, UNIT_CELSIUS, 0 }, // ESC motor or external temperature + HS( HOTT_ID_ESC_VLT, STR_SENSOR_HOTT_ID_ESC_VLT, UNIT_VOLTS, 1 ), // ESC battery voltage + HS( HOTT_ID_ESC_CAP, STR_SENSOR_HOTT_ID_ESC_CAP, UNIT_MAH, 0 ), // ESC battery capacity consumed + HS( HOTT_ID_ESC_TMP, STR_SENSOR_HOTT_ID_ESC_TMP, UNIT_CELSIUS, 0 ), // ESC temperature + HS( HOTT_ID_ESC_CUR, STR_SENSOR_HOTT_ID_ESC_CUR, UNIT_AMPS, 1 ), // ESC current + HS( HOTT_ID_ESC_RPM, STR_SENSOR_HOTT_ID_ESC_RPM, UNIT_RPMS, 0 ), // ESC motor rpm + HS( HOTT_ID_ESC_BEC_VLT, STR_SENSOR_HOTT_ID_ESC_BEC_VLT, UNIT_VOLTS, 1 ), // ESC BEC voltage + HS( HOTT_ID_ESC_BEC_CUR, STR_SENSOR_HOTT_ID_ESC_BEC_CUR, UNIT_AMPS, 1 ), // ESC BEC current + HS( HOTT_ID_ESC_BEC_TMP, STR_SENSOR_HOTT_ID_ESC_BEC_TMP, UNIT_CELSIUS, 0 ), // BEC BEC temperature + HS( HOTT_ID_ESC_MOT_TMP, STR_SENSOR_HOTT_ID_ESC_MOT_TMP, UNIT_CELSIUS, 0 ), // ESC motor or external temperature // GAM - { HOTT_ID_GAM_CELS, STR_SENSOR_HOTT_ID_GAM_CELS, UNIT_CELLS, 2}, // GAM Cels L - { HOTT_ID_GAM_VLT1, STR_SENSOR_HOTT_ID_GAM_VLT1, UNIT_VOLTS, 1 }, // GAM voltage battery 1 - { HOTT_ID_GAM_VLT2, STR_SENSOR_HOTT_ID_GAM_VLT2, UNIT_VOLTS, 1 }, // GAM volatge battery 2 - { HOTT_ID_GAM_TMP1, STR_SENSOR_HOTT_ID_GAM_TMP1, UNIT_CELSIUS, 0 }, // GAM temperature 1 - { HOTT_ID_GAM_TMP2, STR_SENSOR_HOTT_ID_GAM_TMP2, UNIT_CELSIUS, 0 }, // GAM temperature 2 - { HOTT_ID_GAM_FUEL, STR_SENSOR_HOTT_ID_GAM_FUEL, UNIT_PERCENT, 0}, // GAM fuel percentage - { HOTT_ID_GAM_RPM1, STR_SENSOR_HOTT_ID_GAM_RPM1, UNIT_RPMS, 0 }, // GAM rpm 1 - { HOTT_ID_GAM_ALT, STR_SENSOR_HOTT_ID_GAM_ALT, UNIT_METERS, 0 }, // GAM altitude - { HOTT_ID_GAM_VV, STR_SENSOR_HOTT_ID_GAM_VV, UNIT_METERS_PER_SECOND, 2 }, // GAM vertical velocity - { HOTT_ID_GAM_CUR, STR_SENSOR_HOTT_ID_GAM_CUR, UNIT_AMPS, 1 }, // GAM current - { HOTT_ID_GAM_VLT3, STR_SENSOR_HOTT_ID_GAM_VLT3, UNIT_VOLTS, 1 }, // GAM voltage battery 3 - { HOTT_ID_GAM_CAP, STR_SENSOR_HOTT_ID_GAM_CAP, UNIT_MAH, 0 }, // GAM battery capacity - { HOTT_ID_GAM_SPEED, STR_SENSOR_HOTT_ID_GAM_SPEED, UNIT_KMH, 0 } , // GAM speed - { HOTT_ID_GAM_RPM2, STR_SENSOR_HOTT_ID_GAM_RPM2, UNIT_RPMS, 0 }, // GAM rmp 2 + HS( HOTT_ID_GAM_CELS, STR_SENSOR_HOTT_ID_GAM_CELS, UNIT_CELLS, 2), // GAM Cels L + HS( HOTT_ID_GAM_VLT1, STR_SENSOR_HOTT_ID_GAM_VLT1, UNIT_VOLTS, 1 ), // GAM voltage battery 1 + HS( HOTT_ID_GAM_VLT2, STR_SENSOR_HOTT_ID_GAM_VLT2, UNIT_VOLTS, 1 ), // GAM volatge battery 2 + HS( HOTT_ID_GAM_TMP1, STR_SENSOR_HOTT_ID_GAM_TMP1, UNIT_CELSIUS, 0 ), // GAM temperature 1 + HS( HOTT_ID_GAM_TMP2, STR_SENSOR_HOTT_ID_GAM_TMP2, UNIT_CELSIUS, 0 ), // GAM temperature 2 + HS( HOTT_ID_GAM_FUEL, STR_SENSOR_HOTT_ID_GAM_FUEL, UNIT_PERCENT, 0), // GAM fuel percentage + HS( HOTT_ID_GAM_RPM1, STR_SENSOR_HOTT_ID_GAM_RPM1, UNIT_RPMS, 0 ), // GAM rpm 1 + HS( HOTT_ID_GAM_ALT, STR_SENSOR_HOTT_ID_GAM_ALT, UNIT_METERS, 0 ), // GAM altitude + HS( HOTT_ID_GAM_VV, STR_SENSOR_HOTT_ID_GAM_VV, UNIT_METERS_PER_SECOND, 2 ), // GAM vertical velocity + HS( HOTT_ID_GAM_CUR, STR_SENSOR_HOTT_ID_GAM_CUR, UNIT_AMPS, 1 ), // GAM current + HS( HOTT_ID_GAM_VLT3, STR_SENSOR_HOTT_ID_GAM_VLT3, UNIT_VOLTS, 1 ), // GAM voltage battery 3 + HS( HOTT_ID_GAM_CAP, STR_SENSOR_HOTT_ID_GAM_CAP, UNIT_MAH, 0 ), // GAM battery capacity + HS( HOTT_ID_GAM_SPEED, STR_SENSOR_HOTT_ID_GAM_SPEED, UNIT_KMH, 0 ) , // GAM speed + HS( HOTT_ID_GAM_RPM2, STR_SENSOR_HOTT_ID_GAM_RPM2, UNIT_RPMS, 0 ), // GAM rmp 2 //EAM - { HOTT_ID_EAM_CELS_L, STR_SENSOR_HOTT_ID_EAM_CELS_L, UNIT_CELLS, 2}, // EAM Cells L voltage - { HOTT_ID_EAM_CELS_H, STR_SENSOR_HOTT_ID_EAM_CELS_H, UNIT_CELLS, 2}, // EAM Cells H voltage - { HOTT_ID_EAM_VLT1, STR_SENSOR_HOTT_ID_EAM_VLT1, UNIT_VOLTS, 1 }, // EAM Voltage battery 1 - { HOTT_ID_EAM_VLT2, STR_SENSOR_HOTT_ID_EAM_VLT2, UNIT_VOLTS, 1 }, // EAM Voltage battery 2 - { HOTT_ID_EAM_TMP1, STR_SENSOR_HOTT_ID_EAM_TMP1, UNIT_CELSIUS, 0 }, // EAM temperature 1 - { HOTT_ID_EAM_TMP2, STR_SENSOR_HOTT_ID_EAM_TMP2, UNIT_CELSIUS, 0 }, // EAM temperature 2 - { HOTT_ID_EAM_ALT, STR_SENSOR_HOTT_ID_EAM_ALT, UNIT_METERS, 0 }, // EAM altitude - { HOTT_ID_EAM_CUR, STR_SENSOR_HOTT_ID_EAM_CUR, UNIT_AMPS, 1 }, // EAM current - { HOTT_ID_EAM_VLT3, STR_SENSOR_HOTT_ID_EAM_VLT3, UNIT_VOLTS, 1 }, // EAM battery voltage 3 - { HOTT_ID_EAM_CAP, STR_SENSOR_HOTT_ID_EAM_CAP, UNIT_MAH, 0 }, // EAM Batt capacity - { HOTT_ID_EAM_VV, STR_SENSOR_HOTT_ID_EAM_VV, UNIT_METERS_PER_SECOND, 2 }, // EAM vertical velcocity - { HOTT_ID_EAM_RPM, STR_SENSOR_HOTT_ID_EAM_RPM, UNIT_RPMS, 0 }, // EAM rpm - { HOTT_ID_EAM_SPEED, STR_SENSOR_HOTT_ID_EAM_SPEED, UNIT_KMH, 0 } , // EAM speed + HS( HOTT_ID_EAM_CELS_L, STR_SENSOR_HOTT_ID_EAM_CELS_L, UNIT_CELLS, 2), // EAM Cells L voltage + HS( HOTT_ID_EAM_CELS_H, STR_SENSOR_HOTT_ID_EAM_CELS_H, UNIT_CELLS, 2), // EAM Cells H voltage + HS( HOTT_ID_EAM_VLT1, STR_SENSOR_HOTT_ID_EAM_VLT1, UNIT_VOLTS, 1 ), // EAM Voltage battery 1 + HS( HOTT_ID_EAM_VLT2, STR_SENSOR_HOTT_ID_EAM_VLT2, UNIT_VOLTS, 1 ), // EAM Voltage battery 2 + HS( HOTT_ID_EAM_TMP1, STR_SENSOR_HOTT_ID_EAM_TMP1, UNIT_CELSIUS, 0 ), // EAM temperature 1 + HS( HOTT_ID_EAM_TMP2, STR_SENSOR_HOTT_ID_EAM_TMP2, UNIT_CELSIUS, 0 ), // EAM temperature 2 + HS( HOTT_ID_EAM_ALT, STR_SENSOR_HOTT_ID_EAM_ALT, UNIT_METERS, 0 ), // EAM altitude + HS( HOTT_ID_EAM_CUR, STR_SENSOR_HOTT_ID_EAM_CUR, UNIT_AMPS, 1 ), // EAM current + HS( HOTT_ID_EAM_VLT3, STR_SENSOR_HOTT_ID_EAM_VLT3, UNIT_VOLTS, 1 ), // EAM battery voltage 3 + HS( HOTT_ID_EAM_CAP, STR_SENSOR_HOTT_ID_EAM_CAP, UNIT_MAH, 0 ), // EAM Batt capacity + HS( HOTT_ID_EAM_VV, STR_SENSOR_HOTT_ID_EAM_VV, UNIT_METERS_PER_SECOND, 2 ), // EAM vertical velcocity + HS( HOTT_ID_EAM_RPM, STR_SENSOR_HOTT_ID_EAM_RPM, UNIT_RPMS, 0 ), // EAM rpm + HS( HOTT_ID_EAM_SPEED, STR_SENSOR_HOTT_ID_EAM_SPEED, UNIT_KMH, 0 ) , // EAM speed // sentinel - {0x00, NULL, UNIT_RAW, 0} // sentinel + HS(0x00, NULL, UNIT_RAW, 0) // sentinel }; const HottSensor * getHottSensor(uint16_t id) diff --git a/radio/src/telemetry/mlink.cpp b/radio/src/telemetry/mlink.cpp index e1ee48560..5ffa63662 100644 --- a/radio/src/telemetry/mlink.cpp +++ b/radio/src/telemetry/mlink.cpp @@ -25,31 +25,33 @@ struct MLinkSensor { const uint16_t id; - const char * name; const TelemetryUnit unit; const uint8_t precision; + const char * name; }; +#define MS(id,name,unit,precision) {id,unit,precision,name} + const MLinkSensor mlinkSensors[] = { - {MLINK_SPECIAL, STR_SENSOR_SPECIAL, UNIT_RAW, 0}, - {MLINK_RX_VOLTAGE, STR_SENSOR_BATT, UNIT_VOLTS, 1}, - {MLINK_VOLTAGE, STR_SENSOR_VFAS, UNIT_VOLTS, 1}, - {MLINK_CURRENT, STR_SENSOR_CURR, UNIT_AMPS, 1}, - {MLINK_VARIO, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1}, - {MLINK_SPEED, STR_SENSOR_SPEED, UNIT_KMH, 1}, - {MLINK_RPM, STR_SENSOR_RPM, UNIT_RPMS, 0}, - {MLINK_TEMP, STR_SENSOR_TEMP1, UNIT_CELSIUS, 1}, - {MLINK_HEADING, STR_SENSOR_HDG, UNIT_DEGREE, 1}, - {MLINK_ALT, STR_SENSOR_ALT , UNIT_METERS, 0}, - {MLINK_FUEL, STR_SENSOR_FUEL, UNIT_PERCENT, 0}, - {MLINK_CAPACITY, STR_SENSOR_CAPACITY, UNIT_MAH, 0}, - {MLINK_FLOW, STR_SENSOR_FLOW, UNIT_MILLILITERS, 0}, - {MLINK_DISTANCE, STR_SENSOR_DIST, UNIT_KM, 1}, - {MLINK_GRATE, STR_SENSOR_ACC, UNIT_G, 1}, - {MLINK_LQI, STR_SENSOR_RSSI, UNIT_RAW, 0}, - {MLINK_LOSS, STR_SENSOR_LOSS, UNIT_RAW, 0}, - {MLINK_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_RAW, 0}, - {MLINK_TX_LQI, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0}, + MS(MLINK_SPECIAL, STR_SENSOR_SPECIAL, UNIT_RAW, 0), + MS(MLINK_RX_VOLTAGE, STR_SENSOR_BATT, UNIT_VOLTS, 1), + MS(MLINK_VOLTAGE, STR_SENSOR_VFAS, UNIT_VOLTS, 1), + MS(MLINK_CURRENT, STR_SENSOR_CURR, UNIT_AMPS, 1), + MS(MLINK_VARIO, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1), + MS(MLINK_SPEED, STR_SENSOR_SPEED, UNIT_KMH, 1), + MS(MLINK_RPM, STR_SENSOR_RPM, UNIT_RPMS, 0), + MS(MLINK_TEMP, STR_SENSOR_TEMP1, UNIT_CELSIUS, 1), + MS(MLINK_HEADING, STR_SENSOR_HDG, UNIT_DEGREE, 1), + MS(MLINK_ALT, STR_SENSOR_ALT , UNIT_METERS, 0), + MS(MLINK_FUEL, STR_SENSOR_FUEL, UNIT_PERCENT, 0), + MS(MLINK_CAPACITY, STR_SENSOR_CAPACITY, UNIT_MAH, 0), + MS(MLINK_FLOW, STR_SENSOR_FLOW, UNIT_MILLILITERS, 0), + MS(MLINK_DISTANCE, STR_SENSOR_DIST, UNIT_KM, 1), + MS(MLINK_GRATE, STR_SENSOR_ACC, UNIT_G, 1), + MS(MLINK_LQI, STR_SENSOR_RSSI, UNIT_RAW, 0), + MS(MLINK_LOSS, STR_SENSOR_LOSS, UNIT_RAW, 0), + MS(MLINK_TX_RSSI, STR_SENSOR_TX_RSSI, UNIT_RAW, 0), + MS(MLINK_TX_LQI, STR_SENSOR_TX_QUALITY, UNIT_RAW, 0), }; const MLinkSensor * getMLinkSensor(uint16_t id) diff --git a/radio/src/telemetry/spektrum.cpp b/radio/src/telemetry/spektrum.cpp index fd95fc5a8..4998ed2cf 100644 --- a/radio/src/telemetry/spektrum.cpp +++ b/radio/src/telemetry/spektrum.cpp @@ -133,222 +133,224 @@ enum SpektrumDataType : uint8_t { struct SpektrumSensor { const uint8_t i2caddress; - const uint8_t startByte; - const SpektrumDataType dataType; - const char *name; - const TelemetryUnit unit; + const uint8_t startByte:4; + const SpektrumDataType dataType:4; const uint8_t precision; + const TelemetryUnit unit; + const char *name; }; +#define SS(i2caddress,startByte,dataType,name,unit,precision) {i2caddress,startByte,dataType,precision,unit,name} + const SpektrumSensor spektrumSensors[] = { // 0x01 High voltage internal sensor - {I2C_VOLTAGE, 0, int16, STR_SENSOR_A1, UNIT_VOLTS, 2}, // 0.01V increments + SS(I2C_VOLTAGE, 0, int16, STR_SENSOR_A1, UNIT_VOLTS, 2), // 0.01V increments // 0x02 Temperature internal sensor - {I2C_TEMPERATURE, 0, int16, STR_SENSOR_TEMP1, UNIT_FAHRENHEIT, 1}, // Temperature in degrees Fahrenheit + SS(I2C_TEMPERATURE, 0, int16, STR_SENSOR_TEMP1, UNIT_FAHRENHEIT, 1), // Temperature in degrees Fahrenheit // 0x03 High current internal sensor (0x03), Resolution: 300A / 2048 = 0.196791 A/count - {I2C_HIGH_CURRENT, 0, int16, STR_SENSOR_CURR, UNIT_AMPS, 1}, // Range: +/- 150A + SS(I2C_HIGH_CURRENT, 0, int16, STR_SENSOR_CURR, UNIT_AMPS, 1), // Range: +/- 150A // 0x0A Powerbox (also mentioned as 0x7D but that is also transmitter frame data) - {I2C_PBOX, 0, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2}, // Volts, 0.01v - {I2C_PBOX, 2, uint16, STR_SENSOR_BATT2_VOLTAGE, UNIT_VOLTS, 2}, - {I2C_PBOX, 4, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0}, // mAh, 1mAh - {I2C_PBOX, 6, uint16, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0}, + SS(I2C_PBOX, 0, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2), // Volts, 0.01v + SS(I2C_PBOX, 2, uint16, STR_SENSOR_BATT2_VOLTAGE, UNIT_VOLTS, 2), + SS(I2C_PBOX, 4, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0), // mAh, 1mAh + SS(I2C_PBOX, 6, uint16, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0), // 0x0B Lap Timer - {I2C_LAPTIMER, 0, uint8, STR_SENSOR_LAP_NUMBER, UNIT_RAW, 0}, // Lap last finished - {I2C_LAPTIMER, 0, uint8, STR_SENSOR_GATE_NUMBER, UNIT_RAW, 0}, // Last gate passed - {I2C_LAPTIMER, 0, uint32, STR_SENSOR_LAP_TIME, UNIT_SECONDS, 3}, // Time of lap in 1ms increments - {I2C_LAPTIMER, 0, uint32, STR_SENSOR_GATE_TIME, UNIT_SECONDS, 3}, // Duration between last 2 gates + SS(I2C_LAPTIMER, 0, uint8, STR_SENSOR_LAP_NUMBER, UNIT_RAW, 0), // Lap last finished + SS(I2C_LAPTIMER, 0, uint8, STR_SENSOR_GATE_NUMBER, UNIT_RAW, 0), // Last gate passed + SS(I2C_LAPTIMER, 0, uint32, STR_SENSOR_LAP_TIME, UNIT_SECONDS, 3), // Time of lap in 1ms increments + SS(I2C_LAPTIMER, 0, uint32, STR_SENSOR_GATE_TIME, UNIT_SECONDS, 3), // Duration between last 2 gates // Text Generator -//{I2C_TEXTGEN, 0, uint32, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0}, +//SS(I2C_TEXTGEN, 0, uint32, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0), // 0x11 AirSpeed - {I2C_AIRSPEED, 0, int16, STR_SENSOR_ASPD, UNIT_KMH, 0}, // 1 km/h increments -//{I2C_AIRSPEED, 2, int16, STR_SENSOR_MAX_ASPD ?, UNIT_KMH, 0}, // 1 km/h increments + SS(I2C_AIRSPEED, 0, int16, STR_SENSOR_ASPD, UNIT_KMH, 0), // 1 km/h increments +//SS(I2C_AIRSPEED, 2, int16, STR_SENSOR_MAX_ASPD ?, UNIT_KMH, 0), // 1 km/h increments // 0x012 Altitude - {I2C_ALTITUDE, 0, int16, STR_SENSOR_ALT, UNIT_METERS, 1}, // .1m increments -//{I2C_ALTITUDE, 2, int16, STR_SENSOR_MAX_ALT ?, UNIT_METERS, 1}, // .1m increments + SS(I2C_ALTITUDE, 0, int16, STR_SENSOR_ALT, UNIT_METERS, 1), // .1m increments +//SS(I2C_ALTITUDE, 2, int16, STR_SENSOR_MAX_ALT ?, UNIT_METERS, 1), // .1m increments // 0x14 G-Force - {I2C_GMETER, 0, int16, STR_SENSOR_ACCX, UNIT_G, 2}, // force is reported as .01G increments - {I2C_GMETER, 2, int16, STR_SENSOR_ACCY, UNIT_G, 2}, // Range = +/-4000 (+/- 40G) in Pro model - {I2C_GMETER, 4, int16, STR_SENSOR_ACCZ, UNIT_G, 2}, // Range = +/-800 (+/- 8G) in Standard model -//{I2C_GMETER, 6, int16, STR_SENSOR_MAX_ACCX ?, UNIT_G, 2}, // abs(max G X-axis) FORE/AFT -//{I2C_GMETER, 8, int16, STR_SENSOR_MAX_ACCY ?, UNIT_G, 2}, // abs (max G Y-axis) LEFT/RIGHT -//{I2C_GMETER, 10, int16, STR_SENSOR_MAX_ACCZ ?, UNIT_G, 2}, // max G Z-axis WING SPAR LOAD -//{I2C_GMETER, 12, int16, STR_SENSOR_MIN_ACCZ ?, UNIT_G, 2}, // min G Z-axis WING SPAR LOAD + SS(I2C_GMETER, 0, int16, STR_SENSOR_ACCX, UNIT_G, 2), // force is reported as .01G increments + SS(I2C_GMETER, 2, int16, STR_SENSOR_ACCY, UNIT_G, 2), // Range = +/-4000 (+/- 40G) in Pro model + SS(I2C_GMETER, 4, int16, STR_SENSOR_ACCZ, UNIT_G, 2), // Range = +/-800 (+/- 8G) in Standard model +//SS(I2C_GMETER, 6, int16, STR_SENSOR_MAX_ACCX ?, UNIT_G, 2), // abs(max G X-axis) FORE/AFT +//SS(I2C_GMETER, 8, int16, STR_SENSOR_MAX_ACCY ?, UNIT_G, 2), // abs (max G Y-axis) LEFT/RIGHT +//SS(I2C_GMETER, 10, int16, STR_SENSOR_MAX_ACCZ ?, UNIT_G, 2), // max G Z-axis WING SPAR LOAD +//SS(I2C_GMETER, 12, int16, STR_SENSOR_MIN_ACCZ ?, UNIT_G, 2), // min G Z-axis WING SPAR LOAD // 0x15, JETCAT/TURBINE, BCD Encoded values // TODO: Add decoding of status information -//{I2C_JETCAT, 0, uint8, STR_SENSOR_STATUS, UNIT_BITFIELD, 0}, - {I2C_JETCAT, 1, uint8bcd, STR_SENSOR_THROTTLE, UNIT_PERCENT, 0}, - {I2C_JETCAT, 2, uint16bcd, STR_SENSOR_A1, UNIT_VOLTS, 2}, - {I2C_JETCAT, 4, uint16bcd, STR_SENSOR_A2, UNIT_VOLTS, 2}, - {I2C_JETCAT, 6, uint32bcd, STR_SENSOR_RPM, UNIT_RPMS, 0}, - {I2C_JETCAT, 10, uint16bcd, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0}, +//SS(I2C_JETCAT, 0, uint8, STR_SENSOR_STATUS, UNIT_BITFIELD, 0), + SS(I2C_JETCAT, 1, uint8bcd, STR_SENSOR_THROTTLE, UNIT_PERCENT, 0), + SS(I2C_JETCAT, 2, uint16bcd, STR_SENSOR_A1, UNIT_VOLTS, 2), + SS(I2C_JETCAT, 4, uint16bcd, STR_SENSOR_A2, UNIT_VOLTS, 2), + SS(I2C_JETCAT, 6, uint32bcd, STR_SENSOR_RPM, UNIT_RPMS, 0), + SS(I2C_JETCAT, 10, uint16bcd, STR_SENSOR_TEMP1, UNIT_CELSIUS, 0), // 0x16 GPS LOG - {I2C_GPS_LOC, 0, uint16bcd, STR_SENSOR_GPSALT, UNIT_METERS, 1}, // Atl-Low BCD 3.1 - {I2C_GPS_LOC, 2, uint32bcd, STR_SENSOR_GPS, UNIT_GPS, 0}, // LAT and LON - {I2C_GPS_LOC, 10, uint16bcd, STR_SENSOR_HDG, UNIT_DEGREE, 1}, // Course BCD 3.1 -//{I2C_GPS_LOC, 12, uint8bcd, STR_SENSOR_HDOP ?, UNIT_RAW, 1}, // HDOP BCD 1.1 + SS(I2C_GPS_LOC, 0, uint16bcd, STR_SENSOR_GPSALT, UNIT_METERS, 1), // Atl-Low BCD 3.1 + SS(I2C_GPS_LOC, 2, uint32bcd, STR_SENSOR_GPS, UNIT_GPS, 0), // LAT and LON + SS(I2C_GPS_LOC, 10, uint16bcd, STR_SENSOR_HDG, UNIT_DEGREE, 1), // Course BCD 3.1 +//SS(I2C_GPS_LOC, 12, uint8bcd, STR_SENSOR_HDOP ?, UNIT_RAW, 1), // HDOP BCD 1.1 // 0x17 GPS STAT - {I2C_GPS_STAT, 0, uint16bcd, STR_SENSOR_GSPD, UNIT_KTS, 1}, // BCD 3.1 - {I2C_GPS_STAT, 2, uint32bcd, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 1}, // BCD 6.1 HH:MM:SS.S - {I2C_GPS_STAT, 6, uint8bcd, STR_SENSOR_SATELLITES, UNIT_RAW, 0}, // BCD 2.0 + SS(I2C_GPS_STAT, 0, uint16bcd, STR_SENSOR_GSPD, UNIT_KTS, 1), // BCD 3.1 + SS(I2C_GPS_STAT, 2, uint32bcd, STR_SENSOR_GPSDATETIME, UNIT_DATETIME, 1), // BCD 6.1 HH:MM:SS.S + SS(I2C_GPS_STAT, 6, uint8bcd, STR_SENSOR_SATELLITES, UNIT_RAW, 0), // BCD 2.0 // 0x18 Dual Batt Capacity monitor - Receiver - {I2C_RX_BATT, 0, int16, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2}, // Instantaneous current, 0.01A (0-327.66A) - {I2C_RX_BATT, 2, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 1}, // Integrated mAh used, 0.1mAh (0-3276.6mAh) - {I2C_RX_BATT, 4, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2}, // Volts, 0.01V increments (0-16.00V) - {I2C_RX_BATT, 6, int16, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2}, // Instantaneous current, 0.01A (0-327.66A) - {I2C_RX_BATT, 8, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 1}, // Integrated mAh used, 0.1mAh (0-3276.6mAh) - {I2C_RX_BATT, 10, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2}, // Volts, 0.01V increments (0-16.00V) + SS(I2C_RX_BATT, 0, int16, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2), // Instantaneous current, 0.01A (0-327.66A) + SS(I2C_RX_BATT, 2, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 1), // Integrated mAh used, 0.1mAh (0-3276.6mAh) + SS(I2C_RX_BATT, 4, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2), // Volts, 0.01V increments (0-16.00V) + SS(I2C_RX_BATT, 6, int16, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 2), // Instantaneous current, 0.01A (0-327.66A) + SS(I2C_RX_BATT, 8, uint16, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 1), // Integrated mAh used, 0.1mAh (0-3276.6mAh) + SS(I2C_RX_BATT, 10, uint16, STR_SENSOR_BATT1_VOLTAGE, UNIT_VOLTS, 2), // Volts, 0.01V increments (0-16.00V) // 0x19 Jetcat flow rate -//{I2C_JETCAT_2, 0, uint16bcd, STR_SENSOR_FUEL_CONSUMPTION, UNIT_MILLILITERS_PER_MINUTE, 1}, missing ml/min - {I2C_JETCAT_2, 2, uint32bcd, STR_SENSOR_FUEL, UNIT_MILLILITERS, 1}, +//SS(I2C_JETCAT_2, 0, uint16bcd, STR_SENSOR_FUEL_CONSUMPTION, UNIT_MILLILITERS_PER_MINUTE, 1), missing ml/min + SS(I2C_JETCAT_2, 2, uint32bcd, STR_SENSOR_FUEL, UNIT_MILLILITERS, 1), // 0x1a Gyro - {I2C_GYRO, 0, int16, STR_SENSOR_GYROX, UNIT_DEGREE, 1}, // Units are 0.1 deg/sec - {I2C_GYRO, 2, int16, STR_SENSOR_GYROY, UNIT_DEGREE, 1}, - {I2C_GYRO, 4, int16, STR_SENSOR_GYROZ, UNIT_DEGREE, 1}, - //{I2C_GYRO, 6, int16, STR_SENSOR_MAX_GYROX ?, UNIT_DEGREE, 1}, // abs (max) - //{I2C_GYRO, 8, int16, STR_SENSOR_MAX_GYROY ?, UNIT_DEGREE, 1}, - //{I2C_GYRO, 10, int16, STR_SENSOR_MAX_GYROZ ?, UNIT_DEGREE, 1}, + SS(I2C_GYRO, 0, int16, STR_SENSOR_GYROX, UNIT_DEGREE, 1), // Units are 0.1 deg/sec + SS(I2C_GYRO, 2, int16, STR_SENSOR_GYROY, UNIT_DEGREE, 1), + SS(I2C_GYRO, 4, int16, STR_SENSOR_GYROZ, UNIT_DEGREE, 1), + //SS(I2C_GYRO, 6, int16, STR_SENSOR_MAX_GYROX ?, UNIT_DEGREE, 1), // abs (max) + //SS(I2C_GYRO, 8, int16, STR_SENSOR_MAX_GYROY ?, UNIT_DEGREE, 1), + //SS(I2C_GYRO, 10, int16, STR_SENSOR_MAX_GYROZ ?, UNIT_DEGREE, 1), // 0x1b Attitude & Mag Compass // mag Units are tbd so probably no sensor in existance, ignore them for now - {I2C_ATTMAG, 0, int16, STR_SENSOR_ROLL, UNIT_DEGREE, 1}, // Attitude, 3 axes. - {I2C_ATTMAG, 2, int16, STR_SENSOR_PITCH, UNIT_DEGREE, 1}, // Units are 0.1 deg - {I2C_ATTMAG, 4, int16, STR_SENSOR_YAW, UNIT_DEGREE, 1}, -//{I2C_ATTMAG, 6, int16, STR_SENSOR_MAGX ?, ??, 1}, // Magnetic Compass, 3 axes -//{I2C_ATTMAG, 8, int16, STR_SENSOR_MAGY ?, ??, 1}, // Units are 0.1mG -//{I2C_ATTMAG, 10, int16, STR_SENSOR_MAXZ ?, ??, 1}, -//{I2C_ATTMAG, 12, int16, STR_SENSOR_HDG ?, UNIT_DEGREE, 1}, // Heading, 0.1deg + SS(I2C_ATTMAG, 0, int16, STR_SENSOR_ROLL, UNIT_DEGREE, 1), // Attitude, 3 axes. + SS(I2C_ATTMAG, 2, int16, STR_SENSOR_PITCH, UNIT_DEGREE, 1), // Units are 0.1 deg + SS(I2C_ATTMAG, 4, int16, STR_SENSOR_YAW, UNIT_DEGREE, 1), +//SS(I2C_ATTMAG, 6, int16, STR_SENSOR_MAGX ?, ??, 1), // Magnetic Compass, 3 axes +//SS(I2C_ATTMAG, 8, int16, STR_SENSOR_MAGY ?, ??, 1), // Units are 0.1mG +//SS(I2C_ATTMAG, 10, int16, STR_SENSOR_MAXZ ?, ??, 1), +//SS(I2C_ATTMAG, 12, int16, STR_SENSOR_HDG ?, UNIT_DEGREE, 1), // Heading, 0.1deg // 0x20 Smart ESC telemetry - {I2C_ESC, 0, uint16, STR_SENSOR_ESC_RPM2, UNIT_RPMS, 0}, // Electrical RPM, 10RPM (0-655340 RPM) - {I2C_ESC, 2, uint16, STR_SENSOR_ESC_VIN, UNIT_VOLTS, 2}, // Volts, 0.01v (0-655.34V) - {I2C_ESC, 4, uint16, STR_SENSOR_ESC_TFET, UNIT_CELSIUS, 1}, // Temperature, 0.1C (0-6553.4C) - {I2C_ESC, 6, uint16, STR_SENSOR_ESC_CUR, UNIT_AMPS, 2}, // Current, 10mA (0-655.34A) - {I2C_ESC, 8, uint16, STR_SENSOR_ESC_TBEC, UNIT_CELSIUS, 1}, // Temperature, 0.1C (0-6553.4C) - {I2C_ESC, 10, uint8, STR_SENSOR_ESC_BCUR, UNIT_AMPS, 1}, // BEC Current, 100mA (0-25.4A) - {I2C_ESC, 11, uint8, STR_SENSOR_ESC_VBEC, UNIT_VOLTS, 2}, // BEC Volts, 0.05V (0-12.70V) - {I2C_ESC, 12, uint8, STR_SENSOR_ESC_THR, UNIT_PERCENT, 0}, // 0.5% (0-100%) - {I2C_ESC, 13, uint8, STR_SENSOR_ESC_POUT, UNIT_PERCENT, 0}, // Power Output, 0.5% (0-127%) + SS(I2C_ESC, 0, uint16, STR_SENSOR_ESC_RPM2, UNIT_RPMS, 0), // Electrical RPM, 10RPM (0-655340 RPM) + SS(I2C_ESC, 2, uint16, STR_SENSOR_ESC_VIN, UNIT_VOLTS, 2), // Volts, 0.01v (0-655.34V) + SS(I2C_ESC, 4, uint16, STR_SENSOR_ESC_TFET, UNIT_CELSIUS, 1), // Temperature, 0.1C (0-6553.4C) + SS(I2C_ESC, 6, uint16, STR_SENSOR_ESC_CUR, UNIT_AMPS, 2), // Current, 10mA (0-655.34A) + SS(I2C_ESC, 8, uint16, STR_SENSOR_ESC_TBEC, UNIT_CELSIUS, 1), // Temperature, 0.1C (0-6553.4C) + SS(I2C_ESC, 10, uint8, STR_SENSOR_ESC_BCUR, UNIT_AMPS, 1), // BEC Current, 100mA (0-25.4A) + SS(I2C_ESC, 11, uint8, STR_SENSOR_ESC_VBEC, UNIT_VOLTS, 2), // BEC Volts, 0.05V (0-12.70V) + SS(I2C_ESC, 12, uint8, STR_SENSOR_ESC_THR, UNIT_PERCENT, 0), // 0.5% (0-100%) + SS(I2C_ESC, 13, uint8, STR_SENSOR_ESC_POUT, UNIT_PERCENT, 0), // Power Output, 0.5% (0-127%) // 0x26 GPS Binary - {I2C_GPS_BIN, 0, uint16, STR_SENSOR_GPSALT, UNIT_METERS, 0}, // altitude m, 1000m offset - {I2C_GPS_BIN, 2, int32, STR_SENSOR_GPS, UNIT_GPS, 0}, // latitude+long degree / 10,000,000 - {I2C_GPS_BIN, 10, uint16, STR_SENSOR_HDG, UNIT_DEGREE, 1}, // heading/course degree / 10 - {I2C_GPS_BIN, 12, uint8, STR_SENSOR_GSPD, UNIT_KMH, 0}, // ground speed Km/h - {I2C_GPS_BIN, 13, uint8, STR_SENSOR_SATELLITES, UNIT_RAW, 0}, // count + SS(I2C_GPS_BIN, 0, uint16, STR_SENSOR_GPSALT, UNIT_METERS, 0), // altitude m, 1000m offset + SS(I2C_GPS_BIN, 2, int32, STR_SENSOR_GPS, UNIT_GPS, 0), // latitude+long degree / 10,000,000 + SS(I2C_GPS_BIN, 10, uint16, STR_SENSOR_HDG, UNIT_DEGREE, 1), // heading/course degree / 10 + SS(I2C_GPS_BIN, 12, uint8, STR_SENSOR_GSPD, UNIT_KMH, 0), // ground speed Km/h + SS(I2C_GPS_BIN, 13, uint8, STR_SENSOR_SATELLITES, UNIT_RAW, 0), // count // 0x34 Dual Batt Capacity monitor - Flight Pack // The difference with sensor 0x18 (RX capacity monitor) is the consumption magnitude. // RX (0x18) is up to 3.2A, and flight pack is up to 32A (x 10 or 1 decimal place) // Right now they have the same sensor name... could this sensors (0x18 and 0x34) be used at the same time? - {I2C_FP_BATT, 0, int16le, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 1}, // Instantaneous current, 0.1A (0-3276.6A) - {I2C_FP_BATT, 2, int16le, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0}, // Integrated mAh used, 1mAh (0-32.766Ah) - {I2C_FP_BATT, 4, int16le, STR_SENSOR_BATT1_TEMP, UNIT_CELSIUS, 1}, // Temperature, 0.1C (0-150C) - {I2C_FP_BATT, 6, int16le, STR_SENSOR_BATT2_CURRENT, UNIT_AMPS, 1}, // Instantaneous current, 0.1A (0-3276.6A) - {I2C_FP_BATT, 8, int16le, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0}, // Integrated mAh used, 1mAh (0-32.766Ah) - {I2C_FP_BATT, 10, int16le, STR_SENSOR_BATT2_TEMP, UNIT_CELSIUS, 1}, // Temperature, 0.1C (0-150C) + SS(I2C_FP_BATT, 0, int16le, STR_SENSOR_BATT1_CURRENT, UNIT_AMPS, 1), // Instantaneous current, 0.1A (0-3276.6A) + SS(I2C_FP_BATT, 2, int16le, STR_SENSOR_BATT1_CONSUMPTION, UNIT_MAH, 0), // Integrated mAh used, 1mAh (0-32.766Ah) + SS(I2C_FP_BATT, 4, int16le, STR_SENSOR_BATT1_TEMP, UNIT_CELSIUS, 1), // Temperature, 0.1C (0-150C) + SS(I2C_FP_BATT, 6, int16le, STR_SENSOR_BATT2_CURRENT, UNIT_AMPS, 1), // Instantaneous current, 0.1A (0-3276.6A) + SS(I2C_FP_BATT, 8, int16le, STR_SENSOR_BATT2_CONSUMPTION, UNIT_MAH, 0), // Integrated mAh used, 1mAh (0-32.766Ah) + SS(I2C_FP_BATT, 10, int16le, STR_SENSOR_BATT2_TEMP, UNIT_CELSIUS, 1), // Temperature, 0.1C (0-150C) // Tank pressure + custom input bits (ignore for now) -//{0x38, 0, uint16, STR_SENSOR_STATUS_BITS, UNIT_BITFIELD, 0}, -//{0x38, 0, uint16, STR_SENSOR_PRESSSURE, UNIT_PSI, 1}, +//SS(0x38, 0, uint16, STR_SENSOR_STATUS_BITS, UNIT_BITFIELD, 0), +//SS(0x38, 0, uint16, STR_SENSOR_PRESSSURE, UNIT_PSI, 1), // 0x3A Lipo 6s Monitor Cells - {I2C_CELLS, 0, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, // Voltage across cell 1, .01V steps - {I2C_CELLS, 2, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, - {I2C_CELLS, 4, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, - {I2C_CELLS, 6, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, - {I2C_CELLS, 8, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, - {I2C_CELLS, 10, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2}, - {I2C_CELLS, 12, uint16, STR_SENSOR_TEMP2, UNIT_CELSIUS, 2}, // Temperature, 0.1C (0-655.34C) + SS(I2C_CELLS, 0, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), // Voltage across cell 1, .01V steps + SS(I2C_CELLS, 2, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), + SS(I2C_CELLS, 4, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), + SS(I2C_CELLS, 6, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), + SS(I2C_CELLS, 8, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), + SS(I2C_CELLS, 10, uint16, STR_SENSOR_CELLS, UNIT_VOLTS, 2), + SS(I2C_CELLS, 12, uint16, STR_SENSOR_TEMP2, UNIT_CELSIUS, 2), // Temperature, 0.1C (0-655.34C) // 0x40 Vario-S - {I2C_VARIO, 0, int16, STR_SENSOR_ALT, UNIT_METERS, 1}, - {I2C_VARIO, 2, int16, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1}, + SS(I2C_VARIO, 0, int16, STR_SENSOR_ALT, UNIT_METERS, 1), + SS(I2C_VARIO, 2, int16, STR_SENSOR_VSPD, UNIT_METERS_PER_SECOND, 1), // 0x42 Smartbat -//{I2C_SMART_BAT_REALTIME, 1, int8, STR_SMART_BAT_BTMP, UNIT_CELSIUS, 0}, // disabled because sensor is a duplicate of cells sensors ones - {I2C_SMART_BAT_REALTIME, 2, uint32le, STR_SENSOR_SMART_BAT_BCUR, UNIT_MAH, 0}, - {I2C_SMART_BAT_REALTIME, 6, uint16le, STR_SENSOR_SMART_BAT_BCAP, UNIT_MAH, 0}, - {I2C_SMART_BAT_REALTIME, 8, uint16le, STR_SENSOR_SMART_BAT_MIN_CEL, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_REALTIME, 10, uint16le, STR_SENSOR_SMART_BAT_MAX_CEL, UNIT_VOLTS, 2}, -//{I2C_SMART_BAT_REALTIME, 12, uint16le, "RFU[2]", UNIT_RAW, 0}, // disabled to save sensors slots +//SS(I2C_SMART_BAT_REALTIME, 1, int8, STR_SMART_BAT_BTMP, UNIT_CELSIUS, 0), // disabled because sensor is a duplicate of cells sensors ones + SS(I2C_SMART_BAT_REALTIME, 2, uint32le, STR_SENSOR_SMART_BAT_BCUR, UNIT_MAH, 0), + SS(I2C_SMART_BAT_REALTIME, 6, uint16le, STR_SENSOR_SMART_BAT_BCAP, UNIT_MAH, 0), + SS(I2C_SMART_BAT_REALTIME, 8, uint16le, STR_SENSOR_SMART_BAT_MIN_CEL, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_REALTIME, 10, uint16le, STR_SENSOR_SMART_BAT_MAX_CEL, UNIT_VOLTS, 2), +//SS(I2C_SMART_BAT_REALTIME, 12, uint16le, "RFU[2]", UNIT_RAW, 0), // disabled to save sensors slots - {I2C_SMART_BAT_CELLS_1_6, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0}, - {I2C_SMART_BAT_CELLS_1_6, 2, uint16le, STR_SENSOR_CL01, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_1_6, 4, uint16le, STR_SENSOR_CL02, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_1_6, 6, uint16le, STR_SENSOR_CL03, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_1_6, 8, uint16le, STR_SENSOR_CL04, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_1_6, 10, uint16le, STR_SENSOR_CL05, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_1_6, 12, uint16le, STR_SENSOR_CL06, UNIT_VOLTS, 2}, + SS(I2C_SMART_BAT_CELLS_1_6, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0), + SS(I2C_SMART_BAT_CELLS_1_6, 2, uint16le, STR_SENSOR_CL01, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_1_6, 4, uint16le, STR_SENSOR_CL02, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_1_6, 6, uint16le, STR_SENSOR_CL03, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_1_6, 8, uint16le, STR_SENSOR_CL04, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_1_6, 10, uint16le, STR_SENSOR_CL05, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_1_6, 12, uint16le, STR_SENSOR_CL06, UNIT_VOLTS, 2), - {I2C_SMART_BAT_CELLS_7_12, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0}, - {I2C_SMART_BAT_CELLS_7_12, 2, uint16le, STR_SENSOR_CL07, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_7_12, 4, uint16le, STR_SENSOR_CL08, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_7_12, 6, uint16le, STR_SENSOR_CL09, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_7_12, 8, uint16le, STR_SENSOR_CL10, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_7_12, 10, uint16le, STR_SENSOR_CL11, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_7_12, 12, uint16le, STR_SENSOR_CL12, UNIT_VOLTS, 2}, + SS(I2C_SMART_BAT_CELLS_7_12, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0), + SS(I2C_SMART_BAT_CELLS_7_12, 2, uint16le, STR_SENSOR_CL07, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_7_12, 4, uint16le, STR_SENSOR_CL08, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_7_12, 6, uint16le, STR_SENSOR_CL09, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_7_12, 8, uint16le, STR_SENSOR_CL10, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_7_12, 10, uint16le, STR_SENSOR_CL11, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_7_12, 12, uint16le, STR_SENSOR_CL12, UNIT_VOLTS, 2), - {I2C_SMART_BAT_CELLS_13_18, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0}, - {I2C_SMART_BAT_CELLS_13_18, 2, uint16le, STR_SENSOR_CL13, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_13_18, 4, uint16le, STR_SENSOR_CL14, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_13_18, 6, uint16le, STR_SENSOR_CL15, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_13_18, 8, uint16le, STR_SENSOR_CL16, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_13_18, 10, uint16le, STR_SENSOR_CL17, UNIT_VOLTS, 2}, - {I2C_SMART_BAT_CELLS_13_18, 12, uint16le, STR_SENSOR_CL18, UNIT_VOLTS, 2}, + SS(I2C_SMART_BAT_CELLS_13_18, 1, int8, STR_SENSOR_SMART_BAT_BTMP, UNIT_CELSIUS, 0), + SS(I2C_SMART_BAT_CELLS_13_18, 2, uint16le, STR_SENSOR_CL13, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_13_18, 4, uint16le, STR_SENSOR_CL14, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_13_18, 6, uint16le, STR_SENSOR_CL15, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_13_18, 8, uint16le, STR_SENSOR_CL16, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_13_18, 10, uint16le, STR_SENSOR_CL17, UNIT_VOLTS, 2), + SS(I2C_SMART_BAT_CELLS_13_18, 12, uint16le, STR_SENSOR_CL18, UNIT_VOLTS, 2), - //{I2C_SMART_BAT_ID, 1, uint8, "chemistery", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_ID, 2, uint8, "number of cells", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_ID, 3, uint8, "manufacturer code", UNIT_RAW, 0}, // disabled to save sensors slots - {I2C_SMART_BAT_ID, 4, uint16le, STR_SENSOR_SMART_BAT_CYCLES, UNIT_RAW, 0}, - //{I2C_SMART_BAT_ID, 6, uint8, "uniqueID[8]", UNIT_RAW, 0}, // disabled to save sensors slots + //SS(I2C_SMART_BAT_ID, 1, uint8, "chemistery", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_ID, 2, uint8, "number of cells", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_ID, 3, uint8, "manufacturer code", UNIT_RAW, 0), // disabled to save sensors slots + SS(I2C_SMART_BAT_ID, 4, uint16le, STR_SENSOR_SMART_BAT_CYCLES, UNIT_RAW, 0), + //SS(I2C_SMART_BAT_ID, 6, uint8, "uniqueID[8]", UNIT_RAW, 0), // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 1, uint8, "rfu", UNIT_RAW, 0}, // disabled to save sensors slots - {I2C_SMART_BAT_LIMITS, 2, uint16le, STR_SENSOR_SMART_BAT_CAPACITY,UNIT_MAH, 0}, - //{I2C_SMART_BAT_LIMITS, 4, uint16le, "dischargeCurrentRating", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 6, uint16le, "overDischarge_mV", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 8, uint16le, "zeroCapacity_mV", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 10, uint16le, "fullyCharged_mV", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 12, uint8, "minWorkingTemp", UNIT_RAW, 0}, // disabled to save sensors slots - //{I2C_SMART_BAT_LIMITS, 13, uint8, "maxWorkingTemp", UNIT_RAW, 0}, // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 1, uint8, "rfu", UNIT_RAW, 0), // disabled to save sensors slots + SS(I2C_SMART_BAT_LIMITS, 2, uint16le, STR_SENSOR_SMART_BAT_CAPACITY,UNIT_MAH, 0), + //SS(I2C_SMART_BAT_LIMITS, 4, uint16le, "dischargeCurrentRating", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 6, uint16le, "overDischarge_mV", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 8, uint16le, "zeroCapacity_mV", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 10, uint16le, "fullyCharged_mV", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 12, uint8, "minWorkingTemp", UNIT_RAW, 0), // disabled to save sensors slots + //SS(I2C_SMART_BAT_LIMITS, 13, uint8, "maxWorkingTemp", UNIT_RAW, 0), // disabled to save sensors slots // 0x50-0x56 custom 3rd party sensors - //{0x50, 0, int16, STR_SENSOR_} + //SS(0x50, 0, int16, STR_SENSOR_) // 0x7d are transmitter channels frame data [7], probably only available on the Spektrum // telemetry bus on the model itself // 0x7E RPM/Volts/Temperature - {I2C_RPM, 0, uint16, STR_SENSOR_RPM, UNIT_RPMS, 0}, // microseconds between pulse leading edges - {I2C_RPM, 2, uint16, STR_SENSOR_A3, UNIT_VOLTS, 2}, // 0.01V increments (typically flight pack voltage) - {I2C_RPM, 4, int16, STR_SENSOR_TEMP2, UNIT_FAHRENHEIT, 0}, // Temperature in degrees F. + SS(I2C_RPM, 0, uint16, STR_SENSOR_RPM, UNIT_RPMS, 0), // microseconds between pulse leading edges + SS(I2C_RPM, 2, uint16, STR_SENSOR_A3, UNIT_VOLTS, 2), // 0.01V increments (typically flight pack voltage) + SS(I2C_RPM, 4, int16, STR_SENSOR_TEMP2, UNIT_FAHRENHEIT, 0), // Temperature in degrees F. // 0x7f, QoS DATA, also called Flight Log - {I2C_QOS, 0, uint16, STR_SENSOR_QOS_A, UNIT_RAW, 0}, // A - Antenna Fades on Receiver A - {I2C_QOS, 2, uint16, STR_SENSOR_QOS_B, UNIT_RAW, 0}, // B - Antenna Fades on Receiver B - {I2C_QOS, 4, uint16, STR_SENSOR_QOS_L, UNIT_RAW, 0}, // L - Antenna Fades on left Receiver - {I2C_QOS, 6, uint16, STR_SENSOR_QOS_R, UNIT_RAW, 0}, // R - Antenna Fades on right Receiver - {I2C_QOS, 8, uint16, STR_SENSOR_QOS_F, UNIT_RAW, 0}, // F - Frame losses. - {I2C_QOS, 10, uint16, STR_SENSOR_QOS_H, UNIT_RAW, 0}, // H - Holds - {I2C_QOS, 12, uint16, STR_SENSOR_A2, UNIT_VOLTS, 2}, // Volts, .01V increment. + SS(I2C_QOS, 0, uint16, STR_SENSOR_QOS_A, UNIT_RAW, 0), // A - Antenna Fades on Receiver A + SS(I2C_QOS, 2, uint16, STR_SENSOR_QOS_B, UNIT_RAW, 0), // B - Antenna Fades on Receiver B + SS(I2C_QOS, 4, uint16, STR_SENSOR_QOS_L, UNIT_RAW, 0), // L - Antenna Fades on left Receiver + SS(I2C_QOS, 6, uint16, STR_SENSOR_QOS_R, UNIT_RAW, 0), // R - Antenna Fades on right Receiver + SS(I2C_QOS, 8, uint16, STR_SENSOR_QOS_F, UNIT_RAW, 0), // F - Frame losses. + SS(I2C_QOS, 10, uint16, STR_SENSOR_QOS_H, UNIT_RAW, 0), // H - Holds + SS(I2C_QOS, 12, uint16, STR_SENSOR_A2, UNIT_VOLTS, 2), // Volts, .01V increment. - {I2C_PSEUDO_TX, 0, uint8, STR_SENSOR_TX_RSSI, UNIT_RAW, 0}, - {I2C_PSEUDO_TX, 4, uint32, STR_SENSOR_BIND, UNIT_RAW, 0}, - {I2C_PSEUDO_TX, 8, uint32, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0}, - {0, 0, int16, NULL, UNIT_RAW, 0} //sentinel + SS(I2C_PSEUDO_TX, 0, uint8, STR_SENSOR_TX_RSSI, UNIT_RAW, 0), + SS(I2C_PSEUDO_TX, 4, uint32, STR_SENSOR_BIND, UNIT_RAW, 0), + SS(I2C_PSEUDO_TX, 8, uint32, STR_SENSOR_FLIGHT_MODE, UNIT_TEXT, 0), + SS(0, 0, int16, NULL, UNIT_RAW, 0) //sentinel }; // Alt Low and High needs to be combined (in 2 diff packets)