|
|
import log
|
|
|
import usocket as socket
|
|
|
import ubinascii as binascii
|
|
|
import urandom as random
|
|
|
import log
|
|
|
import ure as re
|
|
|
import ustruct as struct
|
|
|
import urandom as random
|
|
|
import _thread
|
|
|
import utime
|
|
|
import checkNet
|
|
|
import ujson
|
|
|
import utime
|
|
|
from uio import StringIO
|
|
|
"""
|
|
|
运行本例程，需要通过串口线连接开发板的 MAIN 口和PC，在PC上通过串口工具
|
|
|
打开 MAIN 口，并向该端口发送数据，即可看到 PC 发送过来的消息。
|
|
|
"""
|
|
|
from machine import UART
|
|
|
|
|
|
'''
|
|
|
* 参数1：端口
|
|
|
注：EC100YCN平台与EC600SCN平台，UARTn作用如下
|
|
|
UART0 - DEBUG PORT
|
|
|
UART1 – BT PORT
|
|
|
UART2 – MAIN PORT
|
|
|
UART3 – USB CDC PORT
|
|
|
* 参数2：波特率
|
|
|
* 参数3：data bits （5~8）
|
|
|
* 参数4：Parity （0：NONE 1：EVEN 2：ODD）
|
|
|
* 参数5：stop bits （1~2）
|
|
|
* 参数6：flow control （0: FC_NONE 1：FC_HW）
|
|
|
'''
|
|
|
from ucollections import namedtuple
|
|
|
|
|
|
|
|
|
|
|
|
REG_REQUEST = {
|
|
|
"jsonrpc": "2.0",
|
|
|
"id": "1",
|
|
|
"method":"/iotserver/device/reg",
|
|
|
"params":{
|
|
|
"secret_key":"ELXPMM12bxE0LQ6YtWr9u7tyZZSMWALKAIiLdDlwUai5SBUS",
|
|
|
"serial_number":"SN_TEST_REAL_001"
|
|
|
}
|
|
|
}
|
|
|
|
|
|
GRAVITY = 9.8
|
|
|
|
|
|
LOGGER = log.getLogger(__name__)
|
|
|
|
|
|
# Opcodes
|
|
|
OP_CONT = 0x0
|
|
|
OP_TEXT = 0x1
|
|
|
OP_BYTES = 0x2
|
|
|
OP_CLOSE = 0x8
|
|
|
OP_PING = 0x9
|
|
|
OP_PONG = 0xa
|
|
|
|
|
|
# Close codes
|
|
|
CLOSE_OK = 1000
|
|
|
CLOSE_GOING_AWAY = 1001
|
|
|
CLOSE_PROTOCOL_ERROR = 1002
|
|
|
CLOSE_DATA_NOT_SUPPORTED = 1003
|
|
|
CLOSE_BAD_DATA = 1007
|
|
|
CLOSE_POLICY_VIOLATION = 1008
|
|
|
CLOSE_TOO_BIG = 1009
|
|
|
CLOSE_MISSING_EXTN = 1010
|
|
|
CLOSE_BAD_CONDITION = 1011
|
|
|
|
|
|
URL_RE = re.compile(r'(wss|ws)://([A-Za-z0-9-\.]+)(?:\:([0-9]+))?(/.+)?')
|
|
|
URI = namedtuple('URI', ('protocol', 'hostname', 'port', 'path'))
|
|
|
|
|
|
|
|
|
def urlparse(uri):
|
|
|
"""Parse ws:// URLs"""
|
|
|
match = URL_RE.match(uri)
|
|
|
if match:
|
|
|
protocol = match.group(1)
|
|
|
host = match.group(2)
|
|
|
port = match.group(3)
|
|
|
path = match.group(4)
|
|
|
|
|
|
if protocol == 'wss':
|
|
|
if port is None:
|
|
|
port = 443
|
|
|
elif protocol == 'ws':
|
|
|
if port is None:
|
|
|
port = 80
|
|
|
else:
|
|
|
raise ValueError('Scheme {} is invalid'.format(protocol))
|
|
|
|
|
|
return URI(protocol, host, int(port), path)
|
|
|
|
|
|
|
|
|
class NoDataException(Exception):
|
|
|
pass
|
|
|
|
|
|
|
|
|
class ConnectionClosed(Exception):
|
|
|
pass
|
|
|
|
|
|
|
|
|
class Websocket(object):
|
|
|
"""
|
|
|
Basis of the Websocket protocol.
|
|
|
|
|
|
This can probably be replaced with the C-based websocket module, but
|
|
|
this one currently supports more options.
|
|
|
"""
|
|
|
is_client = False
|
|
|
|
|
|
def __init__(self, sock, debug=False):
|
|
|
self.sock = sock
|
|
|
self.open = True
|
|
|
self.debug = debug
|
|
|
|
|
|
def __enter__(self):
|
|
|
return self
|
|
|
|
|
|
def __exit__(self, exc_type, exc, tb):
|
|
|
self.close()
|
|
|
|
|
|
def settimeout(self, timeout):
|
|
|
self.sock.settimeout(timeout)
|
|
|
|
|
|
def read_frame(self, max_size=None):
|
|
|
"""
|
|
|
Read a frame from the socket.
|
|
|
See https://tools.ietf.org/html/rfc6455#section-5.2 for the details.
|
|
|
"""
|
|
|
|
|
|
# Frame header
|
|
|
two_bytes = self.sock.read(2)
|
|
|
|
|
|
if not two_bytes:
|
|
|
raise NoDataException
|
|
|
|
|
|
byte1, byte2 = struct.unpack('!BB', two_bytes)
|
|
|
|
|
|
# Byte 1: FIN(1) _(1) _(1) _(1) OPCODE(4)
|
|
|
fin = bool(byte1 & 0x80)
|
|
|
opcode = byte1 & 0x0f
|
|
|
|
|
|
# Byte 2: MASK(1) LENGTH(7)
|
|
|
mask = bool(byte2 & (1 << 7))
|
|
|
length = byte2 & 0x7f
|
|
|
|
|
|
if length == 126: # Magic number, length header is 2 bytes
|
|
|
length, = struct.unpack('!H', self.sock.read(2))
|
|
|
elif length == 127: # Magic number, length header is 8 bytes
|
|
|
length, = struct.unpack('!Q', self.sock.read(8))
|
|
|
|
|
|
if mask: # Mask is 4 bytes
|
|
|
mask_bits = self.sock.read(4)
|
|
|
|
|
|
try:
|
|
|
data = self.sock.read(length)
|
|
|
except MemoryError:
|
|
|
# We can't receive this many bytes, close the socket
|
|
|
if self.debug: LOGGER.info("Frame of length %s too big. Closing", length)
|
|
|
self.close(code=CLOSE_TOO_BIG)
|
|
|
return True, OP_CLOSE, None
|
|
|
|
|
|
if mask:
|
|
|
data = bytes(b ^ mask_bits[i % 4]
|
|
|
for i, b in enumerate(data))
|
|
|
|
|
|
return fin, opcode, data
|
|
|
|
|
|
def write_frame(self, opcode, data=b''):
|
|
|
"""
|
|
|
Write a frame to the socket.
|
|
|
See https://tools.ietf.org/html/rfc6455#section-5.2 for the details.
|
|
|
"""
|
|
|
fin = True
|
|
|
mask = self.is_client # messages sent by client are masked
|
|
|
|
|
|
length = len(data)
|
|
|
|
|
|
# Frame header
|
|
|
# Byte 1: FIN(1) _(1) _(1) _(1) OPCODE(4)
|
|
|
byte1 = 0x80 if fin else 0
|
|
|
byte1 |= opcode
|
|
|
|
|
|
# Byte 2: MASK(1) LENGTH(7)
|
|
|
byte2 = 0x80 if mask else 0
|
|
|
|
|
|
if length < 126: # 126 is magic value to use 2-byte length header
|
|
|
byte2 |= length
|
|
|
self.sock.write(struct.pack('!BB', byte1, byte2))
|
|
|
|
|
|
elif length < (1 << 16): # Length fits in 2-bytes
|
|
|
byte2 |= 126 # Magic code
|
|
|
self.sock.write(struct.pack('!BBH', byte1, byte2, length))
|
|
|
|
|
|
elif length < (1 << 64):
|
|
|
byte2 |= 127 # Magic code
|
|
|
self.sock.write(struct.pack('!BBQ', byte1, byte2, length))
|
|
|
|
|
|
else:
|
|
|
raise ValueError()
|
|
|
|
|
|
if mask: # Mask is 4 bytes
|
|
|
mask_bits = struct.pack('!I', random.getrandbits(32))
|
|
|
self.sock.write(mask_bits)
|
|
|
|
|
|
data = bytes(b ^ mask_bits[i % 4]
|
|
|
for i, b in enumerate(data))
|
|
|
|
|
|
self.sock.write(data)
|
|
|
|
|
|
def recv(self):
|
|
|
"""
|
|
|
Receive data from the websocket.
|
|
|
|
|
|
This is slightly different from 'websockets' in that it doesn't
|
|
|
fire off a routine to process frames and put the data in a queue.
|
|
|
If you don't call recv() sufficiently often you won't process control
|
|
|
frames.
|
|
|
"""
|
|
|
assert self.open
|
|
|
|
|
|
while self.open:
|
|
|
try:
|
|
|
fin, opcode, data = self.read_frame()
|
|
|
except NoDataException:
|
|
|
return ''
|
|
|
except ValueError:
|
|
|
if self.debug: LOGGER.info("Failed to read frame. Socket dead.")
|
|
|
self._close()
|
|
|
raise ConnectionClosed()
|
|
|
|
|
|
if not fin:
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
if opcode == OP_TEXT:
|
|
|
return data.decode('utf-8')
|
|
|
elif opcode == OP_BYTES:
|
|
|
return data
|
|
|
elif opcode == OP_CLOSE:
|
|
|
self._close()
|
|
|
return
|
|
|
elif opcode == OP_PONG:
|
|
|
# Ignore this frame, keep waiting for a data frame
|
|
|
continue
|
|
|
elif opcode == OP_PING:
|
|
|
# We need to send a pong frame
|
|
|
if self.debug: LOGGER.info("Sending PONG")
|
|
|
self.write_frame(OP_PONG, data)
|
|
|
# And then wait to receive
|
|
|
continue
|
|
|
elif opcode == OP_CONT:
|
|
|
# This is a continuation of a previous frame
|
|
|
raise NotImplementedError(opcode)
|
|
|
else:
|
|
|
raise ValueError(opcode)
|
|
|
|
|
|
def send(self, buf):
|
|
|
"""Send data to the websocket."""
|
|
|
|
|
|
assert self.open
|
|
|
|
|
|
if isinstance(buf, str):
|
|
|
opcode = OP_TEXT
|
|
|
buf = buf.encode('utf-8')
|
|
|
elif isinstance(buf, bytes):
|
|
|
opcode = OP_BYTES
|
|
|
else:
|
|
|
raise TypeError()
|
|
|
|
|
|
self.write_frame(opcode, buf)
|
|
|
|
|
|
def close(self, code=CLOSE_OK, reason=''):
|
|
|
"""Close the websocket."""
|
|
|
if not self.open:
|
|
|
return
|
|
|
|
|
|
buf = struct.pack('!H', code) + reason.encode('utf-8')
|
|
|
|
|
|
self.write_frame(OP_CLOSE, buf)
|
|
|
self._close()
|
|
|
|
|
|
def _close(self):
|
|
|
if self.debug: LOGGER.info("Connection closed")
|
|
|
self.open = False
|
|
|
self.sock.close()
|
|
|
|
|
|
|
|
|
class WebsocketClient(Websocket):
|
|
|
is_client = True
|
|
|
|
|
|
|
|
|
class Client(object):
|
|
|
|
|
|
@staticmethod
|
|
|
def connect(uri, headers=None, debug=False):
|
|
|
"""
|
|
|
Connect a websocket.
|
|
|
:param uri: example ws://172.16.185.123/
|
|
|
:param headers: k, v of header
|
|
|
:param debug: allow output log
|
|
|
:return:
|
|
|
"""
|
|
|
if not headers:
|
|
|
headers = dict()
|
|
|
if not isinstance(headers, dict):
|
|
|
raise Exception("headers must be dict type but {} you given.".format(type(headers)))
|
|
|
|
|
|
uri = urlparse(uri)
|
|
|
assert uri
|
|
|
|
|
|
if debug: LOGGER.info("open connection %s:%s",
|
|
|
uri.hostname, uri.port)
|
|
|
|
|
|
sock = socket.socket()
|
|
|
addr = socket.getaddrinfo(uri.hostname, uri.port)
|
|
|
|
|
|
sock.connect(addr[0][4])
|
|
|
|
|
|
|
|
|
|
|
|
if uri.protocol == 'wss':
|
|
|
import ussl
|
|
|
sock = ussl.wrap_socket(sock)
|
|
|
|
|
|
def send_header(header, *args):
|
|
|
if debug: LOGGER.info(str(header), *args)
|
|
|
sock.write(header % args + '\r\n')
|
|
|
|
|
|
# Sec-WebSocket-Key is 16 bytes of random base64 encoded
|
|
|
key = binascii.b2a_base64(bytes(random.getrandbits(8) for _ in range(16)))[:-1]
|
|
|
send_header(b'GET %s HTTP/1.1', uri.path or '/')
|
|
|
send_header(b'Host: %s:%s', uri.hostname, uri.port)
|
|
|
send_header(b'Connection: Upgrade')
|
|
|
send_header(b'Upgrade: websocket')
|
|
|
send_header(b'Sec-WebSocket-Key: %s', key)
|
|
|
send_header(b'Sec-WebSocket-Version: 13')
|
|
|
send_header(b'Origin: http://{hostname}:{port}'.format(
|
|
|
hostname=uri.hostname,
|
|
|
port=uri.port)
|
|
|
)
|
|
|
for k, v in headers.items():
|
|
|
send_header('{}:{}'.format(k, v).encode())
|
|
|
send_header(b'')
|
|
|
|
|
|
header = sock.readline()[:-2]
|
|
|
assert header.startswith(b'HTTP/1.1 101 '), header
|
|
|
|
|
|
# We don't (currently) need these headers
|
|
|
# FIXME: should we check the return key?
|
|
|
while header:
|
|
|
if debug: LOGGER.info(str(header))
|
|
|
header = sock.readline()[:-2]
|
|
|
|
|
|
return WebsocketClient(sock, debug)
|
|
|
|
|
|
|
|
|
def recv(cli):
|
|
|
while True:
|
|
|
# 死循环接收数据
|
|
|
recv_data = cli.recv()
|
|
|
|
|
|
print(recv_data)
|
|
|
|
|
|
if not recv_data:
|
|
|
# 服务器关闭连接或客户端关闭连接
|
|
|
print("cli close")
|
|
|
cli.close()
|
|
|
break
|
|
|
#io = StringIO()
|
|
|
#ujson.dump("{}".format(recv_data), io)
|
|
|
request = ujson.loads("{}".format(recv_data))
|
|
|
|
|
|
if "method" in request:
|
|
|
if request["method"] == "/lampControl/push":
|
|
|
uart_test = Example_uart(bate=9600)
|
|
|
print(request["params"])
|
|
|
print("{}".format(request["params"]))
|
|
|
uart_test.uartWrite("{}".format(request["params"]))
|
|
|
utime.sleep(2)
|
|
|
print(uart_test.uartRead(1024))
|
|
|
del uart_test
|
|
|
continue
|
|
|
|
|
|
if request["method"] == "/lampControl":
|
|
|
uart_test = Example_uart(bate=9600)
|
|
|
print(request["params"])
|
|
|
print("{}".format(request["params"]))
|
|
|
uart_test.uartWrite("{}".format(request["params"]))
|
|
|
utime.sleep(2)
|
|
|
msg = uart_test.uartRead(1024)
|
|
|
print(msg)
|
|
|
utf8_msg = msg.decode()
|
|
|
|
|
|
resp = {
|
|
|
"jsonrpc": "2.0",
|
|
|
"id": request["id"],
|
|
|
"result":utf8_msg,
|
|
|
"error":{
|
|
|
"message":"",
|
|
|
"code":200,
|
|
|
"data":""
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
cli.send(ujson.dumps(resp))
|
|
|
|
|
|
del uart_test
|
|
|
continue
|
|
|
|
|
|
if request["method"] == "towgo.websocket.ping":
|
|
|
del request["params"]
|
|
|
del request["method"]
|
|
|
request["error"]={'message':"no",'code':500}
|
|
|
|
|
|
|
|
|
json_str = ujson.dumps(request)
|
|
|
cli.send(json_str)
|
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 设置日志输出级别
|
|
|
log.basicConfig(level=log.INFO)
|
|
|
uart_log = log.getLogger("UART")
|
|
|
|
|
|
class Example_uart(object):
|
|
|
def __init__(self, no=UART.UART2, bate=115200, data_bits=8, parity=0, stop_bits=1, flow_control=0):
|
|
|
self.uart = UART(no, bate, data_bits, parity, stop_bits, flow_control)
|
|
|
#self.uart.set_callback(self.callback)
|
|
|
|
|
|
|
|
|
def callback(self, para):
|
|
|
uart_log.info("call para:{}".format(para))
|
|
|
if(0 == para[0]):
|
|
|
self.uartRead(para[2])
|
|
|
|
|
|
|
|
|
def uartWrite(self, msg):
|
|
|
uart_log.info("write msg:{}".format(msg))
|
|
|
self.uart.write(msg)
|
|
|
|
|
|
def uartRead(self, len):
|
|
|
msg = self.uart.read(len)
|
|
|
utf8_msg = msg.decode()
|
|
|
uart_log.info("UartRead msg: {}".format(utf8_msg))
|
|
|
return utf8_msg
|
|
|
|
|
|
def uartWrite_test(self):
|
|
|
for i in range(10):
|
|
|
write_msg = "Hello count={}".format(i)
|
|
|
self.uartWrite(write_msg)
|
|
|
utime.sleep(1)
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
while True:
|
|
|
stagecode, subcode = checkNet.wait_network_connected(30)
|
|
|
if stagecode == 3 and subcode == 1:
|
|
|
try:
|
|
|
client = Client.connect('wss://iotserver.ruixininfo.com/jsonrpc/websocket', debug=False)
|
|
|
|
|
|
client.send(ujson.dumps(REG_REQUEST))
|
|
|
#print(s)
|
|
|
#utime.sleep(2)
|
|
|
|
|
|
print("发送注册信息成功,开始接收信息")
|
|
|
recv(client)
|
|
|
|
|
|
except Exception as e:
|
|
|
print(e)
|
|
|
# We can't receive this many bytes, close the socket
|
|
|
|
|
|
utime.sleep(10) |
