4g-云api文档

4g-云api文档

先进行连接，再互相传输数据

ip:*，*，*，*，port:8888,type:tcp

连接：

# from表明是哪一个4g卡
{'action':'connect', 'from': 'A/B/C'}
# 响应："connect_success"

发送

# to 要发送到哪个卡，message：发送的内容
{'action':'send', 'to': 'A/B/C', 'message': '***'}
# 响应："send_success"

心跳包，每30秒下发一次

# 下发内容：
"heartBeat"

python服务器脚本：

# -*- coding: utf-8 -*-
import functools
from tornado.platform.asyncio import AsyncIOMainLoop

from tornado.tcpserver import TCPServer
from tornado.iostream import StreamClosedError
from tornado import gen
from tornado.ioloop import IOLoop, PeriodicCallback

storage = {}

class EchoServer(TCPServer):
    async def handle_stream(self, stream, address):
        # storage = {}
        print(address)
        while True:
            try:
                data = await stream.read_bytes(1024, partial=True)
                try:
                    format_data = eval(data)
                    if format_data['action'] == 'connect':
                        storage[format_data['from']] = stream
                        stream.write(b"connect_success")
                        print('storage', storage)
                    elif format_data['action'] == 'send':
                        if format_data['to'] not in storage:
                            stream.write('{} not connect'.format(storage['to']).encode())
                        else:
                            storage_stream = storage[format_data['to']]
                            storage_stream.write(format_data['message'].encode())
                            stream.write(b'send_success')
                except NameError:
                    stream.write(b"wrong format")
            except StreamClosedError:
                for key ,value in storage:
                    if stream == value:
                        storage.pop(key)
                # storage.

    def heartbeat(self):
        # try:
        print(storage)
        if storage:
            for stream in storage.values():
                stream.write(b'heartBeat')
        else:
        # except:
            print('heartbeat_fail')

if __name__ == "__main__":
    AsyncIOMainLoop().install()
    server = EchoServer()
    server.listen(8888)
    server.start()

    # scheduler.add_job(functools.partial(EchoServerClientProtocol.heartbeat), 'interval', seconds=3, id='one')
    # PeriodicCallback(functools.partial(EchoServer.heartbeat2), callback_time=3000).start()  # start scheduler 每隔30s执行一次发送心跳包
    PeriodicCallback(functools.partial(EchoServer().heartbeat), callback_time=30000).start()  # start scheduler 每隔30s执行一次发送心跳包
    IOLoop.current().start()

python客户端脚本(不支持win，关键是要实现全双工通信)：

from socket import *
from time import ctime
import select
import sys

HOST = '*，*，*，*'
PORT = 8888
BUFSIZ = 1024
ADDR = (HOST, PORT)  # 服务器的地址与端口

tcpCliSock = socket(AF_INET, SOCK_STREAM)  # 生成客户端的套接字，并连上服务器
tcpCliSock.connect(ADDR)
input1 = [tcpCliSock, sys.stdin]
# 实现双工通讯
while True:
    readyInput, readyOutput, readyException = select.select(input1, [], [])
    for indata in readyInput:
        if indata == tcpCliSock:
            data = tcpCliSock.recv(BUFSIZ)
            if not data:
                break
            print(data)
        else:
            data = input()
            if not data:
                break
            tcpCliSock.send(data.encode())  # 发送时间与数据


# {'action':'connect', 'from': 'A'}
# {'action':'send', 'to': 'B', 'message': 'xxxxx'}

测试结果：

模仿A

模仿B