private static string GetUnit(SensorType type, byte scale)
        {
            var tankCapacityUnits = new[] { "l", "cbm", "gal" };
            var distanceUnits = new [] { "m", "cm", "ft" };

            switch (type)
            {
                case SensorType.Temperature: return(scale == 1 ? "°F" : "°C");
                case SensorType.General: return (scale == 1 ? "" : "%");
                case SensorType.Luminance: return(scale == 1 ? "lux" : "%");
                case SensorType.Power: return(scale == 1 ? "BTU/h" : "W");
                case SensorType.RelativeHumidity: return("%");
                case SensorType.Velocity: return(scale == 1 ? "mph" : "m/s");
                case SensorType.Direction: return("");
                case SensorType.AtmosphericPressure: return(scale == 1 ? "inHg" : "kPa");
                case SensorType.BarometricPressure: return(scale == 1 ? "inHg" : "kPa");
                case SensorType.SolarRadiation: return("W/m2");
                case SensorType.DewPoint: return(scale == 1 ? "in/h" : "mm/h");
                case SensorType.RainRate: return(scale == 1 ? "F" : "C");
                case SensorType.TideLevel: return(scale == 1 ? "ft" : "m");
                case SensorType.Weight: return(scale == 1 ? "lb" : "kg");
                case SensorType.Voltage: return(scale == 1 ? "mV" : "V");
                case SensorType.Current: return(scale == 1 ? "mA" : "A");
                case SensorType.CO2: return("ppm");
                case SensorType.AirFlow: return(scale == 1 ? "cfm" : "m3/h");
                case SensorType.TankCapacity: return(tankCapacityUnits[scale]);
                case SensorType.Distance: return(distanceUnits[scale]);
                default: return string.Empty;
            }
        }

   public Sensor(string name, int index, SensorType sensorType,
 Hardware hardware, ParameterDescription[] parameterDescriptions, 
 ISettings settings)
       : this(name, index, false, sensorType, hardware,
   parameterDescriptions, settings)
   {
   }

        private static void SimulateDeviceDataTransmission(SensorType type, string topic, string deviceId)
        {
            int value = Random.Next(1, Math.Min(120, 100 + (_count/25)));

            if (value%13 == 0)
            {
                value = value/2;
            }
            else if (value%17 == 0)
            {
                value = value*2;
            }

            var payload =
                Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(
                    new SensorData
                    {
                        Value = value.ToString(),
                        DeviceId = deviceId,
                        Type = type
                    }));

            Client.Publish(topic, payload,
                MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE,
                true);
        }

        public Sensor(string name, int index, bool defaultHidden, 
            SensorType sensorType, Hardware hardware,
            ParameterDescription[] parameterDescriptions, ISettings settings)
        {
            this.index = index;
              this.defaultHidden = defaultHidden;
              this.sensorType = sensorType;
              this.hardware = hardware;
              Parameter[] parameters = new Parameter[parameterDescriptions == null ?
            0 : parameterDescriptions.Length];
              for (int i = 0; i < parameters.Length; i++ )
            parameters[i] = new Parameter(parameterDescriptions[i], this, settings);
              this.parameters = parameters;

              this.settings = settings;
              this.defaultName = name;
              this.name = settings.GetValue(
            new Identifier(Identifier, "name").ToString(), name);

              GetSensorValuesFromSettings();

              hardware.Closing += delegate(IHardware h) {
            SetSensorValuesToSettings();
              };
        }

 public GradientChanger(SensorManager sensorManager, SensorType sensorType, AbsoluteLayout layout)
 {
     this._sensorManager = sensorManager;
     this._sensorType = sensorType;
     _layout = layout;
     this.StartListening();
 }

        public Control(ISensor sensor, ISettings settings, float minSoftwareValue,
            float maxSoftwareValue)
        {
            this.identifier = new Identifier(sensor.Identifier, "control");
              this.settings = settings;
              this.minSoftwareValue = minSoftwareValue;
              this.maxSoftwareValue = maxSoftwareValue;
              //fan add
              this.sensorType = sensor.SensorType;

              float softValue = 0;
              if (!float.TryParse(settings.GetValue(
              new Identifier(identifier, "value").ToString(), "-a"),
            NumberStyles.Float, CultureInfo.InvariantCulture,
            out softValue)){
              this.softwareValue = 0;
              if (this.sensorType.Equals(SensorType.TinyFanControl))
              this.SoftwareValue = 50; //init value(when .config was not exist)
              }
              else
              this.softwareValue = softValue;
              int mode;
              if (!int.TryParse(settings.GetValue(
              new Identifier(identifier, "mode").ToString(),
              ((int)ControlMode.Default).ToString(CultureInfo.InvariantCulture)),
            NumberStyles.Integer, CultureInfo.InvariantCulture,
            out mode))
              {
            this.mode = ControlMode.Default;
              } else {
            this.mode = (ControlMode)mode;
              }
              int fanMode;
              if (!int.TryParse(settings.GetValue(
              new Identifier(identifier, "fanMode").ToString(),
              ((int)FanMode.Pin4).ToString(CultureInfo.InvariantCulture)),
            NumberStyles.Integer, CultureInfo.InvariantCulture,
            out fanMode))
              {
              this.fanMode = FanMode.Pin4;
              }
              else
              {
              this.fanMode = (FanMode)fanMode;
              }
              int fanFollow;//again
              if (!int.TryParse(settings.GetValue(
              new Identifier(identifier, "fanFollow").ToString(),
              ((int)FanFollow.NONE).ToString(CultureInfo.InvariantCulture)),
            NumberStyles.Integer, CultureInfo.InvariantCulture,
            out fanFollow))
              {
              this.fanFollow = FanFollow.NONE;
              }
              else
              {
              this.fanFollow = (FanFollow)fanFollow;
              }
        }

        public TypeNode(SensorType sensorType)
            : base()
        {
            this.sensorType = sensorType;

              switch (sensorType) {
            case SensorType.Voltage:
              this.Image = Utilities.EmbeddedResources.GetImage("voltage.png");
              this.Text = "电压";
              break;
            case SensorType.Clock:
              this.Image = Utilities.EmbeddedResources.GetImage("clock.png");
              this.Text = "频率";
              break;
            case SensorType.Load:
              this.Image = Utilities.EmbeddedResources.GetImage("load.png");
              this.Text = "负载";
              break;
            case SensorType.Temperature:
              this.Image = Utilities.EmbeddedResources.GetImage("temperature.png");
              this.Text = "温度";
              break;
            case SensorType.Fan:
              this.Image = Utilities.EmbeddedResources.GetImage("fan.png");
              this.Text = "风扇";
              break;
            case SensorType.Flow:
              this.Image = Utilities.EmbeddedResources.GetImage("flow.png");
              this.Text = "Flows";
              break;
            case SensorType.Control:
              this.Image = Utilities.EmbeddedResources.GetImage("control.png");
              this.Text = "控制台";
              break;
            case SensorType.TinyFanControl:
              this.Image = Utilities.EmbeddedResources.GetImage("control.png");
              this.Text = "控制台";
              break;
            case SensorType.Level:
              this.Image = Utilities.EmbeddedResources.GetImage("level.png");
              this.Text = "Levels";
              break;
            case SensorType.Power:
              this.Image = Utilities.EmbeddedResources.GetImage("power.png");
              this.Text = "功率";
              break;
            case SensorType.Data:
              this.Image = Utilities.EmbeddedResources.GetImage("data.png");
              this.Text = "Data";
              break;
            case SensorType.Factor:
              this.Image = Utilities.EmbeddedResources.GetImage("factor.png");
              this.Text = "Factors";
              break;
              }

              NodeAdded += new NodeEventHandler(TypeNode_NodeAdded);
              NodeRemoved += new NodeEventHandler(TypeNode_NodeRemoved);
        }

 public AndroidSensorListener(SensorType sensorType, SensorDelay sensorDelay, Action<SensorStatus> sensorAccuracyChangedCallback, Action<SensorEvent> sensorValueChangedCallback)
 {
     _sensorType = sensorType;
     _sensorDelay = sensorDelay;
     _sensorAccuracyChangedCallback = sensorAccuracyChangedCallback;
     _sensorValueChangedCallback = sensorValueChangedCallback;
     _listening = false;
 }

 public VideoStream CreateVideoStream(SensorType sensorType)
 {
     if (!this.isValid)
         return null;
     if (!VideoStreams_Cache.ContainsKey(sensorType))
         VideoStreams_Cache[sensorType] = VideoStream.Private_Create(this, sensorType);
     return VideoStreams_Cache[sensorType];
 }

 public CollisionSensor(CollisionBox linkedCollisionBox, SensorType sensorType, int sensorDepth)
     : base(0, 0, Vector2.Zero, Color.Blue)
 {
     this.linkedCollisionBox = linkedCollisionBox;
     this.sensorType = sensorType;
     this.sensorDepth = sensorDepth;
     SetSensorDetails();
 }

        private void UpdateValue(Device sd, ZibaseDll.ZiBase.SensorInfo si, SensorType st)
        {
            DeviceValue dv = null;

            var q = sd.Values.Where(x => x.ValueType == st);
            if (q.Any())
            {
                dv = q.First();
                dv.Value = si.sHTMLValue;

                if (st == SensorType.ENERGY_KW || st == SensorType.ENERGY_KWH)
                {
                    String[] splitted = si.sValue.Split(new char[] { ' ' });
                    if (splitted.Length == 2)
                    {
                        float val = Convert.ToSingle(dv.Value,System.Globalization.CultureInfo.InvariantCulture); // Convert.ToInt32(splitted[0]);
                        //val /= 1000.0F;
                        dv.DisplayValue = val + " " + splitted[1];
                    }
                }
                else
                    dv.DisplayValue = si.sValue;
            }
            else
            {
                dv = new DeviceValue {Value = si.sHTMLValue, ValueType = st};
                if (st == SensorType.ENERGY_KW || st == SensorType.ENERGY_KWH)
                {
                    String[] splitted = si.sValue.Split(new char[] { ' ' });
                    if (splitted.Length == 2)
                    {
                        //float val = Convert.ToInt32(splitted[0]);
                        //val /= 1000.0F;
                        float val = Convert.ToSingle(dv.Value, System.Globalization.CultureInfo.InvariantCulture); // Convert.ToInt32(splitted[0]);
                        dv.DisplayValue = val + " " + splitted[1];
                    }
                }
                else
                    dv.DisplayValue = si.sValue;
                sd.Values.Add(dv);
            }

            // if no HSDevice associated,look for the current device in HS
            // IOMisc contains the ID followed by the SensorType
            if (dv.HSDevice == null)
            {
                var q2 = HSDevice.Where(x => x.iomisc.Contains(si.sID) && x.iomisc.Contains(st.ToString()));

                if (q2.Any())
                {
                    dv.AlreadyInHS = true;
                    dv.HSDevice = q2.First();
                }
            }
            dv.DwValue = si.dwValue;
            dv.HSUpdate();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SmartAttribute"/> class.
 /// </summary>
 /// <param name="identifier">The SMART identifier of the attribute.</param>
 /// <param name="name">The name of the attribute.</param>
 /// <param name="rawValueConversion">A delegate for converting the raw byte 
 /// array into a value (or null to use the attribute value).</param>
 /// <param name="sensorType">Type of the sensor or null if no sensor is to 
 /// be created.</param>
 /// <param name="sensorChannel">If there exists more than one attribute with 
 /// the same sensor channel and type, then a sensor is created only for the  
 /// first attribute.</param>
 /// <param name="defaultHiddenSensor">True to hide the sensor initially.</param>
 public SmartAttribute(byte identifier, string name,
     RawValueConversion rawValueConversion, SensorType? sensorType,
     int sensorChannel, bool defaultHiddenSensor = false)
 {
     this.Identifier = identifier;
       this.Name = name;
       this.rawValueConversion = rawValueConversion;
       this.SensorType = sensorType;
       this.SensorChannel = sensorChannel;
       this.DefaultHiddenSensor = defaultHiddenSensor;
 }

        internal SensorMultiLevelReport(Node node, byte[] payload) : base(node)
        {
            if (payload == null)
                throw new ArgumentNullException(nameof(payload));
            if (payload.Length < 3)
                throw new ReponseFormatException($"The response was not in the expected format. {GetType().Name}: Payload: {BitConverter.ToString(payload)}");

            Type = (SensorType)payload[0];
            Value = PayloadConverter.ToFloat(payload.Skip(1).ToArray(), out Scale);
            Unit = GetUnit(Type, Scale);
        }

        public SensorInfoImpl(int aId, string aName, SensorType aSensorType, SensorSide aSide, double aShift)
        {
            if (string.IsNullOrEmpty(aName)) {
                throw new ArgumentNullException("aName");
            }

            id = aId;
            name = aName;
            sType = aSensorType;
            side = aSide;
            shift = aShift;
        }

        public object GetImageArray(Bitmap bmp, SensorType sensorType, LumaConversionMode conversionMode)
        {
            this.imageWidth = bmp.Width;
            this.imageHeight = bmp.Height;

            if (sensorType == SensorType.Monochrome)
                return NativeHelpers.GetMonochromePixelsFromBitmap(bmp, conversionMode);
            else if (sensorType == SensorType.Color)
                return NativeHelpers.GetColourPixelsFromBitmap(bmp);
            else
                throw new NotSupportedException(string.Format("Sensor type {0} is not currently supported.", sensorType));
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SmartAttribute"/> class.
 /// </summary>
 /// <param name="identifier">The SMART identifier of the attribute.</param>
 /// <param name="name">The name of the attribute.</param>
 /// <param name="rawValueConversion">A delegate for converting the raw byte 
 /// array into a value (or null to use the attribute value).</param>
 /// <param name="sensorType">Type of the sensor or null if no sensor is to 
 /// be created.</param>
 /// <param name="sensorChannel">If there exists more than one attribute with 
 /// the same sensor channel and type, then a sensor is created only for the  
 /// first attribute.</param>
 /// <param name="defaultHiddenSensor">True to hide the sensor initially.</param>
 /// <param name="parameterDescriptions">Description for the parameters of the sensor 
 /// (or null).</param>
 public SmartAttribute(byte identifier, string name,
   RawValueConversion rawValueConversion, SensorType? sensorType, 
   int sensorChannel, bool defaultHiddenSensor = false,
   ParameterDescription[] parameterDescriptions = null) 
 {
   this.Identifier = identifier;
   this.Name = name;
   this.rawValueConversion = rawValueConversion;
   this.SensorType = sensorType;
   this.SensorChannel = sensorChannel;
   this.DefaultHiddenSensor = defaultHiddenSensor;
   this.ParameterDescriptions = parameterDescriptions;
 }

        public void SetImageArray(object imageArray, int imageWidth, int imageHeight, SensorType sensorType)
        {
            this.imageArray = imageArray;
            this.imageWidth = imageWidth;
            this.imageHeight = imageHeight;
            this.sensorType = sensorType;

            objPixelArray = null;
            intPixelArray = null;
            intColourPixelArray = null;
            objColourPixelArray = null;

            if (sensorType == SensorType.Monochrome)
            {
                if (imageArray is int[,])
                {
                    intPixelArray = (int[,])imageArray;
                    isColumnMajor = intPixelArray.GetLength(0) == imageWidth;
                    isRowMajor = intPixelArray.GetLength(0) == imageHeight;
                    return;
                }
                else if (imageArray is object[,])
                {
                    objPixelArray = (object[,])imageArray;
                    isColumnMajor = objPixelArray.GetLength(0) == imageWidth;
                    isRowMajor = objPixelArray.GetLength(0) == imageHeight;
                    return;
                }
            }
            else
            {
                // Color sensor type is represented as 3-dimentional array that can be either: [3, height, width], [width, height, 3]
                if (imageArray is int[, ,])
                {
                    intColourPixelArray = (int[, ,])imageArray;
                    isColumnMajor = intColourPixelArray.GetLength(0) == imageWidth;
                    isRowMajor = intColourPixelArray.GetLength(0) == 3;
                    return;
                }
                else if (imageArray is object[, ,])
                {
                    objColourPixelArray = (object[, ,])imageArray;
                    isColumnMajor = objColourPixelArray.GetLength(0) == imageWidth;
                    isRowMajor = objColourPixelArray.GetLength(0) == 3;
                    return;
                }
            }

            throw new ArgumentException();
        }

			/// <summary>
			/// Gets the sensor type and mode.
			/// </summary>
			/// <param name="type">Type.</param>
			/// <param name="mode">Mode.</param>
			protected void GetTypeAndMode(out SensorType type, out SensorMode mode){
				if(!isInitialized)
					Initialize();
				var command = new Command(2,0,200,true);
				command.Append(ByteCodes.InputDevice);
				command.Append(InputSubCodes.GetTypeMode);
				command.Append(this.DaisyChainLayer);
				command.Append(this.Port);
				
				command.Append((byte)0, VariableScope.Global);
				command.Append((byte)1, VariableScope.Global);
				var reply = Connection.SendAndReceive(command);
				Error.CheckForError(reply,200);
				type = (SensorType) reply.GetByte(3);
				mode = (SensorMode) reply.GetByte(4);
			}

        public Sensor(string name, int index, bool defaultHidden, 
      SensorType sensorType, Hardware hardware, 
      ParameterDescription[] parameterDescriptions)
        {
            this.index = index;
              this.defaultHidden = defaultHidden;
              this.sensorType = sensorType;
              this.hardware = hardware;
              Parameter[] parameters = new Parameter[parameterDescriptions == null ?
            0 : parameterDescriptions.Length];
              for (int i = 0; i < parameters.Length; i++ )
            parameters[i] = new Parameter(parameterDescriptions[i], this);
              this.parameters = parameters;

              this.defaultName = name;
              this.name = name;
        }

 internal static Location GenerateLocation(SensorType sensorType, int seed)
 {
     IList<Sensor> list = new List<Sensor>();
     switch (sensorType)
     {
         case SensorType.All:
             list.Add(WiFiSensorHelper.GetASensor(seed));
             list.Add(WiFiConnectedSensorHelper.GetASensor());
             break;
         case SensorType.WiFiConnected:
             list.Add(WiFiConnectedSensorHelper.GetASensor());
             break;
         case SensorType.WiFi:
             list.Add(WiFiSensorHelper.GetASensor(seed));
             break;
     }
     return new Location(list);
 }