API Structure Datatypes



  • In the Serial API pages we can find a table that show the correlation, between type of sensor and data structure that can be used , eg a switch will be of type S_Binary and S_ Binary has elements of V_Status & V_Watt so far all well and good. But when we come to write C code be should be disciplined in our data type and we should be typecasting or ensuring that the data we pass into V_Watt is correct type w shouldn;t be passing in a DINT when V_Watt if it is defined as type Real (float), Similarly we should only pass Bool into S_Status if it is defined as bool, but it could be defined as sint?

    This leads to my Question, is there a table showing the data types (Bool, Float, Int, Din, Sint etc) for each of these elements. ?

    Type		                  Data Type 
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    V_TEMP		                     ?INT
    V_HUM		                     ?INT
    V_STATUS		             ?BOOL
    V_PERCENTAGE		             ?INT
    V_PRESSURE		             ?INT
    V_FORECAST		             ??????
    V_RAIN		
    V_RAINRATE		
    V_WIND		
    V_GUST		
    V_DIRECTION		
    V_UV		
    V_WEIGHT		
    V_DISTANCE		
    V_IMPEDANCE		
    V_ARMED		
    V_TRIPPED		
    V_WATT		
    V_KWH		
    V_SCENE_ON		
    V_SCENE_OFF		
    V_HVAC_FLOW_STATE		
    V_HVAC_SPEED		
    V_LIGHT_LEVEL		
    V_VAR1		
    V_VAR2		
    V_VAR3		
    V_VAR4		
    V_VAR5		
    V_UP		
    V_DOWN		
    V_STOP		
    V_IR_SEND		
    V_IR_RECEIVE		
    V_FLOW		
    V_VOLUME		
    V_LOCK_STATUS		
    V_LEVEL		
    V_VOLTAGE		
    V_CURRENT		
    V_RGB		
    V_RGBW		
    V_ID		
    V_UNIT_PREFIX		
    V_HVAC_SETPOINT_COOL		
    V_HVAC_SETPOINT_HEAT		
    V_HVAC_FLOW_MODE		
    V_TEXT		
    V_CUSTOM		
    V_POSITION		
    V_IR_RECORD		
    V_PH		
    V_ORP		
    V_EC		
    V_VAR		
    V_VA		
    V_POWER_FACTOR		
    
    
    

    So can anyone complete the above table ?


  • Admin

    This little Javascript data structure might help you (used by a thing I'm working on). Not 100% mappable to C but you should be able to read out the assumed data types.

    let parseB = function(x) {
      return x === "1" ? 1:0;
    };
    
    let serializeB = function(x) {
      if (!x)
        return "0";
      return x==="1"?"1":"0";
    };
    
    let parseS = function(x) {
      return striptags(x.toString());
    };
    
    let serializeS = function(x) {
      if (!x)
        return "";
      return x.toString();
    };
    
    let parseRGB = function(x) {
      if (x.length() != 6)
        return null;
      try {
        let r = parseInt(x.substr(0,2), 16);
        let g = parseInt(x.substr(2,2), 16);
        let b = parseInt(x.substr(4,2), 16);
        if (isNaN(r) && isNaN(g) && isNaN(b))
          return null;
        return {r: r, g: g, b: b };
      } catch (e) {
      } 
      return null;
    };
    
    let serializeRGB = function(x) {
      if (!x || !x.r || !x.g || !x.b)
        return "";
      return x.r.toString(16) + x.g.toString(16) + x.b.toString(16);
    };
    
    let parseRGBW = function(x) {
      if (x.length() != 8)
        return null;
      try {
        let r = parseInt(x.substr(0,2), 16);
        let g = parseInt(x.substr(2,2), 16);
        let b = parseInt(x.substr(4,2), 16);
        let w = parseInt(x.substr(6,2), 16);
        if (isNaN(r) && isNaN(g) && isNaN(b) && isNaN(w))
          return null;
        return {r: r, g: g, b: b, w: w };
      } catch (e) {
        return null;
      } 
    };
    
    let serializeRGBW = function(x) {
      if (!x || !x.r || !x.g || !x.b || !x.w)
        return "";
      return x.r.toString(16) + x.g.toString(16) + x.b.toString(16) + x.w.toString(16);
    };
    
    
    let parsePos = function(x) {
      return x.split(";");
    };
    
    
    let serializePos = function(x) {
      if (!x || !Array.isArray(x))
        return "";
      return x.join(";");
    };
    
    let parseF = function(x) {
      try {
        let f = Number.parseFloat(x); 
        return isNaN(f) ? null : f;
      } catch (e) {
         return null;
      }
    };
    
    let serializeF = function(x) {
      if (x===undefined || x==="")
        return "";
      return x.toString();
    };
    
    let parseI = function(x) {
      try {
        let i = Number.parseInt(x, 10);
        return isNaN(i) ? null : i;
      } catch (e) {
         return null;
      }
    };
    
    let serializeI = function(x) {
      if (!x)
        return "";
      return x.toString();
    };
    
    
    let parseP = function(x) {
      try {
          let i = Number.parseInt(x, 10);
          return isNaN(i) ? null : Math.min(Math.max(0,i),100);
      } catch (e) {
        return null;
      }
    };
    
    let serializeP = function(x) {
      if (!x)
        return "0";
      return x.toString();
    };
    
    
    let allowedForecast = ["stable", "sunny", "cloudy", "unstable", "thunderstorm", "unknown"];
    let parseForecast = function(x) {
      if(allowedForecast.indexOf(x)>=0)
        return x;
      return "unknown";    
    };
    
    let serializeForecast = function(x) {
      if(allowedForecast.indexOf(x)>=0)
        return x;
      return "unknown";
    };
    
    let allowedFlowState = ["Off", "HeatOn", "CoolOn", "AutoChangeOver"];
    let parseFlowState = function(x) {
      if(allowedFlowState.indexOf(x)>=0)
        return x;
      return null;    
    };
    
    let serializeFlowState = function(x) {
      if(allowedFlowState.indexOf(x)>=0)
        return x;
      return "";
    };
    
    let allowedHvacSpeed = ["Min", "Normal", "Max", "Auto"];
    let parseHvacSpeed = function(x) {
      if(allowedHvacSpeed.indexOf(x)>=0)
        return x;
      return null;    
    };
    
    let serializeHvacSpeed = function(x) {
      if(allowedHvacSpeed.indexOf(x)>=0)
        return x;
      return "";
    };
    
    let allowedHvacFlowMode = ["Auto", "ContinuousOn", "PeriodicOn"];
    let parseHvacFlowMode = function(x) {
      if(allowedHvacFlowMode.indexOf(x)>=0)
        return x;
      return null;    
    };
    
    let serializeHvacFlowMode = function(x) {
      if(allowedHvacFlowMode.indexOf(x)>=0)
        return x;
      return "";
    };
    
    
    
    let vars = module.exports.vars = {
        TEMP: {
          id:0,
          title: "Temperature",
          parse: parseF,
          serialize: serializeF,
          type: "numeric",
          unit: {I: "°F", M: "°C"},
        }, 
        HUM : {
          id:1,
          title: "Humidity",
          parse: parseP, 
          serialize: serializeP,
          type: "numeric",
          unit: {I: "%", M: "%"},
          min:0,
          max:100
        },
        BINARY : {
          id:2,
          title: "Binary value",
          opts: { 
            1: {
              title: "On",
              icon: "binary-1.png"
            }, 
            0: {
              title: "Off",
              icon: "binary-0.png"
            }
          },
          type: "binary",
          parse: parseB, 
          serialize: serializeB,
        },
        PERCENTAGE : {
          id:3,
          title: "Percentage",
          parse: parseP, 
          serialize: serializeP,
          unit: {I: "%", M: "%"},
          type: "numeric",
          min: 0,
          max: 100,
        },
        PRESSURE : {
          id:4,
          title: "Pressure",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "hPa", M: "hPa"},
          decimals: 1,
          type: "numeric",
        }, 
        FORECAST : {
          id:5,
          title: "Forecast",
          opts: { 
            stable: { 
              icon: "forecast-stable.png",
              title: "Stable"
            }, 
            sunny: { 
              icon: "forecast-sunny.png",
              title: "Sunny"
            }, 
            cloudy: { 
              icon: "forecast-cloudy.png",
              title: "Cloudy"
            }, 
            unstable: { 
              icon: "forecast-unstable.png",
              title: "Unstable"
            }, 
            thunderstorm: { 
              icon: "forecast-thunderstorm.png",
              title: "Thunderstorm"
            }, 
            unknown: { 
              icon: "forecast-unknown.png",
              title: "Unknown"
            }, 
          },
          parse: parseForecast,
          serialize: serializeForecast,
          type: "text",
        },
        RAIN : {
          id:6,
          title: "Rain",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "in", M: "mm"},
          decimals: 1,
          type: "numeric",
        },
        RAINRATE : {
          id:7,
          title: "Rain Rate",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "in/h", M: "mm/h"},
          decimals: 1,
          type: "numeric",
        },
        WIND : {
          id:8,
          title: "Wind",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "mph", M: "m/s"} ,   // Knots?
          decimals: 1,
          type: "numeric",
        },
        GUST : {
          id:9,
          title: "Gust",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "mph", M: "m/s"},   
          decimals: 1,
          type: "numeric",
        },
        DIRECTION : {
          id:10,
          title: "Direction",
          parse: parseF,        // Should come in as degrees from north 
          serialize: serializeF,
          unit: {I: "°", M: "°"},
          type: "numeric",
        },
        UV : {
          id:11,
          title: "UV Level",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        WEIGHT : {
          id:12,
          title: "Weight",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "lb", M: "kg"},
          decimals: 1,
          type: "numeric",
        },
        DISTANCE : {
          id:13,
          title: "Distance",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "in", M: "cm"},
          type: "numeric",
        },
        IMPEDANCE : {
          id:14,
          title: "Impedance",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "Ω", M: "Ω"},
          type: "numeric",
        },
        ARMED : {
          id:15,
          title: "Armed Status",
          parse: parseB, 
          serialize: serializeB,
          type: "binary",
        },
        TRIPPED : {
          id:16,
          title: "Tripped Status",
          opts: { 
            1: { 
              title: "Tripped",
              icon: "door-1.png"
            }, 
            0: {
              title: "Untripped",
              icon: "door-0.png"
            }
          },
          parse: parseB, 
          serialize: serializeB,
          type: "binary",
          sensors: {
            DOOR: {
              opts: { 
                1: { 
                  title: "Open",
                  icon: "door-1.png"
                }, 
                0: {
                  title: "Closed",
                  icon: "door-0.png"
                }
              }
            },
            MOTION: {
              opts: { 
                1: { 
                  title: "Motion",
                  icon: "motion-1.png"
                }, 
                0: {
                  title: "No Motion",
                  icon: "motion-0.png"
                }
              }
            },
            SMOKE: {
              opts: { 
                1: { 
                  title: "Fire!",
                  icon: "smoke-1.png"
                }, 
                0: {
                  title: "No Fire",
                  icon: "smoke-0.png"
                }
              }
            }
          }
        },
        WATT : {
          id:17,
          title: "Watt",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "W", M: "W"},
          decimals: 0,
          default: 0,
          type: "numeric",
        },
        KWH : {
          id:18,
          title: "Energy Used",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "kWh", M: "kWh"},
          decimals: 1,
          type: "numeric",
        },
        SCENE_ON : {
          id:19,
          title: "Scene On",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        SCENE_OFF : {
          id:20,
          title: "Scene Off",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        HVAC_FLOW_STATE : {
          id:21,
          title: "HVAC Flow State",
          opts: { 
            Off: { title: "Off"}, 
            HeatOn: { title: "Heat On"},
            CoolOn: { title: "Cool On" },
            AutoChangeOver: { title: "Auto" }
          },
          parse: parseFlowState,
          serialize: serializeFlowState,
          type: "text",
        },
        HVAC_SPEED : {
          id:22,
          title: "HVAC Speed",
          parse: parseHvacSpeed, 
          serialize: serializeHvacSpeed,
          opts: {
            Min: { title: "Min"}, 
            Normal: { title: "Normal"}, 
            Max: { title: "Max"}, 
            Auto: { title: "Auto"}  
          },
          type: "text",
        },
        LIGHT_LEVEL : {
          id:23,
          title: "Light Level",
          parse: parseP, 
          serialize: serializeP,
          unit: {I: "%", M: "%"},
          type: "numeric",
          min: 0,
          max: 100,
        },
        VAR1 : {
          id:24,
          title: "Var 1",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        VAR2 : {
          id:25,
          title: "Var 2",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        VAR3 : {
          id:26,
          title: "Var 3",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        VAR4 : {
          id:27,
          title: "Var 4",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        VAR5 : {
          id:28,
          title: "Var 5",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        UP : {
          id:29,
          title: "Up",
          command: true,
          parse: parseS, 
          serialize: serializeS,
          type: "action",
        },
        DOWN : {
          id:30,
          title: "Down",
          parse: parseS, 
          serialize: serializeS,
          type: "action",
        },
        STOP : {
          id:31,
          title: "Stop",
          parse: parseS, 
          serialize: serializeS,
          type: "action",
        },
        IR_SEND : {
          id:32,
          title: "IR Send",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        IR_RECEIVE : {
          id:33,
          title: "IR Received",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        FLOW : {
          id:34,
          title: "Flow",
          parse: parseF,
          serialize: serializeF,
          sensors: {
            WATER: { unit: {I: "gal/min", M: "l/s"} },
            GAS: { unit: {I: "scfm", M: "scm/h"} },
          },
          decimals: 1,
          type: "numeric",
        },
        VOLUME : {
          id:35,
          title: "Volume",
          parse: parseF,
          serialize: serializeF,
          sensors: {
            WATER: { unit: {I: "gal", M: "l"} },
            GAS: { unit: {I: "SCF", M: "Nm³"} },
          },
          type: "numeric",
        },
        LOCK_STATUS : {
          id:36,
          title: "Lock Status",
          parse: parseB, 
          serialize: serializeB,
          opts: { 
            0: {
              title: "Open",
              icon: "lock-0.png"
            },
            1: { 
              title: "Lock",
              icon: "lock-1.png"
            }, 
          },
          type: "binary",
        },
        LEVEL : {
          id:37,
          title: "Level",
          parse: parseF,
          serialize: serializeF,
          sensors: {
            AIR_QUALITY: { unit: { I: "mg/m³", M: "mg/m³"} },
            DUST: { unit: {I: "mg/m³", M: "mg/m³"} }, 
            SOUND: { unit: {I: "dB", M: "dB"} }, 
            VIBRATION: { unit: {I: "Hz", M: "Hz"} }, 
            LIGHT_LEVEL: { unit: {I: "Lux", M: "Lux"} }, 
            MOISTURE: { unit: {I: "", M: ""} },
          },
          decimals: 1,
          type: "numeric",
        },
        VOLTAGE : {
          id:38,
          title: "Voltage",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "V", M: "V"},
          decimals: 1,
          type: "numeric",
        },
        CURRENT : {
          id:39,
          title: "Current",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "A", M: "A"},
          decimals: 1,
          type: "numeric",
        },
        RGB : {
          id:40,
          title: "RGB Color",
          parse: parseRGB,
          serialize: serializeRGB,
          type: "rgb",
        },
        RGBW : {
          id:41,
          title: "RGBW Color",
          parse: parseRGBW,
          serialize: serializeRGBW,
          type: "rgbw",
        },
        ID : {
          id:42,
          title: "Id",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        UNIT_PREFIX : {
          id:43,
          title: "Unit Prefix",
          parse: parseS, 
          serialize: serializeS,
          type: "text"
        },
        HVAC_SETPOINT_COOL : {
          id:44,
          title: "HVAC Setpoint Cool",
          parse: parseP, 
          serialize: serializeP,
          unit: {I: "°F", M: "°C"},
          decimals: 1,
          type: "numeric", 
          min:0, 
          max:100, 
        },
        HVAC_SETPOINT_HEAT : {
          id:45,
          title: "HVAC Setpoint Heat",
          parse: parseP, 
          serialize: serializeP,
          unit: {I: "°F", M: "°C"},
          decimals: 1,
          type: "numeric", 
          min:0, 
          max:100, 
        },
        HVAC_FLOW_MODE : {
          id:46,
          title: "HVAC Flow State",
          parse: parseHvacFlowMode, 
          serialize: serializeHvacFlowMode,
          opts: {
            Auto: {title: "Auto"}, 
            ContinuousOn: { title: "Continuous On"}, 
            PeriodicOn: {title: "Periodic On"} 
          },
          type: "text",
        },
        TEXT : {
          id:47,
          title: "Text",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        CUSTOM : {
          id:48,
          title: "Custom",
          parse: parseS, 
          serialize: serializeS,
          type: "text",
        },
        POSITION : {
          id:49,
          title: "Position",
          parse: parsePos, 
          serialize: serializePos,
          type: "map",
        },
        IR_RECORD : {
          id:50,
          title: "IR Record",
          parse: parseI,        
          serialize: serializeI,
          type: "numeric",
        },
        PH : {
          id:51,
          title: "PH",
          parse: parseF,
          serialize: serializeF,
          decimals: 1,
          type: "numeric",
        },
        ORP : {
          id:52,
          title: "ORP",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "mV", M: "mV"},
          decimals: 1,
          type: "numeric",
        },
        EC : {
          id:53,
          title: "EC",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "μS/cm", M: "μS/cm"},
          decimals: 1,
          type: "numeric",
        },
        VAR : {
          id:54,
          title: "Reactive Power",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "VAR", M: "VAR"},
          decimals: 1,
          type: "numeric",
        },
        VA : {
          id:55,
          title: "Apparent Power",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "VA", M: "VA"},
          decimals: 1,
          type: "numeric",
        },
    
        POWER_FACTOR : {
          id:56,
          title: "Power Factor",
          parse: parseF,
          serialize: serializeF,
          unit: {I: "", M: ""},
          decimals: 1,
          type: "numeric",
        },
    
        // Internal variables used by web interface
        I_BATTERY_LEVEL : {
          title: "Battery Level",
          id: 1000,
          parse: parseP,
          serialize: serializeP,
          unit: "%",
          type: "numeric",
        }, 
    };
    


  • @AndyDHill
    Look at "MockMySensors" sketch in MySensors examples. Maybe it helps with some types.


Log in to reply
 

Looks like your connection to MySensors Forum was lost, please wait while we try to reconnect.