#著作権 (c) 2015-2019 Volodymyr Simansky. Consulte el archivo LICENSE para obtener permisos de copia.
__Versión__ = “1.0.0”
importación Estructura
importación Hora
importación …sys
importación Masculino
probar:
importación máquina
Obtener tiempo = lambda: Hora.ticks_ms()
SOCK_TIMEOUT = 0
exceptuar Error de importación:
constante = lambda x: x
Obtener tiempo = lambda: entero(Hora.Hora() * 1000)
SOCK_TIMEOUT = 0.05
Def tonto(*argumento):
pasar
MSG_RSP = constante(0)
MSG_LOGIN = constante(2)
MSG_PING = constante(6)
MSG_TWEET = constante(12)
MSG_NOTIFY = constante(14)
MSG_BRIDGE = constante(15)
MSG_HW_SYNC = constante(16)
MSG_INTERNAL = constante(17)
MSG_PROPERTY = constante(19)
MSG_HW = constante(20)
MSG_HW_LOGIN = constante(29)
MSG_EVENT_LOG = constante(64)
MSG_REDIRECT = constante(41) # TAREAS: No implementado
MSG_DBG_PRINT = constante(55) # TAREAS: No implementado
STA_SUCCESS = constante(200)
STA_INVALID_TOKEN = constante(9)
roto = constante(0)
conexión = constante(1)
conexión = constante(2)
Impresión(“”“
___ __ __
/ _ )/ /_ _____ / /__
/ _ / / // / _ \\/ ‘_/
/____/_/\\_, /_//_/_/\\_\\
/___/ para Python v”“” + __Versión__ + ” (“ + …sys.plataforma + “)\n”)
…class Emisores de eventos:
Def __Init__(propio):
propio._cbks = {}
Def en(propio, Teletipo, f=ninguno):
Si f:
propio._cbks[evt] = f
de otra manera:
Def D(f):
propio._cbks[evt] = f
devolución f
devolución D
Def emitir(propio, Teletipo, *Ser, **Kv):
Si Teletipo Y propio._cbks:
propio._cbks[evt](*Ser, **Kv)
…class Protocolo de parpadeo(Emisores de eventos):
Def __Init__(propio, autenticación, tmpl_id=ninguno, fw_ver=ninguno, latido=50, Baffin=1024, …log=ninguno):
Emisores de eventos.__Init__(propio)
propio.latido = Latido*1000
propio.Baffin = Baffin
propio.…log = …log o tonto
propio.autenticación = autenticación
propio.tmpl_id = tmpl_id
propio.fw_ver = fw_ver
propio.estado = roto
propio.conectar()
Def virtual_write(propio, anclar, *Val):
propio._Transmisión(MSG_HW, ‘VW’, anclar, *Val)
Def send_internal(propio, anclar, *Val):
propio._Transmisión(MSG_INTERNAL, anclar, *Val)
Def set_property(propio, anclar, puntal, *Val):
propio._Transmisión(MSG_PROPERTY, anclar, puntal, *Val)
Def sync_virtual(propio, *anclar):
propio._Transmisión(MSG_HW_SYNC, ‘VR’, *anclar)
Def log_event(propio, *Val):
propio._Transmisión(MSG_EVENT_LOG, *Val)
Def _Transmisión(propio, Teletipo, *argumento, **Kwags):
Si ‘id’ Y Kwags:
Documentos de identificación = Kwags.adquisición(‘id’)
de otra manera:
Documentos de identificación = propio.msg_id
propio.msg_id += 1
Si propio.msg_id > 0xFFFF:
propio.msg_id = 1
Si Teletipo == MSG_RSP:
datos = b”
Drenar = argumento[0]
de otra manera:
datos = (‘\0’.conexión(mapa(Teletipo, argumento))).codificar(‘utf8’)
Drenar = Len(datos)
propio.…log(‘<‘, Teletipo, Documentos de identificación, ‘|’, *argumento)
…msg = Estructura.duende(“¡Vaya!”, Teletipo, Documentos de identificación, Drenar) + datos
propio.Enviar último = Obtener tiempo()
propio._escribir(…msg)
Def conectar(propio):
Si propio.estado != roto: devolución
propio.msg_id = 1
(propio.Última caminata, propio.Enviar último, propio.Último Pin) = (Obtener tiempo(), 0, 0)
propio.…bin = b“”
propio.estado = conexión
propio._Transmisión(MSG_HW_LOGIN, propio.autenticación)
Def cortar(propio):
Si propio.estado == roto: devolución
propio.…bin = b“”
propio.estado = roto
propio.emitir(“Desconectar”)
Def proceso(propio, datos=ninguno):
Si No (propio.estado == Connectin G o propio.estado == conexión): devolución
Ahora = Obtener tiempo()
Si Ahora – propio.Última caminata > propio.latido+(propio.latido2):
devolución propio.cortar()
Si (Ahora – propio.Último Pin > propio.latido10 y
(Ahora – propio.Enviar último > propio.latido o
Ahora – propio.Última caminata > propio.latido)):
propio._Transmisión(MSG_PING)
propio.Último Pin = Ahora
Si datos != ninguno Y Len(datos):
propio.…bin += datos
mientras verdadero:
Si Len(propio.…bin) < 5:
quebrar
Teletipo, Yo, Drenar = Estructura.descongelación(“¡Vaya!”, propio.…bin[:5])
Si Yo == 0: devolución propio.cortar()
propio.Última caminata = Ahora
Si Teletipo == MSG_RSP:
propio.…bin = propio.…bin[5:]
propio.…log(‘>’, Teletipo, Yo, ‘|’, Drenar)
Si propio.estado == conexión Y Yo == 1:
Si Drenar == STA_SUCCESS:
propio.estado = conexión
Teletipo = Ahora – propio.Enviar último
información = [‘ver’, __version__, ‘h-beat’, self.heartbeat//1000, ‘buff-in’, self.buffin, ‘dev’, sys.platform+’-py’]
Si propio.tmpl_id:
información.extender([‘tmpl’, self.tmpl_id])
información.extender([‘fw-type’, self.tmpl_id])
Si propio.fw_ver:
información.extender([‘fw’, self.fw_ver])
propio._Transmisión(MSG_INTERNAL, *información)
probar:
propio.emitir(“Conectado”, anclar=Teletipo)
exceptuar Error tipográfico:
propio.emitir(“Conectado”)
de otra manera:
Si Drenar == STA_INVALID_TOKEN:
propio.emitir(「invalid_auth」)
Impresión(“Token de autenticación no válido”)
devolución propio.cortar()
de otra manera:
Si Drenar >= propio.Baffin:
Impresión(“cmd demasiado grande:”, Drenar)
devolución propio.cortar()
Si Len(propio.…bin) < 5+Drenar:
quebrar
datos = propio.…bin[5:5+dlen]
propio.…bin = propio.…bin[5+dlen:]
argumento = lista(mapa(lambda x: x.descodificar(‘utf8’), datos.partir(b‘\0’)))
propio.…log(‘>’, Teletipo, Yo, ‘|’, ‘,’.conexión(argumento))
Si Teletipo == MSG_PING:
propio._Transmisión(MSG_RSP, STA_SUCCESS, Documentos de identificación=Yo)
Elihu Teletipo == MSG_HW o Teletipo == MSG_BRIDGE:
Si argumento[0] == ‘VW’:
propio.emitir(“V”+argumento[1], argumento[2:])
propio.emitir(“V*”, argumento[1], argumento[2:])
Elihu Teletipo == MSG_INTERNAL:
propio.emitir(“Interno:”+argumento[0], argumento[1:])
Elihu Teletipo == MSG_REDIRECT:
propio.emitir(Redirigir, argumento[0], entero(argumento[1]))
de otra manera:
Impresión(“Coman inesperadoDe: “, Teletipo)
devolución propio.cortar()
importación enchufe
…class Parpadear(Protocolo de parpadeo):
Def __Init__(propio, autenticación, **Kwags):
propio.ansiedad = Kwags.pop(“Inseguro”, falso)
propio.servidor = Kwags.pop(‘Servidor’, 「blynk.cloud」)
propio.puerto = Kwags.pop(‘puerto’, 80 Si propio.ansiedad de otra manera 443)
Protocolo de parpadeo.__Init__(propio, autenticación, **Kwags)
propio.en(‘redirigir’, propio.redirigir)
Def redirigir(propio, servidor, puerto):
propio.servidor = servidor
propio.puerto = puerto
propio.cortar()
propio.conectar()
Def conectar(propio):
Impresión(Conexión a ‘%s:%d …’ % (propio.servidor, propio.puerto))
s = enchufe.enchufe()
s.conectar(enchufe.getaddrinfo(propio.servidor, propio.puerto)[0][–1])
probar:
s.Cetsocopt(enchufe.IPPROTO_TCP, enchufe.TCP_NODELAY, 1)
exceptuar:
pasar
Si propio.ansiedad:
propio.Contra = s
de otra manera:
probar:
importación Teletipo
ssl_context = Teletipo
exceptuar Error de importación:
importación Teletipo
ssl_context = Teletipo.create_default_context()
propio.Contra = ssl_context.wrap_socket(s, server_hos Nombre=propio.servidor)
probar:
propio.Contra.Establecer tiempo de espera(SOCK_TIMEOUT)
exceptuar:
s.Establecer tiempo de espera(SOCK_TIMEOUT)
Protocolo de parpadeo.conectar(propio)
Def _escribir(propio, datos):
#print(‘<‘, datos)
propio.Contra.escribir(datos)
# TAREAS: Mango de corte
Def correr(propio):
datos = b”
probar:
datos = propio.Contra.leer(propiotú.Baffin)
#print(‘>’, datos)
exceptuar Interrupciones de teclado:
levantar
exceptuar enchufe.Tiempo de espera:
#データが受信されず llamar al proceso que envía un mensaje de ping si es necesario
pasar
exceptuar: # TAREAS: Mango de corte
devolución
propio.proceso(datos)