2021-08-06 1.配合海克传感器，调整处理模拟量传感器状态

JLChen

2021-08-06 47675876dbc24ea2fa54a1f4090f1a998ed2e5cf

2021-08-06 1.配合海克传感器，调整处理模拟量传感器状态

 README.md

@@ -66,8 +66,6 @@
HDLDeviceManager.saveDevicesDataList();


提供声必可SDK项目

##Version 1.0.2
1.新增地热模块和新风系统控制和读取状态接口；
2.新增地热模块和新风系统控制演示页面；

 READMEµÄ¸±±¾.md

New file
@@ -0,0 +1,74 @@
## Android_HDL_SDK_XW

HDL XW Android SDK  Copyright (c) 2019 HDL Inc.

SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.7.2.20201020_beta
1.增加RGB和CCT灯设备支持


SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.7.0.20200601_beta
1.如果温度为0自动修改为28

SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.6.9.20200316_beta
1.增加小类是3的音乐播放器支持;
2.加地热模块单独控制温度接口，接口自动根据当前模式设置当前模式的温度参数，不需要上层自己判断;(HDLCommand.geothermalCtrlTemp())
3.增加简易编程搜索回复,通过配置大类小类，让声必可设备模拟成第三方音乐播放器被搜索 ;
//配置简易编程搜索的参数 (SDK åˆå§‹åŒ–的时候配置一次)
/**
 * é…ç½®ç®€æ˜“编程搜索返回的默认参数
 * @param mSDKLocalBigClass å¤§ç±»ID
 * @param mSDKLocalSmallClass å°ç±»ID
 * @param mSDKLocalRemark å¤‡æ³¨
 */
public static void setEasyProgrammingSearchLocalData(int mSDKLocalBigClass, int mSDKLocalSmallClass, String mSDKLocalRemark);
声必可设备setEasyProgrammingSearchLocalData(9,1,"声必可音乐");

原地热对应关系  
HDL å£°å¿…可
普通 è‡ªåŠ¨
白天 æ‰‹åŠ¨
离开 ä¼‘眠
2020-03-15 ä¿®æ”¹ä¸º
HDL å£°å¿…可
普通 æ‰‹åŠ¨
白天 è‡ªåŠ¨
离开 ä¼‘眠

SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.6.9.20200118_beta
1.修复RCU混合调光混合开关 ç±»æ¨¡å—，使用物理回路问题;
2.增加默认获取WiFi连接的广播配置方法;


SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.6.8.20191016_beta
1.控制都改成广播形式了，不记录一端口的IP。


SDK ç‰ˆæœ¬ï¼šhdl_lib_v1.6.4.20191015_beta
1.增加搜索完设备或者备注刷新完，自动保存一次数据到本地。
2.增加读取本地数据接口；
3.增加刷新所有设备的备注和状态接口；

接口说明：
    /**
     * è¯»å–和加载本地数据
     */
    private void getLocalDevicesDataList() {
        devicesDatas = HDLDeviceManager.getLocalDevicesDataList();
        if (devicesDatas.size() > 0) {
            updateDeviceListView();
            HandleSearch.refreshAllDevicesStateAndRemarks();//如果本地有数据，可以调用该方法，遍历发送指令，刷新所有设备的备注和状态
        } else {
            //showToast("本地数据为空");
        }
    }

/**保存数据到本地接口，除SDK自动保存后，上层可以选择手动调用保存*/
HDLDeviceManager.saveDevicesDataList();


提供声必可SDK项目

##Version 1.0.2
1.新增地热模块和新风系统控制和读取状态接口；
2.新增地热模块和新风系统控制演示页面；
3.targetSdkVersion 28；

 app/src/main/java/com/hdl/sdk/hdl_sdk/activity/SensorActivity.java

@@ -9,6 +9,7 @@


import com.hdl.sdk.hdl_core.HDLAppliances.Config.HDLApConfig;
import com.hdl.sdk.hdl_core.HDLAppliances.HDLSensor.SensorStateBackInfo;
import com.hdl.sdk.hdl_core.HDLDeviceManger.Bean.AppliancesInfo;
import com.hdl.sdk.hdl_core.HDLDeviceManger.Core.HDLCommand;
import com.hdl.sdk.hdl_core.HDLDeviceManger.EventBusEvent.DryContactSensorBackEvent;
@@ -56,7 +57,7 @@
        initOnClick();
        displayStateView();
        //从网络上查询刷新一次设备状态，待调试
        HDLCommand.getDryContactSensorStateFromNetwork(appliancesInfo);
        HDLCommand.getSensorStateFromNetwork(appliancesInfo);
    }

    /**
@@ -94,7 +95,7 @@
            @Override
            public void onClick(View view) {
                //从网络上查询刷新一次设备状态，待调试
                HDLCommand.getDryContactSensorStateFromNetwork(appliancesInfo);
                HDLCommand.getSensorStateFromNetwork(appliancesInfo);
            }
        });
    }
@@ -102,33 +103,34 @@
    private void displayStateView() {

        switch (appliancesInfo.getDeviceType()) {
//            case HDLApConfig.TYPE_SENSOR_TEMP:////2019-07-03 å±è”½
//            case HDLApConfig.TYPE_SENSOR_HUMIDITY:
//            case HDLApConfig.TYPE_SENSOR_ILLUMINACE:
//            case HDLApConfig.TYPE_SENSOR_VOC:
//            case HDLApConfig.TYPE_SENSOR_PM_2_POINT_5:
//            case HDLApConfig.TYPE_SENSOR_C02:
//            case HDLApConfig.TYPE_SENSOR_LPG:
            case HDLApConfig.TYPE_SENSOR_TEMP:////2019-07-03 å±è”½
            case HDLApConfig.TYPE_SENSOR_HUMIDITY:
            case HDLApConfig.TYPE_SENSOR_ILLUMINACE:
            case HDLApConfig.TYPE_SENSOR_VOC:
            case HDLApConfig.TYPE_SENSOR_PM_2_POINT_5:
            case HDLApConfig.TYPE_SENSOR_C02:
            case HDLApConfig.TYPE_SENSOR_LPG:
//            case HDLApConfig.TYPE_SENSOR_CO_H2:
//            case HDLApConfig.TYPE_SENSOR_CH4:
            case HDLApConfig.TYPE_SENSOR_CH4:
//            case HDLApConfig.TYPE_SENSOR_SMOG:
//            case HDLApConfig.TYPE_SENSOR_WIND_SPEED:
//            case HDLApConfig.TYPE_SENSOR_WIND_PRESSURE:
//            case HDLApConfig.TYPE_SENSOR_LIQUID_FLOW:
//            case HDLApConfig.TYPE_SENSOR_LIQUID_PRESSURE:
//            case HDLApConfig.TYPE_SENSOR_LIQUID_DEPTH:
//            case HDLApConfig.TYPE_SENSOR_RAIN_FALL:
//            case HDLApConfig.TYPE_SENSOR_WEIGHT:
//            case HDLApConfig.TYPE_SENSOR_HEIGHT_LENGTH:
//            case HDLApConfig.TYPE_SENSOR_OBJECT_SPEED:
//            case HDLApConfig.TYPE_SENSOR_SHAKE:
//            case HDLApConfig.TYPE_SENSOR_VOLTAGE:
//            case HDLApConfig.TYPE_SENSOR_ELECTRICITY:
//            case HDLApConfig.TYPE_SENSOR_POWER:
            case HDLApConfig.TYPE_SENSOR_WIND_SPEED:
            case HDLApConfig.TYPE_SENSOR_WIND_PRESSURE:
            case HDLApConfig.TYPE_SENSOR_LIQUID_FLOW:
            case HDLApConfig.TYPE_SENSOR_LIQUID_PRESSURE:
            case HDLApConfig.TYPE_SENSOR_LIQUID_DEPTH:
            case HDLApConfig.TYPE_SENSOR_RAIN_FALL:
            case HDLApConfig.TYPE_SENSOR_WEIGHT:
            case HDLApConfig.TYPE_SENSOR_HEIGHT_LENGTH:
            case HDLApConfig.TYPE_SENSOR_OBJECT_SPEED:
            case HDLApConfig.TYPE_SENSOR_SHAKE:
            case HDLApConfig.TYPE_SENSOR_VOLTAGE:
            case HDLApConfig.TYPE_SENSOR_ELECTRICITY:
            case HDLApConfig.TYPE_SENSOR_POWER:
//            case HDLApConfig.TYPE_SENSOR_FLOODING:
//            case HDLApConfig.TYPE_SENSOR_DOOR_MAGNET:
//            case HDLApConfig.TYPE_SENSOR_EMERGENCY_BUTTON:

//
//          ä¸‹é¢çš„都是用干节点指令
            case HDLApConfig.TYPE_SENSOR_DRY_CONTACT: //干节点
            case HDLApConfig.TYPE_SENSOR_MOVEMENT_DETECTOR: //红外感应传感器
            case HDLApConfig.TYPE_SENSOR_CO_H2:         //煤气传感器
@@ -177,29 +179,30 @@
    }


//    /**
//     * ä¼ æ„Ÿå™¨çŠ¶æ€å›žè°ƒ Event
//     *
//     * @param event
//     */
//    @Subscribe(threadMode = ThreadMode.MAIN)
//    public void onSensorStateBackInfoMain(SensorStateBackInfo event) {
//        if (event.getAppliancesInfo().getDeviceSubnetID() == appliancesInfo.getDeviceSubnetID()
//                && event.getAppliancesInfo().getDeviceDeviceID() == appliancesInfo.getDeviceDeviceID()
//                && event.getAppliancesInfo().getChannelNum() == appliancesInfo.getChannelNum()
//        ) {
//            //这个返回的信息是当前状态的
//            switch (event.getAppliancesInfo().getDeviceType()) {
//                case HDLApConfig.TYPE_SENSOR_DRY_CONTACT://2019-07-03 å±è”½
    /**
     * ä¼ æ„Ÿå™¨çŠ¶æ€å›žè°ƒ Event
     *
     * @param event
     */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onSensorStateBackInfoMain(SensorStateBackInfo event) {
        if (event.getAppliancesInfo().getDeviceSubnetID() == appliancesInfo.getDeviceSubnetID()
                && event.getAppliancesInfo().getDeviceDeviceID() == appliancesInfo.getDeviceDeviceID()
                && event.getAppliancesInfo().getChannelNum() == appliancesInfo.getChannelNum()
                && event.getAppliancesInfo().getDeviceType() == appliancesInfo.getDeviceType()//设备类型也要匹配解决混合回路
        ) {
            //这个返回的信息是当前状态的
            switch (event.getAppliancesInfo().getDeviceType()) {
//                case HDLApConfig.TYPE_SENSOR_DRY_CONTACT:
//                    //传感器 å¹²æŽ¥ç‚¹ ã€‚只有开关状态
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---干接点状态失败，请重新再试");
//                        return;
//                    }
//                    float dryContactValue = (float) event.getAppliancesInfo().getCurState();
//                    float dryContactValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String dryContactUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---干接点状态：" + dryContactValue + dryContactUnit);
//                    HDLLog.Log("传感器---干接点状态：" + dryContactValue + dryContactUnit);
//                    HDLLog.I("传感器---干接点状态：" + dryContactValue + dryContactUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_MOVEMENT_DETECTOR:
//                    //传感器 ç§»åŠ¨æŽ¢æµ‹ ã€‚灵敏度
@@ -207,274 +210,274 @@
//                        showToast("获取传感器---移动探测灵敏度状态失败，请重新再试");
//                        return;
//                    }
//                    float mdValue = (float) event.getAppliancesInfo().getCurState();
//                    float mdValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String mdValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---移动探测灵敏度：" + mdValue + mdValueUnit);
//                    HDLLog.Log("传感器---移动探测灵敏度：" + mdValue + mdValueUnit);
//                    HDLLog.I("传感器---移动探测灵敏度：" + mdValue + mdValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_TEMP:
//                    //传感器 æ¸©åº¦
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---温度状态失败，请重新再试");
//                        return;
//                    }
//                    float tempValue = (float) event.getAppliancesInfo().getCurState();
//                    String tempValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---温度：" + tempValue + tempValueUnit);
//                    HDLLog.Log("传感器---温度：" + tempValue + tempValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_HUMIDITY:
//                    //传感器 æ¹¿åº¦
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---湿度状态失败，请重新再试");
//                        return;
//                    }
//                    float humidityValue = (float) event.getAppliancesInfo().getCurState();
//                    String humidityValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---湿度：" + humidityValue + humidityValueUnit);
//                    HDLLog.Log("传感器---湿度：" + humidityValue + humidityValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_ILLUMINACE:
//                    //传感器 ç…§åº¦
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---照度状态失败，请重新再试");
//                        return;
//                    }
//                    float illuminaceValue = (float) event.getAppliancesInfo().getCurState();
//                    String illuminaceValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---照度：" + illuminaceValue + illuminaceValueUnit);
//                    HDLLog.Log("传感器---照度：" + illuminaceValue + illuminaceValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_VOC:
//                    //传感器 å½“前空气质量等级
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---当前空气质量等级状态失败，请重新再试");
//                        return;
//                    }
//                    float vocValue = (float) event.getAppliancesInfo().getCurState();
//                    String vocValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---当前空气质量等级：" + vocValue + vocValueUnit);
//                    HDLLog.Log("传感器---当前空气质量等级：" + vocValue + vocValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_PM_2_POINT_5:
//                    //传感器 pm2.5
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---pm2.5状态失败，请重新再试");
//                        return;
//                    }
//                    float pm2_5Value = (float) event.getAppliancesInfo().getCurState();
//                    String pm2_5ValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---pm2.5：" + pm2_5Value + pm2_5ValueUnit);
//                    HDLLog.Log("传感器---pm2.5：" + pm2_5Value + pm2_5ValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_C02:
//                    //传感器 äºŒæ°§åŒ–碳
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---二氧化碳状态失败，请重新再试");
//                        return;
//                    }
//                    float co2Value = (float) event.getAppliancesInfo().getCurState();
//                    String co2ValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---二氧化碳：" + co2Value + co2ValueUnit);
//                    HDLLog.Log("传感器---二氧化碳：" + co2Value + co2ValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_LPG:
//                    //传感器 æ¶²åŒ–石油气
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---液化石油气状态失败，请重新再试");
//                        return;
//                    }
//                    float lpgValue = (float) event.getAppliancesInfo().getCurState();
//                    String lpgValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---液化石油气：" + lpgValue + lpgValueUnit);
//                    HDLLog.Log("传感器---液化石油气：" + lpgValue + lpgValueUnit);
//                    break;
                case HDLApConfig.TYPE_SENSOR_TEMP:
                    //传感器 æ¸©åº¦
                    if (!event.isSuccess()) {
                        showToast("获取传感器---温度状态失败，请重新再试");
                        return;
                    }
                    float tempValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String tempValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---温度：" + tempValue + tempValueUnit);
                    HDLLog.I("传感器---温度：" + tempValue + tempValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_HUMIDITY:
                    //传感器 æ¹¿åº¦
                    if (!event.isSuccess()) {
                        showToast("获取传感器---湿度状态失败，请重新再试");
                        return;
                    }
                    float humidityValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String humidityValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---湿度：" + humidityValue + humidityValueUnit);
                    HDLLog.I("传感器---湿度：" + humidityValue + humidityValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_ILLUMINACE:
                    //传感器 ç…§åº¦
                    if (!event.isSuccess()) {
                        showToast("获取传感器---照度状态失败，请重新再试");
                        return;
                    }
                    float illuminaceValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String illuminaceValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---照度：" + illuminaceValue + illuminaceValueUnit);
                    HDLLog.I("传感器---照度：" + illuminaceValue + illuminaceValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_VOC:
                    //传感器 å½“前空气质量等级
                    if (!event.isSuccess()) {
                        showToast("获取传感器---当前空气质量等级状态失败，请重新再试");
                        return;
                    }
                    float vocValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String vocValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---当前空气质量等级：" + vocValue + vocValueUnit);
                    HDLLog.I("传感器---当前空气质量等级：" + vocValue + vocValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_PM_2_POINT_5:
                    //传感器 pm2.5
                    if (!event.isSuccess()) {
                        showToast("获取传感器---pm2.5状态失败，请重新再试");
                        return;
                    }
                    float pm2_5Value = (float) event.getAppliancesInfo().getCurStateObject();
                    String pm2_5ValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---pm2.5：" + pm2_5Value + pm2_5ValueUnit);
                    HDLLog.I("传感器---pm2.5：" + pm2_5Value + pm2_5ValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_C02:
                    //传感器 äºŒæ°§åŒ–碳
                    if (!event.isSuccess()) {
                        showToast("获取传感器---二氧化碳状态失败，请重新再试");
                        return;
                    }
                    float co2Value = (float) event.getAppliancesInfo().getCurStateObject();
                    String co2ValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---二氧化碳：" + co2Value + co2ValueUnit);
                    HDLLog.I("传感器---二氧化碳：" + co2Value + co2ValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_LPG:
                    //传感器 æ¶²åŒ–石油气
                    if (!event.isSuccess()) {
                        showToast("获取传感器---液化石油气状态失败，请重新再试");
                        return;
                    }
                    float lpgValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String lpgValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---液化石油气：" + lpgValue + lpgValueUnit);
                    HDLLog.I("传感器---液化石油气：" + lpgValue + lpgValueUnit);
                    break;
//                case HDLApConfig.TYPE_SENSOR_CO_H2:
//                    //传感器 äººå·¥ç…¤æ°”
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---人工煤气状态失败，请重新再试");
//                        return;
//                    }
//                    float coh2Value = (float) event.getAppliancesInfo().getCurState();
//                    float coh2Value = (float) event.getAppliancesInfo().getCurStateObject();
//                    String coh2ValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---人工煤气：" + coh2Value + coh2ValueUnit);
//                    HDLLog.Log("传感器---人工煤气：" + coh2Value + coh2ValueUnit);
//                    HDLLog.I("传感器---人工煤气：" + coh2Value + coh2ValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_CH4:
//                    //传感器 å¤©ç„¶æ°”
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---天然气状态失败，请重新再试");
//                        return;
//                    }
//                    float ch4Value = (float) event.getAppliancesInfo().getCurState();
//                    String ch4ValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---天然气：" + ch4Value + ch4ValueUnit);
//                    HDLLog.Log("传感器---天然气：" + ch4Value + ch4ValueUnit);
//                    break;
                case HDLApConfig.TYPE_SENSOR_CH4:
                    //传感器 å¤©ç„¶æ°”
                    if (!event.isSuccess()) {
                        showToast("获取传感器---天然气状态失败，请重新再试");
                        return;
                    }
                    float ch4Value = (float) event.getAppliancesInfo().getCurStateObject();
                    String ch4ValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---天然气：" + ch4Value + ch4ValueUnit);
                    HDLLog.I("传感器---天然气：" + ch4Value + ch4ValueUnit);
                    break;
//                case HDLApConfig.TYPE_SENSOR_SMOG:
//                    //传感器 çƒŸé›¾
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---烟雾状态失败，请重新再试");
//                        return;
//                    }
//                    float smogValue = (float) event.getAppliancesInfo().getCurState();
//                    float smogValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String smogValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---烟雾：" + smogValue + smogValueUnit);
//                    HDLLog.Log("传感器---烟雾：" + smogValue + smogValueUnit);
//                    HDLLog.I("传感器---烟雾：" + smogValue + smogValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_WIND_SPEED:
//                    //传感器 é£Žé€Ÿ
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---风速状态失败，请重新再试");
//                        return;
//                    }
//                    float windSpeedValue = (float) event.getAppliancesInfo().getCurState();
//                    String windSpeedValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---风速：" + windSpeedValue + windSpeedValueUnit);
//                    HDLLog.Log("传感器---风速：" + windSpeedValue + windSpeedValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_WIND_PRESSURE:
//                    //传感器 é£ŽåŽ‹
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---风压状态失败，请重新再试");
//                        return;
//                    }
//                    float windPressureValue = (float) event.getAppliancesInfo().getCurState();
//                    String windPressureValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---风压：" + windPressureValue + windPressureValueUnit);
//                    HDLLog.Log("传感器---风压：" + windPressureValue + windPressureValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_LIQUID_FLOW:
//                    //传感器 æ¶²ä½“流量
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---液体流量状态失败，请重新再试");
//                        return;
//                    }
//                    float liquidFlowValue = (float) event.getAppliancesInfo().getCurState();
//                    String liquidFlowValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---液体流量：" + liquidFlowValue + liquidFlowValueUnit);
//                    HDLLog.Log("传感器---液体流量：" + liquidFlowValue + liquidFlowValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_LIQUID_PRESSURE:
//                    //传感器 æ¶²ä½“压力
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---液体压力状态失败，请重新再试");
//                        return;
//                    }
//                    float liquidPressureValue = (float) event.getAppliancesInfo().getCurState();
//                    String liquidPressureValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---液体压力：" + liquidPressureValue + liquidPressureValueUnit);
//                    HDLLog.Log("传感器---液体压力：" + liquidPressureValue + liquidPressureValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_LIQUID_DEPTH:
//                    //传感器 æ¶²ä½“深度
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---液体深度状态失败，请重新再试");
//                        return;
//                    }
//                    float liquidDepthValue = (float) event.getAppliancesInfo().getCurState();
//                    String liquidDepthValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---液体深度：" + liquidDepthValue + liquidDepthValueUnit);
//                    HDLLog.Log("传感器---液体深度：" + liquidDepthValue + liquidDepthValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_RAIN_FALL:
//                    //传感器 é›¨é‡
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---雨量状态失败，请重新再试");
//                        return;
//                    }
//                    float rainFallValue = (float) event.getAppliancesInfo().getCurState();
//                    String rainFallValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---雨量：" + rainFallValue + rainFallValueUnit);
//                    HDLLog.Log("传感器---雨量：" + rainFallValue + rainFallValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_WEIGHT:
//                    //传感器 é‡é‡
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---重量状态失败，请重新再试");
//                        return;
//                    }
//                    float weightValue = (float) event.getAppliancesInfo().getCurState();
//                    String weightValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---重量：" + weightValue + weightValueUnit);
//                    HDLLog.Log("传感器---重量：" + weightValue + weightValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_HEIGHT_LENGTH:
//                    //传感器 é‡é‡
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---重量状态失败，请重新再试");
//                        return;
//                    }
//                    float height_lengthValue = (float) event.getAppliancesInfo().getCurState();
//                    String height_lengthValueUnit = ((SensorStateBackInfo) event).getUnite();
//                    showToast("传感器---重量：" + height_lengthValue + height_lengthValueUnit);
//                    HDLLog.Log("传感器---重量：" + height_lengthValue + height_lengthValueUnit);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_OBJECT_SPEED:
//                    //传感器 ç‰©ä½“速度
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---物体速度状态失败，请重新再试");
//                        return;
//                    }
//                    float objectSpeedValue = (float) event.getAppliancesInfo().getCurState();
//                    String objectSpeedUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---物体速度：" + objectSpeedValue + objectSpeedUnite);
//                    HDLLog.Log("传感器---物体速度：" + objectSpeedValue + objectSpeedUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_SHAKE:
//                    //传感器 éœ‡åŠ¨
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---震动状态失败，请重新再试");
//                        return;
//                    }
//                    float shakeValue = (float) event.getAppliancesInfo().getCurState();
//                    String shakeValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---震动：" + shakeValue + shakeValueUnite);
//                    HDLLog.Log("传感器---震动：" + shakeValue + shakeValueUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_VOLTAGE:
//                    //传感器 ç”µåŽ‹
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---电压状态失败，请重新再试");
//                        return;
//                    }
//                    float voltageValue = (float) event.getAppliancesInfo().getCurState();
//                    String voltageValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---电压：" + voltageValue + voltageValueUnite);
//                    HDLLog.Log("传感器---电压：" + voltageValue + voltageValueUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_ELECTRICITY:
//                    //传感器 ç”µæµ
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---电流状态失败，请重新再试");
//                        return;
//                    }
//                    float electricityValue = (float) event.getAppliancesInfo().getCurState();
//                    String electricityValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---电流：" + electricityValue + electricityValueUnite);
//                    HDLLog.Log("传感器---电流：" + electricityValue + electricityValueUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_POWER:
//                    //传感器 åŠŸçŽ‡
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---功率状态失败，请重新再试");
//                        return;
//                    }
//                    float powerValue = (float) event.getAppliancesInfo().getCurState();
//                    String powerValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---功率：" + powerValue + powerValueUnite);
//                    HDLLog.Log("传感器---功率：" + powerValue + powerValueUnite);
//                    break;
                case HDLApConfig.TYPE_SENSOR_WIND_SPEED:
                    //传感器 é£Žé€Ÿ
                    if (!event.isSuccess()) {
                        showToast("获取传感器---风速状态失败，请重新再试");
                        return;
                    }
                    float windSpeedValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String windSpeedValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---风速：" + windSpeedValue + windSpeedValueUnit);
                    HDLLog.I("传感器---风速：" + windSpeedValue + windSpeedValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_WIND_PRESSURE:
                    //传感器 é£ŽåŽ‹
                    if (!event.isSuccess()) {
                        showToast("获取传感器---风压状态失败，请重新再试");
                        return;
                    }
                    float windPressureValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String windPressureValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---风压：" + windPressureValue + windPressureValueUnit);
                    HDLLog.I("传感器---风压：" + windPressureValue + windPressureValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_LIQUID_FLOW:
                    //传感器 æ¶²ä½“流量
                    if (!event.isSuccess()) {
                        showToast("获取传感器---液体流量状态失败，请重新再试");
                        return;
                    }
                    float liquidFlowValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String liquidFlowValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---液体流量：" + liquidFlowValue + liquidFlowValueUnit);
                    HDLLog.I("传感器---液体流量：" + liquidFlowValue + liquidFlowValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_LIQUID_PRESSURE:
                    //传感器 æ¶²ä½“压力
                    if (!event.isSuccess()) {
                        showToast("获取传感器---液体压力状态失败，请重新再试");
                        return;
                    }
                    float liquidPressureValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String liquidPressureValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---液体压力：" + liquidPressureValue + liquidPressureValueUnit);
                    HDLLog.I("传感器---液体压力：" + liquidPressureValue + liquidPressureValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_LIQUID_DEPTH:
                    //传感器 æ¶²ä½“深度
                    if (!event.isSuccess()) {
                        showToast("获取传感器---液体深度状态失败，请重新再试");
                        return;
                    }
                    float liquidDepthValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String liquidDepthValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---液体深度：" + liquidDepthValue + liquidDepthValueUnit);
                    HDLLog.I("传感器---液体深度：" + liquidDepthValue + liquidDepthValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_RAIN_FALL:
                    //传感器 é›¨é‡
                    if (!event.isSuccess()) {
                        showToast("获取传感器---雨量状态失败，请重新再试");
                        return;
                    }
                    float rainFallValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String rainFallValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---雨量：" + rainFallValue + rainFallValueUnit);
                    HDLLog.I("传感器---雨量：" + rainFallValue + rainFallValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_WEIGHT:
                    //传感器 é‡é‡
                    if (!event.isSuccess()) {
                        showToast("获取传感器---重量状态失败，请重新再试");
                        return;
                    }
                    float weightValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String weightValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---重量：" + weightValue + weightValueUnit);
                    HDLLog.I("传感器---重量：" + weightValue + weightValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_HEIGHT_LENGTH:
                    //传感器 é‡é‡
                    if (!event.isSuccess()) {
                        showToast("获取传感器---重量状态失败，请重新再试");
                        return;
                    }
                    float height_lengthValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String height_lengthValueUnit = ((SensorStateBackInfo) event).getUnite();
                    showToast("传感器---重量：" + height_lengthValue + height_lengthValueUnit);
                    HDLLog.I("传感器---重量：" + height_lengthValue + height_lengthValueUnit);
                    break;
                case HDLApConfig.TYPE_SENSOR_OBJECT_SPEED:
                    //传感器 ç‰©ä½“速度
                    if (!event.isSuccess()) {
                        showToast("获取传感器---物体速度状态失败，请重新再试");
                        return;
                    }
                    float objectSpeedValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String objectSpeedUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
                    showToast("传感器---物体速度：" + objectSpeedValue + objectSpeedUnite);
                    HDLLog.I("传感器---物体速度：" + objectSpeedValue + objectSpeedUnite);
                    break;
                case HDLApConfig.TYPE_SENSOR_SHAKE:
                    //传感器 éœ‡åŠ¨
                    if (!event.isSuccess()) {
                        showToast("获取传感器---震动状态失败，请重新再试");
                        return;
                    }
                    float shakeValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String shakeValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
                    showToast("传感器---震动：" + shakeValue + shakeValueUnite);
                    HDLLog.I("传感器---震动：" + shakeValue + shakeValueUnite);
                    break;
                case HDLApConfig.TYPE_SENSOR_VOLTAGE:
                    //传感器 ç”µåŽ‹
                    if (!event.isSuccess()) {
                        showToast("获取传感器---电压状态失败，请重新再试");
                        return;
                    }
                    float voltageValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String voltageValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
                    showToast("传感器---电压：" + voltageValue + voltageValueUnite);
                    HDLLog.I("传感器---电压：" + voltageValue + voltageValueUnite);
                    break;
                case HDLApConfig.TYPE_SENSOR_ELECTRICITY:
                    //传感器 ç”µæµ
                    if (!event.isSuccess()) {
                        showToast("获取传感器---电流状态失败，请重新再试");
                        return;
                    }
                    float electricityValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String electricityValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
                    showToast("传感器---电流：" + electricityValue + electricityValueUnite);
                    HDLLog.I("传感器---电流：" + electricityValue + electricityValueUnite);
                    break;
                case HDLApConfig.TYPE_SENSOR_POWER:
                    //传感器 åŠŸçŽ‡
                    if (!event.isSuccess()) {
                        showToast("获取传感器---功率状态失败，请重新再试");
                        return;
                    }
                    float powerValue = (float) event.getAppliancesInfo().getCurStateObject();
                    String powerValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
                    showToast("传感器---功率：" + powerValue + powerValueUnite);
                    HDLLog.I("传感器---功率：" + powerValue + powerValueUnite);
                    break;
//                case HDLApConfig.TYPE_SENSOR_FLOODING:
//                    //传感器 æ°´æµ¸
//                    if (!event.isSuccess()) {
//                        showToast("获取传感器---水浸状态失败，请重新再试");
//                        return;
//                    }
//                    float floodingValue = (float) event.getAppliancesInfo().getCurState();
//                    float floodingValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String floodingValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---水浸：" + floodingValue + floodingValueUnite);
//                    HDLLog.Log("传感器---水浸：" + floodingValue + floodingValueUnite);
//                    HDLLog.I("传感器---水浸：" + floodingValue + floodingValueUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_DOOR_MAGNET:
//                    //传感器 é—¨ç£çª—磁
@@ -482,10 +485,10 @@
//                        showToast("获取传感器---门磁窗磁状态失败，请重新再试");
//                        return;
//                    }
//                    float doorMagnetValue = (float) event.getAppliancesInfo().getCurState();
//                    float doorMagnetValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String doorMagnetValueUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---门磁窗磁：" + doorMagnetValue + doorMagnetValueUnite);
//                    HDLLog.Log("传感器---门磁窗磁：" + doorMagnetValue + doorMagnetValueUnite);
//                    HDLLog.I("传感器---门磁窗磁：" + doorMagnetValue + doorMagnetValueUnite);
//                    break;
//                case HDLApConfig.TYPE_SENSOR_EMERGENCY_BUTTON:
//                    //传感器 ç´§æ€¥æŒ‰é’®
@@ -493,15 +496,15 @@
//                        showToast("获取传感器---紧急按钮状态失败，请重新再试");
//                        return;
//                    }
//                    float emergencyButtonValue = (float) event.getAppliancesInfo().getCurState();
//                    float emergencyButtonValue = (float) event.getAppliancesInfo().getCurStateObject();
//                    String emergencyButtonUnite = ((SensorStateBackInfo) event).getUnite();//数值单位
//                    showToast("传感器---紧急按钮：" + emergencyButtonValue + emergencyButtonUnite);
//                    HDLLog.Log("传感器---紧急按钮：" + emergencyButtonValue + emergencyButtonUnite);
//                    HDLLog.I("传感器---紧急按钮：" + emergencyButtonValue + emergencyButtonUnite);
//                    break;
//
//
//            }
//        }
//    }


            }
        }
    }

}

 hdl_core/src/main/java/com/hdl/sdk/hdl_core/Config/Configuration.java

@@ -65,6 +65,9 @@
    //读取备注信息 æœç´¢å¤‡æ³¨
    public static final int ReadRemark = 0x000E;
    public static final int ReadRemarkACK = 0x000F;
    //读设备MAC
    public static final int READ_MAC_COMMAND = 0xF003;
    public static final int READ_MAC_BACK_COMMAND = 0xF004;

    //简易编程设备搜索操作码、设备读取操作码
    public static final int DEVICES_SEARCH_COMMAND = 0xE548;
@@ -122,9 +125,9 @@


    //六端口交换机传感器 ä¼ æ„Ÿå™¨æ“ä½œç 
    public static final int SENSOR_STATE_COMMAND = 0xE4F9;
    public static final int SENSOR_STATE_BACK_COMMAND = 0xE4FA;
//    public static final int SENSOR_BROADCAST_COMMAND = 0x1647;
    public static final int SENSOR_STATE_COMMAND = 0xE4F9;//读模拟量
    public static final int SENSOR_STATE_BACK_COMMAND = 0xE4FA;//读模拟量返回
    public static final int SENSOR_BROADCAST_COMMAND = 0x353A;//模拟量广播

    public static final int WARNING_COMMAND = 0xF606;


 hdl_core/src/main/java/com/hdl/sdk/hdl_core/HDLAppliances/HDLSensor/SensorStateBackInfo.java

@@ -4,6 +4,7 @@
import com.hdl.sdk.hdl_core.HDLDeviceManger.EventBusEvent.DeviceStateEvent;

public class SensorStateBackInfo extends DeviceStateEvent {
    //单位
    private String unite;

    public SensorStateBackInfo(AppliancesInfo appliancesInfo, boolean isSuccess) {

 hdl_core/src/main/java/com/hdl/sdk/hdl_core/HDLDeviceManger/Core/HDLCommand.java

@@ -1255,6 +1255,76 @@
//    }



    /**
     * èŽ·å–干接点传感器模块状态
     *
     * @param info
     */
    public static void getSensorStateFromNetwork(final AppliancesInfo info) {
        if (info == null) {
            return;
        }
        HDLDeviceManager.isGetDeviceStateSuccess = false;
        switch (info.getDeviceType()) {
//            case HDLApConfig.TYPE_SENSOR_DRY_CONTACT:
//            case HDLApConfig.TYPE_SENSOR_MOVEMENT_DETECTOR:
            case HDLApConfig.TYPE_SENSOR_TEMP:
            case HDLApConfig.TYPE_SENSOR_HUMIDITY:
            case HDLApConfig.TYPE_SENSOR_ILLUMINACE:
            case HDLApConfig.TYPE_SENSOR_VOC:
            case HDLApConfig.TYPE_SENSOR_PM_2_POINT_5:
            case HDLApConfig.TYPE_SENSOR_C02:
            case HDLApConfig.TYPE_SENSOR_LPG:
//            case HDLApConfig.TYPE_SENSOR_CO_H2:
            case HDLApConfig.TYPE_SENSOR_CH4:
//            case HDLApConfig.TYPE_SENSOR_SMOG:
            case HDLApConfig.TYPE_SENSOR_WIND_SPEED:
            case HDLApConfig.TYPE_SENSOR_WIND_PRESSURE:
            case HDLApConfig.TYPE_SENSOR_LIQUID_FLOW:
            case HDLApConfig.TYPE_SENSOR_LIQUID_PRESSURE:
            case HDLApConfig.TYPE_SENSOR_LIQUID_DEPTH:
            case HDLApConfig.TYPE_SENSOR_RAIN_FALL:
            case HDLApConfig.TYPE_SENSOR_WEIGHT:
            case HDLApConfig.TYPE_SENSOR_HEIGHT_LENGTH:
            case HDLApConfig.TYPE_SENSOR_OBJECT_SPEED:
            case HDLApConfig.TYPE_SENSOR_SHAKE:
            case HDLApConfig.TYPE_SENSOR_VOLTAGE:
            case HDLApConfig.TYPE_SENSOR_ELECTRICITY:
            case HDLApConfig.TYPE_SENSOR_POWER:
//            case HDLApConfig.TYPE_SENSOR_FLOODING:
//            case HDLApConfig.TYPE_SENSOR_DOOR_MAGNET:
//            case HDLApConfig.TYPE_SENSOR_EMERGENCY_BUTTON:
                //发送获传感器模块 æ¨¡æ‹Ÿé‡çŠ¶æ€æ•°æ®
                byte[] sendDatabyte = new byte[]{
                        (byte) info.getBigType(),
                        (byte) info.getLittleType(),
                        (byte) info.getChannelNum()
                };

                addSendData(info, sendDatabyte, Configuration.STATE);
                break;
            //          ä¸‹é¢çš„都是用干节点指令
            case HDLApConfig.TYPE_SENSOR_DRY_CONTACT: //干节点
            case HDLApConfig.TYPE_SENSOR_MOVEMENT_DETECTOR: //红外感应传感器
            case HDLApConfig.TYPE_SENSOR_CO_H2:         //煤气传感器
            case HDLApConfig.TYPE_SENSOR_SMOG:          //烟雾传感器
            case HDLApConfig.TYPE_SENSOR_FLOODING:       //水浸传感器
            case HDLApConfig.TYPE_SENSOR_DOOR_MAGNET:   //门磁传感器
            case HDLApConfig.TYPE_SENSOR_EMERGENCY_BUTTON://紧急按钮
                //发送获传感器模块 å¹²èŠ‚点状态数据
                byte[] sendDatabyte2 = new byte[]{
                        (byte) 1,
                        (byte) info.getChannelNum()
                };
                addSendData(info, sendDatabyte2, Configuration.STATE);
                break;
            default:
                HDLLog.info("不是传感器模块");
                break;
        }
    }

    /**
     * èŽ·å–干接点传感器模块状态
     *

 hdl_core/src/main/java/com/hdl/sdk/hdl_core/HDLDeviceManger/Core/HDLDeviceManager.java

@@ -181,6 +181,9 @@
            case Configuration.ReadRemark://2021-01-05 000E搜索备注处理
                handleReadRemarkBackData(getDatas);
                break;
            case Configuration.READ_MAC_COMMAND://2021-01-07 F003读设备Mac
                handleReadMacBackData(getDatas);
                break;
//          æŽ§åˆ¶è®¾å¤‡
            case Configuration.LIGHT_CTRL_BACK_COMMAND:
            case Configuration.CURTAIN_CTRL_BACK_COMMAND:
@@ -233,8 +236,13 @@
            case Configuration.LIGHT_STATE_BACK_COMMAND:
            case Configuration.CURTAIN_STATE_BACK_COMMAND:
            case Configuration.AIR_STATE_BACK_COMMAND:
            case Configuration.SENSOR_STATE_BACK_COMMAND:
                handleStateData(getDatas);
                break;
            case Configuration.SENSOR_STATE_BACK_COMMAND:
                handleSensorAnalogStateData(getDatas, true);
                break;
            case Configuration.SENSOR_BROADCAST_COMMAND://传感器模拟量广播
                handleSensorAnalogStateData(getDatas, false);
                break;
            //获取新风设备状态 20190709新增
            case Configuration.FRESH_AIR_STATE_BACK_COMMAND:
@@ -400,6 +408,7 @@
    /**
     * ReadRemark
     * æœç´¢è®¾å¤‡000E å›žå¤å¤„理
     *
     * @param getDatas
     */
    public static void handleReadRemarkBackData(UdpDataBean getDatas) {
@@ -412,6 +421,26 @@
                addBytes,
                getDatas.port, getDatas.ipAddress);
    }

    /**
     * READ MAC
     * è¯»å–MAC å›žå¤å¤„理
     *
     * @param getDatas
     */
    public static void handleReadMacBackData(UdpDataBean getDatas) {
        //Mac地址8个byte
        byte[] addBytes = new byte[8];
        addBytes[0] = (byte) 200;
        //把真实的MAC赋值给addBytes
//        System.arraycopy(remarkByte, 0, addBytes, 0, Math.min(remarkByte.length, 20));
        HDLCommand.cusSendCommand(Configuration.READ_MAC_BACK_COMMAND,
                getDatas.sourceSubnetID,
                getDatas.sourceDeviceID,
                addBytes,
                getDatas.port, getDatas.ipAddress);
    }


    /**
     * å¤„理RCU搜索数据
@@ -2054,15 +2083,35 @@
//                                    aa += (getDatas.addBytes[i] & 0xff) + ",";
//                                }
//                                HDLLog.info( aa);
                                float curState;
                                if (getDatas.addBytes.length >= 28) {
                                    curState = DataConverseUtil.byte2Float(Arrays.copyOfRange(getDatas.addBytes, 24, 27));

                                //使用干节点指令的传感器
                                if (DeviceParser.getIfDryContactSensor(infos.get(appPos).getLittleType())) {
                                    //干节点传感器，要特殊处理修改回路号
                                    int curState;
                                    if (getDatas.addBytes.length >= 26) {
                                        curState = (int) (getDatas.addBytes[24] & 0xff);
                                        devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setChannelNum(getDatas.addBytes[25] & 0xff);

                                    } else {
                                        curState = (int) (getDatas.addBytes[getDatas.addBytes.length - 1] & 0xff);
                                    }

                                    devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setCurState(curState);
                                    devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setIntCurState((int) curState);
                                } else {
                                    curState = (float) (getDatas.addBytes[getDatas.addBytes.length - 1] & 0xff);
                                    //标准模拟量传感器
                                    float curState;
                                    if (getDatas.addBytes.length >= 28) {
                                        curState = DataConverseUtil.byte2Float(Arrays.copyOfRange(getDatas.addBytes, 24, 27));

                                    } else {
                                        curState = (float) (getDatas.addBytes[getDatas.addBytes.length - 1] & 0xff);
                                    }
                                    devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setCurState(curState);
                                    devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setIntCurState((int) curState);
                                }
                                devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setCurState(curState);
                                devicesDataList.get(devPos).getAppliancesInfoList().get(appPos).setIntCurState((int) curState);


                                break;
                            case Configuration.FRESH_AIR_BIG_TYPE://20190711新增
                                switch (infos.get(appPos).getLittleType()) {
@@ -2248,8 +2297,40 @@
                            }

                            break;
                        case Configuration.SENSOR_BIG_TYPE:
                            isGetDeviceStateSuccess = true;

                        default:
                            HDLLog.info("handle state æ²¡æœ‰æ‰¾åˆ°åŒ¹é…ç±»åž‹");
                            break;
                    }

                }
                break outter;
            }
        }
    }

    /**
     * å¤„理各种传感器模拟量状态数据
     * 2021-08-05
     *
     * @param getDatas
     */
    private static void handleSensorAnalogStateData(UdpDataBean getDatas, boolean isState) {
        outter:
        for (int i = 0, len = devicesDataList.size(); i < len; i++) {
            if (devicesDataList.get(i).getSourceSubnetID() == getDatas.sourceSubnetID
                    && devicesDataList.get(i).getSourceDeviceID() == getDatas.sourceDeviceID) {
                List<AppliancesInfo> infos = devicesDataList.get(i).getAppliancesInfoList();
                for (int j = 0, len2 = infos.size(); j < len2; j++) {
                    if (devicesDataList.get(i).getAppliancesInfoList().get(j).getBigType() == Configuration.SENSOR_BIG_TYPE) {
                        //大类是5 åŒ¹é…å°ç±»ä»¥åŠå›žè·¯å·
                        if (getDatas.addBytes[0] == Configuration.SENSOR_BIG_TYPE
                                && getDatas.addBytes[1] == devicesDataList.get(i).getAppliancesInfoList().get(j).getLittleType()
                                && getDatas.addBytes[2] == devicesDataList.get(i).getAppliancesInfoList().get(j).getChannelNum()) {

                            if (isState) {
                                isGetDeviceStateSuccess = true;
                            }
                            AppliancesInfo sensorInfo = devicesDataList.get(i).getAppliancesInfoList().get(j);
                            float value = DataConverseUtil.byte2Float(Arrays.copyOfRange(getDatas.addBytes, 5, 8));
                            devicesDataList.get(i).getAppliancesInfoList().get(j).setCurState(value);
@@ -2257,8 +2338,8 @@

                            sensorInfo.setCurState(value);


                            String unite = "";
                            boolean ifNeedPost = true;
                            switch (sensorInfo.getDeviceType()) {
                                case HDLApConfig.TYPE_SENSOR_DRY_CONTACT:
                                    unite = "";
@@ -2398,18 +2479,18 @@
                                    unite = "W";
                                    break;
                                default:
                                    ifNeedPost = false;
                                    unite = "未知单位";
                                    break;
                            }

                            if (ifNeedPost) {
                                HDLLog.info("发送传感器通知更新");
                                EventBus.getDefault().post(new SensorStateBackInfo(sensorInfo, true, unite));
                            }

//                            EventBus.getDefault().post(new DeviceStateEvent(sensorInfo, true));
                            HDLLog.info("发送传感器通知更新");
                            EventBus.getDefault().post(new SensorStateBackInfo(sensorInfo, true, unite));
                            break;
                        default:
                            HDLLog.info("handle state æ²¡æœ‰æ‰¾åˆ°åŒ¹é…ç±»åž‹");
                            break;
                            break outter;
                        }
                    }

                }

 hdl_core/src/main/java/com/hdl/sdk/hdl_core/HDLDeviceManger/Core/HDLUdpCore.java

@@ -421,6 +421,7 @@
                break;
            case Configuration.DEVICES_SEARCH_COMMAND: //简易编程设备搜索操作码、设备读取操作码 å›žå¤
            case Configuration.ReadRemark: //000E æœç´¢å›žå¤
            case Configuration.READ_MAC_COMMAND: //F003 è¯»è®¾å¤‡Mac
            case Configuration.LIGHT_CTRL_BACK_COMMAND:
            case Configuration.CURTAIN_CTRL_BACK_COMMAND:
            case Configuration.AIR_CTRL_BACK_COMMAND:
@@ -453,7 +454,7 @@
            case Configuration.WARNING_COMMAND:

            case Configuration.SENSOR_STATE_BACK_COMMAND:

            case Configuration.SENSOR_BROADCAST_COMMAND://2021-08-05
//            case Configuration.AUDIO_CTRL_READ_COMMAND:
            case Configuration.AUDIO_CTRL_READ_BACK_COMMAND:
//            case Configuration.AUDIO_MenuPlay_INSTRUCTION_COMMAND:

 hdl_core/src/main/java/com/hdl/sdk/hdl_core/HDLDeviceManger/Parser/DeviceParser.java

@@ -204,7 +204,15 @@
                }
                break;
            case Configuration.SENSOR_BIG_TYPE:
                if (littleType >= 0 && littleType <= 24) {
//                if (littleType >= 0 && littleType <= 27) {
//                    isWant = true;
//                } else {
//                    isWant = false;
//                }

                //2021-08-05 å¢žåŠ æµ·å…‹ä¼ æ„Ÿå™¨5种类型支持 2：温度 3：湿度 5：TVOC 6：PM2.5 7：CO2
                if (littleType == 0 || littleType == 1 || littleType == 2 || littleType == 3 || littleType == 5 || littleType == 6 || littleType == 7
                        || littleType == 9 || littleType == 11 || (littleType > 24 && littleType <= 27)) {
                    isWant = true;
                } else {
                    isWant = false;
@@ -663,7 +671,7 @@
            appliancesInfo.setIpAddress(ipAddress);


            if (littleType == 0 || littleType == 1 || littleType == 10 ||  littleType == 11 || littleType == 25 || littleType == 26 || littleType == 27) {
            if (getIfDryContactSensor(littleType)) {
                //干节点0 ç§»åŠ¨ä¼ æ„Ÿå™¨1 ç…¤æ°”传感器10 çƒŸé›¾ä¼ æ„Ÿå™¨11 æ°´æµ¸25 é—¨ç£çª—磁26 ç´§æ€¥æŒ‰é’®27
                appliancesInfo.setStateCommand(Configuration.DRY_CONTACT_STATE_COMMAND);
                appliancesInfo.setStateBackCommand(Configuration.DRY_CONTACT_STATE_BACK_COMMAND);
@@ -675,9 +683,14 @@

        }


    }

    /**
     * åˆ¤æ–­å½“前小类是否为使用干节点指令的传感器
     */
    public static boolean getIfDryContactSensor(int littleType){
        return (littleType == 0 || littleType == 1 || littleType == 10 ||  littleType == 11 || littleType == 25 || littleType == 26 || littleType == 27);
    }

    /**
     *地热