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

# -*- coding: utf-8 -*-
import re

from apilib.utils_datetime import get_zero_time
from apps.web.core.adapter.base import *
from apps.web.device.models import Device
from apps.web.user.models import Card, RechargeRecord


class WasherCarLSHBBox(SmartBox):
    def __init__(self, device):
        super(WasherCarLSHBBox, self).__init__(device)
    
    def reverse_hex(self, data):
        # type:(str) -> str
        if not isinstance(data, (str, unicode)):
            raise TypeError

        return ''.join(list(reversed(re.findall(r'.{2}', data))))
    
    def check_dev_status(self, attachParas = None):
        if attachParas and attachParas.has_key('price'):
            return

        if not self.device.need_fetch_online:
            raise ServiceException(
                {'result': 2, 'description': DeviceErrorCodeDesc.get(ErrorCode.DEVICE_CONN_CHECK_FAIL)})

        try:
            workStatus = self.get_device_workstatus()
            if workStatus == 0x05 or workStatus == 0x01:
                raise ServiceException({'result': 2, 'description': u'设备缺货、缺液，请联系老板'})
            elif workStatus == 0x04:
                raise ServiceException({'result': 2, 'description': u'设备工作中, 请等待设备工作完成再使用'})
            else:
                pass
        except ServiceException, e:
            raise e

    def get_device_workstatus(self):
        devInfo = MessageSender.send(device = self.device, cmd = DeviceCmdCode.OPERATE_DEV_SYNC,
                                     payload = {'IMEI': self._device['devNo'], "funCode": '02', 'data': ''})
        if devInfo['rst'] != ErrorCode.DEVICE_SUCCESS:
            if devInfo['rst'] == ErrorCode.DEVICE_CONN_FAIL:
                raise ServiceException(
                    {'result': 2, 'description': u'当前设备正在玩命找网络,请您稍候再试'})
            elif devInfo['rst'] == ErrorCode.BOARD_UART_TIMEOUT:
                raise ServiceException(
                    {'result': 2, 'description': u'当前设备忙,无响应,请您稍候再试'})
            else:
                raise ServiceException(
                    {'result': 2, 'description': u'检测设备状态失败({})'.format(devInfo['rst'])})

        workStatus = devInfo['data'][-4:-2]
        return int(workStatus)

    #获取计费工作模式
    def get_jfgzms(self):
        data = '0504000100'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        mode = devInfo['data'][-4:-2]
        return int(mode)

    #设置计费工作模式
    def set_jfgzms(self,mode):
        if int(mode) not in [0,1]:
            raise ServiceException({'result': 2, 'description': u'输入错误的参数，请输入正确的参数'})
        data = '05040001'
        if int(mode) == 0:
            data += '00'
        else:
            data += '01'

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-4:-2]
        if resultMode == '00' and mode != '0':
            raise ServiceException({'result': 2, 'description': u'设置失败，请再重新试试看哦'})
        elif resultMode == '01' and mode != '1':
            raise ServiceException({'result': 2, 'description': u'设置失败，请再重新试试看哦'})

    #获取清水刷卡模式费率
    def get_qsskmsfl(self):
        data = '0602000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置清水刷卡计费费率
    def set_qsskmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '06020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取刷卡模式费率
    def get_qstbmsfl(self):
        data = '0702000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置投币计费费率
    def set_qstbmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '07020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取泡沫投币模式费率
    def get_pmskmsfl(self):
        data = '1F02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置泡沫刷卡计费费率
    def set_pmskmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '1F020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取泡沫投币模式费率
    def get_pmtbmsfl(self):
        data = '2002000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置泡沫刷卡计费费率
    def set_pmtbmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '20020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取洗尘刷卡投币模式费率
    def get_xcskmsfl(self):
        data = '2102000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置吸尘刷卡计费费率
    def set_xcskmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '21020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取洗尘投币投币模式费率
    def get_xctbmsfl(self):
        data = '2202000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置吸尘投币计费费率
    def set_xctbmsfl(self,fl):
        hexFl = fill_2_hexByte(hex(int(fl)), 8)
        data = '22020004' + hexFl

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexFl.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取臭氧周期
    def get_cyzq(self):
        data = '1002000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置臭氧周期
    def set_cyzq(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '10020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取开灯时间
    def get_lightopening_time(self):
        data = '1102000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    # 获取串口设备信息
    def get_machine_info(self):
        data = ''
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '01', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        return devInfo['data']

    #设置开灯时间
    def set_lightopening_time(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '11020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #获取关灯时间
    def get_lightclosing_time(self):
        data = '1202000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置关灯时间
    def set_lightclosing_time(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '12020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    # 获取投币最低限额
    def get_coin_min_fee(self):
        data = '0A02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl

    # 设置投币最低限额
    def set_coin_min_fee(self, value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '0A020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})


    #获取IC卡单次扣费金额
    def get_IC_koufei(self):
        data = '1402000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    #设置IC卡单词扣费金额
    def set_IC_koufei(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '14020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #设置刷卡最低消费
    def set_card_min_consume(self, value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '26020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    def get_card_min_consume(self):
        data = '2602000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl


    #实体卡挂失
    def set_card_hangup(self, cardId):
        card = Card.objects.get(id = cardId)
        cardNo = '{:0>8s}'.format(card.cardNo)
        hexV = binascii.hexlify(cardNo)
        data = '0E030008' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-18:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    #实体卡解挂
    def set_card_hangout(self, cardId):
        card = Card.objects.get(id = cardId)
        cardNo = '{:0>8s}'.format(card.cardNo)
        hexV = binascii.hexlify(cardNo)
        data = '0F030008' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-18:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    def set_control_mode(self, funCode):
        hexV = '{:0>8X}'.format(funCode)
        data = '28020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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 get_control_mode(self):
        data = '2802000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl

    def set_disinfect_mode_fee(self, value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '23020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    def get_disinfect_mode_fee(self):
        data = '2302000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl

    def set_water_unit_price(self, value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '13020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})


    def get_water_unit_price(self):
        data = '1302000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl

    def set_trade_exit_timeout(self, value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '24020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    def get_trade_exit_timeout(self):
        data = '2402000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2], 16)
        return fl

    #给实体卡充值
    def recharge_card(self, cardNo, money, orderNo=None):
        try:
            hexV = fill_2_hexByte(hex(int(money * 10)), 8)
            data = '19020004' + hexV

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

            if devInfo['rst'] != 0:
                if devInfo['rst'] == ErrorCode.DEVICE_CONN_FAIL:
                    return {
                               'result': ErrorCode.DEVICE_CONN_FAIL,
                               'description': u'当前设备正在玩命找网络,请您稍候再试'
                           }, None
                elif devInfo['rst'] == ErrorCode.BOARD_UART_TIMEOUT:
                    return {
                               'result': ErrorCode.BOARD_UART_TIMEOUT,
                               'description': u'当前设备忙,无响应,请您稍候再试'
                           }, None
                else:
                    return {
                               'result': devInfo['rst'],
                               'description': u'系统异常'
                           }, None

            resultMode = devInfo['data'][-10:-2]

            if hexV.lower() != resultMode.lower():
                return {
                           'result': ErrorCode.IC_RECHARGE_FAIL,
                           'description': u'设置的结果和预期不符合，请您联系老板，进行检查哦'
                       }, None

            return {
                       'result': ErrorCode.SUCCESS,
                       'description': ''
                   }, None
        except Exception as e:
            logger.exception(e)

            return {
                       'result': ErrorCode.EXCEPTION,
                       'description': e.message
                   }, None

    def get_coins_count(self):
        data = '1c02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    def set_coins_count(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '1c020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您稍后再试哦'})

    def get_card_count(self):
        data = '1d02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    def set_card_count(self,value):
        hexV = fill_2_hexByte(hex(int(value)), 8)
        data = '1d020004' + hexV

        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        resultMode = devInfo['data'][-10:-2]

        if hexV.lower() != resultMode.lower():
            raise ServiceException({'result': 2, 'description': u'设置的结果和预期不符合，请您检查是否已经把卡放到了合适的位置，或者卡是否正常，或者读卡器是否损坏哦'})

    def clear_dev_feecount(self):
        self.set_card_count(0)
        self.set_coins_count(0)

    def get_today_card_count(self):
        data = '0c02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    def get_today_coin_count(self):
        data = '0b02000400000000'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '05', 'data': 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'当前设备忙,无响应,请您稍候再试'})

        fl = int(devInfo['data'][-10:-2],16)
        return fl

    def analyze_event_data(self, data):
        resultDict = {}
        funCode = data[12:14]
        if funCode == '01':#状态
            cmd = data[-4:-2]
            if cmd == '00':
                return {'funCode': funCode, 'status': Const.DEV_WORK_STATUS_IDLE, 'cmd': cmd, 'isFaultClass': True}
            elif cmd == '01':
                return {'funCode': funCode, 'status': Const.DEV_WORK_STATUS_FAULT, 'statusInfo': u'缺货、缺液', 'cmd': cmd,
                        'isFaultClass': True}
            elif cmd == '02':
                return {'funCode': funCode, 'status': Const.DEV_WORK_STATUS_FAULT, 'statusInfo': u'缺货、缺液', 'cmd': cmd,
                        'isFaultClass': True}
            elif cmd == '04':
                return {'funCode': funCode, 'status': Const.DEV_WORK_STATUS_WORKING, 'statusInfo': u'工作中', 'cmd': cmd,
                        'isFaultClass': True}

        elif funCode == '08':
            useTime = int(data[-10:-2],16)
            minutes = int(useTime/60.0)
            return {'funCode':funCode,'status':Const.DEV_WORK_STATUS_WORKING,'useTime':minutes}
        elif funCode == '0B':
            count = int(data[-10:-2],16)
            return {'funCode':funCode,'coin':count}
        elif funCode == '0C':
            count = int(data[-10:-2],16)
            return {'funCode':funCode,'card':count}
        elif funCode == '0D':
            count = int(data[-10:-2],16)
            return {'funCode':funCode,'chargeCard':count}
        elif funCode == '13':
            count = int(data[-10:-2],16)
            return {'funCode':funCode,'showWater':count}

        elif funCode == '15':#卡信息上报
            money = int(data[20:24],16)/10.0
            uid = data[24:34]
            cardNoStr = data[34:50]
            cardNo = ''
            ii = 0
            for jj in range(8):
                strTemp = chr(int(cardNoStr[ii:ii+2],16))
                ii += 2
                cardNo += strTemp

            return {'funCode':funCode,'cardNo':'{:d}'.format(int(cardNo)),
                    'money':money,'uid':uid,'status':Const.DEV_WORK_STATUS_WORKING}

        elif funCode == '16':#刷卡消费
            uid = data[24:34]
            money = int(data[20:24],16)/10.0
            cardNoStr = data[34:50]
            cardNo = ''
            ii = 0
            for jj in range(8):
                strTemp = chr(int(cardNoStr[ii:ii+2],16))
                ii += 2
                cardNo += strTemp

            return {'funCode':funCode,'cardNo':'{:d}'.format(int(cardNo)),
                    'money':money,'uid':uid,'status':Const.DEV_WORK_STATUS_WORKING}
        
        elif funCode == '17':#充值
            uid = data[24:34]
            money = int(data[20:24],16)/10.0
            cardNoStr = data[34:50]
            cardNo = ''
            ii = 0
            for jj in range(8):
                strTemp = chr(int(cardNoStr[ii:ii+2],16))
                ii += 2
                cardNo += strTemp

            return {'funCode':funCode,'cardNo':'{:d}'.format(int(cardNo)),
                    'money':money,'uid':uid,'status':Const.DEV_WORK_STATUS_WORKING}
        
        elif funCode == '1B':#使用移动支付的洗车结束
            resultType = data[20:22]
            if resultType != '03':
                return resultDict
            sequanceNo = data[24:28]
            money = int(data[28:32],16)/10.0
            return {'funCode':funCode,'sequanceNo':sequanceNo,'money':money,'status':Const.DEV_WORK_STATUS_IDLE}
        
        elif funCode == '19' or funCode == '20':
            cardBalance = round((int(data[20:28], 16) * 0.1), 2)
            cardNoHex = data[28:38] # 卡号用了前四个bit 最后一个是校验
            cardNo = '{}'.format(int(self.reverse_hex(cardNoHex[:-2]), 16))
            occupyData = data[38:50]
            return {'funCode': funCode, 'cardNo': cardNo, 'cardBalance': cardBalance, 'occupyData': occupyData,
                    'data': data, 'cardNoHex': cardNoHex}
        
        return resultDict

    def get_dev_setting(self):
        billingModel = self.get_jfgzms()
        cardRates = self.get_qsskmsfl()
        coinRates = self.get_qstbmsfl()
        foamCardRates = self.get_pmskmsfl()
        foamCoinRates = self.get_pmtbmsfl()
        dustingCardRates = self.get_xcskmsfl()
        dustingCoinRates = self.get_xctbmsfl()
        cardOneTimeFee = self.get_IC_koufei()
        ozoneCycle = self.get_cyzq()
        lightTime = self.get_lightopening_time()
        offLightTime = self.get_lightclosing_time()
        swing_card_minfee = self.get_card_min_consume()

        return {'billingModel':billingModel,'cardRates':cardRates,'coinRates':coinRates,
                'cardOneTimeFee':cardOneTimeFee,'ozoneCycle':ozoneCycle,'lightTime':lightTime,
                'offLightTime':offLightTime,'foamCardRates':foamCardRates,'foamCoinRates':foamCoinRates,
                'dustingCardRates':dustingCardRates,'dustingCoinRates':dustingCoinRates,
                'swing_card_minfee':swing_card_minfee}

    def make_sequanceNo(self):
        nowTime = datetime.datetime.now()
        zeroTime = get_zero_time(nowTime)
        deltaMinutes = (nowTime - zeroTime).total_seconds()/60
        return fill_2_hexByte(hex(int(deltaMinutes)), 4)
    
    def stop(self,port=None):
        data = '2802000400000006'
        devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC,
                                     {'IMEI': self._device['devNo'], "funCode": '06', 'data': 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'设备正忙，无响应，您的金币还在，重试不需要重新付款，请您稍后再试哦'})

        #计算剩余时间，如果是按照次的方式，剩余时间为0
        ctrInfo = Device.get_dev_control_cache(self._device['devNo'])
        try:
            unit = ctrInfo.get('unit')
            needTime = ctrInfo.get('needTime')
            startTime = to_datetime(ctrInfo.get('startTime'))
        except Exception,e:
            devInfo.update({'remainder_time':0})
            return devInfo
        
        if unit == u'次':
            devInfo.update({'remainder_time':0})
            return devInfo
        
        nowTime = datetime.datetime.now()
        spendTime = (nowTime - startTime).total_seconds()/60
        remainderTime = needTime - spendTime if needTime > spendTime else 0
        devInfo.update({'remainder_time':remainderTime})
        return devInfo    
    
    def calc_stop_back_coins(self,totalFee,remainderTime,totalTime):
        refundFee = round(totalFee * (float(remainderTime) / (totalTime)),2)
        if refundFee > totalFee:
            refundFee = totalFee

        if refundFee <= 0.0:
            refundFee = 0.00
        
        return refundFee

    def start_device(self, package, openId, attachParas):
        money = package['coins']
        needTime = package['time']
        unit = package['unit']
        price = package.get('price', 0)

        hexMoney = fill_2_hexByte(hex(int(money * 10)), 4)
        sequanceNo = self.make_sequanceNo()
        data = '1b0000060100' + sequanceNo + hexMoney
        devInfo = MessageSender.send(device = self.device, cmd = DeviceCmdCode.OPERATE_DEV_SYNC, payload = {
            'IMEI': self._device['devNo'],
            "funCode": '06',
            'data': data
        }, 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'设备正忙，无响应，您的金币还在，重试不需要重新付款，请您稍后再试哦'})

        returnCode = devInfo['data'][-12:-10]
        if returnCode == '01':
            raise ServiceException({'result': 2, 'description': u'命令格式错误'})
        elif returnCode == '02':
            raise ServiceException({'result': 2, 'description': u'收到重复指令'})
        elif returnCode == '03':
            raise ServiceException({'result': 2, 'description': u'金额超出范围'})
        elif returnCode == '04':
            raise ServiceException({'result': 2, 'description': u'正在交易过程中，不允许接受扫码付款'})
        elif returnCode == '00':
            devInfo.update({'sequanceNo': sequanceNo})
            # 刷新状态
            newValue = {'startTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                        'money': money, 'isStart': True,'coins':money,
                        'needTime':needTime,'unit':unit,
                        'refunded': False, 'openId': openId,
                        'price': price,
                        'vCardId':self._vcard_id, 'sequanceNo': sequanceNo}

            if 'linkedRechargeRecordId' in attachParas and attachParas.get('isQuickPay', False):
                linkedRechargeRecordId = str(attachParas['linkedRechargeRecordId'])
                rechargeRecord = RechargeRecord.objects(id=linkedRechargeRecordId).first()
                if rechargeRecord.isQuickPay is True:
                    newValue.update({'rechargeRcdId': str(attachParas['linkedRechargeRecordId'])})
                else:
                    pass

            Device.update_dev_control_cache(self._device['devNo'], newValue)
            return devInfo

    def get_device_function_by_key(self,keyName):
        if keyName == "swing_card_minfee" :
            return float(self.get_card_min_consume()) / 10
        elif keyName == "cardOneTimeFee":
            return float(self.get_IC_koufei()) / 10
        elif keyName == "coin_min_fee":
            return float(self.get_coin_min_fee()) / 10
        elif keyName == "billingModel":
            return self.get_jfgzms()
        elif keyName == "trade_exit_timeout":
            return self.get_trade_exit_timeout()
        elif keyName == "disinfect_mode_fee":
            return float(self.get_disinfect_mode_fee())
        elif keyName == "water_unit_price":
            return float(self.get_water_unit_price()) / 10
        elif keyName == "water_card_fee":
            return float(self.get_qsskmsfl())
        elif keyName == "water_coin_fee":
            return float(self.get_qstbmsfl())
        elif keyName == "ozoneCycle":
            return self.get_cyzq()
        elif keyName == "lightTime":
            return self.get_lightopening_time()
        elif keyName == "offLightTime":
            return self.get_lightclosing_time()
        elif keyName == "foam_card_fee":
            return float(self.get_pmskmsfl())
        elif keyName == "foam_coin_fee":
            return float(self.get_pmtbmsfl())
        elif keyName == "clean_card_fee":
            return float(self.get_xcskmsfl())
        elif keyName == "clean_coin_fee":
            return float(self.get_xctbmsfl())
        return None

    def press_down_key(self, keyName, value=None):
        if keyName == "swing_card_minfee" :
            self.set_card_min_consume(int(value * 10))
        elif keyName == "cardOneTimeFee":
            self.set_IC_koufei(int(value * 10))
        elif keyName == "billingModel":
            self.set_jfgzms(value)
        elif keyName == "trade_exit_timeout":
            self.set_trade_exit_timeout(value)
        elif keyName == "disinfect_mode_fee":
            self.set_disinfect_mode_fee(int(value))
        elif keyName == "water_unit_price":
            self.set_water_unit_price(int(value * 10))
        elif keyName == "water_card_fee":
            self.set_qsskmsfl(int(value))
        elif keyName == "water_coin_fee":
            self.set_qstbmsfl(int(value))
        elif keyName == "ozoneCycle":
            self.set_cyzq(value)
        elif keyName == "lightTime":
            self.set_lightopening_time(value)
        elif keyName == "offLightTime":
            self.set_lightclosing_time(value)
        elif keyName == "foam_card_fee":
            self.set_pmskmsfl(int(value))
        elif keyName == "foam_coin_fee":
            self.set_pmtbmsfl(int(value))
        elif keyName == "clean_card_fee":
            self.set_xcskmsfl(int(value))
        elif keyName == "clean_coin_fee":
            self.set_xctbmsfl(int(value))
    
    def set_device_function_param(self,request,lastSetConf):
        if request.POST.has_key('cardOneTimeFee'):
            self.set_IC_koufei(float(request.POST.get('cardOneTimeFee')) * 10)

        if request.POST.has_key('swing_card_minfee'):
            self.set_card_min_consume(float(request.POST.get('swing_card_minfee')) * 10)

        if request.POST.has_key('coin_min_fee'):
            self.set_coin_min_fee(float(request.POST.get('coin_min_fee')) * 10)

        if request.POST.has_key('water_unit_price'):
            self.set_water_unit_price(float(request.POST.get('water_unit_price')) * 10)
    
    def response_card_money(self, cardNo, balance, occupyData):
        data = '55AA000700131900000F'
        data += '{:0>8X}'.format(int(balance * 10)) # 单位  角
        data += cardNo
        data += occupyData
        
        devInfo = MessageSender.send(self.device, DeviceCmdCode.PASSTHROUGH_OPERATE_DEV_NO_RESPONSE,
                           {'IMEI': self._device['devNo'], 'data': data, 'funCode':'07'})

    def response_card_change_sucess(self, cardNo, balance, occupyData):
        data = '55AA000800132000000F'
        data += '{:0>8X}'.format(int(balance * 10))  # 单位  角
        data += cardNo
        data += occupyData
    
        devInfo = MessageSender.send(self.device, DeviceCmdCode.PASSTHROUGH_OPERATE_DEV_NO_RESPONSE,
                                     {'IMEI': self._device['devNo'], 'data': data, 'funCode': '08'})

    @property
    def isHaveStopEvent(self):
        return True