wqy
/
LampMainPy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

Browse Source
main
RIceWqy 2 years ago
commit aa6d67f879
1 changed files with 482 additions and 0 deletions
Show Stats Download Patch File Download Diff File

482
main.py
Unescape View File

@ -0,0 +1,482 @@
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)
Write Preview
Loading…
Cancel
Save