-import ujson
-import utime
-import EventMesh
-import constants
-from common import Abstract
-import uhashlib
-import ubinascii
-from misc import Power
-import audio
-from machine import Pin
-import ujson
-import ql_fs
-import dataCall
-import checkNet
-import net
-import usocket
-import osTimer
-
-import machine
-import urandom
-import _thread
-import usys
-import request
-import umqtt
-import modem
-import versions
-SHA256 = uhashlib.sha256
-import SecureData
-import log
-import ustruct
-
-def server_init(server_type = None):
- #服务器选择1，防走丢，2大锤,3三基同创,4童信，5云米,6荣为 8:ds未知 dey.hinwatch. com:9968 9:183.62.239.121:31869 10:183.62.239.121:33461
- if server_type == None:
- server_type = 2
- #EventMesh.debug_log("server_init:server_type:{}".format(server_type))
-
- d_server_addr = "api.xcloudtech.com"
- d_server_port = 9000
- d_md5_key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"
- d_PID = "SZKW"
- if server_type == 1:
- pass
-
- elif server_type == 2:
- # test.iot.socket.thisiot.com:9999
- # iot.socket .thisiot.com:9999
- # d_server_addr = "test.iot.socket.thisiot.com"
- # d_server_port = 9999
- # d_md5_key = "3JyCjsw4ryXKzjzudayY"
- # d_PID = "qAELPTKmFanR4RHe"
-
- d_server_addr = "iot.socket.thisiot.com"
- d_server_port = 9999
- d_md5_key = "SZYhyGhroQ3xFKFWZq1g"
- d_PID = "oxLwDqcwJCtiPSRu"
-
- elif server_type == 3:
- d_server_addr = "tcp.zhihuixuexiao.com"
- d_server_port = 2346
- d_md5_key = ""
- d_PID = "3G"
- elif server_type == 4:
- d_server_addr = "tcp.tx.kidxin.com"
- d_server_port = 20500
- elif server_type == 5:
- d_server_addr = "device.miwitracker.com"
- d_server_port = 8505
- d_md5_key = ""
- d_PID = "3G"
- elif server_type == 6:
- d_server_addr = "120.26.104.21"
- d_server_port = 9968
- d_md5_key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"
- d_PID = "SZKW"
- elif server_type == 7:
- d_server_addr = "8.134.68.15"
- d_server_port = 30346
- d_PID="KnHnj1Cd5VxcO3Ft"
- d_md5_key = "evxThVhMBmRNiQ1Twigw"
- elif server_type == 99:
- d_server_addr = "lab.xcloudtech.com"
- d_server_port = 9000
- elif server_type == 8:
- d_server_addr = "dev.hxinwatch.com"
- d_server_port = 9968
- elif server_type == 9:
- d_server_addr = "183.62.239.121"
- d_server_port = 31869
- elif server_type == 10:
- d_server_addr = "183.62.239.121"
- d_server_port = 33461
-
- return [d_server_addr,d_server_port,d_md5_key,d_PID]
-from queue import Queue
-def unicode_to_utf8(src):
- ref = 0xe08080
- result = ref
-
- #取最后六位
- a = src & 0x3f
-
- #将最后六位放在ref最后六位的空位置
- result = result | a
- src = src >> 6
-
- #取接下来的六位
- a = src & 0x3f
-
- #放在ref对应的六个位置
- result = result | (a << 8)
-
- #保留最后四位
- src = src >> 6
-
- #放在ref对应的四个位置
- result = result | (src << 16)
- return result
-
-def UnicodeHexStr_To_Utf8Str(str):
- odata = 0
-
- result = bytes()
- su =str.upper()
-
- i = 0
- for c in su:
- tmp=ord(c)
- if tmp <= ord('9') :
- odata = odata << 4
- odata += tmp - ord('0')
-
- elif ord('A') <= tmp <= ord('F'):
- odata = odata << 4
- odata += tmp - ord('A') + 10
- if(i%4==3): #每2字节获取一个int，拿到转换后的unicode int
- #print(odata.to_bytes(2, 'big'))
- #result.append(odata)
- if odata > 255:
- tmp = unicode_to_utf8(odata)#拿到转换后的utf8 int
- tmp2 = tmp.to_bytes(3, 'big') #转bytes
- else :
- tmp2 = odata.to_bytes(1, 'big')
- #print("tmp2:{}".format(tmp2))
- result = result + tmp2
- odata = 0
- i+=1
- return result.decode('utf-8') #返回utf8的str
-
-def gewu_init():
- productKey = "cu1shld45y4hjr1L"
- return productKey
-mqtt_state = 0
-def mqttsub_cb(topic, msg):
- global mqtt_state
- print("Subscribe Recv: Topic={},Msg={}".format(topic.decode(), msg.decode()))
- jsload_data = ujson.loads(msg.decode())
- print("jsload_data-{} type:{}".format(jsload_data,type(msg.decode())))
- # jsload_data = {'data':'111','protocolType':'', 'host':'device.miwitracker.com', 'secretKey': 'bZld0ALsZTt15tKEZhOlLPgbsO75BLTP', 'port':8505, 'bid': '3G', 'extJsonStr': ''}
- # ujson.loads(c)
- # $sys/cu1shld45y4hjr1L/866610001011658/ext/regist
- #data = {"messageId":"25","params":{"deviceSecret":"C1D75A63C0338978438E9197372FC698""}}
- if "params" in jsload_data:
- params_str = jsload_data["params"]
- if "deviceSecret" in params_str:
- str_tmp = params_str["deviceSecret"]
- print(str_tmp)
- EventMesh.publish("set_deviceSecret",str_tmp)
- mqtt_state = 1
-def mqtterr_cb(error):
- '''
- 接收umqtt线程内异常的回调函数
- '''
- print("error!!!!!!!!!!!".format(error))
-
-def HMAC(k, m):
- SHA1_BLOCK_SIZE = 64
- KEY_BLOCK = k + (b'\0' * (SHA1_BLOCK_SIZE - len(k)))
- KEY_INNER = bytes((x ^ 0x36) for x in KEY_BLOCK)
- KEY_OUTER = bytes((x ^ 0x5C) for x in KEY_BLOCK)
- inner_message = KEY_INNER + m
- outer_message = KEY_OUTER + SHA256(inner_message).digest()
- return SHA256(outer_message)
-
-
-def get_hmac_sha256(k, m):
- data = HMAC(k, m).digest()
- # print("HMAC(k, m).digest()：", data)
- # print("HMAC(k, m).digest()：", ubinascii.hexlify(data))
- hex_data = ubinascii.hexlify(data)
- hex_data = hex_data.decode('ascii')
- return hex_data
-
-def mqtt_client_pro_init():#一型一密
- client = 0
-
- # 创建一个mqtt实例
-#
- # {"productKey":"cu1r1rjjrjdhz0lx","deviceKey":"DD86000000001","deviceSecret":"93FEEC6D16D30E2B90FE0DBC2FFCDB14"} 设备基本信息
- # hmac_sha256(deviceIddeviceKeyproductKey,deviceSecret) mqttclientId
- deviceId = ""#"bOOSGN5FlXEjt15"
- deviceKey = ''#"bOOSGN5FlXEjt15"
- imei = EventMesh.publish(constants.EVENT.GET_IMEI)
- deviceId = str(imei)
- deviceKey = str(imei)
- productKey = gewu_init()
-
- EventMesh.publish("set_product_key",productKey)
- data = "{}{}{}".format(deviceId,deviceKey,productKey)#需要用户定义产品是提供数据
- # data = b"The data to encrypt"
- # 密钥
- productSecret = b"765fc66242616852209d1c57e51b0744" #765fc66242616852209d1c57e51b0744 ,productSecret
-
- # {"productKey":"cu1shld45y4hjr1L","deviceKey":"bOOSGN5FlXEjt15","deviceSecret":"9234577490038E0949B800C243BF4321"}
- checkpassword = get_hmac_sha256(productSecret,data)
- # print(checkpassword)
- # {deviceId}|{productKey}|{signMethod}|{authType}|{operator}；连接id格式
-
- Client_id = "{}|{}|0|1|0".format(deviceId,productKey) #
- # print(Client_id)
- server = "dmp-mqtts.cuiot.cn"#"dmp-mqtt.cuiot.cn"
- port = 8883
- # {deviceKey}|{productKey} mqttUsername
- userName = "{}|{}".format(deviceKey,productKey)
- userpassword = checkpassword
- # print(userName)
- # print(userpassword)
- # client = umqtt.MQTTClient("866610001011658|cu1shld45y4hjr1L|0|1|0","dmp-mqtt.cuiot.cn", 1883, "866610001011658|cu1shld45y4hjr1L","675f6fbfb15a729bbc280273632ce3a96f8b38d4736fbaf888fe8a48fd7aee09")
- # client = umqtt.MQTTClient("lxRXQayZ4poQz8G|cujg06l29iav591b|0|0|0","dmp-mqtt.cuiot.cn", 1883, "lxRXQayZ4poQz8G|cujg06l29iav591b","1f8c69d29afca0505d967066b39d84a5eb1e54302b87e337b405f99d029a9242")
- client = umqtt.MQTTClient(Client_id,server, port, userName,"{}".format(userpassword),reconn=False,ssl=True)
- # client = MqttClient(Client_id, server, port, userName,"{}".format(userpassword))
- # 设置消息回调
- client.set_callback(mqttsub_cb)
- # 设置异常回调
- client.error_register_cb(mqtterr_cb)
- return client
-
-def mqtt_client_dev_init():#一机一密
- client = 0
-
- # 创建一个mqtt实例
-#
- # {"productKey":"cu1r1rjjrjdhz0lx","deviceKey":"DD86000000001","deviceSecret":"93FEEC6D16D30E2B90FE0DBC2FFCDB14"} 设备基本信息
- # hmac_sha256(deviceIddeviceKeyproductKey,deviceSecret) mqttclientId
- deviceId = '' #"bOOSGN5FlXEjt15"
- deviceKey = ''#"bOOSGN5FlXEjt15"
- imei = EventMesh.publish(constants.EVENT.GET_IMEI)
- deviceId = str(imei)
- deviceKey = str(imei)
- productKey = gewu_init()
- data = "{}{}{}".format(deviceId,deviceKey,productKey)#需要用户定义产品是提供数据
- # data = b"The data to encrypt"
- # 密钥
- deviceSecret_tmp = EventMesh.publish("get_deviceSecret")
- subscribe_msg = deviceSecret_tmp.encode('ascii')
- deviceSecret = subscribe_msg #765fc66242616852209d1c57e51b0744 ,productSecret
- print(deviceSecret)
-
- checkpassword = get_hmac_sha256(deviceSecret,data)
- print(checkpassword)
- # {deviceId}|{productKey}|{signMethod}|{authType}|{operator}；连接id格式
- Client_id = "{}|{}|0|0|0".format(deviceId,productKey) # 860132060346475|cu1shld45y4hjr1L|0|0|0
- server = "dmp-mqtts.cuiot.cn"#"dmp-mqtt.cuiot.cn"
- port = 8883
- # {deviceKey}|{productKey} mqttUsername
- userName = "{}|{}".format(deviceKey,productKey)
- userpassword = checkpassword
-
- client = umqtt.MQTTClient(Client_id,server, port, userName,"{}".format(userpassword),reconn=False,ssl=True)
- # client = MqttClient(Client_id, server, port, userName,"{}".format(userpassword))
- # 设置消息回调
- client.set_callback(mqttsub_cb)
- # 设置异常回调
- client.error_register_cb(mqtterr_cb)
- return client
-
-
-
-import uwebsocket
-import sim
-
-class WEB_CMD_ENUM:
- POST_DEVICE_STATE_R_CMD = "post_device_state_R"
- POST_DEVICE_STATE_S_CMD = "post_device_state_S"
-
- POST_DEVICE_INFOR_R_CMD = "POST_DEVICE_INFOR_R_CMD"
- POST_DEVICE_INFOR_S_CMD = "POST_DEVICE_INFOR_S_CMD"
-
- POST_ALARM_R_CMD = "post_alarm_R"
- POST_ALARM_S_CMD = "post_alarm_S"
-
- FIND_DEVCE_R_CMD = "find_device_R"
- FIND_DEVCE_S_CMD = "find_device_S"
-
- ALARM_CONFIG_R_CMD = "alarm_config_R"
- ALARM_CONFIG_S_CMD = "alarm_config_S"
-
- ALARM_LIST_R_CMD = "alarm_list_R"
- ALARM_LIST_S_CMD = "alarm_list_S"
-
- UNBIND_DEV_R="unbind_dev_R"
- UNBIND_DEV_S="unbind_dev_S"
-
- DEVICE_SHAKE_STATE_R_CMD = "device_shake_state_R"
- DEVICE_SHAKE_STATE_S_CMD = "device_shake_state_S"
-
-class IOT_socket_SendCmdManager(Abstract):
- #
- def __init__(self):
- self.send_data = ""
- self.time_tmp = 0
- def post_processor_after_instantiation(self):
- EventMesh.subscribe("GET_IOT_SEND_CMD", self.get_iot_send_cmd)
- print("IOTSendCmdManager")
- #调用：device_state=EventMesh.publish("GET_IOT_SEND_CMD",WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD)
- # print("device_state{}".format(device_state))
- def get_iot_send_cmd(self, event, msg):#获取准备发送的值
- date_tmp = utime.localtime()
- self.time_tmp = utime.mktime(date_tmp)
- if msg == WEB_CMD_ENUM.POST_DEVICE_STATE_S_CMD:#设备VC状态
- self.send_data = self.device_report_state_send_data()
- return self.send_data
- elif msg == WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD:#设备信息
- self.send_data = self.device_information_send_data()
- return self.send_data
- elif msg == WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD:#聊天内容
- self.send_data = self.device_information_send_data()
- return self.send_data
-
- # 设备对话内容上报数据格式
- def device_talk_send_data(self):
- print("device_talk_send_data")
- infor_send_data = {
- "cmd":"chat_text",
- "data":
- {
- "device_id":modem.getDevImei(),#设备号
- "type":"req:请求说的话；res：响应的内容",
- "text":"用户说话内容",
- "createTime":"时间戳"
- }
- }
- return infor_send_data
-
- # 设备信息上报数据格式
- def device_information_send_data(self):
- print("device_information_send_data")
- battery_state = (EventMesh.publish("screen_get_battery"))[0]
- battery = (EventMesh.publish("screen_get_battery"))[1]
- if battery >= 100 or battery == None:
- battery = 100
- VC_TTS_volume = EventMesh.publish("get_storage_config","VC_TTS_volume")#音量配置
- if VC_TTS_volume == None:
- VC_TTS_volume =100
- sourceVersion =versions.Build_Time
- Timeversion ="JSWM-"+sourceVersion
- infor_send_data = {
- "data":{
- "version":Timeversion,#版本号
- "charge":battery_state,#0表示未充电，1表示充电中
- "current_role_name":"",#当前音色的name
- "volume":str(VC_TTS_volume),#百分比数值
- "wifi_rssi":str(net.csqQueryPoll()//6),#wifi强弱：0，1，2，3，4，5。转成这几个梯度
- "battery":str(battery),#电量
- "device_id":modem.getDevImei(),#设备号
- },
- "cmd":"device_info"
- }
- return infor_send_data
-
- #设备上报VC状态
- def device_report_state_send_data(self):
- ai_status = EventMesh.publish("screen_get_ai")
- if EventMesh.publish("get_VC_satrt_flag") == 1:#获取vc是否在运行
- if ai_status < 6 :
- target_status = "listening"
- elif ai_status == 6:
- target_status = "thinking"
- elif ai_status >= 8:
- target_status = "speaking"
- else:
- target_status = "idle"
-
- device_report_data ={
- "data":{
- "device_id":modem.getDevImei(),
- "state":target_status
- },
- "cmd":"chat_state"
- }
- return device_report_data
-def extract_target_number(json_str):
- # 查找"target":"的起始位置
- start_key = '"target":"'
- start_idx = json_str.find(start_key)
- if start_idx == -1:
- print("未找到 target 字段")
- return None # 未找到目标字段
-
- # 计算数字的起始位置（跳过"target":"）
- num_start = start_idx + len(start_key)
-
- # 从数字起始位置开始，查找结束的双引号（"）
- num_end = json_str.find('"', num_start)
- if num_end == -1:
- print("未找到数字的结束位置")
- return None # 格式异常
-
- # 截取数字字符串（从num_start到num_end）
- number_str = json_str[num_start:num_end]
-
- # 转换为整数（如果需要浮点数，可改为float(number_str)）
- try:
- return int(number_str)
- except ValueError:
- print("截取的内容不是有效数字")
- return None
-
-def playload_data(data):
- print("data = {}".format(data))
- if isinstance(data, bytes) == 0 :
- print("data类型错误")
- return
-
- if data[0] != 0xff or data[1] !=0xfe:
- print("data格式错误,重新登录")
- EventMesh.publish("login_IOT")#登录IOT
- return
- payload_len_bytes = data [3:5]
- payload_len = ustruct.unpack ('H', payload_len_bytes)[0]
- # print ("解析到 Payload 长度：{} 字节".format(payload_len))
-
- payload = data [5 : 5+ payload_len]
- try:
- json_str = payload.decode ('utf-8')
- except UnicodeDecodeError:
- try:
- json_str = payload.decode ('gbk')
- print ("提示：Payload 使用 GBK 编码")
- except UnicodeDecodeError:
- print ("Payload 解码失败")
- return
- # json_str = "\"" + json_str + "\""
- if type(json_str) is str and len(json_str)>5:
- print ("解析出的 JSON 字符串:{}".format(json_str) + "-"*50)
- if "get_device_state" in json_str:
- EventMesh.publish("send_device_information")#发送设备信息
- EventMesh.publish("send_device_VC_state")#上传VC状态
- print("get_device_state")
- elif "find_device" in json_str:
- EventMesh.publish("play_tts_single","我在这呀，我在这呀")
- print("find_device")
- elif "renew_device" in json_str:#更新对话模式 重启
- EventMesh.publish("play_tts_single","更新配置中，设备将自动重启")
- print("renew_device")
- utime.sleep_ms(3000)
- EventMesh.publish("Power_off")
- elif "switch_volume" in json_str:
- volume = int(extract_target_number(json_str))
- print("switch_volume = {}".format(volume))
- EventMesh.publish("update_volume",volume)
- elif "switch_brightness" in json_str:
- light = int(extract_target_number(json_str))//10
- print("switch_brightness")
- EventMesh.publish("set_brightness_level",light)
- elif "setup_role" in json_str:
- EventMesh.publish("play_tts_open","角色正在切换")
- print("setup_role")
- EventMesh.publish("load_screen", {"screen": "UI_ai"})#ai画面
-
-
- # data_dict = ujson.loads(json_str)
- # if isinstance(data_dict, dict):
- # #下面做小程序下发指令类型判断
- # data = data_dict["cmd"]
- # if data is "get_device_state":
- # EventMesh.publish("send_device_information")#发送设备信息
- # print("get_device_state")
- # elif data is "find_device":
- # EventMesh.publish("play_tts_single","我在这呀，我在这呀")
- # print("find_device")
- # else:
- # print("JSON数据不是字典类型")
-
-
-
-date_tmp = utime.localtime()
-time_tmp = utime.mktime(date_tmp)
-MAGIC = (0xfffe).to_bytes(2,"big")
-VERSION = (0x01).to_bytes(1,"big")#"03".encode('utf-8')
-TYPE = (0x03).to_bytes(1,"big")
-DATA_LEN = (0x00000000).to_bytes(4,"big")
-#magic+version+type+playload_len+playload
-def protocol_send_total_data(data):
- MAGIC = (0xfffe).to_bytes(2,"big")
- VERSION = (0x01).to_bytes(1,"big")#"03".encode('utf-8')
- TYPE = (0x03).to_bytes(1,"big")
- HR_JSON = ujson.dumps(data)
- GPS_JSON_b = HR_JSON.encode('utf-8')
- DATA_LEN = (len(HR_JSON)).to_bytes(4,"big")
- heards_infor = b''
- heards_infor = MAGIC+VERSION+TYPE+DATA_LEN+GPS_JSON_b
- return heards_infor
-
-DEFIEN_HR_REPORT_TIME = 5*60
-DEFINE_TIME_COUNT = 5
-DEFIEN_LOCATION_REPORT_TIME = 5
-WEB_CONNECT_MAX_COUNT = 10 #默认重连次数
-
-PROJECT_NAME = "JSWM"
-PROJECT_VERSION = "1.0.0"
-checknet = checkNet.CheckNetwork(PROJECT_NAME, PROJECT_VERSION)
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-socket_log = log.getLogger("SOCKET")
-class SockMangager(Abstract):
- def __init__(self):
- self.thread_buf_size = 8*1024
- self.iot_soc_send_queue = Queue(100)
- self.iot_protoclo_recv_id=None
- self.connect_timer = osTimer()
- self.connect_timer_count = 0
- self.hr_report_timer = osTimer()
- self.resolver = None
- self.send_device_time = 0
- self.vbat_buf = []
- self.network_state = 0
- self.socket_send_queue_id = None
- self.bat_count = 0
- self.reconnect_count = 0 #连续重连次数 默认十次 不过就不重连了 等下一个心跳重连
- self._20S_timer = osTimer()
- self._1scnt = 0
- self._5M_timer = osTimer()
- self._10Stimer = osTimer()
- self.timer_id = 0
- self.start_voice_flag = 0
- self.IOT_sock = None
- self.login_statu = 0#登陆状态
- self.sock_lock = _thread.allocate_lock() # 初始化锁
- #对话状态，一秒检查一次
- self.last_data = None # 保存上一次的数据状态
- self.current_data = None # 当前数据
- EventMesh.subscribe("REPORT_ALARM_TO_IOT",self.report_alarm_to_iot)
-
- def report_alarm_to_iot(self,event,msg):
- EventMesh.publish(WEB_CMD_ENUM.POST_ALARM_S_CMD,msg)
- pass
- def usb_event_cb(self, state):
- status = state
- def post_processor_after_instantiation(self):
- EventMesh.subscribe("CHANNEL_IOT_SEND",self.user_send)#发送数据的函数！！重要
- EventMesh.subscribe("GET_IOT_PROTOCOL_CILENT",self.get_IOT_sock)
- EventMesh.subscribe("close_socket_timer",self.close_socket_timer)
- EventMesh.subscribe("connect_iot_socket",self.connect_iot_socket_cb)#使用socket连接iot平台
- EventMesh.subscribe("login_IOT",self.login_IOT)#登录iot平台
- EventMesh.subscribe("heart_IOT",self.heart_IOt)#心跳包
- EventMesh.subscribe("send_device_information",self.send_device_information)#上报设备信息
- EventMesh.subscribe("send_device_VC_state",self.send_device_VC_state)#上报VC状态
- EventMesh.subscribe("send_unbind_dev_to_iot",self.send_unbind_dev_to_iot)#心跳包定时器开启
- self.reconnect_count = 0
- self.deviceReadState = ""
-
- # self.connect_timer.start(2000,0,self.iot_connect_timerCb)
-
- def send_device_information(self,event,msg):
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD})#上报设备信息
- def send_device_VC_state(self,event,msg):
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_STATE_S_CMD})#上报VC状态
-
- def send_unbind_dev_to_iot(self,event,msg):
- self._5M_timer.start(60000*5,1,self._5M_timer_cb)#更新信息
- self._20S_timer.start(20000,1,self._20S_timer_cb)#重连
- # self._10Stimer.start(50000,1,self._10S_timer_cb)
- def _5M_timer_cb(self,*argc):
- EventMesh.publish("heart_IOT")#开启IOT心跳包
- EventMesh.publish("send_device_information")#发送设备信息
- pass
-
- def initialization(self, *args):
- pass
- def connect_iot_socket_cb(self,event,msg):
- self.connect_iot_socket()
- def add_support_resolver(self, resolver):
- self.resolver = resolver
- def hr_report_event(self, *args, **kwargs):
- EventMesh.publish("publish_AI_btnInfo",{"func":self.hr_report_event_cb}) #self.connect_iot_websocket()
- def hr_report_event_cb(self):
- """电池平均值"""
- temp = Power.getVbatt()
- if self.bat_count < 10:
- self.vbat_buf.append(temp)
- self.bat_count += 1
- else:
- for i in range(9):
- self.vbat_buf[i] = self.vbat_buf[i+1]
- self.vbat_buf[9] = temp
- curr_count = len(self.vbat_buf)
- bat_total_value = 0
- for i in range(curr_count):
- bat_total_value += self.vbat_buf[i]
- bat_total_value = bat_total_value//curr_count#一分钟更新一次电量 10个平均值
- EventMesh.publish("AI_alarm_start") #检查是否有闹钟需要提醒
- # self.alarm_test()
- EventMesh.publish("set_curr_battery_level",bat_total_value)
- # EventMesh.publish("publish_AI_btnInfo",{"func":self.hr_report_publish_event,"data":0})
- if self.send_device_time < DEFIEN_LOCATION_REPORT_TIME :
- self.send_device_time+=DEFINE_TIME_COUNT
- else:
- device_state=EventMesh.publish("GET_IOT_SEND_CMD",WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD)
- print("device_information{}".format(device_state))
- # EventMesh.publish(WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD,device_state) #上报设备信息
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD})#上报设备信息
-
- def iot_connect_timerCb(self,*argc):
- self.connect_iot_socket()
-
- def connect_iot_socket(self):
- if EventMesh.publish("get_voice_record_flag") == 1:
- EventMesh.publish("stop_voice_record")
- print("connect_iot_socket !!!!")
-
- stagecode, subcode = checknet.wait_network_connected(30)
- if stagecode == 3 and subcode == 1:
- socket_log.info('Network connection successful!')
-
- if sim.getStatus() != 1 or self.start_voice_flag == 1:#网络正常
- return
-
- if self.reconnect_count >= WEB_CONNECT_MAX_COUNT: #重连次数大于10次不在进重连只有下发心跳才重新连接
- return
- token = EventMesh.publish("get_dev_token")
- # token = "9548860f973bffe39e1679db3110e223cb"
- print("token:{}".format(token))
- if self.IOT_sock is not None:
- print("socket已连接")
- return
- try:
- if token != None:
- self.connect_timer_count = 0
- #创建一个socket实例
- self.IOT_sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)
- try:
- #建立连接
- self.IOT_sock.connect(('iot.socket.thisiot.com', 7777))
- #设置为阻塞
- self.IOT_sock.setblocking(True)
- socket_log.info("IOT 连接建立")
- except Exception as e:
- print("再次连接")
- self.IOT_sock.connect(('iot.socket.thisiot.com', 7777))
- #设置为非阻塞
- self.IOT_sock.setblocking(False)
- self.reconnect_count = 0
- # print("self.socket_send_queue_id = {} , self.iot_protoclo_recv_id = {}".format(self.socket_send_queue_id,self.iot_protoclo_recv_id))
- if self.socket_send_queue_id == None:
- _thread.stack_size(self.thread_buf_size+8*1024) #_thread.stack_size(16*1024)
- self.socket_send_queue_id = _thread.start_new_thread(self.socket_send_queue_thread, ())
- _thread.stack_size(8*1024)
- if self.iot_protoclo_recv_id == None:
- _thread.stack_size(self.thread_buf_size+8*1024)
- self.iot_protoclo_recv_id = _thread.start_new_thread(self.iot_protocol_recv, ())
- _thread.stack_size(8*1024)
-
- socket_log.info("self.IOT_sock thread init!!!!!!!!!")
-
-
- if self.IOT_sock is not None:
- self.start_voice_flag = 1
- else:
- self.start_voice_flag = 0
-
- print("self.IOT_sock {} self.start_voice_flag:{}".format(self.IOT_sock,self.start_voice_flag))
- if self.IOT_sock != None:
- if self.timer_id == 0:
- # self.hr_report_timer.start(DEFINE_TIME_COUNT*1000, 1, self.hr_report_event)
- self.timer_id=1
- else:
- print("没有token!!!!!!!!!!")
- self.connect_timer_count+=1
- if self.connect_timer_count <= 10:
- print("IOT重连定时器开启")
- self.connect_timer.start(5000,0,self.iot_connect_timerCb)
- pass
- except Exception as e:
- self.IOT_sock = None
- print("connect_iot_socket error")
- def heart_IOt(self,event,msg):
- print("heart_IOT.....")
- #Header
- header = ustruct.pack('>H', 0xFFFE) # 使用大端模式
- #Type
- packet_type = ustruct.pack('B', 0x02)
- #拼接
- heart_packet = header + packet_type
- EventMesh.publish("CHANNEL_IOT_SEND", heart_packet)
- # print("心跳发送数据包：{}".format(heart_packet))
-
- def send_packet_iot(self,data):#发送数据给iot,data为接口json数据
- if sim.getStatus() != 1 or self.start_voice_flag == 1:#网络正常
- return
- #Header
- header = ustruct.pack('>H', 0xFFFE) # 使用大端模式
- #Type
- packet_type = ustruct.pack('B', 0x03)
- #字典转为json字符串
- json_str = EventMesh.publish("GET_IOT_SEND_CMD", data)
- json_str = ujson.dumps(json_str)
- #字符串转为二进制数据Payload
- payload = json_str.encode('utf-8')
- #PayloadLen
- payloadLen = ustruct.pack('H', len(payload))
- #CRC16（2字节，基于pay字段计算）
- crc = self.crc16(payload)
- print("crc的长度为{}".format(len(crc)))
- #拼接
- full_packet = header + packet_type + payloadLen + payload+ crc
- EventMesh.publish("CHANNEL_IOT_SEND", full_packet)
- print("发送更新数据包：{}".format(full_packet))
-
- def login_IOT(self,event,msg):
- print("登录中")
- #Header
- header = ustruct.pack('>H', 0xFFFE) # 使用大端模式
- #Type
- packet_type = ustruct.pack('B', 0x00)
- #设备ID
- device_id_bytes = modem.getDevImei().encode('utf-8')[:20] # 转为字节并截断到20字节
- device_id = bytes_ljust(device_id_bytes, 20, b'\x00')
- #令牌
- token_bytes = EventMesh.publish("get_dev_token").encode('utf-8')[:36] # 转为字节并截断
- token_padded = bytes_ljust(token_bytes, 36, b'\x00')
- #拼接
- body = header + packet_type + device_id + token_padded
- #CRC16（2字节，基于上述所有字段计算）
- crc = self.crc16(body)
- # 完整数据包
- full_packet = body + crc
- EventMesh.publish("CHANNEL_IOT_SEND", full_packet)
- print("登录发送数据包：{}".format(full_packet))
-
-
- def crc16(self, data):
- """计算CRC16校验值（MODBUS RTU模式）"""
- crc = 0xFFFF
- for byte in data:
- crc ^= byte
- for _ in range(8):
- if crc & 0x0001:
- crc >>= 1
- crc ^= 0xA001
- else:
- crc >>= 1
- # 返回2字节小端模式
- return ustruct.pack('<H', crc & 0xFFFF)
-
- def close_socket_timer(self,event,msg):
- self._20S_timer.stop()
- self._5M_timer.stop()
-
- def _20S_timer_cb(self,*argc):
- self.current_data = EventMesh.publish("screen_get_ai") # 当前数据
- if self.current_data is not self.last_data :
- print("VC状态改变")
- EventMesh.publish("send_device_VC_state")#上传VC状态
- self.last_data = self.current_data # 保存上一次的数据状态
- self._1scnt += 1
- if self._1scnt >5:
- if self.IOT_sock is not None:
- if self.IOT_sock.getsocketsta() != 4:
- print("iot断线重连")
- self.login_statu = 0
- self.iot_close_therad()
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- EventMesh.publish("login_IOT")#登录IOT
- else:
- if self.login_statu == 0:
- EventMesh.publish("login_IOT")#登录IOT
- self._1scnt = 0
-
-
- def _10S_timer_cb(self,*argc):
- print("主动断线")
- self.IOT_sock.close()
-
- def socket_send_queue_thread(self):
- while True:
- # with self.sock_lock: # 操作Socket前加锁
- data = self.iot_soc_send_queue.get()
- if data != None:
- try:
- if self.IOT_sock is not None:
- self.IOT_sock.send(data)
- # EventMesh.debug_log("发送线程")
- self.reconnect_count = 0
- else:
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- print("socket关闭退出send线程")
- return
- EventMesh.debug_log("socket:send data2 len:{}".format(len(data),self.IOT_sock))
- except Exception as e:
- EventMesh.debug_log("socket:send error")
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- break
-
-
- def iot_protocol_recv(self):
- # 配置超时参数，单位：秒
- RECV_TIMEOUT = 30*1000 # 30秒未收到数据则重连
- last_recv_time = utime.time() # 初始化最后一次收到数据的时间
- while True:
- # 死循环接收数据
- # with self.sock_lock: # 警告：不能加锁，不然会导致线程超长延时
- try:
- data = self.IOT_sock.recv(256)
- if isinstance(data, bytes) and len(data)>10:
- playload_data(data)
- #fffe00010001xxxx
- if isinstance(data, bytes) and len(data) == 8:#登录成功
- target_bytes = b'\xff\xfe\x00\x01\x00\x01'
- if data[:6] == target_bytes:
- self.login_statu = 1#登录成功标志位修改
- socket_log.info("IOT_recv = {} ,len = {}".format(self.bytes_to_hex(data),len(data)))
- #检查socket是否已关闭
- if self.IOT_sock == None:
- print("socket关闭开启重连")
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- return
- #超时检查：如果超过设定时间未收到数据，触发重连
- # print("接收时间差 = {}".format(utime.time() - last_recv_time))
- if utime.time() - last_recv_time > RECV_TIMEOUT:
- print("超过{}秒未收到数据，触发重连".format(RECV_TIMEOUT))
- # 先关闭现有连接
- if self.IOT_sock:
- self.IOT_sock.close()
- # 触发重连
- EventMesh.publish("publish_AI_btnInfo", {"func": self.connect_iot_socket})
- # 重连后短暂延迟再继续循环
- utime.sleep(1)
- # 重置超时计时器
- last_recv_time = utime.time()
- except Exception as e:
- print("cli break")
- print("异常是:{}".format(e))
- # EventMesh.publish("connect_iot_websocket_cb")
- last_recv_time = utime.time()
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- break
- self.iot_protoclo_recv_id =None
- def decode_with_multiple_encodings(self, data):
- #尝试多种常见编码格式解码，返回第一个成功的结果
- # 常见编码格式列表（按优先级排序，根据实际场景调整）
- encodings = ['utf-8', 'gbk', 'latin-1', 'utf-16', 'gb2312']
-
- for encoding in encodings:
- try:
- # 尝试用当前编码解码，errors='strict'严格模式（确保无乱码）
- return data.decode(encoding, errors='strict')
- except UnicodeDecodeError:
- continue # 解码失败，尝试下一种编码
- return None # 所有编码都失败
-
- # bytes转十六进制字符串
- def bytes_to_hex(self, data):
- #将bytes类型转换为十六进制字符串（如b'\x03\x01' -> '0301'）
- hex_chars = '0123456789abcdef'
- hex_str = ''
- for b in data:
- # 处理每个字节的高4位和低4位
- hex_str += hex_chars[(b >> 4) & 0x0F] # 高4位
- hex_str += hex_chars[b & 0x0F] # 低4位
- return hex_str
-
- def iot_send_queue_close(self):
- if self.socket_send_queue_id != None:
-
- if self.iot_soc_send_queue.empty()!=True:
- self.iot_soc_send_queue.clear()
- try:
- _thread.stop_thread(self.socket_send_queue_id)
- except Exception as e:
- print("iot_send_queue_close !!!!!!!!")
- print("iot_send_queue_close 1111!!!!!!!!")
- self.socket_send_queue_id = None
-
- def iot_protoclo_recv_close_therad(self):
- if self.iot_protoclo_recv_id != None:
- try:
- _thread.stop_thread(self.iot_protoclo_recv_id)
- except Exception as e:
- print("iot_protoclo_recv_close_therad !!!!!!!!")
- self.iot_protoclo_recv_id = None
- if self.IOT_sock != None:
- try:
- print("关闭socket")
- self.IOT_sock.close()
- except Exception as e:
- print("关闭socket失败")
- self.IOT_sock = None
-
-
-
- def iot_close_therad(self):
- try:
- self.iot_send_queue_close()
- except Exception as e:
- print("iot_send_queue_close error!!!!!!!!")
-
- try:
- self.iot_protoclo_recv_close_therad()
- except Exception as e:
- print("iot_protoclo_recv_close_therad error!!!!!!!!")
- self.start_voice_flag = 0
- print("iot_close_therad")
-
- def get_IOT_sock(self,event,msg):
- return self.IOT_sock
- def user_send(self,event,data):
- # EventMesh.debug_log("TCP:send data:{}".format(msg))
- # EventMesh.debug_log("TCP:send data:{}".format(msg))
- sim_state = sim.getStatus()
- if sim.getStatus() != 1:#网络不正常
- print("无 sim卡")
- return
- else :
- try:
- if self.start_voice_flag == 0: #如果关闭了就需要重新再连接
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- return
- if data != None:
- if len(data) != 0:
- self.iot_soc_send_queue.put(data)
- # EventMesh.debug_log("self.socket_send_queue.put:success:{}".format(len(data)))
- except Exception as e:
- EventMesh.debug_log("self.socket_send_queue.put:ERROR:")
- usys.print_exception(e)
-
- return
- sim_state = sim.getStatus()
- if sim_state != 1 or self.network_state == 0: #没sim，则不发送 ，没联网
- return
- else :
- try:
- if self.IOT_sock != None:
- EventMesh.publish("publish_AI_btnInfo",{"func":self.iot_protocol_send_cb,"data":data})
- else:
- print("reconnect1 {}".format(data))
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
-
- except Exception as e:
- print("senc data err reconnect{}".format(data))
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
-
- def iot_protocol_send_cb(self,data):
- try:
- if data != None:
- print("socket connect success:{} self.IOT_sock:{}".format(data,self.IOT_sock))
- if self.IOT_sock != None:
- self.IOT_sock.send(data)
- self.reconnect_count = 0
- print("socket send success")
- else:
- print("reconnect2 {}".format(data))
- # EventMesh.publish("connect_iot_socket_cb")
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
- except Exception as e:
- print("发送失败 重新连接")
- self.reconnect_count+=1
- # EventMesh.publish("connect_iot_socket_cb")
- EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})
-
-def bytes_ljust(data, length, fill_byte=b'\x00'):
- """
- 手动实现bytes的ljust功能：将字节流填充到指定长度，不足部分用fill_byte在右侧填充
- :param data: 原始字节流（bytes）
- :param length: 目标长度（int）
- :param fill_byte: 填充字节（默认空字节b'\x00'）
- :return: 填充后的字节流（bytes）
- """
- if len(data) >= length:
- # 若原始长度已超过目标长度，直接截断到指定长度
- return data[:length]
- else:
- # 计算需要填充的长度，用fill_byte补齐
- padding = fill_byte * (length - len(data))
- return data + padding
-
-class NetManager(Abstract):
- THRESHOLD = 10
-
- def __init__(self):
- self.__data_call = dataCall
- self.__net = net
- self.check_net = checkNet.CheckNetwork("QuecPython_Helios_Framework", "this latest version")
- EventMesh.subscribe("get_network_state", self.get_network_state)
- self.network_state = 0
-
- def post_processor_after_instantiation(self, *args, **kwargs):
- count = 0
- while True:
- count += 1
- if count > 5 :
- return
- data = dataCall.getInfo(1, 0)
- EventMesh.debug_log("data call INFO {}".format(data))
- if data[2][0]:
- self.network_state = 1
- break
- utime.sleep(1)
- self.__data_call.start(2, 0, "", "", "", 0)
- self.__data_call.setCallback(self.__datacall_cb)
-
- def __datacall_cb(self, args):
- pdp = args[0]
- nw_sta = args[1]
- if nw_sta == 1:
- self.network_state = 1
- EventMesh.debug_log("*** network %d connected! ***" % pdp)
-
- else:
- self.network_state = 0
- EventMesh.debug_log("*** network %d not connected! ***" % pdp)
-
- def get_network_state(self, topic, msg):
- return self.network_state
-
-class ProtoCol(Abstract):
- TYPE = ""
- HEADER = "#@{}@#;"
- SEPARATOR = ";"
- END = ";" + chr(0x01)
- #PID = "SZKW"
- #PID = "qAELPTKmFanR4RHe"
- md5_key = ''
- PID = ''
-
- def __init__(self):
- self.content = None
- self.check_sum = None
- self.password = EventMesh.publish(constants.EVENT.GET_PASSWORD)
- self.imei = EventMesh.publish(constants.EVENT.GET_IMEI)
- self.cid = EventMesh.publish(constants.EVENT.GET_CID)
- self.imsi = EventMesh.publish(constants.EVENT.GET_IMSI)
- self.key = EventMesh.publish(constants.EVENT.GET_KEY)
- self.HEADER = self.HEADER.format(self.TYPE)
-
- self.md5_key = ''
- self.PID = ''
- server_data = EventMesh.publish("get_new_key_pid")#获取pid和key
- if server_data == None:
- server_data = server_init()#如果获取的数据是None,就用默认的大锤key和pid
- self.md5_key = server_data[2]
- self.PID = server_data[3]
- else:
- self.md5_key = server_data[0]
- self.PID = server_data[1]
-
- # EventMesh.debug_log("md5_key:--",self.md5_key,self.PID)
- # ip_infor = {}
- # ip_infor = EventMesh.publish("get_new_ip_com")
- # if ip_infor != None:
- # self.md5_key = ip_infor[2]
- # EventMesh.debug_log("md5_key",self.md5_key)
-
- def initialization(self, *args, **kwargs):
- EventMesh.subscribe(self.TYPE + "_SEND", self.handler)
- EventMesh.subscribe(self.TYPE + "_RECV", self.handler)
- #EventMesh.debug_log("ProtoCol:{}".format(self.TYPE + "_SEND"))
-
- def handler(self, event, msg):
- #EventMesh.debug_log("ProtoCol:handler:{}".format(event))
- self.password = EventMesh.publish(constants.EVENT.GET_PASSWORD)
- self.imei = EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166" #EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI) #"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI) #"867387060319166"#"867387060319188"#"867387060319177"#"867387060319166"#"860132060004322"#"867387060319166"#"860132060004322"#EventMesh.publish(constants.EVENT.GET_IMEI)
- self.cid = EventMesh.publish(constants.EVENT.GET_CID)
- self.imsi = EventMesh.publish(constants.EVENT.GET_IMSI)
- self.key = EventMesh.publish(constants.EVENT.GET_KEY)
- if event.endswith("_SEND"):
- self.send(event, msg)
- else:
- self.recv(event, msg)
-
- def send(self, event, msg):
- pass
-
- def recv(self, event, msg):
- pass
-
- @staticmethod
- def get_date():
- return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
-
- @staticmethod
- def get_time():
- return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
-
- def calc_crc(self):
- data = self.content
- if not isinstance(data, bytes):
- data = data.encode()
- count = 0
- for x in data:
- count += x
- self.check_sum = 100 - count % 100
-
- def pack(self):
- self.calc_crc()
- return self.HEADER.encode() + self.content.encode() + self.SEPARATOR.encode() + int(self.check_sum).to_bytes(1,'little') + self.END.encode()
-
- def pack_MD5_head(self,data):
- #key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"
- self.md5_key=EventMesh.publish("get_new_key")
- if self.md5_key == None:
- self.md5_key = server_init[2]
-
- if(self.md5_key == ""):
- return ""
- MD5_head = ""
- hash_obj = uhashlib.md5(data+self.md5_key)
- res = hash_obj.digest()
-
- # 转成十六进制表示
- MD5_head = ubinascii.hexlify(res)
- MD5_head = MD5_head.decode('ascii')
- #EventMesh.debug_log("data+self.md5_key:{}".format(data+self.md5_key))
- #EventMesh.debug_log(res)
- #EventMesh.debug_log(MD5_head)
- return MD5_head
-#查找设备
-class IOT_FindDeviceProtoCol(ProtoCol):
- """find_device"""
- TYPE = "find_device"
-
- def send(self, event, msg):
- # print("send locafind_devicetion{}".format(msg))
- # 通过websocket发送到服务器端
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)
- find_device = {
- "cmd":"dispatch_rest",
- "ts":time_tmp,
- "msg":"消息收到响应",
- "data":{
- "cmd":"find_device",
- "rest":"success",
- "msg":"收到查找设备指令"
- }
- }
- send_data = b''
- send_data = protocol_send_total_data(find_device)
- print("send_data find_device{}".format(send_data))
- EventMesh.publish("CHANNEL_IOT_SEND", send_data)
-
- def recv(self, event, msg):
- """
-
- @param event:定位信息下发
- @param msg: 接收到的下行数据
- """
- alarm_TTS_str="在这呢"
- base_sentence = "{}".format(alarm_TTS_str)
- repeat_sentence = (base_sentence + ",") * 3 # 重复5次并加逗号分隔
- final_sentence = repeat_sentence.rstrip(",")
-
- EventMesh.publish("play_tts",[final_sentence,1]) #播放tts闹钟文本内容
- print("recv find_device{}".format(msg))
- EventMesh.publish(WEB_CMD_ENUM.FIND_DEVCE_S_CMD)
-
-#上报设备VC状态
-class IOT_post_device_stateProtoCol(ProtoCol):
- """post_device_state"""
- TYPE = "post_device_state"
-
- def send(self, event, msg):
- print("send post_device_state{}".format(msg))
- # 通过websocket发送到服务器端
-
- send_data = b''
- send_data = protocol_send_total_data(msg)
- EventMesh.publish("CHANNEL_IOT_SEND",send_data)
-
- def recv(self, event, msg):
- """
-
- @param event:mpost_device_state
- @param msg: 接收到的下行数据
- """
- # locate_now = {
- # "cmd":"locate_duration",
- # "ts":1738283829,
- # "msg":"下发定位周期",
- # "data":300,0表示关
- # }
- print("send post_device_state{}".format(msg))
-class LK_ProtoCol(ProtoCol):
- """链路保持"""
- TYPE = "LK"
-
- def send(self, event, msg):
- #[SZKW*334588000000156*0002*LK]
- #EventMesh.debug_log('self.imei:%s'%(self.imei))
- send_data = EventMesh.publish("get_new_pid")+"*%s*0002*LK"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("LK_ProtoCol:send:%s"%(data))
-
-
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: LK成功
- @param msg: 接收到的下行数据
- """
- EventMesh.debug_log("LK_ProtoCol:recv:%s"%(msg))
- EventMesh.publish(constants.PROTOCOL.PING_SEND)
- EventMesh.publish(constants.PROTOCOL.KA_SEND)
- EventMesh.publish(constants.PROTOCOL.TIME_SEND)
-
- EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始UD定位
- EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.WT_SEND) #开始WT定位
- if EventMesh.model == 'D15':
- EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND)
-
-class PING_ProtoCol(ProtoCol):
- """获取绑定状态"""
- TYPE = "PING"
-
- def send(self, event, msg):
- #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0004*PING"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("PING_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: PING
- @param msg: 接收到的下行数据
- """
- #EventMesh.debug_log("PING_ProtoCol:recv:%s"%(msg))
- data_tmp = msg.decode('ascii')
- data_tmp = data_tmp.split(']')[0] #去掉]
- EventMesh.publish(constants.EVENT.SET_PING, data_tmp.split(',')[1])
- if EventMesh.model == 'D15':
- EventMesh.publish(constants.PROTOCOL.JPREG_SEND)
- EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND)
-
-class KA_ProtoCol(ProtoCol):
- """心跳"""
- TYPE = "KA"
- count = 0
- roll_count = 0
- def send(self, event, msg):
- #"{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
- #[XT*YYYYYYYYYYYYYYY*LEN*KA,日期，步数,翻滚次数,电量百分数,车载里程数(km)] 实例:[XT*334588000000156*0014*KA,120414,50,100,100,100.12]
- date = "{:04d}{:02d}{:02d}".format(*utime.localtime()[0:3])
- date = date[2:]
- #EventMesh.debug_log("date:",date)
- #步数
- old_step = 0
- step = 0
- step = EventMesh.publish("get_old_step_value")
- if step != None:
- if step != 0:
- read_data = EventMesh.publish("get_storage_config","old_step_new")
- if read_data != None:
- old_step = read_data
-
- if old_step != step:
- # EventMesh.debug_log("old_step:send:%d %d"%(old_step,step))
- EventMesh.publish("set_storage_config",["old_step_new",step+10])
- EventMesh.publish("set_storage_config",["old_step_new",step])
-
- old_step = step
- # step = EventMesh.publish(constants.EVENT.GET_STEP)[0]
- # 电池电量百分比
-
- bat_tmp = EventMesh.publish("screen_get_battery")
- sleep_time = EventMesh.publish("get_storage_config","sleep_time")
- if sleep_time != None:
- if len(sleep_time) != 0:
- hour = utime.localtime()[3]
- min = utime.localtime()[4]
- cur_time = hour*60+min
- start_hour = int(sleep_time["start_hour"])
- start_min = int(sleep_time["start_min"])
- start_total = start_hour*60+start_min
-
- end_hour = int(sleep_time["end_hour"])
- end_min = int(sleep_time["end_min"])
- end_total = end_hour*60+end_min
- # EventMesh.debug_log("ka roll_:",hour,min,cur_time,start_total,end_total)
- if cur_time >= start_total and cur_time <= end_total:
- self.roll_count = int(hour)
- if self.roll_count == 0:
- self.roll_count+=1
- else:
- self.roll_count = 0
- else:
- self.roll_count = 0
- else:
- self.roll_count = 0
- hour = utime.localtime()[3]
- min = utime.localtime()[4]
- EventMesh.txt_log("ka step:{} hour:{} min:{}".format(step,hour,min))
-
- battery_caption = bat_tmp[1]
- send_data = "KA,%s,%d,%d,%d"%(date,step,self.roll_count,battery_caption)
- send_len = len(send_data)
-
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"KA")
-
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("KA_ProtoCol:send:%s"%(data))
-
-
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: PING
- @param msg: 接收到的下行数据
- """
- #EventMesh.debug_log("KA_ProtoCol:recv:%s"%(msg))
-
-class UD_ProtoCol(ProtoCol):
- """位置信息"""
- TYPE = "UD"
- UD_count = 0#每6次定位获取一次天气数据
- def send(self, event, msg):
- #EventMesh.debug_log("UD:send:%s"%(msg))
- #"{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
- #[6f62cfc40fc50173f9a7b21e87be3424IS*861217001020120*00f6*UD,220726,211210,A,22.649529,N,114.119165,E,0.28,137.4,100.0,8,24,63,119,0,00000000,2,1,460,11,30472,125667122,24,30472,218944048,19,4,
- # wifi0,34:93:44:01:28:b9,-74,wifi1,34:20:03:96:35:ad,-78,wifi2,ea:b5:7b:e8:56:54,-80,wifi3,c4:49:bb:d4:d9:78,-88]
-
-
- self.UD_count+=1
- #每6次定位获取一次天气数据
- if self.UD_count>=6:
- self.UD_count = 0
- EventMesh.publish(constants.PROTOCOL.WT_SEND,msg)
-
- send_data ="UD,"+msg
- send_len = len(send_data)
- #wt_data = "%s"%(send_data)
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"UD")
-
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("{}".format(data))
- # wt_data = EventMesh.publish("get_weather_data")
- # # #如果没有天气数据，则获取天气数据
- # if wt_data != None or wt_data[0] == None :
- #
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
- if EventMesh.platform == "gewu":
- if(msg != ""):
- client = EventMesh.publish("get_mqtt_dev_connect_state")
- if client != 0:
- mqtt_connect = -1
- try:
- mqtt_connect = client.connect()
- except Exception as e:
- print(e)
- mqtt_connect = -1
- print("mqtt_connect:{}".format(mqtt_connect))
- if mqtt_connect == 0:
- # 订阅主题
- get_device_id = EventMesh.publish(constants.EVENT.GET_IMEI)
- get_deviceKey = EventMesh.publish(constants.EVENT.GET_IMEI)
- get_productKey = gewu_init()
- #$sys/{productKey}/{deviceKey}/ext/regist
- event_msg = "$sys/{}/{}/event/pub_reply".format(get_productKey,get_deviceKey)
- # client_msg = "$sys/cu1shld45y4hjr1L/866610001011658/ext/regist"
- subscribe_msg = event_msg.encode('ascii')
-
- client.subscribe(subscribe_msg,0)#订阅事件消息消息主题
- print("Connected to dmp-mqtt.cuiot.cn, subscribed to /public/TEST/quecpython topic")
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- longitude = float(msg_tmp[3])
- latitude = float(msg_tmp[5])
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)#需要转换成毫秒级别
- updataTime = "{}".format(time_tmp*1000)
- data_info = {
- "messageId":"0",
- "params": {
- "key":"location",
- "info": [
- {
- "key":"longitude",
- "value":longitude
- },
- {
- "key":"latitude",
- "value":latitude
- },
- {
- "key":"UpdateTime",
- "value":updataTime
- }
- ]
- }
- }
- data_json = ujson.dumps(data_info)
- event_pub_msg = "$sys/{}/{}/event/pub".format(get_productKey,get_deviceKey)
- pub_msg = event_pub_msg.encode('ascii')
- client.publish(pub_msg,data_json,0)#publis主题内容
-
- print("Publish topic: /public/TEST/quecpython758, msg: my name is Quecpython")
-
-
-
- def recv(self, event, msg):
- pass
- # EventMesh.debug_log("UD_ProtoCol:recv:%s"%(msg))
-
-class CR_ProtoCol(ProtoCol):
- """立即定位"""
- TYPE = "CR"
-
- def send(self, event, msg):
- #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0002*CR"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("CR_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: PING
- @param msg: 接收到的下行数据
- """
- EventMesh.publish(constants.PROTOCOL.CR_SEND)
- EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始ud定位
- #EventMesh.debug_log("CR_ProtoCol:recv:%s"%(msg))
-
-class AL_ProtoCol(ProtoCol):
- """报警数据上报"""
- TYPE = "AL"
- timer_repetition_send = None
- repetition_queue = None
-
- def send(self, event, msg):
- if EventMesh.platform != "gewu":
- if self.timer_repetition_send == None:
- self.timer_repetition_send = osTimer()
- if self.repetition_queue == None:
- self.repetition_queue = Queue(100)
-
-
- send_data ="AL,"+msg
- send_len = len(send_data)
- #wt_data = "%s"%(send_data)
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"AL")
-
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("AL_ProtoCol:send:{}".format(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
- if EventMesh.platform != "gewu":
- self.repetition_queue.put(data)#发送入队
- self.timer_repetition_send.start(10000, 1, self.repetition_timer_cb)
- EventMesh.publish("set_dev_state",0)
- def recv(self, event, msg):
- """
-
- @param event: PING
- @param msg: 接收到的下行数据
- """
- #EventMesh.publish(constants.PROTOCOL.CR_SEND)
- #EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始ud定位
- # print("报警数据上报:recv:%s"%(msg))
- EventMesh.debug_log("报警数据上报:recv:{}".format(msg))
- #
- if EventMesh.platform != "gewu":
- if self.repetition_queue.empty() == False:
- self.repetition_queue.get()#出队
- else:
- self.timer_repetition_send.stop()
-
- def repetition_timer_cb(self, *args, **kwargs):#每隔10秒发送一次
- if self.repetition_queue.empty() == False:
- data = self.repetition_queue.get()#出队
- self.repetition_queue.put(data)#发送入队
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
- else:
- self.timer_repetition_send.stop()
-
-class FIND_ProtoCol(ProtoCol):
- """查找设备"""
- TYPE = "FIND"
-
- def send(self, event, msg):
- #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0004*FIND"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("FIND_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: FIND,播放铃声
- @param msg: 接收到的下行数据
- """
- EventMesh.publish(constants.PROTOCOL.FIND_SEND)
- # a = audio.Audio(0)
- # a.set_pa(Pin.GPIO29)
- # a.setVolume(10)
- # a.play(1, 1, 'E:/audio_find_haixiu.mp3') #文件名前面要加上路径
-
- # EventMesh.publish("load_screen", {"screen": "FIND"})
- EventMesh.publish("OPEN_FIND_WATCH")#
- #EventMesh.debug_log("FIND_ProtoCol:recv:%s"%(msg))
-
-class POWEROFF_ProtoCol(ProtoCol):
- """关机"""
- TYPE = "POWEROFF"
-
- def send(self, event, msg):
- # [SZKW*867387060319491*0008*POWEROFF]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*POWEROFF"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: POWEROFF关机
- @param msg: 接收到的下行数据
- """
- EventMesh.publish(constants.PROTOCOL.POWEROFF_SEND)
- #EventMesh.debug_log("POWEROFF_ProtoCol:recv:%s"%(msg))
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("open_power_on", 2)# #远程关机
-
-class PHL_ProtoCol(ProtoCol):
- """电话本同步"""
- TYPE = "PHL"
-
-
- def send(self, event, msg):
- # [SZKW*867387060319491*0008*PHL]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0003*PHL"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #EventMesh.debug_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: 电话本同步
- @param msg: 接收到的下行数据
- """
- msg = msg[1:-1]
- # EventMesh.debug_log("phonebook:msg:%s\r\n"%msg)
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- # EventMesh.debug_log("phonebook:len:{}\r\n data:{}".format(len(msg_tmp),msg_tmp))
-
- phonebook = {}
- msg_tmp = msg_tmp[1:]
-
- j = 0
- i = 0
- phonebook_oldtmp = {}
- # 0 1 2 3
- for phonebook_tmp in msg_tmp:
- j+=1
- # EventMesh.debug_log("phonebook_tmp:{} len:{}".format(phonebook_tmp,len(phonebook_tmp)))
-
- if (j%2) == 0:
- i+=1
- if len(phonebook_tmp) != 0:
- phonebook_name = UnicodeHexStr_To_Utf8Str(phonebook_tmp)
- phonebook_name = "{}:{}".format("%03d"%i,phonebook_name)
- phonebook[phonebook_name] = phonebook_oldtmp
-
- phonebook_oldtmp = phonebook_tmp
- # EventMesh.debug_log("phonebook_oldtmp!!!:{}".format(str(phonebook_oldtmp)))
- # EventMesh.debug_log("phonebook!!!:{}".format(str(phonebook)))
- with open("/usr/static/storage_file/phonebook.json","w",encoding="utf-8") as fd:
- ujson.dump(phonebook,fd)
- EventMesh.debug_log("创建电话簿")
-
- EventMesh.publish(constants.PROTOCOL.PHL_SEND)
- EventMesh.publish("set_phonebook_list",[1,phonebook])
- EventMesh.publish("contact_updata_list_show")
-
-
-class WT_ProtoCol(ProtoCol):
- """天气数据"""
- TYPE = "WT"
- WT_T = 0
-
- def send(self, event, msg):
- # [SZKW*867387060319491*0008*WT]
- # if self.WT_T != 0:
- # tmp_WT =
- if(msg != ""):
- msg_tmp = "WT," + msg
- data_len = len(msg_tmp)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*WT"%(self.imei,data_len)
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,data_len,msg_tmp)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("WT_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: T天气温度数据下发
- @param msg: 接收到的下行数据
- """
- # b'SZKW*860132060004322*0035*WT,23-04-06,14:41:06,b6e0d4c6,1,27,-1,40,6DF157335E02'
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split('WT,')
- # EventMesh.debug_log("phonebook:len:{}\r\n data:{}".format(len(msg_tmp),msg_tmp))
- msg_tmp = str(msg_tmp[1])
-
- # EventMesh.debug_log("msg_tmp :%s"%(msg_tmp))
-
- msg_date = msg_tmp.split(',')[0]
-
- msg_time = msg_tmp.split(',')[1]
- msg_weather_content = msg_tmp.split(',')[2]
- msg_type = msg_tmp.split(',')[3]
- msg_temp = msg_tmp.split(',')[4]
- msg_min_temp = msg_tmp.split(',')[5]
- msg_max_temp = msg_tmp.split(',')[6]
- msg_city = msg_tmp.split(',')[7]
-
- msg_city = UnicodeHexStr_To_Utf8Str(msg_city)
- msg_weather_content = UnicodeHexStr_To_Utf8Str(msg_weather_content)
- # EventMesh.debug_log("msg_date:{} msg_time:{} msg_weather_content:{} msg_type:{} msg_temp:{} msg_min_temp:{} msg_max_temp:{} msg_city:{}".format(msg_date,msg_time,\
- # msg_weather_content,msg_type,msg_temp,msg_min_temp,msg_max_temp,msg_city))
- EventMesh.debug_log("WT_ProtoCol RECV msg:%s"%(msg))
-
- EventMesh.publish("set_weather_data",[msg_date,msg_time,msg_weather_content,msg_type,msg_temp,msg_min_temp,msg_max_temp,msg_city,1])
- EventMesh.publish("updata_weather_show")
-class REMIND_ProtoCol(ProtoCol):#普通闹钟
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND]
- """
- TYPE = "REMIND"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*REMIND"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_new = str(msg_tmp.split('REMIND,')[1])
- msg_tmp_data = str(msg_tmp.split('REMIND')[1])
- count = 0
- for i in str(msg_tmp_data):
- # print("i",i)
- if i == ",":
- count+=1
-
- normal_alarm_save = []
- # # ("handler -> b'[SZKW*860132060346475*001C*REMIND,08:00-1-1,,]'",)
- # b'[SZKW*860132060346475*001B*REMIND,08:00-1-1,,]'",)
- # medicine_alarmday = str(msg_data[4])
- # alarmday=[]
- alarm_day = []
- alarm_switch = 0
-
- print("count",count,msg_tmp_new)
- if count >= 3:
- count = 3
- for i in range(0,count):#默认是三个时间多了也不保存
- alarm_day = []
- alarm_data = str(msg_tmp_new.split(',')[i])
- # print("i",i,sleep_data)
- if len(alarm_data) != 0:
- b = alarm_data.find('-')
- if b != -1:
- alarm_time = alarm_data.split('-')[0]#-作为分隔符
- alarm_switch = int(alarm_data.split('-')[1])#开关
- alarm_repeat = int(alarm_data.split('-')[2])#是单次还是每天 还是自定义
-
- alarm_hour = int(alarm_time.split(":")[0])#时间
- alarm_min = int(alarm_time.split(":")[1])#冒号分隔时间 时 分
-
-
- if alarm_repeat == 2:#每一天
- alarm_day = [0,1,2,3,4,5,6]
- elif alarm_repeat == 3:#自定义
- alarm_day_tmp = alarm_data.split('-')[3]#-作为分隔符
- if len(str(alarm_day_tmp)) != 0:
- for i in range(0,7):
- if alarm_day_tmp[i] != '0':
- alarm_day.append(i)
- else:#单次 1
- alarm_day=[]
- if alarm_switch != 0:
- normal_alarm_save.append({"hour":alarm_hour,"min":alarm_min,"day":alarm_day,"enable":alarm_switch})
-
- EventMesh.publish("set_storage_config",["normal_alarm",normal_alarm_save])
- # normal_alarm = EventMesh.publish("get_storage_config","normal_alarm")
-
- # EventMesh.debug_log("recv REMIND_SEND:{} normal_alarm ;{}".format(msg,normal_alarm))
-
- EventMesh.publish(constants.PROTOCOL.REMIND_SEND)
- EventMesh.publish("clear_normal_alarm")
-
-class HRSTART_ProtoCol(ProtoCol):
- """心率频率数据"""
- TYPE = "hrtstart"
-
-
- def send(self, event, msg):
- # [SZKW*867387060319491*0008*hrtstart]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*hrtstart"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("HRSTART_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 心率数据下发
- @param msg: 接收到的下行数据
- """
- # b'SZKW*860132060004322*0035*REMIND,23-04-06,14:41:06,b6e0d4c6,1,27,-1,40,6DF157335E02'
- # EventMesh.debug_log("REMIND_ProtoCol RECV msg:%s"%(msg))
- # HRSTART_ProtoCol RECV msg:b'SZKW*860132060004322*000D*hrtstart,7200' msg_:7200
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
- EventMesh.debug_log("HRSTART_ProtoCol RECV msg:{} msg_:{}".format(msg,msg_tmp))
- hrTotal = int(msg_tmp)
- if hrTotal == 1:#单次测量
- EventMesh.debug_log("HRSTART_ 2".format(hrTotal))
- get_hr_state = EventMesh.publish("get_hr_state")
- get_spo2_state = EventMesh.publish("get_spo2_state")
- get_bp_state = EventMesh.publish("get_bp_state")
- get_bg_state = EventMesh.publish("get_bg_state")
- # if (get_hr_state == 3 ) or (get_spo2_state == 0 and get_hr_state == 0):#只要两个不在测量 单次优先级最低
- if (get_spo2_state == 0 and get_hr_state == 0 and get_bg_state == 0 and get_bp_state == 0):
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("set_hr_state",3)#3代表单次测量
- pass
- else:
- if hrTotal > 0 and hrTotal <= 300:
- hrTotal = 300
- elif hrTotal >= 65536:
- hrTotal = 65536
- EventMesh.debug_log("HRSTART_ 3".format(hrTotal))
- on = 0
- if hrTotal != 0:
- on = 1
- EventMesh.publish("set_time_hr",[on,hrTotal])
-
-
- EventMesh.publish(constants.PROTOCOL.HRTSTART_SEND)
-
-class HEART_ProtoCol(ProtoCol):
- """心率数据"""
- TYPE = "heart"
-
-
- def send(self, event, msg):
- # [SZKW*334588000000156*len*heart,x]
- # EventMesh.debug_log("HEART:send:{}".format(msg))
- len_size = len(str(msg))+len("heart,")
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*heart"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"heart")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)
- # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 心率数据下发
- @param msg: 接收到的下行数据
- """
- # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")
- #EventMesh.publish(constants.PROTOCOL.HEART_SEND)
-class OXYGEN_ProtoCol(ProtoCol):
- """上传血氧测试数据"""
- TYPE = "oxygen"
- def send(self, event, msg):
- # [SZKW*334588000000156*len*heart,x]
- # EventMesh.debug_log("oxstart:send:{}".format(msg))
- len_size = len(str(msg))+len("oxygen,")
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*oxygen"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"oxygen")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)
- # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 心率数据下发
- @param msg: 接收到的下行数据
- """
- # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")
- #EventMesh.publish(constants.PROTOCOL.OXYGEN_SEND)
-
-class OXYGEN_One_ProtoCol(ProtoCol):#单次测量
- """上传单次测量测试数据"""
- TYPE = "oxstart"
-
-# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*oxygen,x]
-# x 表示血氧饱和度
-# 示例[XT*334588000000156*0009*oxygen,15]
-# 平台回复：handler -> b'[SZKW*860132060004322*0009*oxstart,1]'
-# [XT*334588000000156*0006*oxygen]
- def send(self, event, msg):
- # [SZKW*334588000000156*len*heart,x]
- EventMesh.debug_log("oxstart:")
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*oxstart"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 血氧单次测量下发
- @param msg: 接收到的下行数据
- """
- EventMesh.debug_log("oxstart:{}".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
-
- oxstartTotal = int(msg_tmp)
- # oxstartTotal = 300
- print("oxstartTotal:{}".format(oxstartTotal))
- if oxstartTotal == 1:#单次测量
- get_bp_state = EventMesh.publish("get_bp_state")
- get_hr_state = EventMesh.publish("get_hr_state")
- get_spo2_state = EventMesh.publish("get_spo2_state")
- get_bg_state = EventMesh.publish("get_bp_state")
- print("get_bp_state:{}".format(get_bp_state))
- if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("set_spo2_state",3)#3代表单次测量
- else:
- if oxstartTotal > 0 and oxstartTotal <= 300:
- oxstartTotal = 300
- elif oxstartTotal >= 65536:
- oxstartTotal = 65536
-
- # if oxstartTotal == 0:#关闭自动测量
- # EventMesh.debug_log("bpSTART_ 1")
- # EventMesh.publish("set_spo2_time",[0,0])
- # else:
- on = 0
- if oxstartTotal != 0:
- on = 1
- EventMesh.publish("set_spo2_time",[on,oxstartTotal])
-
- EventMesh.publish(constants.PROTOCOL.OXSTART_SEND)
-
-class TEMP_ProtoCol(ProtoCol):
- """上传体温测试数据"""
- TYPE = "temp"
- def send(self, event, msg):
- # [SZKW*334588000000156*len*heart,x]
- # EventMesh.debug_log("temp:send:{}".format(msg))
- len_size = len(str(msg[0]))+len("temp,")+1+len(str(msg[1]))
- EventMesh.debug_log("temp:send:{} len:{}".format(msg,len_size))
- # 实例：[XT*334588000000156*0009*temp,36.2]
- # 代表终端的温度为：36.2
- # 平台回复：
- # [XT*334588000000156*0004*temp]
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*temp"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"temp")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d.%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1])
- # EventMesh.debug_log("temp:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")
- #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)
-
-class WDSTART_ProtoCol(ProtoCol):
- """上传体温频率"""
- TYPE = "wdstart"
- def send(self, event, msg):
- #[XT*334588000000156*len*wdstart,300]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*wdstart"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("temp:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 体温下发频率数据
- @param msg: 接收到的下行数据
- """
- # EventMesh.debug_log("WDSTART_ProtoCol RECV msg:")
- EventMesh.debug_log("wdstart:{}".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
-
- tempTotal = int(msg_tmp)
- EventMesh.debug_log("tempTotal:{}".format(tempTotal))
- if tempTotal == 1:#单次测量
- get_temp_state = EventMesh.publish("get_temp_state")
- EventMesh.debug_log("get_temp_state:{}".format(get_temp_state))
- if get_temp_state == 0:#只要两个不在测量 单次优先级最低
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("set_temp_state",3)#3代表单次测量
- else:
- if tempTotal > 0 and tempTotal <= 300:
- tempTotal = 300
- elif tempTotal >= 65536:
- tempTotal = 65536
-
- EventMesh.publish("set_temp_time",tempTotal)
-
-
-
- EventMesh.publish(constants.PROTOCOL.WDSTART_SEND)
-#解绑
-# 设置血压上传频率
-# 平台发送[XT*YYYYYYYYYYYYYYY*LEN*bldstart,x]
-# x为上传间隔时间，单位秒,连续上传时最小时间不小于300秒，最大不超过65535.
-# 示例[XT*334588000000156*0008*bldstart,300]
-# 终端回复：
-# [XT*334588000000156*0005*bldstart]
-# x为1则代表终端单次上传。
-# x为0则代表终端上传关闭。
-class bldstart_ProtoCol(ProtoCol):
- """app下发血压测试频率"""
- TYPE = "bldstart"
- def send(self, event, msg):
- #[XT*334588000000156*len*wdstart,300]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*bldstart"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # print("temp:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 体温下发频率数据
- @param msg: 接收到的下行数据
- """
- # print("WDSTART_ProtoCol RECV msg:")
- print("bldstart:{}".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
-
- bldstartTotal = int(msg_tmp)
- # bldstartTotal = 300
- print("bldstartTotal:{}".format(bldstartTotal))
- if bldstartTotal == 1:#单次测量
- get_bp_state = EventMesh.publish("get_bp_state")
- get_hr_state = EventMesh.publish("get_hr_state")
- get_spo2_state = EventMesh.publish("get_spo2_state")
- get_bg_state = EventMesh.publish("get_bg_state")
- print("get_bp_state:{}".format(get_bp_state))
- if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("set_bp_state",3)#3代表单次测量
- else:
- if bldstartTotal > 0 and bldstartTotal <= 300:
- bldstartTotal = 300
- elif bldstartTotal >= 65536:
- bldstartTotal = 65536
-
- on = 0
- if bldstartTotal != 0:#关闭自动测量
- on = 1
- print("on:{} bldstartTotal:{} ".format(on,bldstartTotal))
- EventMesh.publish("set_bp_time",[on,bldstartTotal])
-
- EventMesh.publish(constants.PROTOCOL.BLDSTART_SEND)
-
-
-# 注：回复完后开始测量血压并上传（一般测一次90秒，app端会提醒用户两分钟后刷新页面查看）
-# 上传血压数据
-# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*blood,x,y]
-# x 是收缩压（高压）
-# y 是舒张压（低压）
-# 示例[XT*334588000000156*000C*blood,150,70]
-# 平台回复：
-# [XT*334588000000156*0005*blood]
-class blood_ProtoCol(ProtoCol):
- """上传血压测试数据"""
- TYPE = "blood"
- def send(self, event, msg):
- len_size = len(str(msg[0]))+len("blood,")+1+len(str(msg[1]))
- print("blood:send:{} len:{}".format(msg,len_size))
- # 实例：[XT*334588000000156*0009*blood,36,2]
- # 代表终端的
- # 平台回复：
- # [XT*334588000000156*0004*blood]
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*blood"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"blood")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d,%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1])
- print("blood:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # print("HRSTART_ProtoCol RECV msg:")
- #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)
-
-
-
-
-# 设置血糖上传频率
-# 平台发送:
-# [XT*334588000000156*len*bgstart,x]
-# x为上传间隔时间，单位秒,连续上传时最小时间不小于300秒，最大不超过65535.
-# 实例：[XT*334588000000156*len*bgstart,300]
-# 终端会每隔300秒检测一次
-
-# x为1则代表终端单次上传。
-# x为0则代表终端上传关闭。
-class bgstart_ProtoCol(ProtoCol):
- """app下发血糖测试频率"""
- TYPE = "bgstart"
- def send(self, event, msg):
- #[XT*334588000000156*len*wdstart,300]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*bgstart"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # print("temp:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event: 体温下发频率数据
- @param msg: 接收到的下行数据
- """
- # print("WDSTART_ProtoCol RECV msg:")
- print("bgstart:{}".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
-
- bgstartTotal = int(msg_tmp)
- print("bgstartTotal:{}".format(bgstartTotal))
- if bgstartTotal == 1:#单次测量
- get_bp_state = EventMesh.publish("get_bp_state")
- get_hr_state = EventMesh.publish("get_hr_state")
- get_spo2_state = EventMesh.publish("get_spo2_state")
- get_bg_state = EventMesh.publish("get_bg_state")
- print("get_bg_state:{}".format(get_bg_state))
- if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低
- battery = EventMesh.publish("screen_get_battery")
- if battery != None:
- if battery[0] != "1":
- EventMesh.publish("set_bg_state",3)#3代表单次测量
- else:
- if bgstartTotal > 0 and bgstartTotal <= 300:
- bgstartTotal = 300
- elif bgstartTotal >= 65536:
- bgstartTotal = 65536
-
- # if bgstartTotal == 0:#关闭自动测量
- # EventMesh.debug_log("bgSTART_ 1")
- # EventMesh.publish("set_bgauto_time",[0,0])
- # else:
- on = 0
- if bgstartTotal != 0:
- on = 1
- EventMesh.publish("set_bgauto_time",[on,bgstartTotal])
-
- EventMesh.publish(constants.PROTOCOL.BGSTART_SEND)
-
-# 上传血糖数据
-# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*bloodglucose,x]
-# x 表示血糖，单位mmol/L
-# 示例[XT*334588000000156*0010*bloodglucose,6.1]
-# 平台回复：
-# [XT*334588000000156*000B*bloodglucose]
-class bloodglucose_ProtoCol(ProtoCol):
- """上传血糖测试数据"""
- TYPE = "bloodglucose"
- def send(self, event, msg):
- len_size = len("bloodglucose,")+1+len(str(msg))
- print("bloodglucose:send:{} len:{}".format(msg,len_size))
- # 实例：[XT*334588000000156*0009*blood,36,2]
- # 代表终端的
- # 平台回复：
- # [XT*334588000000156*0004*blood]
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*bloodglucose"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"bloodglucose")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%s]"%(str(MD5_SIGN),send_data,msg)
- print("bloodglucose:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # print("HRSTART_ProtoCol RECV msg:")
- #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)
-
-# [XT*334588000000156*0003*DLT]
-def reset_factory(msg):
- if msg == 1:
- Power.powerRestart()
-class DLT_ProtoCol(ProtoCol):
- """解绑数据"""
- TYPE = "DLT"
- def send(self, event, msg):
- # [XT*334588000000156*0004*temp]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0003*DLT"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("temp:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # EventMesh.debug_log("DLT_ProtoCol RECV msg:")
-
-
-#定位频率
-class UPLOAD_ProtoCol(ProtoCol):
- """定位频率数据"""
- TYPE = "UPLOAD"
- def send(self, event, msg):
- # [XT*334588000000156*0004*temp]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*UPLOAD"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
-
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*UPLOAD,600]'
- # EventMesh.debug_log("DLT_ProtoCol RECV msg:".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
- upload_time = int(msg_tmp)
- EventMesh.publish("set_storage_config",["upload_time",upload_time])
-
- EventMesh.publish("set_upload_data", upload_time)
- EventMesh.publish(constants.PROTOCOL.UPLOAD_SEND)
-
-#设置快捷号码
-class CENTER_ProtoCol(ProtoCol):
- """设置快捷号码"""
- TYPE = "CENTER"
- def send(self, event, msg):
- # [XT*334588000000156*0004*temp]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*CENTER"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("UPLOAD:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*UPLOAD,600]'
- # EventMesh.debug_log("DLT_ProtoCol RECV msg:".format(msg))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1]
- EventMesh.debug_log("CENTER_ProtoCol RECV msg:{} msg_:{}".format(msg,msg_tmp))
- center_dial = str(msg_tmp)
- EventMesh.publish("set_storage_config",["center_dial",center_dial])
- EventMesh.publish(constants.PROTOCOL.CENTER_SEND)
-
-#呼叫快捷电话号码
-import voiceCall
-class MONITOR_ProtoCol(ProtoCol):
- """呼叫快捷号码"""
- TYPE = "MONITOR"
- def send(self, event, msg):
- # [XT*334588000000156*0004*MONITOR]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MONITOR"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("MONITOR:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*MONITOR]'
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split('MONITOR')
- msg_tmp = msg_tmp[1]
- EventMesh.debug_log("MONITOR_ProtoCol RECV msg:{} msg_:{}".format(msg,len(msg_tmp)))
- if len(msg_tmp) != 0:
- EventMesh.publish("save_phonename", contact)
- EventMesh.publish("save_phonenum", contact)
- EventMesh.publish("dial_out_call_center_cb",contact)#电话拨出去
- else:
- read_data = EventMesh.publish("get_storage_config","center_dial")
- EventMesh.debug_log("MONITOR:data:%s"%(read_data))
- if read_data != None:
- contact = read_data
- if len(contact) > 0:
- EventMesh.debug_log("MONITOR RECV msg:{} {}".format(contact,type(contact)))
- EventMesh.publish("save_phonename", contact)
- EventMesh.publish("save_phonenum", contact)
- EventMesh.publish("dial_out_call_center_cb",contact)#电话拨出去
- EventMesh.publish(constants.PROTOCOL.MONITOR_SEND)
-
-#定时开关机
-class bootoff_ProtoCol(ProtoCol):
- """定时开关机"""
- TYPE = "BOOTOFF"
- def send(self, event, msg):
- # [XT*334588000000156*0004*MONITOR]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*BOOTOFF"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("BOOTOFF:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*SOS_SEND]'
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- on_bt = int(msg_tmp[1])
- start_hour = int(str(msg_tmp[2]).split(":")[0])
- start_min = int(str(msg_tmp[2]).split(":")[1])
-
- end_hour = int(str(msg_tmp[3]).split(":")[0])
- end_min = int(str(msg_tmp[3]).split(":")[1])
-
- EventMesh.debug_log("BOOTOFF:send data:",on_bt,start_hour,start_min,end_hour,end_min)
- poweroff = []
- poweroff.append({"poweroff_on":on_bt,"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min})
- #b'[SZKW*860132060006970*0015*BOOTOFF,1,06:00,23:59]'
- EventMesh.publish("set_boot_off_time",poweroff)#设置关机时间
-
- EventMesh.publish(constants.PROTOCOL.BOOTOFF_SEND)
-
-
-#sos家庭号码
-class sosHome_dial_ProtoCol(ProtoCol):
- """sos家庭号码"""
- TYPE = "SOS"
- def send(self, event, msg):
- # [XT*334588000000156*0004*MONITOR]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0003*SOS"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- print("sosHome_dial_ProtoCol:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
-
- # b'[SZKW*867387060319166*000A*SOS_SEND]'
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
-
- # print("sosHome_dial_ProtoCol:send data :{} {}".format(len(msg_tmp),msg_tmp))
- #b'[SZKW*860132060006970*0015*sosHome_dial_ProtoCol,15521469561,10086,15521469561]'
- i = 0
- num = 0
- count = 0
- print("sos msg_tmp",msg_tmp)
- if len(msg_tmp) > 4:
- num = 3
- else:
- num = len(msg_tmp)-1
- data = []
- for i in range(num):
- # print("sos:send data :{}".format(msg_tmp[i+1]))
- if len(msg_tmp[i+1]) != 0:
- EventMesh.publish("set_storage_config",["SOS_NUMBER{}".format(i+1),msg_tmp[i+1]])
- data.append(str(msg_tmp[i+1]))
- count+=1
- print("data:{}".format(data))
- EventMesh.publish("set_dial_sos_number",data)
-
- EventMesh.publish(constants.PROTOCOL.SOS_SEND)
-
-
-# 低电提醒
-#[XT*334588000000156*0008*LOWBAT,1]
-class LOWBAT_ProtoCol(ProtoCol):
- """低电提醒"""
- TYPE = "LOWBAT"
- def send(self, event, msg):
- # [XT*334588000000156*0006*LOWBAT]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*LOWBAT"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("LOWBAT:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*LOWBAT]'
-
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- on_bt = msg_tmp[1]
- EventMesh.debug_log("LOWBAT:send data:{}".format(on_bt))
- #b'[SZKW*860132060006970*0015*LOWBAT,1,06:00,23:59]'
- EventMesh.publish("set_low_bat_btn",on_bt)
- EventMesh.publish(constants.PROTOCOL.LOWBAT_SEND)
-
-# 设置系统时间
-#
-class Time_ProtoCol(ProtoCol):
- """设置系统时间"""
- TYPE = "Time"
- def send(self, event, msg):
- #
- send_data = EventMesh.publish("get_new_pid")+"*%s*0004*Time"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("Time:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # rtc = RTC()
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
-
- timeSecond = int(msg_data[1])
- #EventMesh.debug_log("type {} timeSecond {}".format((msg_data[1]),timeSecond))
- # timeSecond = 1703001360
- next_alarm_time = utime.localtime(timeSecond)
- #EventMesh.debug_log("next_alarm_time",next_alarm_time)
- #EventMesh.debug_log("local time",msg)
- # machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6], tm[3], tm[4], tm[5], 0))
-
- machine.RTC().datetime((next_alarm_time[0],next_alarm_time[1],next_alarm_time[2],next_alarm_time[6],next_alarm_time[3],next_alarm_time[4],next_alarm_time[5],0))
- #next_alarm_time = utime.localtime(old_Timesec)#年月日时分秒星期365中的第几天
- EventMesh.publish("set_rtc_alarm")
- #EventMesh.publish(constants.PROTOCOL.TIME_SEND)
-
-
-
-
-#免打扰
-class SILENCETIME2_ProtoCol(ProtoCol):
- """免打扰"""
- TYPE = "SILENCETIME2"
- def send(self, event, msg):
- # [XT*334588000000156*0006*SILENCETIME2]
- send_data = EventMesh.publish("get_new_pid")+"*%s*000C*SILENCETIME2"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("KEYBRD:data:%s"%(data))
- # EventMesh.debug_log("SILENCETIME2!!!!!!!!!!!!!",msg)
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*KEYBRD]'
- # EventMesh.debug_log("SILENCETIME2!!!!!!!!!!!!!",msg)
- EventMesh.publish(constants.PROTOCOL.SILENCETIME2_SEND)
-
-#键盘开关
-class KEYBRD_ProtoCol(ProtoCol):
- """免打扰"""
- TYPE = "KEYBRD"
- def send(self, event, msg):
- # [XT*334588000000156*0006*SILENCETIME2]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*KEYBRD"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # EventMesh.debug_log("KEYBRD:data:%s"%(data))
- # EventMesh.debug_log("KEYBRD!!!!!!!!!!!!!",msg)
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*KEYBRD]'
- # EventMesh.debug_log("KEYBRD!!!!!!!!!!!!!",msg)
- EventMesh.publish(constants.PROTOCOL.KEYBRD_SEND)
-
-class TK_ProtoCol(ProtoCol):
- """微聊"""
- TYPE = "TK"
-
-
- def send(self, event, msg):
- EventMesh.debug_log("TK send:")
- if len(str(msg)) == 1:
-
- len_size = len(str(msg))+len("TK,")
- # 实例：[XT*334588000000156*0009*TK,1]
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*TK"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"TK")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)
- EventMesh.debug_log("TK:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
- else:
- # [SZKW*YYYYYYYYYYYYYYY*LEN*TK,AMR 格式音频数据]
- #[XT*YYYYYYYYYYYYYYY*LEN*TKS,秒数（十进制）,AMR 格式音频数据]
- arm_data = msg
- # arm_sec = msg[0]
- # EventMesh.debug_log("TK_ProtoCol:msgtype:{} arm_sec:{}".format(len(msg[1]),arm_sec))
-
- arm = bytearray()
- for i in range(len(arm_data)):
- if arm_data[i] == 0x7d:
- arm.extend(b'\x7d\x01')
- elif arm_data[i] == 0x5b :
- arm.extend(b'\x7d\x02')
- elif arm_data[i] == 0x5d :
- arm.extend(b'\x7d\x03')
- elif arm_data[i] == 0x2c :
- arm.extend(b'\x7d\x04')
- elif arm_data[i] == 0x2a :
- arm.extend(b'\x7d\x05')
- else :
- arm.append(arm_data[i])
-
- datalen = len(arm) + len("TK,")+1
- #Wechat_log("len(str(arm_sec)):{}".format(len(str(arm_sec))+1))
- send_data = bytearray(EventMesh.publish("get_new_pid")+"*%s*%04X*TK,"%(self.imei,datalen))
- send_data.extend(arm)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,datalen,"TK")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = bytearray('[')
- data.extend(MD5_SIGN)
- data.extend(send_data)
- data.extend(']')
- # EventMesh.debug_log("TK:send data:%s MD5_head_data:%s"%(data,MD5_head_data))
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
-
- def recv(self, event, msg):
- """
-
- ("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))
- @param event: 微聊
- @param msg: 接收到的下行数据
- [SZKW*860132060004322*20BD*TK,#!AMR...]
- """
- #Wechat_log("K_ProtoCol:recv:data:{}".format(msg))
-
- msg_tmp = msg.decode('ascii')
- str = msg_tmp.split('TK,')
- # Wechat_log("TK_ProtoCol:recv:len:{} {} {}".format(len(msg),len(str),msg_tmp.find("#!AMR")))
-
- read_AMR_flag = msg_tmp.find("#!AMR")
- #EventMesh.debug_log("TK recv:read_AMR_flag:{} ,{}".format(read_AMR_flag,EventMesh.publish("get_wechat_record_flag")))
- # if EventMesh.publish("get_wechat_record_flag") != 1 and read_AMR_flag != -1: #是否是服务器下发音频数据
- if read_AMR_flag != -1: #是否是服务器下发音频数据
- # Wechat_log("TK_ProtoCol:recv:datalen{}".format(len(msg)))
- arm_data = bytearray(str[1])#获取amr输出
- get_wechat_data = EventMesh.publish("get_wechat_data")
- MXA_MSG = get_wechat_data[0]
- wechat_recode_list = get_wechat_data[1]
- wechat_num = int(wechat_recode_list["num"])
- # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))
-
- if wechat_num >= MXA_MSG:
- wechat_num = 0
- if wechat_num == 0:
- wechat_num += 1
- elif wechat_num > 0:
- wechat_num += 1
-
-
- EventMesh.debug_log("num_total:datalen:{} {}".format(MXA_MSG,wechat_recode_list))
- wechat_recode_list["%02d"%(wechat_num)] = "read:1"
- wechat_recode_list['num'] = wechat_num
- EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])
- #写语音文件数据
-
- # path = "/usr/static/storage_file/wechat.amr"
- path = "/usr/static/storage_file/{}.amr".format(wechat_num)
- with open(path,"w") as fd:
- arm = bytearray()
- j = 0
- for i in range(len(arm_data)):
- if arm_data[j] == 0x7d and arm_data[j+1] == 0x01:
- arm.extend(b'\x7d')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x02:
- arm.extend(b'\x5b')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x03:
- arm.extend(b'\x5d')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x04:
- arm.extend(b'\x2c')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x05:
- arm.extend(b'\x2a')
- j+=1
- else :
- arm.append(arm_data[j])
- j+=1
- if j >= len(arm_data):
- break
- fd.write(arm)
- EventMesh.publish("recv_wechat_audio")#
- EventMesh.publish(constants.PROTOCOL.TK_SEND,1)
- EventMesh.debug_log("constants.PROTOCOL.TK_SEND1!!!")
- else :
- if read_AMR_flag != -1:
- EventMesh.publish(constants.PROTOCOL.TK_SEND,0)
-
-class TKS_ProtoCol(ProtoCol):
- """微聊"""
- TYPE = "TKS"
-
-
- def send(self, event, msg):
- EventMesh.debug_log("TKS send:")
- if len(str(msg)) == 1:
- len_size = len(str(msg))+len("TKS,")
- # 实例：[XT*334588000000156*0009*TK,1]
- send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*TKS"%(self.imei,len_size)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"TKS")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)
- EventMesh.debug_log("TKS:data:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
- else:
- # [SZKW*YYYYYYYYYYYYYYY*LEN*TK,AMR 格式音频数据]
- #[XT*YYYYYYYYYYYYYYY*LEN*TKS,秒数（十进制）,AMR 格式音频数据]
- arm_data = msg[1]
- arm_sec = msg[0]
- EventMesh.debug_log("TK_ProtoCol:msgtype:{} arm_sec:{}".format(len(msg[1]),arm_sec))
-
- arm = bytearray()
- for i in range(len(arm_data)):
- if arm_data[i] == 0x7d:
- arm.extend(b'\x7d\x01')
- elif arm_data[i] == 0x5b :
- arm.extend(b'\x7d\x02')
- elif arm_data[i] == 0x5d :
- arm.extend(b'\x7d\x03')
- elif arm_data[i] == 0x2c :
- arm.extend(b'\x7d\x04')
- elif arm_data[i] == 0x2a :
- arm.extend(b'\x7d\x05')
- else :
- arm.append(arm_data[i])
-
- datalen = len(arm) + len("TKS,")+len(str(arm_sec))+1
- #Wechat_log("len(str(arm_sec)):{}".format(len(str(arm_sec))+1))
- send_data = bytearray(EventMesh.publish("get_new_pid")+"*%s*%04X*TKS,%d,"%(self.imei,datalen,arm_sec))
- send_data.extend(arm)
- MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,datalen,"TKS")
- MD5_SIGN = self.pack_MD5_head(MD5_head_data)
- data = bytearray('[')
- data.extend(MD5_SIGN)
- data.extend(send_data)
- data.extend(']')
- # EventMesh.debug_log("TK:send data:%s MD5_head_data:%s"%(data,MD5_head_data))
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
-
- def recv(self, event, msg):
- """
-
- ("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))
- @param event: 微聊
- @param msg: 接收到的下行数据
- [SZKW*860132060004322*20BD*TK,#!AMR...]
- """
- #Wechat_log("K_ProtoCol:recv:data:{}".format(msg))
- # EventMesh.debug_log("TK recv:{}".format(msg))
- msg_tmp = msg.decode('ascii')
- str = msg_tmp.split('TKS,')
- # Wechat_log("TK_ProtoCol:recv:len:{} {} {}".format(len(msg),len(str),msg_tmp.find("#!AMR")))
- read_AMR_flag = msg_tmp.find("#!AMR")
- # if EventMesh.publish("get_wechat_record_flag") != 1 and read_AMR_flag != -1: #是否是服务器下发音频数据
- if read_AMR_flag != -1: #是否是服务器下发音频数据
- # Wechat_log("TK_ProtoCol:recv:datalen{}".format(len(msg)))
- arm_data = bytearray(str[1])#获取amr输出
- get_wechat_data = EventMesh.publish("get_wechat_data")
- MXA_MSG = get_wechat_data[0]
- wechat_recode_list = get_wechat_data[1]
- wechat_num = int(wechat_recode_list["num"])
- # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))
-
- if wechat_num >= MXA_MSG:
- wechat_num = 0
- if wechat_num == 0:
- wechat_num += 1
- elif wechat_num > 0:
- wechat_num += 1
-
-
- EventMesh.debug_log("num_total:datalen:{} {}".format(MXA_MSG,wechat_recode_list))
- wechat_recode_list["%02d"%(wechat_num)] = "read:1"
- wechat_recode_list['num'] = wechat_num
- EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])
- #写语音文件数据
-
- # path = "/usr/static/storage_file/wechat.amr"
- path = "/usr/static/storage_file/{}.amr".format(wechat_num)
- with open(path,"w") as fd:
- arm = bytearray()
- j = 0
- for i in range(len(arm_data)):
- if arm_data[j] == 0x7d and arm_data[j+1] == 0x01:
- arm.extend(b'\x7d')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x02:
- arm.extend(b'\x5b')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x03:
- arm.extend(b'\x5d')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x04:
- arm.extend(b'\x2c')
- j+=1
- elif arm_data[j] == 0x7d and arm_data[j+1] == 0x05:
- arm.extend(b'\x2a')
- j+=1
- else :
- arm.append(arm_data[j])
- j+=1
- if j >= len(arm_data):
- break
- fd.write(arm)
- EventMesh.publish("recv_wechat_audio")#
- EventMesh.publish(constants.PROTOCOL.TKS_SEND,1)#返回接收成功
- else :
- if read_AMR_flag != -1 :
- EventMesh.publish(constants.PROTOCOL.TKS_SEND,0)#返回接收失败
-
-
-
-
-
-
-
-class MESSAGE_ProtoCol(ProtoCol):
- """微聊"""
- TYPE = "MESSAGE"
-
-
- def send(self, event, msg):
- #[XT*334588000000156*0007*MESSAGE]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MESSAGE"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
-
- @param event: 微聊文字
- @param msg: 接收到的下行数据
- """
- # msg = msg[1:-1]
-
- # msg_s = msg.decode('ascii')
- # msg_s = msg_s.split(',')
- # msg_s = msg_s[1]
- # # Wechat_log("msg_tmp:len:{}\r\n data:{}".format(len(msg_s),msg_s))
-
-
- # get_wechat_data = EventMesh.publish("get_wechat_data")
-
- # MXA_MSG = get_wechat_data[0]
- # wechat_recode_list = get_wechat_data[1]
- # wechat_num = wechat_recode_list["num"]
- # # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))
-
- # if wechat_num >= MXA_MSG:
- # wechat_num = 0
- # if wechat_num == 0:
- # wechat_num += 1
- # elif wechat_num > 0:
- # wechat_num += 1
- # msg_txt = {}
- # # 0 1 2 3
- # Wechat_log("wechat_num:init {}".format(wechat_num))
- # msg_txt = UnicodeHexStr_To_Utf8Str(msg_s)
- # # Wechat_log("msg_txt:{}".format(msg_txt))
- # wechat_recode_list["%02d"%(wechat_num)] = "T:{}".format(msg_txt)
- # wechat_recode_list['num'] = wechat_num
- # EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])
- # # Wechat_log("wechat_recode_list:len data:{}".format(wechat_recode_list))
-
- # screen_NAME = EventMesh.publish("get_screen_NAME")
- # get_lcd_state = EventMesh.publish("get_lcd_state")
- # if screen_NAME != "wechat" or get_lcd_state == 0:
- # EventMesh.publish("load_screen", {"screen": "wechat_popup"})
- # else:
- # EventMesh.publish("wechat_updata_list_show")
- EventMesh.publish(constants.PROTOCOL.MESSAGE_SEND)
- # EventMesh.publish("recv_wechat_audio")#
-
-class FALLDOWN_ProtoCol(ProtoCol):
- """
- 跌倒提醒开关
- 服务器下发跌倒报警设置命令
- [XT*334588000000156*LEN*FALLDOWN,ONOFF]
- ONOFF: 1:开启，0:关闭。
- 终端回复
- [XT*334588000000156*LEN*FALLDOWN]
- """
- TYPE = "FALLDOWN"
-
- def send(self, event, msg):
-
- #[XT*334588000000156*LEN*FALLDOWN]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*FALLDOWN"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
- [SZKW*860132060341484*000A*FALLDOWN,1]
- """
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
-
- Falldowm = msg_data[1]
- EventMesh.debug_log("FALLDOWN:{}".format(Falldowm))
- EventMesh.publish("set_storage_config",["fall_sw",Falldowm])
-
- EventMesh.publish(constants.PROTOCOL.FALLDOWN_SEND)
-
-class REMOVE_ProtoCol(ProtoCol):
- """
- 取下手环报警开关
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMOVE,0或者1]
- 实例:[XT*334588000000156*0008*REMOVE,1]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMOVE]
- """
- TYPE = "REMOVE"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*REMOVE"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
- Falldowm = msg_data[1]
- EventMesh.debug_log("REMOVE:{}".format(Falldowm))
- EventMesh.publish("set_storage_config",["remove_sw",Falldowm])
- EventMesh.publish(constants.PROTOCOL.REMOVE_SEND)
-
-class HELP_ProtoCol(ProtoCol):
- """
-一键报警
- [XT*YYYYYYYYYYYYYYY*LEN*HELP,状态]
- 状态值为整数：60或不带默认是普通报警，61光电式感烟火灾报警，62检测环境温度（高温报警，温度变化报警），
- 63人体活动检测报警，64电池欠压提醒功能，65设备脱落提醒功能，66离线报警，67测试报警，123气感报警，
- 124烟感报警，125水浸报警
- 实例:
- [XT*334588000000156*0004*HELP,60]
- """
- TYPE = "HELP"
-
- def send(self, event, msg):
- #[XT*334588000000156*LEN*FALLDOWN]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*HELP,%d"%(self.imei,msg)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- """
- [XT*334588000000156*0004*HELP,60]
- """
-
- pass
-
-
-#喝水闹钟提示
-# 喝水闹钟设置指令
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_DRINK,4,0]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK]
-# 实例:[XT*334588000000156*000E*REMIND_CH_DRINK]
-class REMIND_CHDRINK_ProtoCol(ProtoCol):
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]
- 实例:[XT*334588000000156*0008*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK]
- """
- TYPE = "REMIND_CH_DRINK"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*000F*REMIND_CH_DRINK"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_DRINK,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
- data = str(msg_data[1])
- hour = int(data.split('-')[0])
- btn_on = int(data.split('-')[1])
-
- EventMesh.debug_log("recv REMIND_CH_DRINK:{}-{}-{}".format(hour,btn_on,msg))
- EventMesh.publish("set_storage_config",["drink_on",btn_on])
- EventMesh.publish("set_storage_config",["drink_time",hour])
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_DRINK_SEND)
-
-# 自定义服药闹钟设置指令
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2,时间1-开关，时间2-开关，周几]
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_MEDICINE2,08:10-0,09:10-0,1000001]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2]
-# 实例:[XT*334588000000156*000E*REMIND_CH_MEDICINE2]
-# 说明:闹铃格式为：时间-开关（0/1），周几（周六到周日）
-
-#REMIND_CH_MEDICINE2,09:00-1,14:00-0,18:00-0,1111111]'",)
-class REMIND_CHMEDICINE2_ProtoCol(ProtoCol):#吃药提醒
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND_CH_MEDICINE2,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2]
- """
- TYPE = "REMIND_CH_MEDICINE2"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0013*REMIND_CH_MEDICINE2"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
-
- msg_data = str(msg_tmp.split('REMIND_CH_MEDICINE2,')[1])
- msg_data_tmp = str(msg_tmp.split('REMIND_CH_MEDICINE2')[1])
-
- medicin_data = []
- alarmday=[]
- count = 0
- for i in str(msg_data_tmp):
- # print("i",i)
- if i == ",":
- count+=1
-
- if count >= 3:
- count = 3
- medicine_alarmday = []
- for i in range(0,count):#默认是三个时间多了也不保存
- medicine_alarmday = str(msg_data.split(",")[count])
- # print("i",i)
- medicine_alarm = str(msg_data.split(",")[i])
- if str(medicine_alarm).find("-") != -1:
- on = int(medicine_alarm.split('-')[1])
- if on != 0:
- alarmday = []
- data = str(medicine_alarm.split('-')[0])
- hour = int(data.split(":")[0])
- min = int(data.split(":")[1])
- for i in range(0,7):
- # print("medicine_alarmday",medicine_alarmday,medicine_alarmday[i])
- if medicine_alarmday[i] != '0':
- alarmday.append(i)
- enable = 1
- medicin_data.append({"hour":hour,"min":min,"day":alarmday,"enable":enable})
-
- EventMesh.publish("set_storage_config",["medicine",medicin_data])
- EventMesh.debug_log("recv REMIND_CH_MEDICINE2:{} medicin_data ;{}".format(msg,medicin_data))
-
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_MEDICINE2_SEND)
- EventMesh.publish("clear_medicine_alarm")
-
-# 回家闹钟设置指令
-# 可设置闹钟的提醒文字
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME,闹钟1,闹钟2,闹钟3]
-# 实例:
-# [XT*334588000000156*0018*REMIND_CH_HOME,08:10，12:10]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME]
-# 实例:[XT*334588000000156*0006*REMIND_CH_HOME]
-# 说明:闹钟为时间点；
-class REMIND_CH_HOME_ProtoCol(ProtoCol):#回家提醒
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND_CH_HOME,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME]
- """
- TYPE = "REMIND_CH_HOME"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*000E*REMIND_CH_HOME"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
-
- # [SZKW*860132060346475*0014*REMIND_CH_HOME,00:00',)
- home_data = str(msg_data[1])
-
- EventMesh.debug_log("recv REMIND_CH_HOME:{} medicin_data ;{}".format(msg,home_data))
- if len(home_data) != 0:
- EventMesh.publish("set_storage_config",["home_alarm",home_data])
- EventMesh.publish("clear_home_alarm")
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_HOME_SEND)
-# 起床闹钟设置指令
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP,闹钟1，闹钟2]
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_WAKEUP,08:10-0-3-1000001,09:10-0-3-1000001]
-# 闹钟格式为：时间-开关-频率(1：一次；2:每天;3：自定义)
-# 08:10-1-1：闹钟时间8:10，打开，响铃一次
-# 08:10-1-2：闹钟时间8:10，打开，每天响铃
-# 08:10-1-3-0111110：闹钟时间8:10，打开，自定义周一至周五打开
-# 最左边是周日，最右边是周六，即0111110的顺序是：周日，周一，周二，周三，周四，周五，周六（1为打开，0为关闭），其中周一至周五打开闹钟
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP]
-# 实例:[XT*334588000000156*000E*REMIND_CH_WAKEUP]
-# 说明:闹铃格式为：时间-开关-周几（周六到周日）
-class REMIND_CH_WAKEUP_ProtoCol(ProtoCol):#该起床了
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND_CH_WAKEUP,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP]
- """
- TYPE = "REMIND_CH_WAKEUP"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0011*REMIND_CH_WAKEUP"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_new = str(msg_tmp.split('REMIND_CH_WAKEUP,')[1])
- msg_tmp_data = str(msg_tmp.split('REMIND_CH_WAKEUP')[1])
- count = 0
- for i in str(msg_tmp_data):
- # print("i",i)
- if i == ",":
- count+=1
- wakeup_data_save = []
- # # ("handler -> b'[SZKW*860132060346475*001C*REMIND_CH_WAKEUP,08:00-1-1,,]'",)
- # medicine_alarmday = str(msg_data[4])
- # alarmday=[]
- wakeup_day = []
- wakeup_switch = 0
-
- print("count",count)
- if count >= 3:
- count = 3
- for i in range(0,count):#默认是三个时间多了也不保存
- wakeup_day = []
- wakeup_data = str(msg_tmp_new.split(',')[i])
- # print("i",i,wakeup_data)
- if len(wakeup_data) != 0:
- b = wakeup_data.find('-')
- if b != -1:
- wakeup_time = wakeup_data.split('-')[0]#-作为分隔符
- wakeup_switch = int(wakeup_data.split('-')[1])#开关
- wakeup_repeat = int(wakeup_data.split('-')[2])#是单次还是每天 还是自定义
-
- wakeup_hour = int(wakeup_time.split(":")[0])#时间
- wakeup_min = int(wakeup_time.split(":")[1])#冒号分隔时间 时 分
-
-
- if wakeup_repeat == 2:#每一天
- wakeup_day = [0,1,2,3,4,5,6]
- elif wakeup_repeat == 3:#自定义
- wakeup_day_tmp = wakeup_data.split('-')[3]#-作为分隔符
- for i in range(0,7):
- if wakeup_day_tmp[i] != '0':
- wakeup_day.append(i)
- else:#单次 1
- wakeup_day=[]
- if wakeup_switch != 0:
- wakeup_data_save.append({"hour":wakeup_hour,"min":wakeup_min,"day":wakeup_day,"enable":wakeup_switch})
-
- EventMesh.publish("set_storage_config",["wakeup_alarm",wakeup_data_save])
- wakeup = EventMesh.publish("get_storage_config","wakeup_alarm")
-
- EventMesh.debug_log("recv REMIND_CH_WAKEUP:{} wakeup ;{}".format(msg,wakeup))
-
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_WAKEUP_SEND)
-
- EventMesh.publish("clear_wakeup_alarm")
-
-
-
-# 睡觉闹钟设置指令
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP,闹钟1，闹钟2]
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_SLEEP,08:10-0-3-1000001,09:10-0-3-1000001]
-# 闹钟格式为：时间-开关-频率(1：一次；2:每天;3：自定义)
-# 08:10-1-1：闹钟时间8:10，打开，响铃一次
-# 08:10-1-2：闹钟时间8:10，打开，每天响铃
-# 08:10-1-3-0111110：闹钟时间8:10，打开，自定义周一至周五打开
-# 最左边是周日，最右边是周六，即0111110的顺序是：周日，周一，周二，周三，周四，周五，周六（1为打开，0为关闭），其中周一至周五打开闹钟
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP]
-# 实例:[XT*334588000000156*000E*REMIND_CH_SLEEP]
-# 说明:闹铃格式为：时间-开关-周几（周六到周日）
-class REMIND_CH_SLEEP_ProtoCol(ProtoCol):#该睡觉了
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND_CH_SLEEP,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP]
- """
- TYPE = "REMIND_CH_SLEEP"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0011*REMIND_CH_SLEEP"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_new = str(msg_tmp.split('REMIND_CH_SLEEP,')[1])
- msg_tmp_data = str(msg_tmp.split('REMIND_CH_SLEEP')[1])
- count = 0
- for i in str(msg_tmp_data):
- # print("i",i)
- if i == ",":
- count+=1
-
- sleep_data_save = []
- # # ("handler -> b'[SZKW*860132060346475*001C*REMIND_CH_SLEEP,08:00-1-1,,]'",)
- # b'[SZKW*860132060346475*001B*REMIND_CH_SLEEP,08:00-1-1,,]'",)
- # medicine_alarmday = str(msg_data[4])
- # alarmday=[]
- sleep_day = []
- sleep_switch = 0
-
- print("count",count)
- if count >= 3:
- count = 3
- for i in range(0,count):#默认是三个时间多了也不保存
- sleep_day = []
- sleep_data = str(msg_tmp_new.split(',')[i])
- # print("i",i,sleep_data)
- if len(sleep_data) != 0:
- b = sleep_data.find('-')
- if b != -1:
- sleep_time = sleep_data.split('-')[0]#-作为分隔符
- sleep_switch = int(sleep_data.split('-')[1])#开关
- sleep_repeat = int(sleep_data.split('-')[2])#是单次还是每天 还是自定义
-
- sleep_hour = int(sleep_time.split(":")[0])#时间
- sleep_min = int(sleep_time.split(":")[1])#冒号分隔时间 时 分
-
-
- if sleep_repeat == 2:#每一天
- sleep_day = [0,1,2,3,4,5,6]
- elif sleep_repeat == 3:#自定义
- sleep_day_tmp = sleep_data.split('-')[3]#-作为分隔符
- for i in range(0,7):
- if sleep_day_tmp[i] != '0':
- sleep_day.append(i)
- else:#单次 1
- sleep_day=[]
- if sleep_switch != 0:
- sleep_data_save.append({"hour":sleep_hour,"min":sleep_min,"day":sleep_day,"enable":sleep_switch})
-
- EventMesh.publish("set_storage_config",["sleep_alarm",sleep_data_save])
- # sleep = EventMesh.publish("get_storage_config","sleep_alarm")
-
- # EventMesh.debug_log("recv REMIND_CH_SLEEP_SEND:{} sleep ;{}".format(msg,sleep))
-
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_SLEEP_SEND)
- EventMesh.publish("clear_sleep_alarm")
-
-
-# 可设置闹钟的提醒文字
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST,时间间隔1,时间间隔2,时间间隔3]
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_REST,08:10-10:00,12:10-15:00]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST]
-# 实例:[XT*334588000000156*000E*REMIND_CH_REST]
-# 说明:时间间隔 【起始-结束】，起始为开始休息，结束为休息结束
-
-class REMIND_CH_REST_ProtoCol(ProtoCol):#该休息了
- """
-
- 平台发送:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST,,时间1-开关，时间2-开关，周几]
- 实例:[XT*334588000000156*0008*REMIND_CH_REST,,时间1-开关，时间2-开关，周几]
- 终端回复:
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST]
- """
- TYPE = "REMIND_CH_REST"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*000E*REMIND_CH_REST"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # SZKW*860132060346475*0013*REMIND_CH_REST,4-1
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = str(msg_tmp.split('REMIND_CH_REST,')[1])
- msg_data_new = str(msg_tmp.split('REMIND_CH_REST')[1])
- print("REMIND_CH_REST",len(msg_data),msg_data)
-
- reset_data_save = []
- count = 0
- for i in str(msg_data_new):
- # print("i",i)
- if i == ",":
- count+=1
-
- if count >= 2:
- count = 2
-
- for i in range(0,count):#默认是三个时间多了也不保存
- reset_data = str(msg_data.split(',')[i])
- print("i",i,reset_data)
- if len(reset_data) != 0:
- b = reset_data.find('-')
- if b != -1:
- start_time = reset_data.split('-')[0]#-作为分隔符
- end_time = reset_data.split('-')[1]#-作为分隔符
-
- start_hour = int(start_time.split(":")[0])
- start_min = int(start_time.split(":")[1])
-
- end_hour = int(end_time.split(":")[0])
- end_min = int(end_time.split(":")[1])
-
- reset_data_save.append({"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min})
-
- EventMesh.publish("set_storage_config",["reset_alarm",reset_data_save])
- # reset = EventMesh.publish("get_storage_config","reset_alarm")
-
- # EventMesh.debug_log("recv REMIND_CH_REST:{} reset ;{}".format(msg,reset))
-
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_REST_SEND)
- EventMesh.publish("clear_reset_alarm")
-
-
-
-class WLKEY_ProtoCol(ProtoCol):#白名单开关
- """
- 白名单开关
- [XT*YYYYYYYYYYYYYYY*LEN*WLKEY,ONOFF] ONOFF: 1:开启，0:关闭，2：30秒后自动接听。
- 实例:[XT*334588000000156*0008*WLKEY,1]
- 终端回复
- [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]
- 实例:[XT*334588000000156*0006*WLKEY]
- """
- TYPE = "WLKEY"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*00006*WLKEY"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
-
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = msg_tmp.split(',')
- EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))
- EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])
-
-
- EventMesh.publish(constants.PROTOCOL.WLKEY_SEND)
-# 终端发送：
-# [XT*YYYYYYYYYYYYYYY*LEN*SLEEP_DATA,清醒时间（分钟）,浅睡时间（分钟）,深睡时间（分钟）,日期（年月日）]
-# 实例: [XT*334588000000156*0004*SLEEP_DATA,120,240,360,20221008]
-# 实例表示：上传睡眠数据
-#[XT*334588000000156*0010*SleepReport,2022-02-09,80,2,532,164,164,25,25,25,25,21:45-0-164-155-3,22:00-1-162-155-0,22:15-2-162-155-0]
-class SLEEP_DATA_ProtoCol(ProtoCol):#睡眠时间
- """
- 白名单开关
- [XT*YYYYYYYYYYYYYYY*LEN*WLKEY,ONOFF] ONOFF: 1:开启，0:关闭，2：30秒后自动接听。
- 实例:[XT*334588000000156*0008*WLKEY,1]
- 终端回复
- [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]
- 实例:[XT*334588000000156*0006*WLKEY]
- """
- TYPE = "SleepReport"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0000b*SleepReport"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s,%s]"%(str(MD5_SIGN),send_data,msg)
- EventMesh.debug_log("SLEEP_DATA:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
-
- EventMesh.debug_log("SLEEP_DATA!!!!!!!!!")
- # msg = msg[1:-1]
- # msg_tmp = msg.decode('ascii')
- # msg_data = msg_tmp.split(',')
- # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))
- # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])
-
-
- # EventMesh.publish(constants.PROTOCOL.WLKEY_SEND)
-
-class SLEEPTIME_ProtoCol(ProtoCol):#睡眠时间
- """
- """
- TYPE = "SLEEPTIME"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*00009*SLEEPTIME"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("SLEEPTIME:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
- # 实例:[XT*5678901234*0014*SLEEPTIME,23:30-7:30]
- EventMesh.debug_log("SLEEPTIME!!!!!!!!!")
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_data = str(msg_tmp.split(',')[1])
- data = {}
- if len(msg_data) == 0:
- EventMesh.publish("set_storage_config",["sleep_time",data])
- pass
- else:
- sleep_start = msg_data.split("-")[0]
- sleep_end = msg_data.split("-")[1]
- start_hour = int(sleep_start.split(":")[0])
- start_min = int(sleep_start.split(":")[1])
-
- end_hour = int(sleep_end.split(":")[0])
- end_min = int(sleep_end.split(":")[1])
-
- data = {"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min}
- # EventMesh.debug_log("SLEEPTIME".format(data))
- EventMesh.publish("set_storage_config",["sleep_time",data])
- # sleep_time = EventMesh.publish("get_storage_config","sleep_time")
- # EventMesh.debug_log("sleep_time:{}".format(sleep_time))
-
- EventMesh.publish(constants.PROTOCOL.SLEEPTIME_SEND)
-
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*FACTORY]
-# 实例:[XT*334588000000156*0007*FACTORY]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*FACTORY]
-# 实例:[XT*334588000000156*0007*FACTORY]
-# 说明:终端恢复出厂设置，里面设置的号码都将清空
-class FACTORY_ProtoCol(ProtoCol):#睡眠时间
- """
- 实例:[XT*334588000000156*0008*FACTORY]
- 终端回复
- [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]
- 实例:[XT*334588000000156*0006*FACTORY]
- """
- TYPE = "FACTORY"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*FACTORY"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("FACTORY:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
-
- EventMesh.debug_log("FACTORY!!!!!!!!!")
- # msg = msg[1:-1]
- # msg_tmp = msg.decode('ascii')
- # msg_data = msg_tmp.split(',')
- # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))
- # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])
-
- EventMesh.publish(constants.PROTOCOL.FACTORY_SEND)
- EventMesh.publish("app_factory",None)#app恢复出厂
-
-# 平台发送:
-# [3G*YYYYYYYYYY*LEN*RESET]
-# 实例:[3g*5678901234*0005*RESET]
-# 终端回复:
-# [3G*YYYYYYYYYY*LEN*RESET]
-class RESET_ProtoCol(ProtoCol):#重启
- """
- 实例:[XT*334588000000156*0008*RESET]
- 终端回复
- [XT*YYYYYYYYYYYYYYY*LEN*RESET]
- 实例:[XT*334588000000156*0006*RESET]
- """
- TYPE = "RESET"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*0005*RESET"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("RESET:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
-
- EventMesh.debug_log("RESET!!!!!!!!!")
- # msg = msg[1:-1]
- # msg_tmp = msg.decode('ascii')
- # msg_data = msg_tmp.split(',')
- # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))
- # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])
-
- EventMesh.publish(constants.PROTOCOL.RESET_SEND)
- Power.powerRestart()
-
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT,时间间隔（分钟）,总开关（0为关，1为开）,午间休息时段，晚间休息时段]
-# 午间/晚间休息时段格式为：开始时间（hh:mm）-结束时间（hh:mm）-开关（0为关，1为开），例如 12：00-15：00-1。
-# 久坐默认值为20分钟。
-# 午间和晚间默认值，午间12:00-14:00，晚上20:00-07:00。
-# 实例:
-# [XT*334588000000156*0026*REMIND_CH_SIT,20，0，12：00-15：00-1，20：00-07：00-1]
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT]
-# 实例:[XT*334588000000156*000E*REMIND_CH_SIT]
-class REMIND_CH_SIT_ProtoCol(ProtoCol):#久坐提醒
- """
- 实例:[XT*334588000000156*0008*REMIND_CH_SIT]
- 终端回复
- [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT]
- 实例:[XT*334588000000156*0006*REMIND_CH_SIT]
- """
- TYPE = "REMIND_CH_SIT"
-
- def send(self, event, msg):
- send_data = EventMesh.publish("get_new_pid")+"*%s*000d*REMIND_CH_SIT"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- EventMesh.debug_log("REMIND_CH_SIT:send:%s"%(data))
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)
-
- def recv(self, event, msg):
-
- EventMesh.debug_log("REMIND_CH_SIT!!!!!!!!!")
- # msg = msg[1:-1]
- # msg_tmp = msg.decode('ascii')
- # msg_data = msg_tmp.split(',')
- # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))
- # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])
-
- EventMesh.publish(constants.PROTOCOL.REMIND_CH_SIT_SEND)
-
-# 平台发送:
-# [XT*YYYYYYYYYYYYYYY*LEN*SCREEN_SHOW,参数内容]
-# 实例:[XT*334588000000156*0016*SCREEN_SHOW,00000000000]
-# 参数内容用 unicode 编码呈现，设备收到后需解码。
-# 解码后的参数内容可能有多个参数，不同参数用逗号分隔，设备自己决定如何在屏幕中显示这些参数。比如 "SCREEN_SHOW，深圳第一中学，三年1班、张三"
-# 终端回复:
-# [XT*YYYYYYYYYYYYYYY*LEN*SCREEN_SHOW]
-# 实例:[XT*334588000000156*000B*SCREEN_SHOW]
-
-class SCREEN_SHOWProtoCol(ProtoCol):
- """开屏显示"""
- TYPE = "SCREEN_SHOW"
- def send(self, event, msg):
- # [XT*334588000000156*0006*SILENCETIME2]
- send_data = EventMesh.publish("get_new_pid")+"*%s*000B*SCREEN_SHOW"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # print("KEYBRD:data:%s"%(data))
- # print("KEYBRD!!!!!!!!!!!!!",msg)
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
- msg_tmp = msg_tmp[1:]
- msg_tmp = msg_tmp[0]
- print("screen_school_data msg",msg)
-
- j = 0
- i = 0
- videobook_old = {}
- videobook_name_tmp = UnicodeHexStr_To_Utf8Str(msg_tmp)
- lst = videobook_name_tmp.split(",")
- print("lst data",lst)
-
- # 0 1 2 3
- screen_school_data = ""#学校
- screen_class_data = ""#班级
- screen_fullname_data = ""#姓名
- if len(lst) != 0:
- count = len(lst)
- if count > 3:
- count = 3
- for i in range(count):
- if i == 0:
- screen_school_data = lst[0]
- EventMesh.publish("set_schoolname", screen_school_data)#
- elif i == 1:
- screen_class_data = lst[1]
- EventMesh.publish("set_classname", screen_class_data)#
- else:
- screen_fullname_data= lst[2]
- EventMesh.publish("set_fullname", screen_fullname_data)#
-
- # EventMesh.publish("update_screen_show")#更新开屏显示
-
- print("screen_school_data!!!:",screen_school_data,screen_class_data,screen_fullname_data)
-
- EventMesh.publish(constants.PROTOCOL.SCREEN_SHOW_SEND)
-
-# #小见平台视频通话
-# # [XT*YYYYYYYYYYYYYYY*LEN*JPREG]
-# # 实例:
-# # [XT*334588000000156*0004*JPREG]
-# # 平台回复:
-# # [XT*设备ID*LEN*JPREG,账号(整型)]
-# # 实例：[XT*334588000000156*0010*JPREG,1087654321]
-class JPREG_ProtoCol(ProtoCol):#登入注册
- """"""
- TYPE = "JPREG"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0005*JPREG"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- # print("WLKEY:data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*KEYBRD]'
- print("JPREG!!!!!!!!!!!!!",msg,EventMesh.publish("get_new_pid"))
- # EventMesh.publish(constants.PROTOCOL.JPREG_SEND)
-
-# # （声网，佰锐的账号是整型）
-# # [XT*YYYYYYYYYYYYYYY*LEN*MEMBERS]
-# # 实例:[XT*334588000000156*0007*MEMBERS]
-# # 平台回复:[XT*设备ID*LEN*MEMBERS,账号1,昵称1,电话1，账号2,昵称2，电话2.....]
-# # 实例：
-# # [XT*334588000000156*003F*MEMBERS,d3e2f759f9d5af3858f3530,爸爸,13662313580,妈妈,555]
-# # 以上数据部分使用Unicode编码，最终上面示例传到服务端将是：
-
-class MEMBERS_ProtoCol(ProtoCol):#获取账号列表
- """"""
- TYPE = "MEMBERS"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MEMBERS"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s]"%(str(MD5_SIGN),send_data)
- print("MEMBERS SEND:data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*876226002021444*0048*MEMBERS,0036003900350031003800330032002C563F563FD83CDF410020D83CDF42002C]'
- print("MEMBERS!!!!!!!!!!!!!",msg,EventMesh.publish("get_new_pid"))
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp = msg_tmp.split(',')
-
- videobook = {}
- msg_tmp = msg_tmp[1:]
- msg_tmp = msg_tmp[0]
-
- j = 0
- i = 0
- videobook_old = {}
- videobook_name_tmp = UnicodeHexStr_To_Utf8Str(msg_tmp)
- lst = videobook_name_tmp.split(",")
-
- print("msg_tmp:{} phonebook_oldtmp:{} type:{}".format(msg_tmp,videobook_name_tmp,lst))
- # 0 1 2 3
- for vediobook_tmp in lst:
-
- if (j % 3) == 0:#账号
- videobook_old = vediobook_tmp
- elif (j % 3) == 1:#名称
- i+=1
- videobook_name_cont= "{}:{}".format("%03d"%(i),videobook_old)
- videobook[videobook_name_cont] = vediobook_tmp
- j+=1
- print("videobook!!!:{}".format(str(videobook)))
- # print("phonebook!!!:{}".format(str(phonebook)))
- with open("/usr/static/storage_file/videobook.json","w",encoding="utf-8") as fd:
- ujson.dump(videobook,fd)
- print("创建视频通话账号")
-
- EventMesh.publish("set_videobook_list",[1,videobook])
- # EventMesh.publish("video_updata_list_show")
- # EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND)
-
-# # [X*Y*LEN*CALLING,呼叫者id,会议id,通话类型，Token]
-
-# # 设备回复
-# # [X*Y*LEN*CALLING,音视频状态]
-# # 音视频状态：为0表示正常可通讯状态，否则填上用音视频返回的状态码，比如200，如果未获取到返回状态码，则填1
-class CALLING_ProtoCol(ProtoCol):#app发起视频通话
- """"""
- TYPE = "CALLING"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0007*CALLING"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)
- # print("CALLING:send data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*CALLING]'
- print("CALLING!!!!!!!!!!!!!",msg)
- if EventMesh.model == "D10":#D10没有视频通话
- EventMesh.publish(constants.PROTOCOL.CALLING_SEND,1)
- return
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_d = msg_tmp.split(',')
- call_id = msg_tmp_d[1]#id
- meet_id = msg_tmp_d[2]#会议id
- call_type = int(msg_tmp_d[3])#会议id# 0音频 1视频
- tokens_data = msg_tmp_d[4]#tokens
- EventMesh.publish("set_vedio_call_id", call_id)#
- EventMesh.publish("set_vedio_meet_id", meet_id)#
- EventMesh.publish("set_vedio_call_type", call_type)#
- EventMesh.publish("set_vedio_tokens_data", tokens_data)#
-
- flag = EventMesh.publish("get_call_state")
- fall_down = EventMesh.publish("get_fall_down_state")#跌倒报警标识
- usb_state = EventMesh.publish("get_usb")#
- video_state = EventMesh.publish("get_video_state")
- sos_dialing = EventMesh.publish("get_sos_state_out")#正在拨打sos电话
- if flag != 0 or fall_down != 0 or video_state != 0 or sos_dialing != 0: #电话在打入或者 在充电不允许视频通话
- EventMesh.publish(constants.PROTOCOL.CALLING_SEND,1)
- else:
- EventMesh.publish(constants.PROTOCOL.CALLING_SEND,0)
- EventMesh.publish("set_video_state", 6)
- EventMesh.publish("set_dev_app_mode", 2)#
- EventMesh.publish("close_hr_sop2")#
- EventMesh.publish("video_call_in_event",call_type)
-
-# # [XT*YYYYYYYYYYYYYYY*LEN*RCALLING,呼叫者id,会议id/声网频道名（没有则留空，但位置保留）,音频还是视频（0为音频，1为视频）]
-# # 实例:
-# # [XT*334588000000156*0007*RCALLING,d3e2f759f9d5af3858f3530b,,0]
-# # 终端回复:
-# # [XT*设备ID*LEN*RCALLING]
-# # 实例：[XT*334588000000156*0009*RCALLING]
-# #
-class RCALLING_ProtoCol(ProtoCol):#设备拒接接听
- """"""
- TYPE = "RCALLING"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0008*RCALLING"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s,%s,%s,%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1],msg[2])
- # print("RCALLING:send data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
- # print("RCALLING:send data end:%s"%(data))
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*RCALLING]'
- print("RCALLING!!!!!!!!!!!!!")
-
-class AGTALK_ProtoCol(ProtoCol):#设备发起视频通话与app接听视频通话
- """"""
- TYPE = "AGTALK"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0006*AGTALK"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s,%d,%s]"%(str(MD5_SIGN),send_data,msg[0],msg[1])
- print("AGTALK:send data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*876226002021444*007B*AGTALK,0,01lqlyqzzQHpfwv5g7jFVC2H6Ha2tHFpMlfSm5sd2uo7o55JEcc=OVxewje6MjP0NgEODwsLDwkJCwkLCA0NDQ==,8762260020214441701226895]'
- # print("AGTALK!!!!!!!!!!!!!")
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_d = msg_tmp.split(',')
- call_state = int(msg_tmp_d[1])#返回是否可以视频通话
- if call_state == 0:#可正常通话
- if EventMesh.publish("get_video_state") != 0:
- # print("AGTALK!!!!!!!!!!!!!answer")
- tokens_data = msg_tmp_d[2]#会议id
- meet_id = msg_tmp_d[3]#会议id
- EventMesh.publish("set_vedio_meet_id", meet_id)#
- EventMesh.publish("set_vedio_tokens_data", tokens_data)#
- EventMesh.publish("open_vedio_infor")
-
- else:
- #不能视频通话
- tokens_data = msg_tmp_d[2]#token数据
- meet_id = msg_tmp_d[3]#会议id
- EventMesh.publish("set_vedio_meet_id", meet_id)#
- EventMesh.publish("set_vedio_tokens_data", tokens_data)#
- EventMesh.publish("video_newwork_reject_cb",None)#挂断视频通话
- # print("AGTALK no!!!!!!!!!!!!!")
-
- print("AGTALK!!!!!!!!!!!!!")
-
-
-class RTALK_ProtoCol(ProtoCol):#app拒接视频通话
- """"""
- TYPE = "RTALK"
- def send(self, event, msg):
-
- # [XT*334588000000156*0005*WLKEY]
- send_data = EventMesh.publish("get_new_pid")+"*%s*0005*RTALK"%(self.imei)
- MD5_SIGN = self.pack_MD5_head(send_data)
- data = "[%s%s,%d,%s]"%(str(MD5_SIGN),send_data,msg[0],msg[1])
- # print("AGTALK:send data:%s"%(data))
- # print("WLKEY!!!!!!!!!!!!!")
- # 通过socket发送到服务器端
- EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)
-
- def recv(self, event, msg):
- """
- @param event:
- @param msg: 接收到的下行数据
- """
- # b'[SZKW*867387060319166*000A*RTALK]'
- print("RTALK!!!!!!!!!!!!!")
- # [SZKW*876226002021444*003A*RTALK,3ef20e64f3abb84b27f7d764,8762260020214441701226522,1]'
- msg = msg[1:-1]
- msg_tmp = msg.decode('ascii')
- msg_tmp_d = msg_tmp.split(',')
- EventMesh.publish("app_rtalk_cb",1)
-
-
-
-
-class ProtoColResolver(object):
- def __init__(self):
- self.protocol_list = []
-
- def add_support(self, prot):
- self.protocol_list.append(prot)
- prot.initialization()
-
- def handler(self, data):
- # 这里接收数据
-
- EventMesh.debug_log("handler -> {}".format(data))
- # if data.startswith('Init;'):
- # data = data[5:]
- # EventMesh.publish(constants.EVENT.SET_KEY, {"value": ujson.loads(data)['KEY']})
-
- # elif data.startswith("Update;"):
- # data = data[7:]
- # EventMesh.publish(constants.PROTOCOL.H04_RECV, data)
- try:
- if len(data) > 0:
- #EventMesh.debug_log("handler:{}".format(len(data)))
- playload_data(data)
- except Exception as e:
- EventMesh.debug_log("handler:ERROR:")
- usys.print_exception(e)
- EventMesh.debug_log("handler:error data:{}".format(len(data)))
+import ujson\r
+import utime\r
+import EventMesh\r
+import constants\r
+from common import Abstract\r
+import uhashlib\r
+import ubinascii\r
+from misc import Power\r
+import audio\r
+from machine import Pin\r
+import ujson\r
+import ql_fs\r
+import dataCall\r
+import checkNet\r
+import net\r
+import usocket\r
+import osTimer\r
+\r
+import machine\r
+import urandom\r
+import _thread\r
+import usys\r
+import request\r
+import umqtt \r
+import modem\r
+import versions\r
+SHA256 = uhashlib.sha256\r
+import SecureData\r
+import log\r
+import ustruct\r
+\r
+def server_init(server_type = None):\r
+ #服务器选择1，防走丢，2大锤,3三基同创,4童信，5云米,6荣为 8:ds未知 dey.hinwatch. com:9968 9:183.62.239.121:31869 10:183.62.239.121:33461\r
+ if server_type == None:\r
+ server_type = 2\r
+ #EventMesh.debug_log("server_init:server_type:{}".format(server_type))\r
+ \r
+ d_server_addr = "api.xcloudtech.com"\r
+ d_server_port = 9000\r
+ d_md5_key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"\r
+ d_PID = "SZKW"\r
+ if server_type == 1:\r
+ pass\r
+ \r
+ elif server_type == 2:\r
+ # test.iot.socket.thisiot.com:9999\r
+ # iot.socket .thisiot.com:9999\r
+ # d_server_addr = "test.iot.socket.thisiot.com"\r
+ # d_server_port = 9999\r
+ # d_md5_key = "3JyCjsw4ryXKzjzudayY"\r
+ # d_PID = "qAELPTKmFanR4RHe"\r
+\r
+ d_server_addr = "iot.socket.thisiot.com"\r
+ d_server_port = 9999\r
+ d_md5_key = "SZYhyGhroQ3xFKFWZq1g"\r
+ d_PID = "oxLwDqcwJCtiPSRu"\r
+\r
+ elif server_type == 3:\r
+ d_server_addr = "tcp.zhihuixuexiao.com"\r
+ d_server_port = 2346\r
+ d_md5_key = ""\r
+ d_PID = "3G"\r
+ elif server_type == 4:\r
+ d_server_addr = "tcp.tx.kidxin.com"\r
+ d_server_port = 20500\r
+ elif server_type == 5:\r
+ d_server_addr = "device.miwitracker.com"\r
+ d_server_port = 8505\r
+ d_md5_key = ""\r
+ d_PID = "3G"\r
+ elif server_type == 6:\r
+ d_server_addr = "120.26.104.21"\r
+ d_server_port = 9968\r
+ d_md5_key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"\r
+ d_PID = "SZKW"\r
+ elif server_type == 7:\r
+ d_server_addr = "8.134.68.15"\r
+ d_server_port = 30346\r
+ d_PID="KnHnj1Cd5VxcO3Ft"\r
+ d_md5_key = "evxThVhMBmRNiQ1Twigw"\r
+ elif server_type == 99:\r
+ d_server_addr = "lab.xcloudtech.com"\r
+ d_server_port = 9000\r
+ elif server_type == 8:\r
+ d_server_addr = "dev.hxinwatch.com"\r
+ d_server_port = 9968\r
+ elif server_type == 9:\r
+ d_server_addr = "183.62.239.121"\r
+ d_server_port = 31869\r
+ elif server_type == 10:\r
+ d_server_addr = "183.62.239.121"\r
+ d_server_port = 33461\r
+\r
+ return [d_server_addr,d_server_port,d_md5_key,d_PID]\r
+from queue import Queue\r
+def unicode_to_utf8(src):\r
+ ref = 0xe08080\r
+ result = ref\r
+ \r
+ #取最后六位\r
+ a = src & 0x3f\r
+ \r
+ #将最后六位放在ref最后六位的空位置\r
+ result = result | a\r
+ src = src >> 6\r
+ \r
+ #取接下来的六位\r
+ a = src & 0x3f\r
+ \r
+ #放在ref对应的六个位置\r
+ result = result | (a << 8)\r
+\r
+ #保留最后四位\r
+ src = src >> 6\r
+\r
+ #放在ref对应的四个位置 \r
+ result = result | (src << 16)\r
+ return result\r
+\r
+def UnicodeHexStr_To_Utf8Str(str):\r
+ odata = 0\r
+\r
+ result = bytes() \r
+ su =str.upper()\r
+\r
+ i = 0\r
+ for c in su:\r
+ tmp=ord(c)\r
+ if tmp <= ord('9') :\r
+ odata = odata << 4\r
+ odata += tmp - ord('0')\r
+\r
+ elif ord('A') <= tmp <= ord('F'):\r
+ odata = odata << 4\r
+ odata += tmp - ord('A') + 10\r
+ if(i%4==3): #每2字节获取一个int，拿到转换后的unicode int\r
+ #print(odata.to_bytes(2, 'big'))\r
+ #result.append(odata)\r
+ if odata > 255:\r
+ tmp = unicode_to_utf8(odata)#拿到转换后的utf8 int\r
+ tmp2 = tmp.to_bytes(3, 'big') #转bytes\r
+ else :\r
+ tmp2 = odata.to_bytes(1, 'big') \r
+ #print("tmp2:{}".format(tmp2))\r
+ result = result + tmp2\r
+ odata = 0 \r
+ i+=1\r
+ return result.decode('utf-8') #返回utf8的str\r
+\r
+def gewu_init():\r
+ productKey = "cu1shld45y4hjr1L"\r
+ return productKey\r
+mqtt_state = 0\r
+def mqttsub_cb(topic, msg):\r
+ global mqtt_state\r
+ print("Subscribe Recv: Topic={},Msg={}".format(topic.decode(), msg.decode()))\r
+ jsload_data = ujson.loads(msg.decode())\r
+ print("jsload_data-{} type:{}".format(jsload_data,type(msg.decode())))\r
+ # jsload_data = {'data':'111','protocolType':'', 'host':'device.miwitracker.com', 'secretKey': 'bZld0ALsZTt15tKEZhOlLPgbsO75BLTP', 'port':8505, 'bid': '3G', 'extJsonStr': ''}\r
+ # ujson.loads(c)\r
+ # $sys/cu1shld45y4hjr1L/866610001011658/ext/regist\r
+ #data = {"messageId":"25","params":{"deviceSecret":"C1D75A63C0338978438E9197372FC698""}}\r
+ if "params" in jsload_data:\r
+ params_str = jsload_data["params"]\r
+ if "deviceSecret" in params_str:\r
+ str_tmp = params_str["deviceSecret"]\r
+ print(str_tmp)\r
+ EventMesh.publish("set_deviceSecret",str_tmp)\r
+ mqtt_state = 1\r
+def mqtterr_cb(error):\r
+ '''\r
+ 接收umqtt线程内异常的回调函数\r
+ '''\r
+ print("error!!!!!!!!!!!".format(error))\r
+\r
+def HMAC(k, m):\r
+ SHA1_BLOCK_SIZE = 64\r
+ KEY_BLOCK = k + (b'\0' * (SHA1_BLOCK_SIZE - len(k)))\r
+ KEY_INNER = bytes((x ^ 0x36) for x in KEY_BLOCK)\r
+ KEY_OUTER = bytes((x ^ 0x5C) for x in KEY_BLOCK)\r
+ inner_message = KEY_INNER + m\r
+ outer_message = KEY_OUTER + SHA256(inner_message).digest()\r
+ return SHA256(outer_message)\r
+\r
+\r
+def get_hmac_sha256(k, m):\r
+ data = HMAC(k, m).digest()\r
+ # print("HMAC(k, m).digest()：", data)\r
+ # print("HMAC(k, m).digest()：", ubinascii.hexlify(data))\r
+ hex_data = ubinascii.hexlify(data)\r
+ hex_data = hex_data.decode('ascii')\r
+ return hex_data\r
+\r
+def mqtt_client_pro_init():#一型一密\r
+ client = 0\r
+ \r
+ # 创建一个mqtt实例\r
+# \r
+ # {"productKey":"cu1r1rjjrjdhz0lx","deviceKey":"DD86000000001","deviceSecret":"93FEEC6D16D30E2B90FE0DBC2FFCDB14"} 设备基本信息\r
+ # hmac_sha256(deviceIddeviceKeyproductKey,deviceSecret) mqttclientId\r
+ deviceId = ""#"bOOSGN5FlXEjt15"\r
+ deviceKey = ''#"bOOSGN5FlXEjt15"\r
+ imei = EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ deviceId = str(imei)\r
+ deviceKey = str(imei)\r
+ productKey = gewu_init()\r
+ \r
+ EventMesh.publish("set_product_key",productKey)\r
+ data = "{}{}{}".format(deviceId,deviceKey,productKey)#需要用户定义产品是提供数据\r
+ # data = b"The data to encrypt"\r
+ # 密钥\r
+ productSecret = b"765fc66242616852209d1c57e51b0744" #765fc66242616852209d1c57e51b0744 ,productSecret\r
+\r
+ # {"productKey":"cu1shld45y4hjr1L","deviceKey":"bOOSGN5FlXEjt15","deviceSecret":"9234577490038E0949B800C243BF4321"}\r
+ checkpassword = get_hmac_sha256(productSecret,data)\r
+ # print(checkpassword)\r
+ # {deviceId}|{productKey}|{signMethod}|{authType}|{operator}；连接id格式\r
+ \r
+ Client_id = "{}|{}|0|1|0".format(deviceId,productKey) #\r
+ # print(Client_id)\r
+ server = "dmp-mqtts.cuiot.cn"#"dmp-mqtt.cuiot.cn"\r
+ port = 8883\r
+ # {deviceKey}|{productKey} mqttUsername\r
+ userName = "{}|{}".format(deviceKey,productKey)\r
+ userpassword = checkpassword\r
+ # print(userName)\r
+ # print(userpassword)\r
+ # client = umqtt.MQTTClient("866610001011658|cu1shld45y4hjr1L|0|1|0","dmp-mqtt.cuiot.cn", 1883, "866610001011658|cu1shld45y4hjr1L","675f6fbfb15a729bbc280273632ce3a96f8b38d4736fbaf888fe8a48fd7aee09")\r
+ # client = umqtt.MQTTClient("lxRXQayZ4poQz8G|cujg06l29iav591b|0|0|0","dmp-mqtt.cuiot.cn", 1883, "lxRXQayZ4poQz8G|cujg06l29iav591b","1f8c69d29afca0505d967066b39d84a5eb1e54302b87e337b405f99d029a9242")\r
+ client = umqtt.MQTTClient(Client_id,server, port, userName,"{}".format(userpassword),reconn=False,ssl=True)\r
+ # client = MqttClient(Client_id, server, port, userName,"{}".format(userpassword))\r
+ # 设置消息回调\r
+ client.set_callback(mqttsub_cb)\r
+ # 设置异常回调\r
+ client.error_register_cb(mqtterr_cb)\r
+ return client\r
+\r
+def mqtt_client_dev_init():#一机一密\r
+ client = 0\r
+ \r
+ # 创建一个mqtt实例\r
+# \r
+ # {"productKey":"cu1r1rjjrjdhz0lx","deviceKey":"DD86000000001","deviceSecret":"93FEEC6D16D30E2B90FE0DBC2FFCDB14"} 设备基本信息\r
+ # hmac_sha256(deviceIddeviceKeyproductKey,deviceSecret) mqttclientId\r
+ deviceId = '' #"bOOSGN5FlXEjt15"\r
+ deviceKey = ''#"bOOSGN5FlXEjt15"\r
+ imei = EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ deviceId = str(imei)\r
+ deviceKey = str(imei)\r
+ productKey = gewu_init()\r
+ data = "{}{}{}".format(deviceId,deviceKey,productKey)#需要用户定义产品是提供数据\r
+ # data = b"The data to encrypt"\r
+ # 密钥\r
+ deviceSecret_tmp = EventMesh.publish("get_deviceSecret")\r
+ subscribe_msg = deviceSecret_tmp.encode('ascii')\r
+ deviceSecret = subscribe_msg #765fc66242616852209d1c57e51b0744 ,productSecret\r
+ print(deviceSecret)\r
+\r
+ checkpassword = get_hmac_sha256(deviceSecret,data)\r
+ print(checkpassword)\r
+ # {deviceId}|{productKey}|{signMethod}|{authType}|{operator}；连接id格式\r
+ Client_id = "{}|{}|0|0|0".format(deviceId,productKey) # 860132060346475|cu1shld45y4hjr1L|0|0|0\r
+ server = "dmp-mqtts.cuiot.cn"#"dmp-mqtt.cuiot.cn"\r
+ port = 8883\r
+ # {deviceKey}|{productKey} mqttUsername\r
+ userName = "{}|{}".format(deviceKey,productKey)\r
+ userpassword = checkpassword\r
+\r
+ client = umqtt.MQTTClient(Client_id,server, port, userName,"{}".format(userpassword),reconn=False,ssl=True)\r
+ # client = MqttClient(Client_id, server, port, userName,"{}".format(userpassword))\r
+ # 设置消息回调\r
+ client.set_callback(mqttsub_cb)\r
+ # 设置异常回调\r
+ client.error_register_cb(mqtterr_cb)\r
+ return client\r
+\r
+ \r
+\r
+import uwebsocket\r
+import sim\r
+\r
+class WEB_CMD_ENUM:\r
+ POST_DEVICE_STATE_R_CMD = "post_device_state_R"\r
+ POST_DEVICE_STATE_S_CMD = "post_device_state_S"\r
+\r
+ POST_DEVICE_INFOR_R_CMD = "POST_DEVICE_INFOR_R_CMD"\r
+ POST_DEVICE_INFOR_S_CMD = "POST_DEVICE_INFOR_S_CMD"\r
+\r
+ POST_ALARM_R_CMD = "post_alarm_R"\r
+ POST_ALARM_S_CMD = "post_alarm_S"\r
+\r
+ FIND_DEVCE_R_CMD = "find_device_R"\r
+ FIND_DEVCE_S_CMD = "find_device_S"\r
+\r
+ ALARM_CONFIG_R_CMD = "alarm_config_R"\r
+ ALARM_CONFIG_S_CMD = "alarm_config_S"\r
+\r
+ ALARM_LIST_R_CMD = "alarm_list_R"\r
+ ALARM_LIST_S_CMD = "alarm_list_S"\r
+\r
+ UNBIND_DEV_R="unbind_dev_R"\r
+ UNBIND_DEV_S="unbind_dev_S"\r
+\r
+ DEVICE_SHAKE_STATE_R_CMD = "device_shake_state_R"\r
+ DEVICE_SHAKE_STATE_S_CMD = "device_shake_state_S"\r
+\r
+class IOT_socket_SendCmdManager(Abstract):\r
+ #\r
+ def __init__(self):\r
+ self.send_data = ""\r
+ self.time_tmp = 0\r
+ def post_processor_after_instantiation(self):\r
+ EventMesh.subscribe("GET_IOT_SEND_CMD", self.get_iot_send_cmd)\r
+ print("IOTSendCmdManager")\r
+ #调用：device_state=EventMesh.publish("GET_IOT_SEND_CMD",WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD)\r
+ # print("device_state{}".format(device_state))\r
+ def get_iot_send_cmd(self, event, msg):#获取准备发送的值\r
+ date_tmp = utime.localtime()\r
+ self.time_tmp = utime.mktime(date_tmp)\r
+ if msg == WEB_CMD_ENUM.POST_DEVICE_STATE_S_CMD:#设备VC状态\r
+ self.send_data = self.device_report_state_send_data()\r
+ return self.send_data\r
+ elif msg == WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD:#设备信息\r
+ self.send_data = self.device_information_send_data()\r
+ return self.send_data\r
+ elif msg == WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD:#聊天内容\r
+ self.send_data = self.device_information_send_data()\r
+ return self.send_data\r
+ \r
+ # 设备对话内容上报数据格式\r
+ def device_talk_send_data(self):\r
+ print("device_talk_send_data")\r
+ infor_send_data = {\r
+ "cmd":"chat_text",\r
+ "data":\r
+ {\r
+ "device_id":modem.getDevImei(),#设备号\r
+ "type":"req:请求说的话；res：响应的内容",\r
+ "text":"用户说话内容",\r
+ "createTime":"时间戳"\r
+ }\r
+ }\r
+ return infor_send_data\r
+ \r
+ # 设备信息上报数据格式\r
+ def device_information_send_data(self):\r
+ print("device_information_send_data")\r
+ battery_state = (EventMesh.publish("screen_get_battery"))[0]\r
+ battery = (EventMesh.publish("screen_get_battery"))[1]\r
+ if battery >= 100 or battery == None:\r
+ battery = 100\r
+ VC_TTS_volume = EventMesh.publish("get_storage_config","VC_TTS_volume")#音量配置\r
+ if VC_TTS_volume == None:\r
+ VC_TTS_volume =100\r
+ sourceVersion =versions.Build_Time\r
+ Timeversion ="JSWM-"+sourceVersion\r
+ infor_send_data = {\r
+ "data":{\r
+ "version":Timeversion,#版本号\r
+ "charge":battery_state,#0表示未充电，1表示充电中\r
+ "current_role_name":"",#当前音色的name\r
+ "volume":str(VC_TTS_volume),#百分比数值\r
+ "wifi_rssi":str(net.csqQueryPoll()//6),#wifi强弱：0，1，2，3，4，5。转成这几个梯度\r
+ "battery":str(battery),#电量\r
+ "device_id":modem.getDevImei(),#设备号\r
+ },\r
+ "cmd":"device_info"\r
+ }\r
+ return infor_send_data\r
+ \r
+ #设备上报VC状态\r
+ def device_report_state_send_data(self):\r
+ ai_status = EventMesh.publish("screen_get_ai")\r
+ if EventMesh.publish("get_VC_satrt_flag") == 1:#获取vc是否在运行\r
+ if ai_status < 6 :\r
+ target_status = "listening"\r
+ elif ai_status == 6:\r
+ target_status = "thinking"\r
+ elif ai_status >= 8:\r
+ target_status = "speaking"\r
+ else:\r
+ target_status = "idle"\r
+\r
+ device_report_data ={\r
+ "data":{\r
+ "device_id":modem.getDevImei(),\r
+ "state":target_status\r
+ },\r
+ "cmd":"chat_state"\r
+ }\r
+ return device_report_data\r
+def extract_target_number(json_str):\r
+ # 查找"target":"的起始位置\r
+ start_key = '"target":"'\r
+ start_idx = json_str.find(start_key)\r
+ if start_idx == -1:\r
+ print("未找到 target 字段")\r
+ return None # 未找到目标字段\r
+ \r
+ # 计算数字的起始位置（跳过"target":"）\r
+ num_start = start_idx + len(start_key)\r
+ \r
+ # 从数字起始位置开始，查找结束的双引号（"）\r
+ num_end = json_str.find('"', num_start)\r
+ if num_end == -1:\r
+ print("未找到数字的结束位置")\r
+ return None # 格式异常\r
+ \r
+ # 截取数字字符串（从num_start到num_end）\r
+ number_str = json_str[num_start:num_end]\r
+ \r
+ # 转换为整数（如果需要浮点数，可改为float(number_str)）\r
+ try:\r
+ return int(number_str)\r
+ except ValueError:\r
+ print("截取的内容不是有效数字")\r
+ return None\r
+ \r
+def playload_data(data):\r
+ print("data = {}".format(data))\r
+ if isinstance(data, bytes) == 0 :\r
+ print("data类型错误")\r
+ return\r
+\r
+ if data[0] != 0xff or data[1] !=0xfe:\r
+ print("data格式错误,重新登录")\r
+ EventMesh.publish("login_IOT")#登录IOT\r
+ return\r
+ payload_len_bytes = data [3:5]\r
+ payload_len = ustruct.unpack ('H', payload_len_bytes)[0]\r
+ # print ("解析到 Payload 长度：{} 字节".format(payload_len))\r
+\r
+ payload = data [5 : 5+ payload_len]\r
+ try:\r
+ json_str = payload.decode ('utf-8')\r
+ except UnicodeDecodeError:\r
+ try:\r
+ json_str = payload.decode ('gbk')\r
+ print ("提示：Payload 使用 GBK 编码")\r
+ except UnicodeDecodeError:\r
+ print ("Payload 解码失败")\r
+ return\r
+ # json_str = "\"" + json_str + "\""\r
+ if type(json_str) is str and len(json_str)>5:\r
+ print ("解析出的 JSON 字符串:{}".format(json_str) + "-"*50)\r
+ if "get_device_state" in json_str:\r
+ EventMesh.publish("send_device_information")#发送设备信息\r
+ EventMesh.publish("send_device_VC_state")#上传VC状态\r
+ print("get_device_state")\r
+ elif "find_device" in json_str:\r
+ EventMesh.publish("play_tts_single","我在这呀，我在这呀")\r
+ print("find_device")\r
+ elif "renew_device" in json_str:#更新对话模式 重启\r
+ EventMesh.publish("play_tts_single","更新配置中，设备将自动重启")\r
+ print("renew_device")\r
+ utime.sleep_ms(3000)\r
+ EventMesh.publish("Power_off")\r
+ elif "switch_volume" in json_str:\r
+ volume = int(extract_target_number(json_str))\r
+ print("switch_volume = {}".format(volume))\r
+ EventMesh.publish("update_volume",volume)\r
+ elif "switch_brightness" in json_str:\r
+ light = int(extract_target_number(json_str))//10\r
+ print("switch_brightness")\r
+ EventMesh.publish("set_brightness_level",light)\r
+ elif "setup_role" in json_str:\r
+ EventMesh.publish("play_tts_open","角色正在切换")\r
+ print("setup_role")\r
+ EventMesh.publish("load_screen", {"screen": "UI_ai"})#ai画面\r
+\r
+ \r
+ # data_dict = ujson.loads(json_str)\r
+ # if isinstance(data_dict, dict):\r
+ # #下面做小程序下发指令类型判断\r
+ # data = data_dict["cmd"]\r
+ # if data is "get_device_state":\r
+ # EventMesh.publish("send_device_information")#发送设备信息\r
+ # print("get_device_state")\r
+ # elif data is "find_device":\r
+ # EventMesh.publish("play_tts_single","我在这呀，我在这呀")\r
+ # print("find_device")\r
+ # else:\r
+ # print("JSON数据不是字典类型")\r
+\r
+ \r
+\r
+date_tmp = utime.localtime()\r
+time_tmp = utime.mktime(date_tmp)\r
+MAGIC = (0xfffe).to_bytes(2,"big")\r
+VERSION = (0x01).to_bytes(1,"big")#"03".encode('utf-8')\r
+TYPE = (0x03).to_bytes(1,"big")\r
+DATA_LEN = (0x00000000).to_bytes(4,"big")\r
+#magic+version+type+playload_len+playload\r
+def protocol_send_total_data(data):\r
+ MAGIC = (0xfffe).to_bytes(2,"big")\r
+ VERSION = (0x01).to_bytes(1,"big")#"03".encode('utf-8')\r
+ TYPE = (0x03).to_bytes(1,"big")\r
+ HR_JSON = ujson.dumps(data)\r
+ GPS_JSON_b = HR_JSON.encode('utf-8')\r
+ DATA_LEN = (len(HR_JSON)).to_bytes(4,"big")\r
+ heards_infor = b''\r
+ heards_infor = MAGIC+VERSION+TYPE+DATA_LEN+GPS_JSON_b\r
+ return heards_infor\r
+\r
+DEFIEN_HR_REPORT_TIME = 5*60\r
+DEFINE_TIME_COUNT = 5\r
+DEFIEN_LOCATION_REPORT_TIME = 5\r
+WEB_CONNECT_MAX_COUNT = 10 #默认重连次数\r
+\r
+PROJECT_NAME = "JSWM"\r
+PROJECT_VERSION = "1.0.0"\r
+checknet = checkNet.CheckNetwork(PROJECT_NAME, PROJECT_VERSION)\r
+# 设置日志输出级别\r
+log.basicConfig(level=log.INFO)\r
+socket_log = log.getLogger("SOCKET")\r
+class SockMangager(Abstract):\r
+ def __init__(self):\r
+ self.thread_buf_size = 8*1024\r
+ self.iot_soc_send_queue = Queue(100)\r
+ self.iot_protoclo_recv_id=None\r
+ self.connect_timer = osTimer() \r
+ self.connect_timer_count = 0\r
+ self.hr_report_timer = osTimer()\r
+ self.resolver = None\r
+ self.send_device_time = 0\r
+ self.vbat_buf = []\r
+ self.network_state = 0\r
+ self.socket_send_queue_id = None\r
+ self.bat_count = 0\r
+ self.reconnect_count = 0 #连续重连次数 默认十次 不过就不重连了 等下一个心跳重连\r
+ self._20S_timer = osTimer()\r
+ self._1scnt = 0\r
+ self._5M_timer = osTimer()\r
+ self._10Stimer = osTimer()\r
+ self.timer_id = 0\r
+ self.start_voice_flag = 0\r
+ self.iot_protocol_client = None\r
+ self.login_statu = 0#登陆状态\r
+ self.sock_lock = _thread.allocate_lock() # 初始化锁\r
+ #对话状态，一秒检查一次\r
+ self.last_data = None # 保存上一次的数据状态\r
+ self.current_data = None # 当前数据\r
+ EventMesh.subscribe("REPORT_ALARM_TO_IOT",self.report_alarm_to_iot)\r
+\r
+ def report_alarm_to_iot(self,event,msg):\r
+ EventMesh.publish(WEB_CMD_ENUM.POST_ALARM_S_CMD,msg)\r
+ pass\r
+ def usb_event_cb(self, state):\r
+ status = state\r
+ def post_processor_after_instantiation(self):\r
+ EventMesh.subscribe("CHANNEL_IOT_SEND",self.user_send)#发送数据的函数！！重要\r
+ EventMesh.subscribe("GET_IOT_PROTOCOL_CILENT",self.get_IOT_sock)\r
+ EventMesh.subscribe("close_socket_timer",self.close_socket_timer)\r
+ EventMesh.subscribe("connect_iot_socket",self.connect_iot_socket_cb)#使用socket连接iot平台\r
+ EventMesh.subscribe("login_IOT",self.login_IOT)#登录iot平台\r
+ EventMesh.subscribe("heart_IOT",self.heart_IOt)#心跳包\r
+ EventMesh.subscribe("send_device_information",self.send_device_information)#上报设备信息\r
+ EventMesh.subscribe("send_device_VC_state",self.send_device_VC_state)#上报VC状态\r
+ EventMesh.subscribe("send_unbind_dev_to_iot",self.send_unbind_dev_to_iot)#心跳包定时器开启\r
+ self.reconnect_count = 0\r
+ self.deviceReadState = ""\r
+ \r
+ # self.connect_timer.start(2000,0,self.iot_connect_timerCb)\r
+\r
+ def send_device_information(self,event,msg):\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD})#上报设备信息\r
+ def send_device_VC_state(self,event,msg):\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_STATE_S_CMD})#上报VC状态\r
+\r
+ def send_unbind_dev_to_iot(self,event,msg):\r
+ self._5M_timer.start(60000*5,1,self._5M_timer_cb)#更新信息\r
+ self._20S_timer.start(20000,1,self._20S_timer_cb)#重连\r
+ # self._10Stimer.start(50000,1,self._10S_timer_cb)\r
+ def _5M_timer_cb(self,*argc):\r
+ EventMesh.publish("heart_IOT")#开启IOT心跳包\r
+ EventMesh.publish("send_device_information")#发送设备信息\r
+ pass\r
+ \r
+ def initialization(self, *args):\r
+ pass\r
+ def connect_iot_socket_cb(self,event,msg):\r
+ self.connect_iot_socket()\r
+ def add_support_resolver(self, resolver):\r
+ self.resolver = resolver\r
+ def hr_report_event(self, *args, **kwargs):\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.hr_report_event_cb}) #self.connect_iot_websocket()\r
+ def hr_report_event_cb(self):\r
+ """电池平均值"""\r
+ temp = Power.getVbatt()\r
+ if self.bat_count < 10:\r
+ self.vbat_buf.append(temp)\r
+ self.bat_count += 1\r
+ else:\r
+ for i in range(9):\r
+ self.vbat_buf[i] = self.vbat_buf[i+1]\r
+ self.vbat_buf[9] = temp\r
+ curr_count = len(self.vbat_buf)\r
+ bat_total_value = 0\r
+ for i in range(curr_count):\r
+ bat_total_value += self.vbat_buf[i]\r
+ bat_total_value = bat_total_value//curr_count#一分钟更新一次电量 10个平均值\r
+ EventMesh.publish("AI_alarm_start") #检查是否有闹钟需要提醒\r
+ # self.alarm_test()\r
+ EventMesh.publish("set_curr_battery_level",bat_total_value)\r
+ # EventMesh.publish("publish_AI_btnInfo",{"func":self.hr_report_publish_event,"data":0}) \r
+ if self.send_device_time < DEFIEN_LOCATION_REPORT_TIME :\r
+ self.send_device_time+=DEFINE_TIME_COUNT\r
+ else:\r
+ device_state=EventMesh.publish("GET_IOT_SEND_CMD",WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD)\r
+ print("device_information{}".format(device_state))\r
+ # EventMesh.publish(WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD,device_state) #上报设备信息\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_packet_iot,"data":WEB_CMD_ENUM.POST_DEVICE_INFOR_S_CMD})#上报设备信息\r
+\r
+ def iot_connect_timerCb(self,*argc):\r
+ self.connect_iot_socket()\r
+\r
+ def connect_iot_socket(self):\r
+ if EventMesh.publish("get_voice_record_flag") == 1:\r
+ EventMesh.publish("stop_voice_record")\r
+ print("connect_iot_socket !!!!")\r
+ \r
+ stagecode, subcode = checknet.wait_network_connected(30)\r
+ if stagecode == 3 and subcode == 1:\r
+ socket_log.info('Network connection successful!')\r
+\r
+ if sim.getStatus() != 1 or self.start_voice_flag == 1:#网络正常\r
+ return\r
+ \r
+ if self.reconnect_count >= WEB_CONNECT_MAX_COUNT: #重连次数大于10次不在进重连只有下发心跳才重新连接\r
+ return\r
+ token = EventMesh.publish("get_dev_token")\r
+ # token = "9548860f973bffe39e1679db3110e223cb"\r
+ print("token:{}".format(token))\r
+ if self.iot_protocol_client is not None:\r
+ print("websocket已连接")\r
+ return\r
+ try:\r
+ if token != None:\r
+ self.connect_timer_count = 0\r
+ # #创建一个socket实例\r
+ # self.IOT_sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)\r
+ # try:\r
+ # #建立连接\r
+ # self.IOT_sock.connect(('iot.socket.thisiot.com', 7777))\r
+ # #设置为阻塞\r
+ # self.IOT_sock.setblocking(True)\r
+ # socket_log.info("IOT 连接建立")\r
+ # except Exception as e:\r
+ # print("再次连接")\r
+ # self.IOT_sock.connect(('iot.socket.thisiot.com', 7777))\r
+ # #设置为非阻塞\r
+ # self.IOT_sock.setblocking(False)\r
+ #三代iot websocket连接\r
+ url_t = "ws://wsiot-nocdn.raisound.com/ws-hub/dev/v1?bz-dt={}".format(token)\r
+ try:\r
+ self.iot_protocol_client=uwebsocket.Client.connect(url_t, debug=True)\r
+ print("iot3连接建立")\r
+ except Exception as e:\r
+ print("再次连接")\r
+ self.reconnect_count += 1\r
+ self.iot_protocol_client=uwebsocket.Client.connect(url_t, debug=True)\r
+ self.reconnect_count = 0\r
+ # print("self.socket_send_queue_id = {} , self.iot_protoclo_recv_id = {}".format(self.socket_send_queue_id,self.iot_protoclo_recv_id))\r
+ if self.socket_send_queue_id == None:\r
+ _thread.stack_size(self.thread_buf_size+8*1024) #_thread.stack_size(16*1024)\r
+ self.socket_send_queue_id = _thread.start_new_thread(self.socket_send_queue_thread, ())\r
+ _thread.stack_size(8*1024)\r
+\r
+ _thread.stack_size(self.thread_buf_size+8*1024)\r
+ self.iot_protoclo_recv_id = _thread.start_new_thread(self.iot_protocol_recv, ())\r
+ _thread.stack_size(8*1024)\r
+\r
+ socket_log.info("self.iot_protocol_client thread init!!!!!!!!!")\r
+\r
+\r
+ if self.iot_protocol_client is not None:\r
+ self.start_voice_flag = 1\r
+ else:\r
+ self.start_voice_flag = 0\r
+ \r
+ print("self.iot_protocol_client {} self.start_voice_flag:{}".format(self.iot_protocol_client,self.start_voice_flag))\r
+ if self.iot_protocol_client != None:\r
+ if self.timer_id == 0:\r
+ # self.hr_report_timer.start(DEFINE_TIME_COUNT*1000, 1, self.hr_report_event)\r
+ self.timer_id=1\r
+ else:\r
+ print("没有token!!!!!!!!!!")\r
+ self.connect_timer_count+=1\r
+ if self.connect_timer_count <= 10:\r
+ print("IOT重连定时器开启")\r
+ self.connect_timer.start(5000,0,self.iot_connect_timerCb)\r
+ pass\r
+ except Exception as e: \r
+ self.iot_protocol_client = None\r
+ print("connect_iot_socket error")\r
+ def heart_IOt(self,event,msg):\r
+ print("heart_IOT.....")\r
+ #Header\r
+ header = ustruct.pack('>H', 0xFFFE) # 使用大端模式\r
+ #Type\r
+ packet_type = ustruct.pack('B', 0x02)\r
+ #拼接\r
+ heart_packet = header + packet_type\r
+ EventMesh.publish("CHANNEL_IOT_SEND", heart_packet)\r
+ # print("心跳发送数据包：{}".format(heart_packet))\r
+\r
+ def send_packet_iot(self,data):#发送数据给iot,data为接口json数据\r
+ if sim.getStatus() != 1 or self.start_voice_flag == 1:#网络正常\r
+ return\r
+ #Header\r
+ header = ustruct.pack('>H', 0xFFFE) # 使用大端模式\r
+ #Type\r
+ packet_type = ustruct.pack('B', 0x03)\r
+ #字典转为json字符串\r
+ json_str = EventMesh.publish("GET_IOT_SEND_CMD", data)\r
+ json_str = ujson.dumps(json_str)\r
+ #字符串转为二进制数据Payload\r
+ payload = json_str.encode('utf-8')\r
+ #PayloadLen\r
+ payloadLen = ustruct.pack('H', len(payload))\r
+ #CRC16（2字节，基于pay字段计算）\r
+ crc = self.crc16(payload)\r
+ print("crc的长度为{}".format(len(crc)))\r
+ #拼接\r
+ full_packet = header + packet_type + payloadLen + payload+ crc\r
+ EventMesh.publish("CHANNEL_IOT_SEND", full_packet)\r
+ print("发送更新数据包：{}".format(full_packet))\r
+\r
+ def login_IOT(self,event,msg):\r
+ print("登录中")\r
+ #Header\r
+ header = ustruct.pack('>H', 0xFFFE) # 使用大端模式\r
+ #Type\r
+ packet_type = ustruct.pack('B', 0x00)\r
+ #设备ID\r
+ device_id_bytes = modem.getDevImei().encode('utf-8')[:20] # 转为字节并截断到20字节\r
+ device_id = bytes_ljust(device_id_bytes, 20, b'\x00')\r
+ #令牌\r
+ token_bytes = EventMesh.publish("get_dev_token").encode('utf-8')[:36] # 转为字节并截断\r
+ token_padded = bytes_ljust(token_bytes, 36, b'\x00')\r
+ #拼接\r
+ body = header + packet_type + device_id + token_padded\r
+ #CRC16（2字节，基于上述所有字段计算）\r
+ crc = self.crc16(body)\r
+ # 完整数据包\r
+ full_packet = body + crc\r
+ EventMesh.publish("CHANNEL_IOT_SEND", full_packet)\r
+ print("登录发送数据包：{}".format(full_packet))\r
+\r
+\r
+ def crc16(self, data):\r
+ """计算CRC16校验值（MODBUS RTU模式）"""\r
+ crc = 0xFFFF\r
+ for byte in data:\r
+ crc ^= byte\r
+ for _ in range(8):\r
+ if crc & 0x0001:\r
+ crc >>= 1\r
+ crc ^= 0xA001\r
+ else:\r
+ crc >>= 1\r
+ # 返回2字节小端模式\r
+ return ustruct.pack('<H', crc & 0xFFFF)\r
+ \r
+ def close_socket_timer(self,event,msg):\r
+ self._20S_timer.stop()\r
+ self._5M_timer.stop()\r
+ \r
+ def _20S_timer_cb(self,*argc):\r
+ self.current_data = EventMesh.publish("screen_get_ai") # 当前数据\r
+ if self.current_data is not self.last_data :\r
+ print("VC状态改变")\r
+ EventMesh.publish("send_device_VC_state")#上传VC状态\r
+ self.last_data = self.current_data # 保存上一次的数据状态\r
+ self._1scnt += 1\r
+ if self._1scnt >5:\r
+ # if self.iot_protocol_client is not None:\r
+ # if self.iot_protocol_client.getsocketsta() != 4:\r
+ # print("iot断线重连")\r
+ # self.login_statu = 0\r
+ # self.iot_close_therad()\r
+ # EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ # EventMesh.publish("login_IOT")#登录IOT\r
+ # else:\r
+ # if self.login_statu == 0:\r
+ # pass\r
+ # EventMesh.publish("login_IOT")#登录IOT\r
+ if self.iot_protocol_client is not None:\r
+ print("iot断线重连")\r
+ self.login_statu = 0\r
+ self.iot_close_therad()\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ EventMesh.publish("login_IOT")#登录IOT\r
+ \r
+ self._1scnt = 0\r
+ \r
+\r
+ def _10S_timer_cb(self,*argc):\r
+ print("主动断线")\r
+ self.iot_protocol_client.close()\r
+\r
+ def socket_send_queue_thread(self):\r
+ while True:\r
+ # with self.sock_lock: # 操作Socket前加锁\r
+ data = self.iot_soc_send_queue.get() \r
+ if data != None:\r
+ try: \r
+ if self.iot_protocol_client is not None:\r
+ self.iot_protocol_client.send(data)\r
+ # EventMesh.debug_log("发送线程") \r
+ self.reconnect_count = 0\r
+ else:\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ print("socket关闭退出send线程")\r
+ return\r
+ EventMesh.debug_log("socket:send data2 len:{}".format(len(data),self.iot_protocol_client)) \r
+ except Exception as e:\r
+ EventMesh.debug_log("socket:send error") \r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ break\r
+ \r
+\r
+ def iot_protocol_recv(self):\r
+ # 配置超时参数，单位：秒\r
+ RECV_TIMEOUT = 30*1000 # 30秒未收到数据则重连\r
+ last_recv_time = utime.time() # 初始化最后一次收到数据的时间\r
+ while True:\r
+ # 死循环接收数据\r
+ # with self.sock_lock: # 警告：不能加锁，不然会导致线程超长延时\r
+ try:\r
+ data = self.iot_protocol_client.recv()\r
+ if isinstance(data, bytes) and len(data)>10:\r
+ playload_data(data)\r
+ #fffe00010001xxxx\r
+ if isinstance(data, bytes) and len(data) == 8:#登录成功\r
+ target_bytes = b'\xff\xfe\x00\x01\x00\x01'\r
+ if data[:6] == target_bytes:\r
+ self.login_statu = 1#登录成功标志位修改\r
+ socket_log.info("IOT_recv = {} ,len = {}".format(self.bytes_to_hex(data),len(data)))\r
+ #检查socket是否已关闭\r
+ if self.iot_protocol_client == None:\r
+ print("socket关闭开启重连")\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket}) \r
+ return\r
+ #超时检查：如果超过设定时间未收到数据，触发重连\r
+ # print("接收时间差 = {}".format(utime.time() - last_recv_time))\r
+ if utime.time() - last_recv_time > RECV_TIMEOUT:\r
+ print("超过{}秒未收到数据，触发重连".format(RECV_TIMEOUT))\r
+ # 先关闭现有连接\r
+ if self.iot_protocol_client:\r
+ self.iot_protocol_client.close()\r
+ # 触发重连\r
+ EventMesh.publish("publish_AI_btnInfo", {"func": self.connect_iot_socket})\r
+ # 重连后短暂延迟再继续循环\r
+ utime.sleep(1)\r
+ # 重置超时计时器\r
+ last_recv_time = utime.time()\r
+ except Exception as e:\r
+ print("cli break")\r
+ print("异常是:{}".format(e))\r
+ # EventMesh.publish("connect_iot_websocket_cb")\r
+ last_recv_time = utime.time()\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket}) \r
+ break\r
+ self.iot_protoclo_recv_id =None\r
+ def decode_with_multiple_encodings(self, data):\r
+ #尝试多种常见编码格式解码，返回第一个成功的结果\r
+ # 常见编码格式列表（按优先级排序，根据实际场景调整）\r
+ encodings = ['utf-8', 'gbk', 'latin-1', 'utf-16', 'gb2312']\r
+ \r
+ for encoding in encodings:\r
+ try:\r
+ # 尝试用当前编码解码，errors='strict'严格模式（确保无乱码）\r
+ return data.decode(encoding, errors='strict')\r
+ except UnicodeDecodeError:\r
+ continue # 解码失败，尝试下一种编码\r
+ return None # 所有编码都失败\r
+ \r
+ # bytes转十六进制字符串\r
+ def bytes_to_hex(self, data):\r
+ #将bytes类型转换为十六进制字符串（如b'\x03\x01' -> '0301'）\r
+ hex_chars = '0123456789abcdef'\r
+ hex_str = ''\r
+ for b in data:\r
+ # 处理每个字节的高4位和低4位\r
+ hex_str += hex_chars[(b >> 4) & 0x0F] # 高4位\r
+ hex_str += hex_chars[b & 0x0F] # 低4位\r
+ return hex_str\r
+ \r
+ def iot_send_queue_close(self):\r
+ if self.socket_send_queue_id != None:\r
+ \r
+ if self.iot_soc_send_queue.empty()!=True:\r
+ self.iot_soc_send_queue.clear()\r
+ try:\r
+ _thread.stop_thread(self.socket_send_queue_id)\r
+ except Exception as e:\r
+ print("iot_send_queue_close !!!!!!!!")\r
+ print("iot_send_queue_close 1111!!!!!!!!")\r
+ self.socket_send_queue_id = None\r
+ \r
+ def iot_protoclo_recv_close_therad(self):\r
+ if self.iot_protoclo_recv_id != None:\r
+ try:\r
+ _thread.stop_thread(self.iot_protoclo_recv_id)\r
+ except Exception as e:\r
+ print("iot_protoclo_recv_close_therad !!!!!!!!")\r
+ self.iot_protoclo_recv_id = None\r
+ if self.iot_protocol_client != None:\r
+ try:\r
+ print("关闭socket")\r
+ self.iot_protocol_client.close()\r
+ except Exception as e: \r
+ print("关闭socket失败")\r
+ self.iot_protocol_client = None\r
+ \r
+\r
+ \r
+ def iot_close_therad(self):\r
+ try:\r
+ self.iot_send_queue_close()\r
+ except Exception as e:\r
+ print("iot_send_queue_close error!!!!!!!!")\r
+\r
+ try:\r
+ self.iot_protoclo_recv_close_therad()\r
+ except Exception as e:\r
+ print("iot_protoclo_recv_close_therad error!!!!!!!!")\r
+ self.start_voice_flag = 0\r
+ print("iot_close_therad")\r
+ \r
+ def get_IOT_sock(self,event,msg):\r
+ return self.iot_protocol_client\r
+ def user_send(self,event,data):\r
+ # EventMesh.debug_log("TCP:send data:{}".format(msg))\r
+ # EventMesh.debug_log("TCP:send data:{}".format(msg))\r
+ sim_state = sim.getStatus() \r
+ if sim.getStatus() != 1:#网络不正常\r
+ print("无 sim卡")\r
+ return\r
+ else :\r
+ try:\r
+ if self.start_voice_flag == 0: #如果关闭了就需要重新再连接\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket}) \r
+ return\r
+ if data != None:\r
+ if len(data) != 0:\r
+ self.iot_soc_send_queue.put(data)\r
+ # EventMesh.debug_log("self.socket_send_queue.put:success:{}".format(len(data)))\r
+ except Exception as e: \r
+ EventMesh.debug_log("self.socket_send_queue.put:ERROR:")\r
+ usys.print_exception(e) \r
+ \r
+ return\r
+ sim_state = sim.getStatus() \r
+ if sim_state != 1 or self.network_state == 0: #没sim，则不发送 ，没联网\r
+ return\r
+ else :\r
+ try:\r
+ if self.iot_protocol_client != None:\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.iot_protocol_send_cb,"data":data})\r
+ else:\r
+ print("reconnect1 {}".format(data))\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+\r
+ except Exception as e: \r
+ print("senc data err reconnect{}".format(data))\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ \r
+ def iot_protocol_send_cb(self,data):\r
+ try:\r
+ if data != None:\r
+ print("socket connect success:{} self.iot_protocol_client:{}".format(data,self.iot_protocol_client))\r
+ if self.iot_protocol_client != None:\r
+ self.iot_protocol_client.send(data)\r
+ self.reconnect_count = 0\r
+ print("socket send success")\r
+ else:\r
+ print("reconnect2 {}".format(data))\r
+ # EventMesh.publish("connect_iot_socket_cb")\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ except Exception as e:\r
+ print("发送失败 重新连接")\r
+ self.reconnect_count+=1\r
+ # EventMesh.publish("connect_iot_socket_cb")\r
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.connect_iot_socket})\r
+ \r
+def bytes_ljust(data, length, fill_byte=b'\x00'):\r
+ """\r
+ 手动实现bytes的ljust功能：将字节流填充到指定长度，不足部分用fill_byte在右侧填充\r
+ :param data: 原始字节流（bytes）\r
+ :param length: 目标长度（int）\r
+ :param fill_byte: 填充字节（默认空字节b'\x00'）\r
+ :return: 填充后的字节流（bytes）\r
+ """\r
+ if len(data) >= length:\r
+ # 若原始长度已超过目标长度，直接截断到指定长度\r
+ return data[:length]\r
+ else:\r
+ # 计算需要填充的长度，用fill_byte补齐\r
+ padding = fill_byte * (length - len(data))\r
+ return data + padding\r
+ \r
+class NetManager(Abstract):\r
+ THRESHOLD = 10\r
+\r
+ def __init__(self):\r
+ self.__data_call = dataCall\r
+ self.__net = net\r
+ self.check_net = checkNet.CheckNetwork("QuecPython_Helios_Framework", "this latest version")\r
+ EventMesh.subscribe("get_network_state", self.get_network_state)\r
+ self.network_state = 0\r
+\r
+ def post_processor_after_instantiation(self, *args, **kwargs):\r
+ count = 0\r
+ while True:\r
+ count += 1\r
+ if count > 5 :\r
+ return\r
+ data = dataCall.getInfo(1, 0)\r
+ EventMesh.debug_log("data call INFO {}".format(data))\r
+ if data[2][0]:\r
+ self.network_state = 1\r
+ break\r
+ utime.sleep(1)\r
+ self.__data_call.start(2, 0, "", "", "", 0)\r
+ self.__data_call.setCallback(self.__datacall_cb)\r
+\r
+ def __datacall_cb(self, args):\r
+ pdp = args[0]\r
+ nw_sta = args[1]\r
+ if nw_sta == 1:\r
+ self.network_state = 1\r
+ EventMesh.debug_log("*** network %d connected! ***" % pdp)\r
+\r
+ else:\r
+ self.network_state = 0\r
+ EventMesh.debug_log("*** network %d not connected! ***" % pdp)\r
+ \r
+ def get_network_state(self, topic, msg):\r
+ return self.network_state \r
+\r
+class ProtoCol(Abstract):\r
+ TYPE = ""\r
+ HEADER = "#@{}@#;"\r
+ SEPARATOR = ";"\r
+ END = ";" + chr(0x01)\r
+ #PID = "SZKW"\r
+ #PID = "qAELPTKmFanR4RHe"\r
+ md5_key = ''\r
+ PID = ''\r
+\r
+ def __init__(self):\r
+ self.content = None\r
+ self.check_sum = None\r
+ self.password = EventMesh.publish(constants.EVENT.GET_PASSWORD)\r
+ self.imei = EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ self.cid = EventMesh.publish(constants.EVENT.GET_CID)\r
+ self.imsi = EventMesh.publish(constants.EVENT.GET_IMSI)\r
+ self.key = EventMesh.publish(constants.EVENT.GET_KEY)\r
+ self.HEADER = self.HEADER.format(self.TYPE)\r
+\r
+ self.md5_key = ''\r
+ self.PID = ''\r
+ server_data = EventMesh.publish("get_new_key_pid")#获取pid和key\r
+ if server_data == None:\r
+ server_data = server_init()#如果获取的数据是None,就用默认的大锤key和pid\r
+ self.md5_key = server_data[2]\r
+ self.PID = server_data[3]\r
+ else:\r
+ self.md5_key = server_data[0]\r
+ self.PID = server_data[1]\r
+ \r
+ # EventMesh.debug_log("md5_key:--",self.md5_key,self.PID)\r
+ # ip_infor = {}\r
+ # ip_infor = EventMesh.publish("get_new_ip_com")\r
+ # if ip_infor != None:\r
+ # self.md5_key = ip_infor[2]\r
+ # EventMesh.debug_log("md5_key",self.md5_key)\r
+\r
+ def initialization(self, *args, **kwargs):\r
+ EventMesh.subscribe(self.TYPE + "_SEND", self.handler)\r
+ EventMesh.subscribe(self.TYPE + "_RECV", self.handler)\r
+ #EventMesh.debug_log("ProtoCol:{}".format(self.TYPE + "_SEND"))\r
+\r
+ def handler(self, event, msg):\r
+ #EventMesh.debug_log("ProtoCol:handler:{}".format(event))\r
+ self.password = EventMesh.publish(constants.EVENT.GET_PASSWORD)\r
+ self.imei = EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166" #EventMesh.publish(constants.EVENT.GET_IMEI)#"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI) #"867387060319166"#EventMesh.publish(constants.EVENT.GET_IMEI) #"867387060319166"#"867387060319188"#"867387060319177"#"867387060319166"#"860132060004322"#"867387060319166"#"860132060004322"#EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ self.cid = EventMesh.publish(constants.EVENT.GET_CID)\r
+ self.imsi = EventMesh.publish(constants.EVENT.GET_IMSI)\r
+ self.key = EventMesh.publish(constants.EVENT.GET_KEY)\r
+ if event.endswith("_SEND"):\r
+ self.send(event, msg)\r
+ else:\r
+ self.recv(event, msg)\r
+\r
+ def send(self, event, msg):\r
+ pass\r
+\r
+ def recv(self, event, msg):\r
+ pass\r
+\r
+ @staticmethod\r
+ def get_date():\r
+ return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])\r
+\r
+ @staticmethod\r
+ def get_time():\r
+ return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])\r
+\r
+ def calc_crc(self):\r
+ data = self.content\r
+ if not isinstance(data, bytes):\r
+ data = data.encode()\r
+ count = 0\r
+ for x in data:\r
+ count += x\r
+ self.check_sum = 100 - count % 100\r
+\r
+ def pack(self):\r
+ self.calc_crc()\r
+ return self.HEADER.encode() + self.content.encode() + self.SEPARATOR.encode() + int(self.check_sum).to_bytes(1,'little') + self.END.encode()\r
+ \r
+ def pack_MD5_head(self,data): \r
+ #key = "bZld0ALsZTt15tKEZhOlLPgbsO75BLTP"\r
+ self.md5_key=EventMesh.publish("get_new_key")\r
+ if self.md5_key == None:\r
+ self.md5_key = server_init[2]\r
+\r
+ if(self.md5_key == ""):\r
+ return ""\r
+ MD5_head = ""\r
+ hash_obj = uhashlib.md5(data+self.md5_key)\r
+ res = hash_obj.digest()\r
+\r
+ # 转成十六进制表示\r
+ MD5_head = ubinascii.hexlify(res)\r
+ MD5_head = MD5_head.decode('ascii')\r
+ #EventMesh.debug_log("data+self.md5_key:{}".format(data+self.md5_key))\r
+ #EventMesh.debug_log(res)\r
+ #EventMesh.debug_log(MD5_head)\r
+ return MD5_head\r
+#查找设备\r
+class IOT_FindDeviceProtoCol(ProtoCol):\r
+ """find_device"""\r
+ TYPE = "find_device"\r
+\r
+ def send(self, event, msg):\r
+ # print("send locafind_devicetion{}".format(msg))\r
+ # 通过websocket发送到服务器端\r
+ date_tmp = utime.localtime()\r
+ time_tmp = utime.mktime(date_tmp)\r
+ find_device = {\r
+ "cmd":"dispatch_rest",\r
+ "ts":time_tmp,\r
+ "msg":"消息收到响应",\r
+ "data":{\r
+ "cmd":"find_device",\r
+ "rest":"success",\r
+ "msg":"收到查找设备指令"\r
+ }\r
+ }\r
+ send_data = b''\r
+ send_data = protocol_send_total_data(find_device)\r
+ print("send_data find_device{}".format(send_data))\r
+ EventMesh.publish("CHANNEL_IOT_SEND", send_data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event:定位信息下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ alarm_TTS_str="在这呢"\r
+ base_sentence = "{}".format(alarm_TTS_str)\r
+ repeat_sentence = (base_sentence + ",") * 3 # 重复5次并加逗号分隔\r
+ final_sentence = repeat_sentence.rstrip(",")\r
+ \r
+ EventMesh.publish("play_tts",[final_sentence,1]) #播放tts闹钟文本内容\r
+ print("recv find_device{}".format(msg))\r
+ EventMesh.publish(WEB_CMD_ENUM.FIND_DEVCE_S_CMD)\r
+\r
+#上报设备VC状态 \r
+class IOT_post_device_stateProtoCol(ProtoCol):\r
+ """post_device_state"""\r
+ TYPE = "post_device_state"\r
+\r
+ def send(self, event, msg):\r
+ print("send post_device_state{}".format(msg))\r
+ # 通过websocket发送到服务器端\r
+ \r
+ send_data = b''\r
+ send_data = protocol_send_total_data(msg)\r
+ EventMesh.publish("CHANNEL_IOT_SEND",send_data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event:mpost_device_state\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # locate_now = {\r
+ # "cmd":"locate_duration",\r
+ # "ts":1738283829,\r
+ # "msg":"下发定位周期",\r
+ # "data":300,0表示关\r
+ # }\r
+ print("send post_device_state{}".format(msg))\r
+class LK_ProtoCol(ProtoCol):\r
+ """链路保持"""\r
+ TYPE = "LK"\r
+\r
+ def send(self, event, msg):\r
+ #[SZKW*334588000000156*0002*LK]\r
+ #EventMesh.debug_log('self.imei:%s'%(self.imei))\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0002*LK"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("LK_ProtoCol:send:%s"%(data))\r
+\r
+ \r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: LK成功\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ EventMesh.debug_log("LK_ProtoCol:recv:%s"%(msg))\r
+ EventMesh.publish(constants.PROTOCOL.PING_SEND)\r
+ EventMesh.publish(constants.PROTOCOL.KA_SEND)\r
+ EventMesh.publish(constants.PROTOCOL.TIME_SEND)\r
+\r
+ EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始UD定位\r
+ EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.WT_SEND) #开始WT定位\r
+ if EventMesh.model == 'D15':\r
+ EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND)\r
+\r
+class PING_ProtoCol(ProtoCol):\r
+ """获取绑定状态"""\r
+ TYPE = "PING"\r
+\r
+ def send(self, event, msg):\r
+ #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0004*PING"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("PING_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: PING\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ #EventMesh.debug_log("PING_ProtoCol:recv:%s"%(msg)) \r
+ data_tmp = msg.decode('ascii') \r
+ data_tmp = data_tmp.split(']')[0] #去掉] \r
+ EventMesh.publish(constants.EVENT.SET_PING, data_tmp.split(',')[1])\r
+ if EventMesh.model == 'D15':\r
+ EventMesh.publish(constants.PROTOCOL.JPREG_SEND) \r
+ EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND)\r
+\r
+class KA_ProtoCol(ProtoCol):\r
+ """心跳"""\r
+ TYPE = "KA"\r
+ count = 0\r
+ roll_count = 0\r
+ def send(self, event, msg):\r
+ #"{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])\r
+ #[XT*YYYYYYYYYYYYYYY*LEN*KA,日期，步数,翻滚次数,电量百分数,车载里程数(km)] 实例:[XT*334588000000156*0014*KA,120414,50,100,100,100.12]\r
+ date = "{:04d}{:02d}{:02d}".format(*utime.localtime()[0:3])\r
+ date = date[2:]\r
+ #EventMesh.debug_log("date:",date)\r
+ #步数\r
+ old_step = 0\r
+ step = 0\r
+ step = EventMesh.publish("get_old_step_value")\r
+ if step != None:\r
+ if step != 0:\r
+ read_data = EventMesh.publish("get_storage_config","old_step_new")\r
+ if read_data != None:\r
+ old_step = read_data\r
+ \r
+ if old_step != step:\r
+ # EventMesh.debug_log("old_step:send:%d %d"%(old_step,step))\r
+ EventMesh.publish("set_storage_config",["old_step_new",step+10])\r
+ EventMesh.publish("set_storage_config",["old_step_new",step])\r
+\r
+ old_step = step\r
+ # step = EventMesh.publish(constants.EVENT.GET_STEP)[0]\r
+ # 电池电量百分比 \r
+ \r
+ bat_tmp = EventMesh.publish("screen_get_battery")\r
+ sleep_time = EventMesh.publish("get_storage_config","sleep_time")\r
+ if sleep_time != None:\r
+ if len(sleep_time) != 0:\r
+ hour = utime.localtime()[3]\r
+ min = utime.localtime()[4]\r
+ cur_time = hour*60+min\r
+ start_hour = int(sleep_time["start_hour"])\r
+ start_min = int(sleep_time["start_min"])\r
+ start_total = start_hour*60+start_min\r
+\r
+ end_hour = int(sleep_time["end_hour"])\r
+ end_min = int(sleep_time["end_min"])\r
+ end_total = end_hour*60+end_min\r
+ # EventMesh.debug_log("ka roll_:",hour,min,cur_time,start_total,end_total)\r
+ if cur_time >= start_total and cur_time <= end_total:\r
+ self.roll_count = int(hour)\r
+ if self.roll_count == 0:\r
+ self.roll_count+=1\r
+ else:\r
+ self.roll_count = 0\r
+ else:\r
+ self.roll_count = 0\r
+ else:\r
+ self.roll_count = 0\r
+ hour = utime.localtime()[3]\r
+ min = utime.localtime()[4]\r
+ EventMesh.txt_log("ka step:{} hour:{} min:{}".format(step,hour,min))\r
+ \r
+ battery_caption = bat_tmp[1]\r
+ send_data = "KA,%s,%d,%d,%d"%(date,step,self.roll_count,battery_caption)\r
+ send_len = len(send_data)\r
+\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"KA")\r
+\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("KA_ProtoCol:send:%s"%(data))\r
+\r
+ \r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: PING\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ #EventMesh.debug_log("KA_ProtoCol:recv:%s"%(msg)) \r
+ \r
+class UD_ProtoCol(ProtoCol):\r
+ """位置信息"""\r
+ TYPE = "UD"\r
+ UD_count = 0#每6次定位获取一次天气数据\r
+ def send(self, event, msg):\r
+ #EventMesh.debug_log("UD:send:%s"%(msg)) \r
+ #"{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])\r
+ #[6f62cfc40fc50173f9a7b21e87be3424IS*861217001020120*00f6*UD,220726,211210,A,22.649529,N,114.119165,E,0.28,137.4,100.0,8,24,63,119,0,00000000,2,1,460,11,30472,125667122,24,30472,218944048,19,4,\r
+ # wifi0,34:93:44:01:28:b9,-74,wifi1,34:20:03:96:35:ad,-78,wifi2,ea:b5:7b:e8:56:54,-80,wifi3,c4:49:bb:d4:d9:78,-88]\r
+ \r
+ \r
+ self.UD_count+=1\r
+ #每6次定位获取一次天气数据\r
+ if self.UD_count>=6:\r
+ self.UD_count = 0\r
+ EventMesh.publish(constants.PROTOCOL.WT_SEND,msg)\r
+\r
+ send_data ="UD,"+msg\r
+ send_len = len(send_data)\r
+ #wt_data = "%s"%(send_data)\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"UD")\r
+ \r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("{}".format(data))\r
+ # wt_data = EventMesh.publish("get_weather_data")\r
+ # # #如果没有天气数据，则获取天气数据\r
+ # if wt_data != None or wt_data[0] == None :\r
+ # \r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+ if EventMesh.platform == "gewu":\r
+ if(msg != ""):\r
+ client = EventMesh.publish("get_mqtt_dev_connect_state")\r
+ if client != 0:\r
+ mqtt_connect = -1\r
+ try:\r
+ mqtt_connect = client.connect()\r
+ except Exception as e:\r
+ print(e)\r
+ mqtt_connect = -1\r
+ print("mqtt_connect:{}".format(mqtt_connect))\r
+ if mqtt_connect == 0:\r
+ # 订阅主题\r
+ get_device_id = EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ get_deviceKey = EventMesh.publish(constants.EVENT.GET_IMEI)\r
+ get_productKey = gewu_init()\r
+ #$sys/{productKey}/{deviceKey}/ext/regist\r
+ event_msg = "$sys/{}/{}/event/pub_reply".format(get_productKey,get_deviceKey)\r
+ # client_msg = "$sys/cu1shld45y4hjr1L/866610001011658/ext/regist"\r
+ subscribe_msg = event_msg.encode('ascii')\r
+\r
+ client.subscribe(subscribe_msg,0)#订阅事件消息消息主题\r
+ print("Connected to dmp-mqtt.cuiot.cn, subscribed to /public/TEST/quecpython topic")\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ longitude = float(msg_tmp[3])\r
+ latitude = float(msg_tmp[5])\r
+ date_tmp = utime.localtime()\r
+ time_tmp = utime.mktime(date_tmp)#需要转换成毫秒级别\r
+ updataTime = "{}".format(time_tmp*1000)\r
+ data_info = {\r
+ "messageId":"0",\r
+ "params": {\r
+ "key":"location",\r
+ "info": [\r
+ {\r
+ "key":"longitude",\r
+ "value":longitude\r
+ },\r
+ {\r
+ "key":"latitude",\r
+ "value":latitude\r
+ },\r
+ {\r
+ "key":"UpdateTime",\r
+ "value":updataTime\r
+ }\r
+ ]\r
+ }\r
+ }\r
+ data_json = ujson.dumps(data_info) \r
+ event_pub_msg = "$sys/{}/{}/event/pub".format(get_productKey,get_deviceKey)\r
+ pub_msg = event_pub_msg.encode('ascii')\r
+ client.publish(pub_msg,data_json,0)#publis主题内容\r
+\r
+ print("Publish topic: /public/TEST/quecpython758, msg: my name is Quecpython")\r
+\r
+ \r
+\r
+ def recv(self, event, msg):\r
+ pass\r
+ # EventMesh.debug_log("UD_ProtoCol:recv:%s"%(msg)) \r
+\r
+class CR_ProtoCol(ProtoCol):\r
+ """立即定位"""\r
+ TYPE = "CR"\r
+\r
+ def send(self, event, msg):\r
+ #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0002*CR"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("CR_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: PING\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ EventMesh.publish(constants.PROTOCOL.CR_SEND)\r
+ EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始ud定位\r
+ #EventMesh.debug_log("CR_ProtoCol:recv:%s"%(msg)) \r
+\r
+class AL_ProtoCol(ProtoCol):\r
+ """报警数据上报"""\r
+ TYPE = "AL"\r
+ timer_repetition_send = None\r
+ repetition_queue = None\r
+\r
+ def send(self, event, msg):\r
+ if EventMesh.platform != "gewu": \r
+ if self.timer_repetition_send == None:\r
+ self.timer_repetition_send = osTimer()\r
+ if self.repetition_queue == None:\r
+ self.repetition_queue = Queue(100)\r
+ \r
+\r
+ send_data ="AL,"+msg\r
+ send_len = len(send_data)\r
+ #wt_data = "%s"%(send_data)\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,send_data)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,send_len,"AL")\r
+ \r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("AL_ProtoCol:send:{}".format(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+ if EventMesh.platform != "gewu":\r
+ self.repetition_queue.put(data)#发送入队\r
+ self.timer_repetition_send.start(10000, 1, self.repetition_timer_cb)\r
+ EventMesh.publish("set_dev_state",0)\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: PING\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ #EventMesh.publish(constants.PROTOCOL.CR_SEND)\r
+ #EventMesh.publish(constants.EVENT.START_LOCATION,constants.PROTOCOL.UD_SEND) #开始ud定位\r
+ # print("报警数据上报:recv:%s"%(msg)) \r
+ EventMesh.debug_log("报警数据上报:recv:{}".format(msg)) \r
+ # \r
+ if EventMesh.platform != "gewu": \r
+ if self.repetition_queue.empty() == False:\r
+ self.repetition_queue.get()#出队\r
+ else:\r
+ self.timer_repetition_send.stop()\r
+\r
+ def repetition_timer_cb(self, *args, **kwargs):#每隔10秒发送一次\r
+ if self.repetition_queue.empty() == False:\r
+ data = self.repetition_queue.get()#出队\r
+ self.repetition_queue.put(data)#发送入队\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+ else:\r
+ self.timer_repetition_send.stop()\r
+\r
+class FIND_ProtoCol(ProtoCol):\r
+ """查找设备"""\r
+ TYPE = "FIND"\r
+\r
+ def send(self, event, msg):\r
+ #[SZKWT*YYYYYYYYYYYYYYY*LEN*PING]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0004*FIND"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("FIND_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: FIND,播放铃声\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ EventMesh.publish(constants.PROTOCOL.FIND_SEND)\r
+ # a = audio.Audio(0)\r
+ # a.set_pa(Pin.GPIO29)\r
+ # a.setVolume(10)\r
+ # a.play(1, 1, 'E:/audio_find_haixiu.mp3') #文件名前面要加上路径\r
+ \r
+ # EventMesh.publish("load_screen", {"screen": "FIND"})\r
+ EventMesh.publish("OPEN_FIND_WATCH")#\r
+ #EventMesh.debug_log("FIND_ProtoCol:recv:%s"%(msg)) \r
+\r
+class POWEROFF_ProtoCol(ProtoCol):\r
+ """关机"""\r
+ TYPE = "POWEROFF"\r
+\r
+ def send(self, event, msg):\r
+ # [SZKW*867387060319491*0008*POWEROFF]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*POWEROFF"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: POWEROFF关机\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ EventMesh.publish(constants.PROTOCOL.POWEROFF_SEND)\r
+ #EventMesh.debug_log("POWEROFF_ProtoCol:recv:%s"%(msg))\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("open_power_on", 2)# #远程关机\r
+ \r
+class PHL_ProtoCol(ProtoCol):\r
+ """电话本同步"""\r
+ TYPE = "PHL"\r
+\r
+\r
+ def send(self, event, msg):\r
+ # [SZKW*867387060319491*0008*PHL]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0003*PHL"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #EventMesh.debug_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: 电话本同步\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ msg = msg[1:-1]\r
+ # EventMesh.debug_log("phonebook:msg:%s\r\n"%msg)\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ # EventMesh.debug_log("phonebook:len:{}\r\n data:{}".format(len(msg_tmp),msg_tmp))\r
+\r
+ phonebook = {}\r
+ msg_tmp = msg_tmp[1:]\r
+ \r
+ j = 0\r
+ i = 0\r
+ phonebook_oldtmp = {}\r
+ # 0 1 2 3\r
+ for phonebook_tmp in msg_tmp: \r
+ j+=1\r
+ # EventMesh.debug_log("phonebook_tmp:{} len:{}".format(phonebook_tmp,len(phonebook_tmp)))\r
+\r
+ if (j%2) == 0:\r
+ i+=1\r
+ if len(phonebook_tmp) != 0:\r
+ phonebook_name = UnicodeHexStr_To_Utf8Str(phonebook_tmp)\r
+ phonebook_name = "{}:{}".format("%03d"%i,phonebook_name) \r
+ phonebook[phonebook_name] = phonebook_oldtmp\r
+ \r
+ phonebook_oldtmp = phonebook_tmp\r
+ # EventMesh.debug_log("phonebook_oldtmp!!!:{}".format(str(phonebook_oldtmp)))\r
+ # EventMesh.debug_log("phonebook!!!:{}".format(str(phonebook)))\r
+ with open("/usr/static/storage_file/phonebook.json","w",encoding="utf-8") as fd:\r
+ ujson.dump(phonebook,fd)\r
+ EventMesh.debug_log("创建电话簿")\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.PHL_SEND)\r
+ EventMesh.publish("set_phonebook_list",[1,phonebook])\r
+ EventMesh.publish("contact_updata_list_show")\r
+\r
+ \r
+class WT_ProtoCol(ProtoCol):\r
+ """天气数据"""\r
+ TYPE = "WT"\r
+ WT_T = 0\r
+\r
+ def send(self, event, msg):\r
+ # [SZKW*867387060319491*0008*WT]\r
+ # if self.WT_T != 0:\r
+ # tmp_WT = \r
+ if(msg != ""):\r
+ msg_tmp = "WT," + msg\r
+ data_len = len(msg_tmp)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*WT"%(self.imei,data_len)\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,data_len,msg_tmp)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("WT_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+ \r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: T天气温度数据下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'SZKW*860132060004322*0035*WT,23-04-06,14:41:06,b6e0d4c6,1,27,-1,40,6DF157335E02'\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split('WT,')\r
+ # EventMesh.debug_log("phonebook:len:{}\r\n data:{}".format(len(msg_tmp),msg_tmp))\r
+ msg_tmp = str(msg_tmp[1])\r
+\r
+ # EventMesh.debug_log("msg_tmp :%s"%(msg_tmp))\r
+\r
+ msg_date = msg_tmp.split(',')[0]\r
+\r
+ msg_time = msg_tmp.split(',')[1]\r
+ msg_weather_content = msg_tmp.split(',')[2]\r
+ msg_type = msg_tmp.split(',')[3]\r
+ msg_temp = msg_tmp.split(',')[4]\r
+ msg_min_temp = msg_tmp.split(',')[5]\r
+ msg_max_temp = msg_tmp.split(',')[6]\r
+ msg_city = msg_tmp.split(',')[7]\r
+\r
+ msg_city = UnicodeHexStr_To_Utf8Str(msg_city)\r
+ msg_weather_content = UnicodeHexStr_To_Utf8Str(msg_weather_content)\r
+ # EventMesh.debug_log("msg_date:{} msg_time:{} msg_weather_content:{} msg_type:{} msg_temp:{} msg_min_temp:{} msg_max_temp:{} msg_city:{}".format(msg_date,msg_time,\\r
+ # msg_weather_content,msg_type,msg_temp,msg_min_temp,msg_max_temp,msg_city))\r
+ EventMesh.debug_log("WT_ProtoCol RECV msg:%s"%(msg))\r
+\r
+ EventMesh.publish("set_weather_data",[msg_date,msg_time,msg_weather_content,msg_type,msg_temp,msg_min_temp,msg_max_temp,msg_city,1])\r
+ EventMesh.publish("updata_weather_show")\r
+class REMIND_ProtoCol(ProtoCol):#普通闹钟\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND]\r
+ """\r
+ TYPE = "REMIND"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*REMIND"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_new = str(msg_tmp.split('REMIND,')[1])\r
+ msg_tmp_data = str(msg_tmp.split('REMIND')[1])\r
+ count = 0\r
+ for i in str(msg_tmp_data):\r
+ # print("i",i)\r
+ if i == ",":\r
+ count+=1\r
+ \r
+ normal_alarm_save = []\r
+ # # ("handler -> b'[SZKW*860132060346475*001C*REMIND,08:00-1-1,,]'",)\r
+ # b'[SZKW*860132060346475*001B*REMIND,08:00-1-1,,]'",)\r
+ # medicine_alarmday = str(msg_data[4])\r
+ # alarmday=[]\r
+ alarm_day = []\r
+ alarm_switch = 0\r
+\r
+ print("count",count,msg_tmp_new)\r
+ if count >= 3:\r
+ count = 3\r
+ for i in range(0,count):#默认是三个时间多了也不保存\r
+ alarm_day = []\r
+ alarm_data = str(msg_tmp_new.split(',')[i])\r
+ # print("i",i,sleep_data)\r
+ if len(alarm_data) != 0:\r
+ b = alarm_data.find('-')\r
+ if b != -1:\r
+ alarm_time = alarm_data.split('-')[0]#-作为分隔符\r
+ alarm_switch = int(alarm_data.split('-')[1])#开关\r
+ alarm_repeat = int(alarm_data.split('-')[2])#是单次还是每天 还是自定义\r
+\r
+ alarm_hour = int(alarm_time.split(":")[0])#时间\r
+ alarm_min = int(alarm_time.split(":")[1])#冒号分隔时间 时 分\r
+ \r
+ \r
+ if alarm_repeat == 2:#每一天\r
+ alarm_day = [0,1,2,3,4,5,6]\r
+ elif alarm_repeat == 3:#自定义\r
+ alarm_day_tmp = alarm_data.split('-')[3]#-作为分隔符\r
+ if len(str(alarm_day_tmp)) != 0:\r
+ for i in range(0,7):\r
+ if alarm_day_tmp[i] != '0':\r
+ alarm_day.append(i)\r
+ else:#单次 1\r
+ alarm_day=[] \r
+ if alarm_switch != 0:\r
+ normal_alarm_save.append({"hour":alarm_hour,"min":alarm_min,"day":alarm_day,"enable":alarm_switch})\r
+ \r
+ EventMesh.publish("set_storage_config",["normal_alarm",normal_alarm_save])\r
+ # normal_alarm = EventMesh.publish("get_storage_config","normal_alarm")\r
+\r
+ # EventMesh.debug_log("recv REMIND_SEND:{} normal_alarm ;{}".format(msg,normal_alarm))\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.REMIND_SEND) \r
+ EventMesh.publish("clear_normal_alarm")\r
+\r
+class HRSTART_ProtoCol(ProtoCol):\r
+ """心率频率数据"""\r
+ TYPE = "hrtstart"\r
+\r
+\r
+ def send(self, event, msg):\r
+ # [SZKW*867387060319491*0008*hrtstart]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*hrtstart"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("HRSTART_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 心率数据下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'SZKW*860132060004322*0035*REMIND,23-04-06,14:41:06,b6e0d4c6,1,27,-1,40,6DF157335E02'\r
+ # EventMesh.debug_log("REMIND_ProtoCol RECV msg:%s"%(msg))\r
+ # HRSTART_ProtoCol RECV msg:b'SZKW*860132060004322*000D*hrtstart,7200' msg_:7200\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+ EventMesh.debug_log("HRSTART_ProtoCol RECV msg:{} msg_:{}".format(msg,msg_tmp))\r
+ hrTotal = int(msg_tmp)\r
+ if hrTotal == 1:#单次测量\r
+ EventMesh.debug_log("HRSTART_ 2".format(hrTotal))\r
+ get_hr_state = EventMesh.publish("get_hr_state")\r
+ get_spo2_state = EventMesh.publish("get_spo2_state")\r
+ get_bp_state = EventMesh.publish("get_bp_state")\r
+ get_bg_state = EventMesh.publish("get_bg_state")\r
+ # if (get_hr_state == 3 ) or (get_spo2_state == 0 and get_hr_state == 0):#只要两个不在测量 单次优先级最低\r
+ if (get_spo2_state == 0 and get_hr_state == 0 and get_bg_state == 0 and get_bp_state == 0):\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("set_hr_state",3)#3代表单次测量\r
+ pass\r
+ else:\r
+ if hrTotal > 0 and hrTotal <= 300:\r
+ hrTotal = 300\r
+ elif hrTotal >= 65536:\r
+ hrTotal = 65536\r
+ EventMesh.debug_log("HRSTART_ 3".format(hrTotal))\r
+ on = 0\r
+ if hrTotal != 0:\r
+ on = 1\r
+ EventMesh.publish("set_time_hr",[on,hrTotal])\r
+\r
+\r
+ EventMesh.publish(constants.PROTOCOL.HRTSTART_SEND)\r
+\r
+class HEART_ProtoCol(ProtoCol):\r
+ """心率数据"""\r
+ TYPE = "heart"\r
+\r
+\r
+ def send(self, event, msg):\r
+ # [SZKW*334588000000156*len*heart,x]\r
+ # EventMesh.debug_log("HEART:send:{}".format(msg))\r
+ len_size = len(str(msg))+len("heart,")\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*heart"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"heart")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)\r
+ # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 心率数据下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")\r
+ #EventMesh.publish(constants.PROTOCOL.HEART_SEND)\r
+class OXYGEN_ProtoCol(ProtoCol):\r
+ """上传血氧测试数据"""\r
+ TYPE = "oxygen"\r
+ def send(self, event, msg):\r
+ # [SZKW*334588000000156*len*heart,x]\r
+ # EventMesh.debug_log("oxstart:send:{}".format(msg))\r
+ len_size = len(str(msg))+len("oxygen,")\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*oxygen"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"oxygen")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)\r
+ # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 心率数据下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")\r
+ #EventMesh.publish(constants.PROTOCOL.OXYGEN_SEND)\r
+\r
+class OXYGEN_One_ProtoCol(ProtoCol):#单次测量\r
+ """上传单次测量测试数据"""\r
+ TYPE = "oxstart"\r
+\r
+# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*oxygen,x]\r
+# x 表示血氧饱和度\r
+# 示例[XT*334588000000156*0009*oxygen,15]\r
+# 平台回复：handler -> b'[SZKW*860132060004322*0009*oxstart,1]'\r
+# [XT*334588000000156*0006*oxygen]\r
+ def send(self, event, msg):\r
+ # [SZKW*334588000000156*len*heart,x]\r
+ EventMesh.debug_log("oxstart:")\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*oxstart"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("HEART_ProtoCol:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 血氧单次测量下发\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ EventMesh.debug_log("oxstart:{}".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+\r
+ oxstartTotal = int(msg_tmp)\r
+ # oxstartTotal = 300\r
+ print("oxstartTotal:{}".format(oxstartTotal))\r
+ if oxstartTotal == 1:#单次测量\r
+ get_bp_state = EventMesh.publish("get_bp_state")\r
+ get_hr_state = EventMesh.publish("get_hr_state")\r
+ get_spo2_state = EventMesh.publish("get_spo2_state")\r
+ get_bg_state = EventMesh.publish("get_bp_state")\r
+ print("get_bp_state:{}".format(get_bp_state))\r
+ if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("set_spo2_state",3)#3代表单次测量\r
+ else:\r
+ if oxstartTotal > 0 and oxstartTotal <= 300:\r
+ oxstartTotal = 300\r
+ elif oxstartTotal >= 65536:\r
+ oxstartTotal = 65536\r
+\r
+ # if oxstartTotal == 0:#关闭自动测量\r
+ # EventMesh.debug_log("bpSTART_ 1")\r
+ # EventMesh.publish("set_spo2_time",[0,0])\r
+ # else:\r
+ on = 0\r
+ if oxstartTotal != 0:\r
+ on = 1\r
+ EventMesh.publish("set_spo2_time",[on,oxstartTotal])\r
+\r
+ EventMesh.publish(constants.PROTOCOL.OXSTART_SEND)\r
+\r
+class TEMP_ProtoCol(ProtoCol):\r
+ """上传体温测试数据"""\r
+ TYPE = "temp"\r
+ def send(self, event, msg):\r
+ # [SZKW*334588000000156*len*heart,x]\r
+ # EventMesh.debug_log("temp:send:{}".format(msg))\r
+ len_size = len(str(msg[0]))+len("temp,")+1+len(str(msg[1]))\r
+ EventMesh.debug_log("temp:send:{} len:{}".format(msg,len_size))\r
+ # 实例：[XT*334588000000156*0009*temp,36.2]\r
+ # 代表终端的温度为：36.2\r
+ # 平台回复：\r
+ # [XT*334588000000156*0004*temp]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*temp"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"temp")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d.%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1])\r
+ # EventMesh.debug_log("temp:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: \r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # EventMesh.debug_log("HRSTART_ProtoCol RECV msg:")\r
+ #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)\r
+\r
+class WDSTART_ProtoCol(ProtoCol):\r
+ """上传体温频率"""\r
+ TYPE = "wdstart"\r
+ def send(self, event, msg):\r
+ #[XT*334588000000156*len*wdstart,300]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*wdstart"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("temp:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 体温下发频率数据\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # EventMesh.debug_log("WDSTART_ProtoCol RECV msg:")\r
+ EventMesh.debug_log("wdstart:{}".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+\r
+ tempTotal = int(msg_tmp)\r
+ EventMesh.debug_log("tempTotal:{}".format(tempTotal))\r
+ if tempTotal == 1:#单次测量\r
+ get_temp_state = EventMesh.publish("get_temp_state")\r
+ EventMesh.debug_log("get_temp_state:{}".format(get_temp_state))\r
+ if get_temp_state == 0:#只要两个不在测量 单次优先级最低\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("set_temp_state",3)#3代表单次测量\r
+ else:\r
+ if tempTotal > 0 and tempTotal <= 300:\r
+ tempTotal = 300\r
+ elif tempTotal >= 65536:\r
+ tempTotal = 65536\r
+ \r
+ EventMesh.publish("set_temp_time",tempTotal)\r
+\r
+ \r
+ \r
+ EventMesh.publish(constants.PROTOCOL.WDSTART_SEND)\r
+#解绑\r
+# 设置血压上传频率\r
+# 平台发送[XT*YYYYYYYYYYYYYYY*LEN*bldstart,x]\r
+# x为上传间隔时间，单位秒,连续上传时最小时间不小于300秒，最大不超过65535.\r
+# 示例[XT*334588000000156*0008*bldstart,300]\r
+# 终端回复：\r
+# [XT*334588000000156*0005*bldstart]\r
+# x为1则代表终端单次上传。\r
+# x为0则代表终端上传关闭。\r
+class bldstart_ProtoCol(ProtoCol):\r
+ """app下发血压测试频率"""\r
+ TYPE = "bldstart"\r
+ def send(self, event, msg):\r
+ #[XT*334588000000156*len*wdstart,300]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*bldstart"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # print("temp:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 体温下发频率数据\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # print("WDSTART_ProtoCol RECV msg:")\r
+ print("bldstart:{}".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+\r
+ bldstartTotal = int(msg_tmp)\r
+ # bldstartTotal = 300\r
+ print("bldstartTotal:{}".format(bldstartTotal))\r
+ if bldstartTotal == 1:#单次测量\r
+ get_bp_state = EventMesh.publish("get_bp_state")\r
+ get_hr_state = EventMesh.publish("get_hr_state")\r
+ get_spo2_state = EventMesh.publish("get_spo2_state")\r
+ get_bg_state = EventMesh.publish("get_bg_state")\r
+ print("get_bp_state:{}".format(get_bp_state))\r
+ if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("set_bp_state",3)#3代表单次测量\r
+ else:\r
+ if bldstartTotal > 0 and bldstartTotal <= 300:\r
+ bldstartTotal = 300\r
+ elif bldstartTotal >= 65536:\r
+ bldstartTotal = 65536\r
+\r
+ on = 0\r
+ if bldstartTotal != 0:#关闭自动测量\r
+ on = 1\r
+ print("on:{} bldstartTotal:{} ".format(on,bldstartTotal))\r
+ EventMesh.publish("set_bp_time",[on,bldstartTotal])\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.BLDSTART_SEND)\r
+\r
+\r
+# 注：回复完后开始测量血压并上传（一般测一次90秒，app端会提醒用户两分钟后刷新页面查看）\r
+# 上传血压数据\r
+# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*blood,x,y]\r
+# x 是收缩压（高压）\r
+# y 是舒张压（低压）\r
+# 示例[XT*334588000000156*000C*blood,150,70]\r
+# 平台回复：\r
+# [XT*334588000000156*0005*blood]\r
+class blood_ProtoCol(ProtoCol):\r
+ """上传血压测试数据"""\r
+ TYPE = "blood"\r
+ def send(self, event, msg):\r
+ len_size = len(str(msg[0]))+len("blood,")+1+len(str(msg[1]))\r
+ print("blood:send:{} len:{}".format(msg,len_size))\r
+ # 实例：[XT*334588000000156*0009*blood,36,2]\r
+ # 代表终端的\r
+ # 平台回复：\r
+ # [XT*334588000000156*0004*blood]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*blood"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"blood")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d,%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1])\r
+ print("blood:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ \r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: \r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # print("HRSTART_ProtoCol RECV msg:")\r
+ #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)\r
+\r
+\r
+\r
+\r
+# 设置血糖上传频率\r
+# 平台发送:\r
+# [XT*334588000000156*len*bgstart,x]\r
+# x为上传间隔时间，单位秒,连续上传时最小时间不小于300秒，最大不超过65535.\r
+# 实例：[XT*334588000000156*len*bgstart,300]\r
+# 终端会每隔300秒检测一次\r
+\r
+# x为1则代表终端单次上传。\r
+# x为0则代表终端上传关闭。\r
+class bgstart_ProtoCol(ProtoCol):\r
+ """app下发血糖测试频率"""\r
+ TYPE = "bgstart"\r
+ def send(self, event, msg):\r
+ #[XT*334588000000156*len*wdstart,300]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*bgstart"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # print("temp:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: 体温下发频率数据\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # print("WDSTART_ProtoCol RECV msg:")\r
+ print("bgstart:{}".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+\r
+ bgstartTotal = int(msg_tmp)\r
+ print("bgstartTotal:{}".format(bgstartTotal))\r
+ if bgstartTotal == 1:#单次测量\r
+ get_bp_state = EventMesh.publish("get_bp_state")\r
+ get_hr_state = EventMesh.publish("get_hr_state")\r
+ get_spo2_state = EventMesh.publish("get_spo2_state")\r
+ get_bg_state = EventMesh.publish("get_bg_state")\r
+ print("get_bg_state:{}".format(get_bg_state))\r
+ if get_bp_state == 0 and get_hr_state == 0 and get_spo2_state == 0 and get_bg_state == 0:#只要两个不在测量 单次优先级最低\r
+ battery = EventMesh.publish("screen_get_battery")\r
+ if battery != None:\r
+ if battery[0] != "1":\r
+ EventMesh.publish("set_bg_state",3)#3代表单次测量\r
+ else:\r
+ if bgstartTotal > 0 and bgstartTotal <= 300:\r
+ bgstartTotal = 300\r
+ elif bgstartTotal >= 65536:\r
+ bgstartTotal = 65536\r
+ \r
+ # if bgstartTotal == 0:#关闭自动测量\r
+ # EventMesh.debug_log("bgSTART_ 1")\r
+ # EventMesh.publish("set_bgauto_time",[0,0])\r
+ # else:\r
+ on = 0\r
+ if bgstartTotal != 0:\r
+ on = 1\r
+ EventMesh.publish("set_bgauto_time",[on,bgstartTotal])\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.BGSTART_SEND)\r
+\r
+# 上传血糖数据\r
+# 终端发送[XT*YYYYYYYYYYYYYYY*LEN*bloodglucose,x]\r
+# x 表示血糖，单位mmol/L\r
+# 示例[XT*334588000000156*0010*bloodglucose,6.1]\r
+# 平台回复：\r
+# [XT*334588000000156*000B*bloodglucose]\r
+class bloodglucose_ProtoCol(ProtoCol):\r
+ """上传血糖测试数据"""\r
+ TYPE = "bloodglucose"\r
+ def send(self, event, msg):\r
+ len_size = len("bloodglucose,")+1+len(str(msg))\r
+ print("bloodglucose:send:{} len:{}".format(msg,len_size))\r
+ # 实例：[XT*334588000000156*0009*blood,36,2]\r
+ # 代表终端的\r
+ # 平台回复：\r
+ # [XT*334588000000156*0004*blood]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*bloodglucose"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"bloodglucose")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%s]"%(str(MD5_SIGN),send_data,msg)\r
+ print("bloodglucose:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ \r
+ def recv(self, event, msg):\r
+ """\r
+ @param event: \r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # print("HRSTART_ProtoCol RECV msg:")\r
+ #EventMesh.publish(constants.PROTOCOL.TEMP_SEND)\r
+\r
+# [XT*334588000000156*0003*DLT]\r
+def reset_factory(msg):\r
+ if msg == 1:\r
+ Power.powerRestart()\r
+class DLT_ProtoCol(ProtoCol):\r
+ """解绑数据"""\r
+ TYPE = "DLT"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*temp]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0003*DLT"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("temp:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # EventMesh.debug_log("DLT_ProtoCol RECV msg:")\r
+ \r
+\r
+#定位频率\r
+class UPLOAD_ProtoCol(ProtoCol):\r
+ """定位频率数据"""\r
+ TYPE = "UPLOAD"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*temp]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*UPLOAD"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ \r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*UPLOAD,600]'\r
+ # EventMesh.debug_log("DLT_ProtoCol RECV msg:".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+ upload_time = int(msg_tmp)\r
+ EventMesh.publish("set_storage_config",["upload_time",upload_time])\r
+\r
+ EventMesh.publish("set_upload_data", upload_time)\r
+ EventMesh.publish(constants.PROTOCOL.UPLOAD_SEND)\r
+\r
+#设置快捷号码\r
+class CENTER_ProtoCol(ProtoCol):\r
+ """设置快捷号码"""\r
+ TYPE = "CENTER"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*temp]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*CENTER"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("UPLOAD:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*UPLOAD,600]'\r
+ # EventMesh.debug_log("DLT_ProtoCol RECV msg:".format(msg))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1]\r
+ EventMesh.debug_log("CENTER_ProtoCol RECV msg:{} msg_:{}".format(msg,msg_tmp))\r
+ center_dial = str(msg_tmp)\r
+ EventMesh.publish("set_storage_config",["center_dial",center_dial])\r
+ EventMesh.publish(constants.PROTOCOL.CENTER_SEND) \r
+\r
+#呼叫快捷电话号码\r
+import voiceCall\r
+class MONITOR_ProtoCol(ProtoCol):\r
+ """呼叫快捷号码"""\r
+ TYPE = "MONITOR"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*MONITOR]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MONITOR"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("MONITOR:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*MONITOR]'\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split('MONITOR')\r
+ msg_tmp = msg_tmp[1]\r
+ EventMesh.debug_log("MONITOR_ProtoCol RECV msg:{} msg_:{}".format(msg,len(msg_tmp)))\r
+ if len(msg_tmp) != 0:\r
+ EventMesh.publish("save_phonename", contact)\r
+ EventMesh.publish("save_phonenum", contact)\r
+ EventMesh.publish("dial_out_call_center_cb",contact)#电话拨出去\r
+ else:\r
+ read_data = EventMesh.publish("get_storage_config","center_dial")\r
+ EventMesh.debug_log("MONITOR:data:%s"%(read_data))\r
+ if read_data != None: \r
+ contact = read_data\r
+ if len(contact) > 0:\r
+ EventMesh.debug_log("MONITOR RECV msg:{} {}".format(contact,type(contact)))\r
+ EventMesh.publish("save_phonename", contact)\r
+ EventMesh.publish("save_phonenum", contact)\r
+ EventMesh.publish("dial_out_call_center_cb",contact)#电话拨出去\r
+ EventMesh.publish(constants.PROTOCOL.MONITOR_SEND) \r
+\r
+#定时开关机\r
+class bootoff_ProtoCol(ProtoCol):\r
+ """定时开关机"""\r
+ TYPE = "BOOTOFF"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*MONITOR]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*BOOTOFF"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("BOOTOFF:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*SOS_SEND]'\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ on_bt = int(msg_tmp[1])\r
+ start_hour = int(str(msg_tmp[2]).split(":")[0])\r
+ start_min = int(str(msg_tmp[2]).split(":")[1])\r
+\r
+ end_hour = int(str(msg_tmp[3]).split(":")[0])\r
+ end_min = int(str(msg_tmp[3]).split(":")[1])\r
+\r
+ EventMesh.debug_log("BOOTOFF:send data:",on_bt,start_hour,start_min,end_hour,end_min)\r
+ poweroff = []\r
+ poweroff.append({"poweroff_on":on_bt,"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min})\r
+ #b'[SZKW*860132060006970*0015*BOOTOFF,1,06:00,23:59]'\r
+ EventMesh.publish("set_boot_off_time",poweroff)#设置关机时间\r
+\r
+ EventMesh.publish(constants.PROTOCOL.BOOTOFF_SEND) \r
+\r
+\r
+#sos家庭号码\r
+class sosHome_dial_ProtoCol(ProtoCol):\r
+ """sos家庭号码"""\r
+ TYPE = "SOS"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0004*MONITOR]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0003*SOS"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ print("sosHome_dial_ProtoCol:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+\r
+ # b'[SZKW*867387060319166*000A*SOS_SEND]'\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+\r
+ # print("sosHome_dial_ProtoCol:send data :{} {}".format(len(msg_tmp),msg_tmp))\r
+ #b'[SZKW*860132060006970*0015*sosHome_dial_ProtoCol,15521469561,10086,15521469561]'\r
+ i = 0\r
+ num = 0\r
+ count = 0\r
+ print("sos msg_tmp",msg_tmp)\r
+ if len(msg_tmp) > 4:\r
+ num = 3\r
+ else:\r
+ num = len(msg_tmp)-1\r
+ data = []\r
+ for i in range(num):\r
+ # print("sos:send data :{}".format(msg_tmp[i+1]))\r
+ if len(msg_tmp[i+1]) != 0:\r
+ EventMesh.publish("set_storage_config",["SOS_NUMBER{}".format(i+1),msg_tmp[i+1]])\r
+ data.append(str(msg_tmp[i+1]))\r
+ count+=1\r
+ print("data:{}".format(data))\r
+ EventMesh.publish("set_dial_sos_number",data)\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.SOS_SEND) \r
+\r
+ \r
+# 低电提醒\r
+#[XT*334588000000156*0008*LOWBAT,1]\r
+class LOWBAT_ProtoCol(ProtoCol):\r
+ """低电提醒"""\r
+ TYPE = "LOWBAT"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0006*LOWBAT]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*LOWBAT"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("LOWBAT:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*LOWBAT]'\r
+\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ on_bt = msg_tmp[1]\r
+ EventMesh.debug_log("LOWBAT:send data:{}".format(on_bt))\r
+ #b'[SZKW*860132060006970*0015*LOWBAT,1,06:00,23:59]'\r
+ EventMesh.publish("set_low_bat_btn",on_bt)\r
+ EventMesh.publish(constants.PROTOCOL.LOWBAT_SEND) \r
+\r
+# 设置系统时间\r
+#\r
+class Time_ProtoCol(ProtoCol):\r
+ """设置系统时间"""\r
+ TYPE = "Time"\r
+ def send(self, event, msg):\r
+ # \r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0004*Time"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("Time:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # rtc = RTC()\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+ \r
+ timeSecond = int(msg_data[1])\r
+ #EventMesh.debug_log("type {} timeSecond {}".format((msg_data[1]),timeSecond))\r
+ # timeSecond = 1703001360\r
+ next_alarm_time = utime.localtime(timeSecond)\r
+ #EventMesh.debug_log("next_alarm_time",next_alarm_time)\r
+ #EventMesh.debug_log("local time",msg)\r
+ # machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6], tm[3], tm[4], tm[5], 0))\r
+\r
+ machine.RTC().datetime((next_alarm_time[0],next_alarm_time[1],next_alarm_time[2],next_alarm_time[6],next_alarm_time[3],next_alarm_time[4],next_alarm_time[5],0))\r
+ #next_alarm_time = utime.localtime(old_Timesec)#年月日时分秒星期365中的第几天\r
+ EventMesh.publish("set_rtc_alarm")\r
+ #EventMesh.publish(constants.PROTOCOL.TIME_SEND) \r
+\r
+\r
+\r
+\r
+#免打扰\r
+class SILENCETIME2_ProtoCol(ProtoCol):\r
+ """免打扰"""\r
+ TYPE = "SILENCETIME2"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0006*SILENCETIME2]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000C*SILENCETIME2"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("KEYBRD:data:%s"%(data))\r
+ # EventMesh.debug_log("SILENCETIME2!!!!!!!!!!!!!",msg)\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*KEYBRD]'\r
+ # EventMesh.debug_log("SILENCETIME2!!!!!!!!!!!!!",msg)\r
+ EventMesh.publish(constants.PROTOCOL.SILENCETIME2_SEND) \r
+\r
+#键盘开关\r
+class KEYBRD_ProtoCol(ProtoCol):\r
+ """免打扰"""\r
+ TYPE = "KEYBRD"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0006*SILENCETIME2]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*KEYBRD"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # EventMesh.debug_log("KEYBRD:data:%s"%(data))\r
+ # EventMesh.debug_log("KEYBRD!!!!!!!!!!!!!",msg)\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*KEYBRD]'\r
+ # EventMesh.debug_log("KEYBRD!!!!!!!!!!!!!",msg)\r
+ EventMesh.publish(constants.PROTOCOL.KEYBRD_SEND) \r
+\r
+class TK_ProtoCol(ProtoCol):\r
+ """微聊"""\r
+ TYPE = "TK"\r
+ \r
+\r
+ def send(self, event, msg):\r
+ EventMesh.debug_log("TK send:")\r
+ if len(str(msg)) == 1:\r
+\r
+ len_size = len(str(msg))+len("TK,")\r
+ # 实例：[XT*334588000000156*0009*TK,1]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*TK"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"TK")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)\r
+ EventMesh.debug_log("TK:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ else:\r
+ # [SZKW*YYYYYYYYYYYYYYY*LEN*TK,AMR 格式音频数据]\r
+ #[XT*YYYYYYYYYYYYYYY*LEN*TKS,秒数（十进制）,AMR 格式音频数据]\r
+ arm_data = msg\r
+ # arm_sec = msg[0]\r
+ # EventMesh.debug_log("TK_ProtoCol:msgtype:{} arm_sec:{}".format(len(msg[1]),arm_sec))\r
+\r
+ arm = bytearray()\r
+ for i in range(len(arm_data)):\r
+ if arm_data[i] == 0x7d:\r
+ arm.extend(b'\x7d\x01')\r
+ elif arm_data[i] == 0x5b :\r
+ arm.extend(b'\x7d\x02')\r
+ elif arm_data[i] == 0x5d :\r
+ arm.extend(b'\x7d\x03')\r
+ elif arm_data[i] == 0x2c :\r
+ arm.extend(b'\x7d\x04')\r
+ elif arm_data[i] == 0x2a :\r
+ arm.extend(b'\x7d\x05')\r
+ else :\r
+ arm.append(arm_data[i])\r
+ \r
+ datalen = len(arm) + len("TK,")+1\r
+ #Wechat_log("len(str(arm_sec)):{}".format(len(str(arm_sec))+1))\r
+ send_data = bytearray(EventMesh.publish("get_new_pid")+"*%s*%04X*TK,"%(self.imei,datalen))\r
+ send_data.extend(arm)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,datalen,"TK")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = bytearray('[')\r
+ data.extend(MD5_SIGN)\r
+ data.extend(send_data)\r
+ data.extend(']')\r
+ # EventMesh.debug_log("TK:send data:%s MD5_head_data:%s"%(data,MD5_head_data))\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ ("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))\r
+ @param event: 微聊\r
+ @param msg: 接收到的下行数据\r
+ [SZKW*860132060004322*20BD*TK,#!AMR...]\r
+ """\r
+ #Wechat_log("K_ProtoCol:recv:data:{}".format(msg))\r
+ \r
+ msg_tmp = msg.decode('ascii')\r
+ str = msg_tmp.split('TK,')\r
+ # Wechat_log("TK_ProtoCol:recv:len:{} {} {}".format(len(msg),len(str),msg_tmp.find("#!AMR")))\r
+\r
+ read_AMR_flag = msg_tmp.find("#!AMR")\r
+ #EventMesh.debug_log("TK recv:read_AMR_flag:{} ,{}".format(read_AMR_flag,EventMesh.publish("get_wechat_record_flag")))\r
+ # if EventMesh.publish("get_wechat_record_flag") != 1 and read_AMR_flag != -1: #是否是服务器下发音频数据\r
+ if read_AMR_flag != -1: #是否是服务器下发音频数据\r
+ # Wechat_log("TK_ProtoCol:recv:datalen{}".format(len(msg)))\r
+ arm_data = bytearray(str[1])#获取amr输出\r
+ get_wechat_data = EventMesh.publish("get_wechat_data")\r
+ MXA_MSG = get_wechat_data[0]\r
+ wechat_recode_list = get_wechat_data[1]\r
+ wechat_num = int(wechat_recode_list["num"])\r
+ # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))\r
+ \r
+ if wechat_num >= MXA_MSG:\r
+ wechat_num = 0 \r
+ if wechat_num == 0:\r
+ wechat_num += 1 \r
+ elif wechat_num > 0:\r
+ wechat_num += 1 \r
+\r
+\r
+ EventMesh.debug_log("num_total:datalen:{} {}".format(MXA_MSG,wechat_recode_list))\r
+ wechat_recode_list["%02d"%(wechat_num)] = "read:1"\r
+ wechat_recode_list['num'] = wechat_num\r
+ EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])\r
+ #写语音文件数据\r
+\r
+ # path = "/usr/static/storage_file/wechat.amr"\r
+ path = "/usr/static/storage_file/{}.amr".format(wechat_num)\r
+ with open(path,"w") as fd:\r
+ arm = bytearray()\r
+ j = 0\r
+ for i in range(len(arm_data)):\r
+ if arm_data[j] == 0x7d and arm_data[j+1] == 0x01:\r
+ arm.extend(b'\x7d')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x02:\r
+ arm.extend(b'\x5b')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x03:\r
+ arm.extend(b'\x5d')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x04:\r
+ arm.extend(b'\x2c')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x05:\r
+ arm.extend(b'\x2a')\r
+ j+=1\r
+ else :\r
+ arm.append(arm_data[j])\r
+ j+=1\r
+ if j >= len(arm_data):\r
+ break\r
+ fd.write(arm)\r
+ EventMesh.publish("recv_wechat_audio")#\r
+ EventMesh.publish(constants.PROTOCOL.TK_SEND,1)\r
+ EventMesh.debug_log("constants.PROTOCOL.TK_SEND1!!!")\r
+ else :\r
+ if read_AMR_flag != -1:\r
+ EventMesh.publish(constants.PROTOCOL.TK_SEND,0)\r
+ \r
+class TKS_ProtoCol(ProtoCol):\r
+ """微聊"""\r
+ TYPE = "TKS"\r
+ \r
+\r
+ def send(self, event, msg):\r
+ EventMesh.debug_log("TKS send:")\r
+ if len(str(msg)) == 1:\r
+ len_size = len(str(msg))+len("TKS,")\r
+ # 实例：[XT*334588000000156*0009*TK,1]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*%04X*TKS"%(self.imei,len_size)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,len_size,"TKS")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)\r
+ EventMesh.debug_log("TKS:data:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ else:\r
+ # [SZKW*YYYYYYYYYYYYYYY*LEN*TK,AMR 格式音频数据]\r
+ #[XT*YYYYYYYYYYYYYYY*LEN*TKS,秒数（十进制）,AMR 格式音频数据]\r
+ arm_data = msg[1]\r
+ arm_sec = msg[0]\r
+ EventMesh.debug_log("TK_ProtoCol:msgtype:{} arm_sec:{}".format(len(msg[1]),arm_sec))\r
+\r
+ arm = bytearray()\r
+ for i in range(len(arm_data)):\r
+ if arm_data[i] == 0x7d:\r
+ arm.extend(b'\x7d\x01')\r
+ elif arm_data[i] == 0x5b :\r
+ arm.extend(b'\x7d\x02')\r
+ elif arm_data[i] == 0x5d :\r
+ arm.extend(b'\x7d\x03')\r
+ elif arm_data[i] == 0x2c :\r
+ arm.extend(b'\x7d\x04')\r
+ elif arm_data[i] == 0x2a :\r
+ arm.extend(b'\x7d\x05')\r
+ else :\r
+ arm.append(arm_data[i])\r
+ \r
+ datalen = len(arm) + len("TKS,")+len(str(arm_sec))+1\r
+ #Wechat_log("len(str(arm_sec)):{}".format(len(str(arm_sec))+1))\r
+ send_data = bytearray(EventMesh.publish("get_new_pid")+"*%s*%04X*TKS,%d,"%(self.imei,datalen,arm_sec))\r
+ send_data.extend(arm)\r
+ MD5_head_data = EventMesh.publish("get_new_pid")+"*%s*%04X*%s"%(self.imei,datalen,"TKS")\r
+ MD5_SIGN = self.pack_MD5_head(MD5_head_data)\r
+ data = bytearray('[')\r
+ data.extend(MD5_SIGN)\r
+ data.extend(send_data)\r
+ data.extend(']')\r
+ # EventMesh.debug_log("TK:send data:%s MD5_head_data:%s"%(data,MD5_head_data))\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ ("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))\r
+ @param event: 微聊\r
+ @param msg: 接收到的下行数据\r
+ [SZKW*860132060004322*20BD*TK,#!AMR...]\r
+ """\r
+ #Wechat_log("K_ProtoCol:recv:data:{}".format(msg))\r
+ # EventMesh.debug_log("TK recv:{}".format(msg))\r
+ msg_tmp = msg.decode('ascii')\r
+ str = msg_tmp.split('TKS,')\r
+ # Wechat_log("TK_ProtoCol:recv:len:{} {} {}".format(len(msg),len(str),msg_tmp.find("#!AMR")))\r
+ read_AMR_flag = msg_tmp.find("#!AMR")\r
+ # if EventMesh.publish("get_wechat_record_flag") != 1 and read_AMR_flag != -1: #是否是服务器下发音频数据\r
+ if read_AMR_flag != -1: #是否是服务器下发音频数据\r
+ # Wechat_log("TK_ProtoCol:recv:datalen{}".format(len(msg)))\r
+ arm_data = bytearray(str[1])#获取amr输出\r
+ get_wechat_data = EventMesh.publish("get_wechat_data")\r
+ MXA_MSG = get_wechat_data[0]\r
+ wechat_recode_list = get_wechat_data[1]\r
+ wechat_num = int(wechat_recode_list["num"])\r
+ # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))\r
+ \r
+ if wechat_num >= MXA_MSG:\r
+ wechat_num = 0 \r
+ if wechat_num == 0:\r
+ wechat_num += 1 \r
+ elif wechat_num > 0:\r
+ wechat_num += 1 \r
+\r
+\r
+ EventMesh.debug_log("num_total:datalen:{} {}".format(MXA_MSG,wechat_recode_list))\r
+ wechat_recode_list["%02d"%(wechat_num)] = "read:1"\r
+ wechat_recode_list['num'] = wechat_num\r
+ EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])\r
+ #写语音文件数据\r
+\r
+ # path = "/usr/static/storage_file/wechat.amr"\r
+ path = "/usr/static/storage_file/{}.amr".format(wechat_num)\r
+ with open(path,"w") as fd:\r
+ arm = bytearray()\r
+ j = 0\r
+ for i in range(len(arm_data)):\r
+ if arm_data[j] == 0x7d and arm_data[j+1] == 0x01:\r
+ arm.extend(b'\x7d')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x02:\r
+ arm.extend(b'\x5b')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x03:\r
+ arm.extend(b'\x5d')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x04:\r
+ arm.extend(b'\x2c')\r
+ j+=1\r
+ elif arm_data[j] == 0x7d and arm_data[j+1] == 0x05:\r
+ arm.extend(b'\x2a')\r
+ j+=1\r
+ else :\r
+ arm.append(arm_data[j])\r
+ j+=1\r
+ if j >= len(arm_data):\r
+ break\r
+ fd.write(arm)\r
+ EventMesh.publish("recv_wechat_audio")#\r
+ EventMesh.publish(constants.PROTOCOL.TKS_SEND,1)#返回接收成功\r
+ else :\r
+ if read_AMR_flag != -1 :\r
+ EventMesh.publish(constants.PROTOCOL.TKS_SEND,0)#返回接收失败\r
+ \r
+\r
+ \r
+ \r
+ \r
+ \r
+\r
+class MESSAGE_ProtoCol(ProtoCol):\r
+ """微聊"""\r
+ TYPE = "MESSAGE"\r
+ \r
+\r
+ def send(self, event, msg):\r
+ #[XT*334588000000156*0007*MESSAGE]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MESSAGE"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+\r
+ @param event: 微聊文字\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # msg = msg[1:-1]\r
+\r
+ # msg_s = msg.decode('ascii')\r
+ # msg_s = msg_s.split(',')\r
+ # msg_s = msg_s[1]\r
+ # # Wechat_log("msg_tmp:len:{}\r\n data:{}".format(len(msg_s),msg_s))\r
+ \r
+\r
+ # get_wechat_data = EventMesh.publish("get_wechat_data")\r
+ \r
+ # MXA_MSG = get_wechat_data[0]\r
+ # wechat_recode_list = get_wechat_data[1]\r
+ # wechat_num = wechat_recode_list["num"]\r
+ # # Wechat_log("TK_ProtoCol:datalen:{} {} {}".format(wechat_num,MXA_MSG,wechat_recode_list))\r
+ \r
+ # if wechat_num >= MXA_MSG:\r
+ # wechat_num = 0 \r
+ # if wechat_num == 0:\r
+ # wechat_num += 1 \r
+ # elif wechat_num > 0:\r
+ # wechat_num += 1 \r
+ # msg_txt = {}\r
+ # # 0 1 2 3\r
+ # Wechat_log("wechat_num:init {}".format(wechat_num))\r
+ # msg_txt = UnicodeHexStr_To_Utf8Str(msg_s)\r
+ # # Wechat_log("msg_txt:{}".format(msg_txt))\r
+ # wechat_recode_list["%02d"%(wechat_num)] = "T:{}".format(msg_txt)\r
+ # wechat_recode_list['num'] = wechat_num\r
+ # EventMesh.publish("set_wechat_data",[MXA_MSG,wechat_recode_list])\r
+ # # Wechat_log("wechat_recode_list:len data:{}".format(wechat_recode_list))\r
+ \r
+ # screen_NAME = EventMesh.publish("get_screen_NAME")\r
+ # get_lcd_state = EventMesh.publish("get_lcd_state")\r
+ # if screen_NAME != "wechat" or get_lcd_state == 0:\r
+ # EventMesh.publish("load_screen", {"screen": "wechat_popup"})\r
+ # else:\r
+ # EventMesh.publish("wechat_updata_list_show")\r
+ EventMesh.publish(constants.PROTOCOL.MESSAGE_SEND)\r
+ # EventMesh.publish("recv_wechat_audio")#\r
+\r
+class FALLDOWN_ProtoCol(ProtoCol):\r
+ """\r
+ 跌倒提醒开关\r
+ 服务器下发跌倒报警设置命令\r
+ [XT*334588000000156*LEN*FALLDOWN,ONOFF]\r
+ ONOFF: 1:开启，0:关闭。\r
+ 终端回复\r
+ [XT*334588000000156*LEN*FALLDOWN]\r
+ """\r
+ TYPE = "FALLDOWN"\r
+ \r
+ def send(self, event, msg):\r
+ \r
+ #[XT*334588000000156*LEN*FALLDOWN]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*FALLDOWN"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ [SZKW*860132060341484*000A*FALLDOWN,1]\r
+ """\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+ \r
+ Falldowm = msg_data[1]\r
+ EventMesh.debug_log("FALLDOWN:{}".format(Falldowm))\r
+ EventMesh.publish("set_storage_config",["fall_sw",Falldowm])\r
+\r
+ EventMesh.publish(constants.PROTOCOL.FALLDOWN_SEND)\r
+\r
+class REMOVE_ProtoCol(ProtoCol):\r
+ """\r
+ 取下手环报警开关\r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMOVE,0或者1]\r
+ 实例:[XT*334588000000156*0008*REMOVE,1]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMOVE]\r
+ """\r
+ TYPE = "REMOVE"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*REMOVE"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+ Falldowm = msg_data[1]\r
+ EventMesh.debug_log("REMOVE:{}".format(Falldowm))\r
+ EventMesh.publish("set_storage_config",["remove_sw",Falldowm])\r
+ EventMesh.publish(constants.PROTOCOL.REMOVE_SEND) \r
+\r
+class HELP_ProtoCol(ProtoCol):\r
+ """\r
+一键报警\r
+ [XT*YYYYYYYYYYYYYYY*LEN*HELP,状态]\r
+ 状态值为整数：60或不带默认是普通报警，61光电式感烟火灾报警，62检测环境温度（高温报警，温度变化报警），\r
+ 63人体活动检测报警，64电池欠压提醒功能，65设备脱落提醒功能，66离线报警，67测试报警，123气感报警，\r
+ 124烟感报警，125水浸报警\r
+ 实例:\r
+ [XT*334588000000156*0004*HELP,60]\r
+ """\r
+ TYPE = "HELP"\r
+ \r
+ def send(self, event, msg):\r
+ #[XT*334588000000156*LEN*FALLDOWN]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*HELP,%d"%(self.imei,msg)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ [XT*334588000000156*0004*HELP,60]\r
+ """\r
+\r
+ pass \r
+\r
+\r
+#喝水闹钟提示\r
+# 喝水闹钟设置指令\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_DRINK,4,0]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_DRINK]\r
+class REMIND_CHDRINK_ProtoCol(ProtoCol):\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_DRINK,时间间隔（小时）,开关（0为关，1为开）]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_DRINK]\r
+ """\r
+ TYPE = "REMIND_CH_DRINK"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000F*REMIND_CH_DRINK"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_DRINK,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+ data = str(msg_data[1])\r
+ hour = int(data.split('-')[0])\r
+ btn_on = int(data.split('-')[1])\r
+\r
+ EventMesh.debug_log("recv REMIND_CH_DRINK:{}-{}-{}".format(hour,btn_on,msg))\r
+ EventMesh.publish("set_storage_config",["drink_on",btn_on])\r
+ EventMesh.publish("set_storage_config",["drink_time",hour])\r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_DRINK_SEND) \r
+\r
+# 自定义服药闹钟设置指令\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2,时间1-开关，时间2-开关，周几]\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_MEDICINE2,08:10-0,09:10-0,1000001]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_MEDICINE2]\r
+# 说明:闹铃格式为：时间-开关（0/1），周几（周六到周日）\r
+\r
+#REMIND_CH_MEDICINE2,09:00-1,14:00-0,18:00-0,1111111]'",)\r
+class REMIND_CHMEDICINE2_ProtoCol(ProtoCol):#吃药提醒\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_MEDICINE2,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_MEDICINE2]\r
+ """\r
+ TYPE = "REMIND_CH_MEDICINE2"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0013*REMIND_CH_MEDICINE2"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+\r
+ msg_data = str(msg_tmp.split('REMIND_CH_MEDICINE2,')[1])\r
+ msg_data_tmp = str(msg_tmp.split('REMIND_CH_MEDICINE2')[1])\r
+\r
+ medicin_data = []\r
+ alarmday=[]\r
+ count = 0\r
+ for i in str(msg_data_tmp):\r
+ # print("i",i)\r
+ if i == ",":\r
+ count+=1\r
+\r
+ if count >= 3:\r
+ count = 3\r
+ medicine_alarmday = []\r
+ for i in range(0,count):#默认是三个时间多了也不保存\r
+ medicine_alarmday = str(msg_data.split(",")[count])\r
+ # print("i",i)\r
+ medicine_alarm = str(msg_data.split(",")[i])\r
+ if str(medicine_alarm).find("-") != -1:\r
+ on = int(medicine_alarm.split('-')[1])\r
+ if on != 0:\r
+ alarmday = []\r
+ data = str(medicine_alarm.split('-')[0])\r
+ hour = int(data.split(":")[0])\r
+ min = int(data.split(":")[1])\r
+ for i in range(0,7):\r
+ # print("medicine_alarmday",medicine_alarmday,medicine_alarmday[i])\r
+ if medicine_alarmday[i] != '0':\r
+ alarmday.append(i)\r
+ enable = 1\r
+ medicin_data.append({"hour":hour,"min":min,"day":alarmday,"enable":enable})\r
+ \r
+ EventMesh.publish("set_storage_config",["medicine",medicin_data])\r
+ EventMesh.debug_log("recv REMIND_CH_MEDICINE2:{} medicin_data ;{}".format(msg,medicin_data))\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_MEDICINE2_SEND) \r
+ EventMesh.publish("clear_medicine_alarm")\r
+\r
+# 回家闹钟设置指令\r
+# 可设置闹钟的提醒文字\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME,闹钟1,闹钟2,闹钟3]\r
+# 实例:\r
+# [XT*334588000000156*0018*REMIND_CH_HOME,08:10，12:10]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME]\r
+# 实例:[XT*334588000000156*0006*REMIND_CH_HOME]\r
+# 说明:闹钟为时间点；\r
+class REMIND_CH_HOME_ProtoCol(ProtoCol):#回家提醒\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_HOME,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_HOME]\r
+ """\r
+ TYPE = "REMIND_CH_HOME"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000E*REMIND_CH_HOME"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+\r
+ # [SZKW*860132060346475*0014*REMIND_CH_HOME,00:00',)\r
+ home_data = str(msg_data[1])\r
+ \r
+ EventMesh.debug_log("recv REMIND_CH_HOME:{} medicin_data ;{}".format(msg,home_data))\r
+ if len(home_data) != 0:\r
+ EventMesh.publish("set_storage_config",["home_alarm",home_data])\r
+ EventMesh.publish("clear_home_alarm")\r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_HOME_SEND) \r
+# 起床闹钟设置指令\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP,闹钟1，闹钟2]\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_WAKEUP,08:10-0-3-1000001,09:10-0-3-1000001]\r
+# 闹钟格式为：时间-开关-频率(1：一次；2:每天;3：自定义)\r
+# 08:10-1-1：闹钟时间8:10，打开，响铃一次\r
+# 08:10-1-2：闹钟时间8:10，打开，每天响铃\r
+# 08:10-1-3-0111110：闹钟时间8:10，打开，自定义周一至周五打开\r
+# 最左边是周日，最右边是周六，即0111110的顺序是：周日，周一，周二，周三，周四，周五，周六（1为打开，0为关闭），其中周一至周五打开闹钟\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_WAKEUP]\r
+# 说明:闹铃格式为：时间-开关-周几（周六到周日）\r
+class REMIND_CH_WAKEUP_ProtoCol(ProtoCol):#该起床了\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_WAKEUP,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_WAKEUP]\r
+ """\r
+ TYPE = "REMIND_CH_WAKEUP"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0011*REMIND_CH_WAKEUP"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_new = str(msg_tmp.split('REMIND_CH_WAKEUP,')[1])\r
+ msg_tmp_data = str(msg_tmp.split('REMIND_CH_WAKEUP')[1])\r
+ count = 0\r
+ for i in str(msg_tmp_data):\r
+ # print("i",i)\r
+ if i == ",":\r
+ count+=1\r
+ wakeup_data_save = []\r
+ # # ("handler -> b'[SZKW*860132060346475*001C*REMIND_CH_WAKEUP,08:00-1-1,,]'",)\r
+ # medicine_alarmday = str(msg_data[4])\r
+ # alarmday=[]\r
+ wakeup_day = []\r
+ wakeup_switch = 0\r
+\r
+ print("count",count)\r
+ if count >= 3:\r
+ count = 3\r
+ for i in range(0,count):#默认是三个时间多了也不保存\r
+ wakeup_day = []\r
+ wakeup_data = str(msg_tmp_new.split(',')[i])\r
+ # print("i",i,wakeup_data)\r
+ if len(wakeup_data) != 0:\r
+ b = wakeup_data.find('-')\r
+ if b != -1:\r
+ wakeup_time = wakeup_data.split('-')[0]#-作为分隔符\r
+ wakeup_switch = int(wakeup_data.split('-')[1])#开关\r
+ wakeup_repeat = int(wakeup_data.split('-')[2])#是单次还是每天 还是自定义\r
+\r
+ wakeup_hour = int(wakeup_time.split(":")[0])#时间\r
+ wakeup_min = int(wakeup_time.split(":")[1])#冒号分隔时间 时 分\r
+ \r
+ \r
+ if wakeup_repeat == 2:#每一天\r
+ wakeup_day = [0,1,2,3,4,5,6]\r
+ elif wakeup_repeat == 3:#自定义\r
+ wakeup_day_tmp = wakeup_data.split('-')[3]#-作为分隔符\r
+ for i in range(0,7):\r
+ if wakeup_day_tmp[i] != '0':\r
+ wakeup_day.append(i)\r
+ else:#单次 1\r
+ wakeup_day=[] \r
+ if wakeup_switch != 0:\r
+ wakeup_data_save.append({"hour":wakeup_hour,"min":wakeup_min,"day":wakeup_day,"enable":wakeup_switch})\r
+ \r
+ EventMesh.publish("set_storage_config",["wakeup_alarm",wakeup_data_save])\r
+ wakeup = EventMesh.publish("get_storage_config","wakeup_alarm")\r
+\r
+ EventMesh.debug_log("recv REMIND_CH_WAKEUP:{} wakeup ;{}".format(msg,wakeup))\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_WAKEUP_SEND) \r
+ \r
+ EventMesh.publish("clear_wakeup_alarm") \r
+\r
+\r
+\r
+# 睡觉闹钟设置指令\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP,闹钟1，闹钟2]\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_SLEEP,08:10-0-3-1000001,09:10-0-3-1000001]\r
+# 闹钟格式为：时间-开关-频率(1：一次；2:每天;3：自定义)\r
+# 08:10-1-1：闹钟时间8:10，打开，响铃一次\r
+# 08:10-1-2：闹钟时间8:10，打开，每天响铃\r
+# 08:10-1-3-0111110：闹钟时间8:10，打开，自定义周一至周五打开\r
+# 最左边是周日，最右边是周六，即0111110的顺序是：周日，周一，周二，周三，周四，周五，周六（1为打开，0为关闭），其中周一至周五打开闹钟\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_SLEEP]\r
+# 说明:闹铃格式为：时间-开关-周几（周六到周日）\r
+class REMIND_CH_SLEEP_ProtoCol(ProtoCol):#该睡觉了\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_SLEEP,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SLEEP]\r
+ """\r
+ TYPE = "REMIND_CH_SLEEP"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0011*REMIND_CH_SLEEP"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_MEDICINE2,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_new = str(msg_tmp.split('REMIND_CH_SLEEP,')[1])\r
+ msg_tmp_data = str(msg_tmp.split('REMIND_CH_SLEEP')[1])\r
+ count = 0\r
+ for i in str(msg_tmp_data):\r
+ # print("i",i)\r
+ if i == ",":\r
+ count+=1\r
+\r
+ sleep_data_save = []\r
+ # # ("handler -> b'[SZKW*860132060346475*001C*REMIND_CH_SLEEP,08:00-1-1,,]'",)\r
+ # b'[SZKW*860132060346475*001B*REMIND_CH_SLEEP,08:00-1-1,,]'",)\r
+ # medicine_alarmday = str(msg_data[4])\r
+ # alarmday=[]\r
+ sleep_day = []\r
+ sleep_switch = 0\r
+\r
+ print("count",count)\r
+ if count >= 3:\r
+ count = 3\r
+ for i in range(0,count):#默认是三个时间多了也不保存\r
+ sleep_day = []\r
+ sleep_data = str(msg_tmp_new.split(',')[i])\r
+ # print("i",i,sleep_data)\r
+ if len(sleep_data) != 0:\r
+ b = sleep_data.find('-')\r
+ if b != -1:\r
+ sleep_time = sleep_data.split('-')[0]#-作为分隔符\r
+ sleep_switch = int(sleep_data.split('-')[1])#开关\r
+ sleep_repeat = int(sleep_data.split('-')[2])#是单次还是每天 还是自定义\r
+\r
+ sleep_hour = int(sleep_time.split(":")[0])#时间\r
+ sleep_min = int(sleep_time.split(":")[1])#冒号分隔时间 时 分\r
+ \r
+ \r
+ if sleep_repeat == 2:#每一天\r
+ sleep_day = [0,1,2,3,4,5,6]\r
+ elif sleep_repeat == 3:#自定义\r
+ sleep_day_tmp = sleep_data.split('-')[3]#-作为分隔符\r
+ for i in range(0,7):\r
+ if sleep_day_tmp[i] != '0':\r
+ sleep_day.append(i)\r
+ else:#单次 1\r
+ sleep_day=[] \r
+ if sleep_switch != 0:\r
+ sleep_data_save.append({"hour":sleep_hour,"min":sleep_min,"day":sleep_day,"enable":sleep_switch})\r
+ \r
+ EventMesh.publish("set_storage_config",["sleep_alarm",sleep_data_save])\r
+ # sleep = EventMesh.publish("get_storage_config","sleep_alarm")\r
+\r
+ # EventMesh.debug_log("recv REMIND_CH_SLEEP_SEND:{} sleep ;{}".format(msg,sleep))\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_SLEEP_SEND) \r
+ EventMesh.publish("clear_sleep_alarm")\r
+\r
+\r
+# 可设置闹钟的提醒文字\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST,时间间隔1,时间间隔2,时间间隔3]\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_REST,08:10-10:00,12:10-15:00]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_REST]\r
+# 说明:时间间隔 【起始-结束】，起始为开始休息，结束为休息结束\r
+\r
+class REMIND_CH_REST_ProtoCol(ProtoCol):#该休息了\r
+ """\r
+ \r
+ 平台发送:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST,,时间1-开关，时间2-开关，周几]\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_REST,,时间1-开关，时间2-开关，周几]\r
+ 终端回复:\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_REST]\r
+ """\r
+ TYPE = "REMIND_CH_REST"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000E*REMIND_CH_REST"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # SZKW*860132060346475*0013*REMIND_CH_REST,4-1\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = str(msg_tmp.split('REMIND_CH_REST,')[1])\r
+ msg_data_new = str(msg_tmp.split('REMIND_CH_REST')[1])\r
+ print("REMIND_CH_REST",len(msg_data),msg_data)\r
+\r
+ reset_data_save = []\r
+ count = 0\r
+ for i in str(msg_data_new):\r
+ # print("i",i)\r
+ if i == ",":\r
+ count+=1\r
+ \r
+ if count >= 2:\r
+ count = 2\r
+\r
+ for i in range(0,count):#默认是三个时间多了也不保存\r
+ reset_data = str(msg_data.split(',')[i])\r
+ print("i",i,reset_data)\r
+ if len(reset_data) != 0:\r
+ b = reset_data.find('-')\r
+ if b != -1:\r
+ start_time = reset_data.split('-')[0]#-作为分隔符\r
+ end_time = reset_data.split('-')[1]#-作为分隔符\r
+ \r
+ start_hour = int(start_time.split(":")[0])\r
+ start_min = int(start_time.split(":")[1])\r
+\r
+ end_hour = int(end_time.split(":")[0])\r
+ end_min = int(end_time.split(":")[1])\r
+ \r
+ reset_data_save.append({"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min})\r
+ \r
+ EventMesh.publish("set_storage_config",["reset_alarm",reset_data_save])\r
+ # reset = EventMesh.publish("get_storage_config","reset_alarm")\r
+\r
+ # EventMesh.debug_log("recv REMIND_CH_REST:{} reset ;{}".format(msg,reset))\r
+ \r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_REST_SEND) \r
+ EventMesh.publish("clear_reset_alarm")\r
+\r
+\r
+\r
+class WLKEY_ProtoCol(ProtoCol):#白名单开关\r
+ """\r
+ 白名单开关\r
+ [XT*YYYYYYYYYYYYYYY*LEN*WLKEY,ONOFF] ONOFF: 1:开启，0:关闭，2：30秒后自动接听。\r
+ 实例:[XT*334588000000156*0008*WLKEY,1]\r
+ 终端回复\r
+ [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]\r
+ 实例:[XT*334588000000156*0006*WLKEY]\r
+ """\r
+ TYPE = "WLKEY"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*00006*WLKEY"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ #Wechat_log("POWEROFF_ProtoCol:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = msg_tmp.split(',')\r
+ EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))\r
+ EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])\r
+ \r
+\r
+ EventMesh.publish(constants.PROTOCOL.WLKEY_SEND) \r
+# 终端发送：\r
+# [XT*YYYYYYYYYYYYYYY*LEN*SLEEP_DATA,清醒时间（分钟）,浅睡时间（分钟）,深睡时间（分钟）,日期（年月日）]\r
+# 实例: [XT*334588000000156*0004*SLEEP_DATA,120,240,360,20221008]\r
+# 实例表示：上传睡眠数据\r
+#[XT*334588000000156*0010*SleepReport,2022-02-09,80,2,532,164,164,25,25,25,25,21:45-0-164-155-3,22:00-1-162-155-0,22:15-2-162-155-0]\r
+class SLEEP_DATA_ProtoCol(ProtoCol):#睡眠时间\r
+ """\r
+ 白名单开关\r
+ [XT*YYYYYYYYYYYYYYY*LEN*WLKEY,ONOFF] ONOFF: 1:开启，0:关闭，2：30秒后自动接听。\r
+ 实例:[XT*334588000000156*0008*WLKEY,1]\r
+ 终端回复\r
+ [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]\r
+ 实例:[XT*334588000000156*0006*WLKEY]\r
+ """\r
+ TYPE = "SleepReport"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0000b*SleepReport"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s,%s]"%(str(MD5_SIGN),send_data,msg)\r
+ EventMesh.debug_log("SLEEP_DATA:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+\r
+ EventMesh.debug_log("SLEEP_DATA!!!!!!!!!")\r
+ # msg = msg[1:-1]\r
+ # msg_tmp = msg.decode('ascii')\r
+ # msg_data = msg_tmp.split(',')\r
+ # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))\r
+ # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])\r
+ \r
+\r
+ # EventMesh.publish(constants.PROTOCOL.WLKEY_SEND) \r
+\r
+class SLEEPTIME_ProtoCol(ProtoCol):#睡眠时间\r
+ """\r
+ """\r
+ TYPE = "SLEEPTIME"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*00009*SLEEPTIME"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("SLEEPTIME:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+ # 实例:[XT*5678901234*0014*SLEEPTIME,23:30-7:30]\r
+ EventMesh.debug_log("SLEEPTIME!!!!!!!!!")\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_data = str(msg_tmp.split(',')[1])\r
+ data = {}\r
+ if len(msg_data) == 0:\r
+ EventMesh.publish("set_storage_config",["sleep_time",data])\r
+ pass\r
+ else:\r
+ sleep_start = msg_data.split("-")[0]\r
+ sleep_end = msg_data.split("-")[1]\r
+ start_hour = int(sleep_start.split(":")[0])\r
+ start_min = int(sleep_start.split(":")[1])\r
+\r
+ end_hour = int(sleep_end.split(":")[0])\r
+ end_min = int(sleep_end.split(":")[1])\r
+\r
+ data = {"start_hour":start_hour,"start_min":start_min,"end_hour":end_hour,"end_min":end_min}\r
+ # EventMesh.debug_log("SLEEPTIME".format(data))\r
+ EventMesh.publish("set_storage_config",["sleep_time",data])\r
+ # sleep_time = EventMesh.publish("get_storage_config","sleep_time")\r
+ # EventMesh.debug_log("sleep_time:{}".format(sleep_time))\r
+\r
+ EventMesh.publish(constants.PROTOCOL.SLEEPTIME_SEND) \r
+\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*FACTORY]\r
+# 实例:[XT*334588000000156*0007*FACTORY]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*FACTORY]\r
+# 实例:[XT*334588000000156*0007*FACTORY]\r
+# 说明:终端恢复出厂设置，里面设置的号码都将清空\r
+class FACTORY_ProtoCol(ProtoCol):#睡眠时间\r
+ """\r
+ 实例:[XT*334588000000156*0008*FACTORY]\r
+ 终端回复\r
+ [XT*YYYYYYYYYYYYYYY*LEN*WLKEY]\r
+ 实例:[XT*334588000000156*0006*FACTORY]\r
+ """\r
+ TYPE = "FACTORY"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*FACTORY"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("FACTORY:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+\r
+ EventMesh.debug_log("FACTORY!!!!!!!!!")\r
+ # msg = msg[1:-1]\r
+ # msg_tmp = msg.decode('ascii')\r
+ # msg_data = msg_tmp.split(',')\r
+ # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))\r
+ # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])\r
+\r
+ EventMesh.publish(constants.PROTOCOL.FACTORY_SEND) \r
+ EventMesh.publish("app_factory",None)#app恢复出厂\r
+\r
+# 平台发送:\r
+# [3G*YYYYYYYYYY*LEN*RESET]\r
+# 实例:[3g*5678901234*0005*RESET]\r
+# 终端回复:\r
+# [3G*YYYYYYYYYY*LEN*RESET]\r
+class RESET_ProtoCol(ProtoCol):#重启\r
+ """\r
+ 实例:[XT*334588000000156*0008*RESET]\r
+ 终端回复\r
+ [XT*YYYYYYYYYYYYYYY*LEN*RESET]\r
+ 实例:[XT*334588000000156*0006*RESET]\r
+ """\r
+ TYPE = "RESET"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0005*RESET"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("RESET:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+\r
+ EventMesh.debug_log("RESET!!!!!!!!!")\r
+ # msg = msg[1:-1]\r
+ # msg_tmp = msg.decode('ascii')\r
+ # msg_data = msg_tmp.split(',')\r
+ # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))\r
+ # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])\r
+\r
+ EventMesh.publish(constants.PROTOCOL.RESET_SEND) \r
+ Power.powerRestart()\r
+\r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT,时间间隔（分钟）,总开关（0为关，1为开）,午间休息时段，晚间休息时段]\r
+# 午间/晚间休息时段格式为：开始时间（hh:mm）-结束时间（hh:mm）-开关（0为关，1为开），例如 12：00-15：00-1。\r
+# 久坐默认值为20分钟。\r
+# 午间和晚间默认值，午间12:00-14:00，晚上20:00-07:00。\r
+# 实例:\r
+# [XT*334588000000156*0026*REMIND_CH_SIT,20，0，12：00-15：00-1，20：00-07：00-1]\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT]\r
+# 实例:[XT*334588000000156*000E*REMIND_CH_SIT]\r
+class REMIND_CH_SIT_ProtoCol(ProtoCol):#久坐提醒\r
+ """\r
+ 实例:[XT*334588000000156*0008*REMIND_CH_SIT]\r
+ 终端回复\r
+ [XT*YYYYYYYYYYYYYYY*LEN*REMIND_CH_SIT]\r
+ 实例:[XT*334588000000156*0006*REMIND_CH_SIT]\r
+ """\r
+ TYPE = "REMIND_CH_SIT"\r
+ \r
+ def send(self, event, msg):\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000d*REMIND_CH_SIT"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ EventMesh.debug_log("REMIND_CH_SIT:send:%s"%(data))\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND, data)\r
+\r
+ def recv(self, event, msg):\r
+\r
+ EventMesh.debug_log("REMIND_CH_SIT!!!!!!!!!")\r
+ # msg = msg[1:-1]\r
+ # msg_tmp = msg.decode('ascii')\r
+ # msg_data = msg_tmp.split(',')\r
+ # EventMesh.debug_log("WLKEY_ProtoCol".format(msg_data[1]))\r
+ # EventMesh.publish("set_storage_config",["WLKEY",msg_data[1]])\r
+\r
+ EventMesh.publish(constants.PROTOCOL.REMIND_CH_SIT_SEND) \r
+ \r
+# 平台发送:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*SCREEN_SHOW,参数内容]\r
+# 实例:[XT*334588000000156*0016*SCREEN_SHOW,00000000000]\r
+# 参数内容用 unicode 编码呈现，设备收到后需解码。\r
+# 解码后的参数内容可能有多个参数，不同参数用逗号分隔，设备自己决定如何在屏幕中显示这些参数。比如 "SCREEN_SHOW，深圳第一中学，三年1班、张三"\r
+# 终端回复:\r
+# [XT*YYYYYYYYYYYYYYY*LEN*SCREEN_SHOW]\r
+# 实例:[XT*334588000000156*000B*SCREEN_SHOW]\r
+\r
+class SCREEN_SHOWProtoCol(ProtoCol):\r
+ """开屏显示"""\r
+ TYPE = "SCREEN_SHOW"\r
+ def send(self, event, msg):\r
+ # [XT*334588000000156*0006*SILENCETIME2]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*000B*SCREEN_SHOW"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # print("KEYBRD:data:%s"%(data))\r
+ # print("KEYBRD!!!!!!!!!!!!!",msg)\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+ msg_tmp = msg_tmp[1:]\r
+ msg_tmp = msg_tmp[0]\r
+ print("screen_school_data msg",msg)\r
+\r
+ j = 0\r
+ i = 0\r
+ videobook_old = {}\r
+ videobook_name_tmp = UnicodeHexStr_To_Utf8Str(msg_tmp)\r
+ lst = videobook_name_tmp.split(",")\r
+ print("lst data",lst)\r
+\r
+ # 0 1 2 3\r
+ screen_school_data = ""#学校\r
+ screen_class_data = ""#班级\r
+ screen_fullname_data = ""#姓名\r
+ if len(lst) != 0: \r
+ count = len(lst)\r
+ if count > 3:\r
+ count = 3\r
+ for i in range(count):\r
+ if i == 0:\r
+ screen_school_data = lst[0]\r
+ EventMesh.publish("set_schoolname", screen_school_data)#\r
+ elif i == 1:\r
+ screen_class_data = lst[1]\r
+ EventMesh.publish("set_classname", screen_class_data)#\r
+ else:\r
+ screen_fullname_data= lst[2]\r
+ EventMesh.publish("set_fullname", screen_fullname_data)#\r
+ \r
+ # EventMesh.publish("update_screen_show")#更新开屏显示\r
+\r
+ print("screen_school_data!!!:",screen_school_data,screen_class_data,screen_fullname_data)\r
+\r
+ EventMesh.publish(constants.PROTOCOL.SCREEN_SHOW_SEND) \r
+\r
+# #小见平台视频通话\r
+# # [XT*YYYYYYYYYYYYYYY*LEN*JPREG]\r
+# # 实例:\r
+# # [XT*334588000000156*0004*JPREG]\r
+# # 平台回复:\r
+# # [XT*设备ID*LEN*JPREG,账号(整型)]\r
+# # 实例：[XT*334588000000156*0010*JPREG,1087654321]\r
+class JPREG_ProtoCol(ProtoCol):#登入注册\r
+ """"""\r
+ TYPE = "JPREG"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0005*JPREG"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ # print("WLKEY:data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*KEYBRD]'\r
+ print("JPREG!!!!!!!!!!!!!",msg,EventMesh.publish("get_new_pid"))\r
+ # EventMesh.publish(constants.PROTOCOL.JPREG_SEND) \r
+\r
+# # （声网，佰锐的账号是整型）\r
+# # [XT*YYYYYYYYYYYYYYY*LEN*MEMBERS]\r
+# # 实例:[XT*334588000000156*0007*MEMBERS]\r
+# # 平台回复:[XT*设备ID*LEN*MEMBERS,账号1,昵称1,电话1，账号2,昵称2，电话2.....]\r
+# # 实例：\r
+# # [XT*334588000000156*003F*MEMBERS,d3e2f759f9d5af3858f3530,爸爸,13662313580,妈妈,555]\r
+# # 以上数据部分使用Unicode编码，最终上面示例传到服务端将是：\r
+\r
+class MEMBERS_ProtoCol(ProtoCol):#获取账号列表\r
+ """"""\r
+ TYPE = "MEMBERS"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*MEMBERS"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s]"%(str(MD5_SIGN),send_data)\r
+ print("MEMBERS SEND:data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*876226002021444*0048*MEMBERS,0036003900350031003800330032002C563F563FD83CDF410020D83CDF42002C]'\r
+ print("MEMBERS!!!!!!!!!!!!!",msg,EventMesh.publish("get_new_pid"))\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp = msg_tmp.split(',')\r
+\r
+ videobook = {}\r
+ msg_tmp = msg_tmp[1:]\r
+ msg_tmp = msg_tmp[0]\r
+\r
+ j = 0\r
+ i = 0\r
+ videobook_old = {}\r
+ videobook_name_tmp = UnicodeHexStr_To_Utf8Str(msg_tmp)\r
+ lst = videobook_name_tmp.split(",")\r
+ \r
+ print("msg_tmp:{} phonebook_oldtmp:{} type:{}".format(msg_tmp,videobook_name_tmp,lst))\r
+ # 0 1 2 3\r
+ for vediobook_tmp in lst: \r
+ \r
+ if (j % 3) == 0:#账号\r
+ videobook_old = vediobook_tmp\r
+ elif (j % 3) == 1:#名称\r
+ i+=1\r
+ videobook_name_cont= "{}:{}".format("%03d"%(i),videobook_old) \r
+ videobook[videobook_name_cont] = vediobook_tmp\r
+ j+=1\r
+ print("videobook!!!:{}".format(str(videobook)))\r
+ # print("phonebook!!!:{}".format(str(phonebook)))\r
+ with open("/usr/static/storage_file/videobook.json","w",encoding="utf-8") as fd:\r
+ ujson.dump(videobook,fd)\r
+ print("创建视频通话账号")\r
+ \r
+ EventMesh.publish("set_videobook_list",[1,videobook])\r
+ # EventMesh.publish("video_updata_list_show")\r
+ # EventMesh.publish(constants.PROTOCOL.MEMBERS_SEND) \r
+\r
+# # [X*Y*LEN*CALLING,呼叫者id,会议id,通话类型，Token]\r
+\r
+# # 设备回复\r
+# # [X*Y*LEN*CALLING,音视频状态]\r
+# # 音视频状态：为0表示正常可通讯状态，否则填上用音视频返回的状态码，比如200，如果未获取到返回状态码，则填1\r
+class CALLING_ProtoCol(ProtoCol):#app发起视频通话\r
+ """"""\r
+ TYPE = "CALLING"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0007*CALLING"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s,%d]"%(str(MD5_SIGN),send_data,msg)\r
+ # print("CALLING:send data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*CALLING]'\r
+ print("CALLING!!!!!!!!!!!!!",msg)\r
+ if EventMesh.model == "D10":#D10没有视频通话\r
+ EventMesh.publish(constants.PROTOCOL.CALLING_SEND,1)\r
+ return\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_d = msg_tmp.split(',')\r
+ call_id = msg_tmp_d[1]#id\r
+ meet_id = msg_tmp_d[2]#会议id\r
+ call_type = int(msg_tmp_d[3])#会议id# 0音频 1视频\r
+ tokens_data = msg_tmp_d[4]#tokens\r
+ EventMesh.publish("set_vedio_call_id", call_id)#\r
+ EventMesh.publish("set_vedio_meet_id", meet_id)#\r
+ EventMesh.publish("set_vedio_call_type", call_type)#\r
+ EventMesh.publish("set_vedio_tokens_data", tokens_data)#\r
+\r
+ flag = EventMesh.publish("get_call_state") \r
+ fall_down = EventMesh.publish("get_fall_down_state")#跌倒报警标识\r
+ usb_state = EventMesh.publish("get_usb")#\r
+ video_state = EventMesh.publish("get_video_state")\r
+ sos_dialing = EventMesh.publish("get_sos_state_out")#正在拨打sos电话\r
+ if flag != 0 or fall_down != 0 or video_state != 0 or sos_dialing != 0: #电话在打入或者 在充电不允许视频通话\r
+ EventMesh.publish(constants.PROTOCOL.CALLING_SEND,1)\r
+ else:\r
+ EventMesh.publish(constants.PROTOCOL.CALLING_SEND,0)\r
+ EventMesh.publish("set_video_state", 6)\r
+ EventMesh.publish("set_dev_app_mode", 2)#\r
+ EventMesh.publish("close_hr_sop2")#\r
+ EventMesh.publish("video_call_in_event",call_type)\r
+\r
+# # [XT*YYYYYYYYYYYYYYY*LEN*RCALLING,呼叫者id,会议id/声网频道名（没有则留空，但位置保留）,音频还是视频（0为音频，1为视频）]\r
+# # 实例:\r
+# # [XT*334588000000156*0007*RCALLING,d3e2f759f9d5af3858f3530b,,0]\r
+# # 终端回复:\r
+# # [XT*设备ID*LEN*RCALLING]\r
+# # 实例：[XT*334588000000156*0009*RCALLING] \r
+# # \r
+class RCALLING_ProtoCol(ProtoCol):#设备拒接接听\r
+ """"""\r
+ TYPE = "RCALLING"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0008*RCALLING"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s,%s,%s,%d]"%(str(MD5_SIGN),send_data,msg[0],msg[1],msg[2])\r
+ # print("RCALLING:send data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+ # print("RCALLING:send data end:%s"%(data))\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*RCALLING]'\r
+ print("RCALLING!!!!!!!!!!!!!")\r
+\r
+class AGTALK_ProtoCol(ProtoCol):#设备发起视频通话与app接听视频通话\r
+ """"""\r
+ TYPE = "AGTALK"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0006*AGTALK"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s,%d,%s]"%(str(MD5_SIGN),send_data,msg[0],msg[1])\r
+ print("AGTALK:send data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*876226002021444*007B*AGTALK,0,01lqlyqzzQHpfwv5g7jFVC2H6Ha2tHFpMlfSm5sd2uo7o55JEcc=OVxewje6MjP0NgEODwsLDwkJCwkLCA0NDQ==,8762260020214441701226895]'\r
+ # print("AGTALK!!!!!!!!!!!!!")\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_d = msg_tmp.split(',')\r
+ call_state = int(msg_tmp_d[1])#返回是否可以视频通话\r
+ if call_state == 0:#可正常通话\r
+ if EventMesh.publish("get_video_state") != 0: \r
+ # print("AGTALK!!!!!!!!!!!!!answer")\r
+ tokens_data = msg_tmp_d[2]#会议id\r
+ meet_id = msg_tmp_d[3]#会议id\r
+ EventMesh.publish("set_vedio_meet_id", meet_id)#\r
+ EventMesh.publish("set_vedio_tokens_data", tokens_data)#\r
+ EventMesh.publish("open_vedio_infor")\r
+\r
+ else:\r
+ #不能视频通话\r
+ tokens_data = msg_tmp_d[2]#token数据\r
+ meet_id = msg_tmp_d[3]#会议id\r
+ EventMesh.publish("set_vedio_meet_id", meet_id)#\r
+ EventMesh.publish("set_vedio_tokens_data", tokens_data)#\r
+ EventMesh.publish("video_newwork_reject_cb",None)#挂断视频通话\r
+ # print("AGTALK no!!!!!!!!!!!!!")\r
+\r
+ print("AGTALK!!!!!!!!!!!!!")\r
+\r
+\r
+class RTALK_ProtoCol(ProtoCol):#app拒接视频通话\r
+ """"""\r
+ TYPE = "RTALK"\r
+ def send(self, event, msg):\r
+ \r
+ # [XT*334588000000156*0005*WLKEY]\r
+ send_data = EventMesh.publish("get_new_pid")+"*%s*0005*RTALK"%(self.imei)\r
+ MD5_SIGN = self.pack_MD5_head(send_data)\r
+ data = "[%s%s,%d,%s]"%(str(MD5_SIGN),send_data,msg[0],msg[1])\r
+ # print("AGTALK:send data:%s"%(data))\r
+ # print("WLKEY!!!!!!!!!!!!!")\r
+ # 通过socket发送到服务器端\r
+ EventMesh.publish(constants.EVENT.CHANNEL_SOCKET_SEND,data)\r
+\r
+ def recv(self, event, msg):\r
+ """\r
+ @param event:\r
+ @param msg: 接收到的下行数据\r
+ """\r
+ # b'[SZKW*867387060319166*000A*RTALK]'\r
+ print("RTALK!!!!!!!!!!!!!") \r
+ # [SZKW*876226002021444*003A*RTALK,3ef20e64f3abb84b27f7d764,8762260020214441701226522,1]'\r
+ msg = msg[1:-1]\r
+ msg_tmp = msg.decode('ascii')\r
+ msg_tmp_d = msg_tmp.split(',')\r
+ EventMesh.publish("app_rtalk_cb",1)\r
+\r
+ \r
+\r
+\r
+class ProtoColResolver(object):\r
+ def __init__(self):\r
+ self.protocol_list = []\r
+\r
+ def add_support(self, prot):\r
+ self.protocol_list.append(prot)\r
+ prot.initialization()\r
+\r
+ def handler(self, data):\r
+ # 这里接收数据\r
+ \r
+ EventMesh.debug_log("handler -> {}".format(data))\r
+ # if data.startswith('Init;'):\r
+ # data = data[5:]\r
+ # EventMesh.publish(constants.EVENT.SET_KEY, {"value": ujson.loads(data)['KEY']})\r
+ \r
+ # elif data.startswith("Update;"):\r
+ # data = data[7:]\r
+ # EventMesh.publish(constants.PROTOCOL.H04_RECV, data)\r
+ try:\r
+ if len(data) > 0: \r
+ #EventMesh.debug_log("handler:{}".format(len(data)))\r
+ playload_data(data)\r
+ except Exception as e:\r
+ EventMesh.debug_log("handler:ERROR:")\r
+ usys.print_exception(e)\r
+ EventMesh.debug_log("handler:error data:{}".format(len(data)))\r
projects / mirrors / ASR1603_G5.git / commitdiff