manyi/apps/web/core/adapter/cxjz.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import datetime
import time

from apilib.utils_datetime import timestamp_to_dt
from apps.web.constant import Const, DeviceCmdCode, MQTT_TIMEOUT
from apps.web.core.adapter.base import SmartBox, fill_2_hexByte
from apps.web.core.exceptions import ServiceException
from apps.web.core.networking import MessageSender
from apps.web.device.models import Device


class ChargingCXJZBox(SmartBox):

    # 从设备侧获取端口状态
    def get_port_status_from_dev(self):
        devInfo = MessageSender.send(self.device, self.make_random_cmdcode(),
                                     {'IMEI': self._device['devNo'], "funCode": 'A0', 'data': '01FFFF'})
        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo['data'][10::]
        workMode = self.A3_setting_data['workMode']  # 0 时间  1 电量

        result = {}
        portNum = 10
        ii = 0
        while ii < portNum:
            port = ii + 1
            statusTemp = data[4 + 16 * ii: 16 + 16 * ii]
            if workMode == 0:
                if statusTemp[0:4] == '0000':
                    status = {'status': Const.DEV_WORK_STATUS_IDLE}
                elif statusTemp[0:4] != '0000':
                    status = {'status': Const.DEV_WORK_STATUS_WORKING}
                else:
                    status = {'status': Const.DEV_WORK_STATUS_WORKING}
            elif workMode == 1:
                if statusTemp[4:8] == '0000':
                    status = {'status': Const.DEV_WORK_STATUS_IDLE}
                elif statusTemp[4:8] != '0000':
                    status = {'status': Const.DEV_WORK_STATUS_WORKING}
                else:
                    status = {'status': Const.DEV_WORK_STATUS_WORKING}
            else:
                if statusTemp == '000000000000':
                    status = {'status': Const.DEV_WORK_STATUS_IDLE}
                else:
                    status = {'status': Const.DEV_WORK_STATUS_WORKING}

            ii += 1
            result[str(port)] = status

        allPorts, usedPorts, usePorts = self.get_port_static_info(result)
        Device.update_dev_control_cache(self._device['devNo'],
                                        {'allPorts': allPorts, 'usedPorts': usedPorts, 'usePorts': usePorts})

        # 这里存在多线程更新缓存的场景，可能性比较低，但是必须先取出来，然后逐个更新状态，然后再记录缓存
        ctrInfo = Device.get_dev_control_cache(self._device['devNo'])
        for strPort, info in result.items():
            if ctrInfo.has_key(strPort):
                ctrInfo[strPort].update({'status': info['status']})
            else:
                ctrInfo[strPort] = info
        Device.update_dev_control_cache(self._device['devNo'], ctrInfo)

        return result

    # 获取端口状态
    def get_port_status(self, force = False):
        if force:
            return self.get_port_status_from_dev()

        ctrInfo = Device.get_dev_control_cache(self._device['devNo'])
        statusDict = {}
        allPorts = ctrInfo.get('allPorts', 10)
        for ii in range(allPorts):
            tempDict = ctrInfo.get(str(ii + 1), {})
            if tempDict.has_key('status'):
                statusDict[str(ii + 1)] = {'status': tempDict.get('status')}
            elif tempDict.has_key('isStart'):
                if tempDict['isStart']:
                    statusDict[str(ii + 1)] = {'status': Const.DEV_WORK_STATUS_WORKING}
                else:
                    statusDict[str(ii + 1)] = {'status': Const.DEV_WORK_STATUS_IDLE}
            else:
                statusDict[str(ii + 1)] = {'status': Const.DEV_WORK_STATUS_IDLE}

        allPorts, usedPorts, usePorts = self.get_port_static_info(statusDict)
        Device.update_dev_control_cache(self._device['devNo'],
                                        {'allPorts': allPorts, 'usedPorts': usedPorts, 'usePorts': usePorts})

        return statusDict

    # 支付成功启动设备
    def start_device(self, package, openId, attachParas):
        if attachParas is None:
            raise ServiceException({'result': 2, 'description': u'请您选择合适的充电线路、电池类型信息'})
        if not attachParas.has_key('chargeIndex'):
            raise ServiceException({'result': 2, 'description': u'请您选择合适的充电线路'})

        port = hex(int(attachParas['chargeIndex']))
        hexPort = fill_2_hexByte(port, 2)

        needTime = int(package['time'])
        needCoins = int(package['coins'])
        needElec = round(needCoins / float(self.elec_fee['elecFee']), 1)
        workMode = self.A3_setting_data['workMode']

        unit = package.get('unit', u'分钟')
        if unit == u'小时':
            needTime = int(package['time']) * 60
        elif unit == u'天':
            needTime = int(package['time']) * 1440

        hexTime = fill_2_hexByte(hex(needTime))
        hexElec = fill_2_hexByte(hex(int(needElec * 10)))

        devInfo = MessageSender.send(device = self.device, cmd = DeviceCmdCode.OPERATE_DEV_SYNC, payload = {
            'IMEI': self._device['devNo'],
            "funCode": 'CA',
            'data': hexPort + hexTime + hexElec
        }, timeout = MQTT_TIMEOUT.START_DEVICE)

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在玩命找网络，您的金币还在，重试不需要重新付款，建议您试试旁边其他设备，或者稍后再试哦'})
            elif devInfo['rst'] == 1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在忙，无响应，您的金币还在，请试试其他线路，或者请稍后再试哦'})

        start_timestamp = int(time.time())

        devInfo['finishedTime'] = start_timestamp + needTime * 60

        Device.update_dev_control_cache(
            self._device['devNo'],
            {
                str(attachParas['chargeIndex']):
                    {
                        'startTime': timestamp_to_dt(start_timestamp).strftime('%Y-%m-%d %H:%M:%S'),
                        'coins': needCoins,
                        'needTime': needTime,
                        'isStart': True,
                        'workMode': workMode,
                        'needElec': needElec,
                        'openId': openId,
                        'refunded': False,
                        'status': Const.DEV_WORK_STATUS_WORKING,
                        'finishedTime': devInfo['finishedTime']
                    }
            })
        return devInfo

    def get_port_info(self, line):
        data = fill_2_hexByte(hex(int(line)), 2)

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'A1', 'data': data + 'FFFF'})
        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        portData = devInfo['data'][10::]
        port = int(portData[0:2], 16)
        leftTime = int(portData[4:8], 16)
        leftElec = int(portData[8:12], 16) / 100
        power = int(portData[12:16], 16)

        return {'port': port, 'leftTime': leftTime, 'leftElec': leftElec, 'power': power}

    # 配合stop_charging_port使用
    def active_deactive_port(self, port, active):
        if active:
            raise ServiceException({'result': 2, 'description': u'该设备不支持直接打开端口'})
        self.stop_charging_port(port)
        devInfo = Device.get_dev_control_cache(self._device['devNo'])
        portCtrInfo = devInfo.get(str(port), {})
        portCtrInfo.update({'isStart': False, 'status': Const.DEV_WORK_STATUS_IDLE,
                            'endTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)})
        newValue = {str(port): portCtrInfo}
        Device.update_dev_control_cache(self._device['devNo'], newValue)

    # 远程停止某个端口的使用
    def stop_charging_port(self, port):
        data = {}
        portStr = fill_2_hexByte(hex(int(port)), 2)
        portData = self.get_port_info(port)
        devData = Device.get_dev_control_cache(self._device['devNo'])
        portCtrInfo = devData.get(str(port), {})
        data.update(portData)
        data.update(portCtrInfo)

        Device.update_dev_control_cache(self._device['devNo'],
                                        {str(port): data})

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'CB',
                                      'data': portStr + 'FFFF' + 'FFFF'})
        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 分析事件上报
    def analyze_event_data(self, data):
        cmdCode = data[2:4]

        if cmdCode in ['88', '80' '01', '02', '03', '04']:

            if cmdCode == '88':  # 断电和正常都走这个
                reason = u'充电结束。'
            elif cmdCode == '01':
                reason = u'线路过载。'
            elif cmdCode == '02':
                reason = u'线路空载。'
            elif cmdCode == '03':
                reason = u'电池已充满。'
            elif cmdCode == '80':
                reason = u'购买电量已用完。'
            elif cmdCode == '04':
                reason = u'设备故障'
                return {'status': Const.DEV_WORK_STATUS_FAULT, 'reason': reason}
            else:
                reason = u''

            port = int(data[10:12], 16)
            leftTime = int(data[14:18], 16)
            leftElec = int(data[18:22], 16) / 100
            power = int(data[22:26], 16)

            return {
                'status': Const.DEV_WORK_STATUS_IDLE,
                'cmdCode': cmdCode, 'port': port,
                'leftTime': leftTime, 'leftElec': leftElec,
                'power': power, 'reason': reason
            }
        # 故障上报
        if cmdCode == 'AE':
            temperature = int(data[14: 18], 16)     # 温度数值
            smokeCon = int(data[18: 22], 16)        # 烟感浓度
            buzzer = bool(int(data[22: 24]))        # 蜂鸣状态 表示设备是否处于告警状态
            smokeSwitch = bool(int(data[24: 26]))   # 烟感开关

            return {
                "cmdCode": cmdCode,
                "temperature": temperature,
                "smokeCon": smokeCon,
                "buzzer": buzzer,
                "smokeSwitch": smokeSwitch
            }

    # 总获取设备参数: A2, A3, A4, A9, 电量计费
    def get_dev_setting(self):
        """
        从设备端获取参数
        可以修改为 从设备上直接读取 新建指令一次性回复
        目前暂时不处理
        :return:
        """
        if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHANGING_CXJZ:  # 无烟感版本
            data = {}
            data.update(self.A2_setting_data)
            data.update(self.A3_setting_data)
            data.update(self.A4_setting_data)
            data.update(self.A9_setting_data)
            data.update(self.elec_fee)
            data.update(self.lock_device)
        else:
            data = self.FA_setting_data
        return data

    # A2: 本机区号, 刷卡统计, 投币统计
    @property
    def A2_setting_data(self):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'A2', 'data': '01FFFF'})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo['data'][14::]

        deviceNum = int(data[0:4], 16)  # 本机区号
        putCards = int(data[4:8], 16)  # 刷卡统计
        putCoins = int(data[8:12], 16)  # 投币统计

        return {'deviceNum': deviceNum, 'putCards': putCards, 'putCoins': putCoins}

    # A3: 工作模式, 限定功率, 断电开关, 预设记币, 预设开关
    @property
    def A3_setting_data(self):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'A3', 'data': '01FFFF'})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo['data'][12::]

        workMode = int(data[0:2], 16)  # 工作模式
        limitedPower = int(data[2:6], 16)  # 限定功率
        powerOffSwitch = True if int(data[6:8], 16) == 1 else False  # 断电开关
        presetCoins = int(data[8:12], 16)  # 预设记币
        presetSwitch = True if int(data[12:14], 16) == 1 else False  # 预设开关

        return {'workMode': workMode, 'limitedPower': limitedPower, 'powerOffSwitch': powerOffSwitch,
                'presetCoins': presetCoins, 'presetSwitch': presetSwitch}

    # A4: 刷卡投币电量设置, 刷卡时间, 投币时间
    @property
    def A4_setting_data(self):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'A4', 'data': '01FFFF'})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo['data'][12::]

        elecSetting = int(data[0:4], 16) / 10  # 刷卡投币电量设置
        cardTime = int(data[4:8], 16)  # 刷卡充电时间
        coinTime = int(data[8:12], 16)  # 投币充电时间
        maxCoins = int(data[12:14], 16)

        return {'elecSetting': elecSetting, 'cardTime': cardTime, 'coinTime': coinTime, 'maxCoins': maxCoins}

    # A9: 空载断电时间, 充满功率判断
    @property
    def A9_setting_data(self):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'A9', 'data': '01FFFF'})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo['data'][14::]
        powerOffTime = int(data[0:4], 16)  # 断电时间
        fullElecJudgPower = int(data[4:8], 16)  # 充满检测功率

        return {'powerOffTime': powerOffTime, 'fullElecJudgPower': fullElecJudgPower}

    @property
    def AE_setting_data(self):
        """
        烟雾告警指令
        :return:
        """
        devInfo = MessageSender.send(
            self.device,
            DeviceCmdCode.OPERATE_DEV_SYNC,
            {
                "IMEI": self.device.devNo,
                "funCode": "AE",
                "data": "01FFFF"
            }

        )
        if 'rst' in devInfo and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            if devInfo['rst'] == 1:
                raise ServiceException({'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        # 两个数值两个开关
        temperature = int(devInfo["data"][14: 18], 16)      # 温度数值
        smokeCon = int(devInfo["data"][18: 22], 16)         # 烟感浓度
        buzzer = bool(int(devInfo["data"][22: 24]))         # 蜂鸣状态 表示设备是否处于告警状态
        smokeSwitch = bool(int(devInfo["data"][24: 26]))    # 烟感开关

        return {
            "temperature": temperature,
            "smokeCon": smokeCon,
            "buzzer": buzzer,
            "smokeSwitch": smokeSwitch
        }

    @property
    def FA_setting_data(self):
        """
        自定义指令合集
        一次性将所有的数据从主板获取
        :return:
        """
        devInfo = MessageSender.send(
            self.device,
            DeviceCmdCode.OPERATE_DEV_SYNC,
            {
                "IMEI": self.device.devNo,
                "funCode": "FA",
            }

        )
        if 'rst' in devInfo and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            if devInfo['rst'] == 1:
                raise ServiceException({'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

        data = devInfo["data"][10:]
        return {
            # A2
            "deviceNum": int(data[0: 16][4: 8], 16),       # 本机区号
            "putCards": int(data[0: 16][8: 12], 16),       # 刷卡统计
            "putCoins": int(data[0: 16][12: 16], 16),      # 投币统计
            # A3
            "workMode": int(data[16: 32][2: 4], 16),
            "limitedPower": int(data[16: 32][4: 8], 16),
            "powerOffSwitch": bool(int(data[16: 32][8: 10], 16)),
            "presetCoins": int(data[16: 32][10: 14], 16),
            "presetSwitch": bool(int(data[16: 32][14: 16], 16)),
            # A4
            "elecSetting": int(data[32: 48][2: 6], 16) / 10,
            "cardTime": int(data[32: 48][6: 10], 16),
            "coinTime": int(data[32: 48][10: 14], 16),
            "maxCoins": int(data[32: 48][14: 16], 16),
            # A9
            "powerOffTime": int(data[48: 64][4: 8], 16),
            "fullElecJudgPower": int(data[48: 64][8: 12], 16),
            # AE
            "temperature": int(data[64: 80][4: 8], 16),
            "smokeCon": int(data[64: 80][8: 12], 16),
            "buzzer": bool(int(data[64: 80][12: 14], 16)),
            "smokeSwitch": bool(int(data[64: 80][14: 16], 16))
        }

    # 获取电量计费标准
    @property
    def elec_fee(self):
        devs = Device.get_collection().find({'devNo': self._device['devNo']})
        if devs.count == 0:
            raise ServiceException(
                {'result': 2, 'description': u'没有找到设备哦'})

        return {'elecFee': devs[0].get('otherConf', {}).get('elecFee', 1)}

    # 获取设备锁定状态
    @property
    def lock_device(self):
        devs = Device.get_collection().find({'devNo': self._device['devNo']})
        if devs.count == 0:
            raise ServiceException(
                {'result': 2, 'description': u'没有找到设备哦'})

        return {'lockDevice': devs[0].get('otherConf', {}).get('lockDevice', False)}

    # 设置电量计费标准
    def set_elec_fee(self, elecFee):
        dev = Device.objects(devNo = self._device['devNo']).first()
        if not dev:
            raise ServiceException({'result': 2, 'description': u'没有找到设备哦'})

        dev.otherConf['elecFee'] = elecFee
        dev.save()

    # 设置清除记币按钮
    def clear_put_coins(self, clear = False):
        if clear is True:
            devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                         {'IMEI': self._device['devNo'], "funCode": 'B0', 'data': '01FFFF'})

            if devInfo.has_key('rst') and devInfo['rst'] != 0:
                if devInfo['rst'] == -1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
                elif devInfo['rst'] == 1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置设备区号
    def set_device_num(self, deviceNum):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B2', 'data': '01' + deviceNum})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置工作模式
    def set_work_mode(self, workMode):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B3', 'data': '01' + workMode})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置限定功率
    def set_limited_power(self, limitedPower):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B4', 'data': '01' + limitedPower})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置断电开关
    def set_power_off_switch(self, switch = True):
        data = '0001' if switch is True else '0000'

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B5', 'data': '01' + data})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置预设开关
    def set_preset_switch(self, switch = False):
        data = '0000' if switch is False else '0001'

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B6', 'data': '01' + data})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置烟感开关
    def set_smoke(self, smokeSwitch):
        if self.device.devTypeCode not in [Const.DEVICE_TYPE_CODE_CHANGING_CXJZ_SMOKE, '1002171']:
            raise ServiceException({"result": 2, "description": "当前设备不支持"})

        if smokeSwitch is None:
            return

        data = "01{:04X}".format(int(smokeSwitch))
        devInfo = MessageSender.send(
            self.device,
            DeviceCmdCode.OPERATE_DEV_SYNC,
            {
                'IMEI': self._device['devNo'],
                "funCode": 'C6',
                'data': data
            }
        )
        if 'rst' in devInfo and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException({'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置预设投币数
    def set_preset_coins(self, presetCoins):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B7', 'data': '01' + presetCoins})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置断电时间
    def set_power_off_time(self, powerOffTime):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B8', 'data': '01' + powerOffTime})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置负载功率
    def set_full_elec_judg_power(self, fullElecJudgPower):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'B8', 'data': '01' + fullElecJudgPower})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置刷卡投币电量
    def set_elec_setting(self, elecSetting):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'C2', 'data': '01' + elecSetting})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置刷卡时间
    def set_card_time(self, cardTime):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'C1', 'data': '01' + cardTime})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置投币时间
    def set_coin_time(self, coinTime):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'C3', 'data': '01' + coinTime})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置单次最大投币数
    def set_max_coins(self, maxCoins):
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": 'C4', 'data': '01' + maxCoins})

        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if devInfo['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 锁定设备
    def lock_unlock_device(self):
        dev = Device.objects(devNo = self._device['devNo']).first()
        if not dev:
            raise ServiceException({'result': 2, 'description': u'没有找到设备哦'})

        lockDev = dev.otherConf.get('lockDevice', False)

        if lockDev is False:
            devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                         {'IMEI': self._device['devNo'], "funCode": 'D0', 'data': '01' + 'FFFF'})

            if devInfo.has_key('rst') and devInfo['rst'] != 0:
                if devInfo['rst'] == -1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
                elif devInfo['rst'] == 1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

            dev.otherConf['lockDevice'] = True
            dev.save()

        else:
            devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                         {'IMEI': self._device['devNo'], "funCode": 'D1', 'data': '01' + 'FFFF'})

            if devInfo.has_key('rst') and devInfo['rst'] != 0:
                if devInfo['rst'] == -1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
                elif devInfo['rst'] == 1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

            dev.otherConf['lockDevice'] = False
            dev.save()

    # 重启设备
    def restart_the_device(self, restart = False):
        if restart is True:
            devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                         {'IMEI': self._device['devNo'], "funCode": 'DE', 'data': '01' + 'FFFF'})

            if devInfo.has_key('rst') and devInfo['rst'] != 0:
                if devInfo['rst'] == -1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩正在玩命找网络,请您稍候再试'})
                elif devInfo['rst'] == 1:
                    raise ServiceException(
                        {'result': 2, 'description': u'充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能'})

    # 设置设备参数(单个)
    def set_device_function(self, request, lastSetConf):
        if 'clearPutCoins' in request.POST:
            clearPutCoins = request.POST.get("clearPutCoins", False)
            self.clear_put_coins(clearPutCoins)

        if 'powerOffSwitch' in request.POST:
            powerOffSwitch = request.POST.get("powerOffSwitch", False)
            self.set_power_off_switch(powerOffSwitch)

        if 'presetSwitch' in request.POST:
            presetSwitch = request.POST.get("presetSwitch", False)
            self.set_preset_switch(presetSwitch)

        # TODO zjl 感觉这个指令做的有问题
        if 'lockDevice' in request.POST:
            self.lock_unlock_device()

        if 'restartDevice' in request.POST:
            restartDevice = request.POST.get("restartDevice", False)
            self.restart_the_device(restartDevice)

        if 'smokeSwitch' in request.POST:
            smokeSwitch = request.POST.get("smokeSwitch")
            self.set_smoke(smokeSwitch)

    # 设置设备参数(整体)
    def set_device_function_param(self, request, lastSetConf):
        deviceNum = request.POST.get('deviceNum', None)
        workMode = request.POST.get('workMode', None)
        limitedPower = request.POST.get('limitedPower', None)
        presetCoins = request.POST.get('presetCoins', None)
        powerOffTime = request.POST.get('powerOffTime', None)
        fullElecJudgPower = request.POST.get('fullElecJudgPower', None)
        cardTime = request.POST.get('cardTime', None)
        elecSetting = request.POST.get('elecSetting', None)
        coinTime = request.POST.get('coinTime', None)
        maxCoins = request.POST.get('maxCoins', None)
        elecFee = request.POST.get('elecFee', None)

        if deviceNum:
            self.set_device_num(fill_2_hexByte(hex(int(deviceNum))))
        if workMode:
            self.set_work_mode(fill_2_hexByte(hex(int(workMode))))
        if limitedPower:
            self.set_limited_power(fill_2_hexByte(hex(int(limitedPower))))
        if presetCoins:
            self.set_preset_coins(fill_2_hexByte(hex(int(presetCoins))))
        if powerOffTime:
            self.set_power_off_time(fill_2_hexByte(hex(int(powerOffTime))))
        if fullElecJudgPower:
            self.set_full_elec_judg_power(fill_2_hexByte(hex(int(fullElecJudgPower))))
        if cardTime:
            self.set_card_time(fill_2_hexByte(hex(int(cardTime))))
        if elecSetting:
            self.set_elec_setting(fill_2_hexByte(hex(int(elecSetting) * 10)))
        if coinTime:
            self.set_coin_time(fill_2_hexByte(hex(int(coinTime))))
        if maxCoins:
            self.set_max_coins(fill_2_hexByte(hex(int(maxCoins))))
        if elecFee:
            self.set_elec_fee(elecFee)