예제 #1
0
class MqttClient():
    '''
    mqtt init
    '''

    def __init__(self, clientid, server, port, pw):
        self.clientid = clientid
        self.pw = pw
        self.server = server
        self.port = port
        self.uasename = clientid
        self.client = None

    def connect(self):
        self.client = MQTTClient(self.clientid, self.server, self.port, self.uasename, self.pw, keepalive=300)
        self.client.set_callback(self.sub_cb)
        self.client.connect()

    def sub_cb(self, topic, msg):
        print("Subscribe Recv:   %s, %s" % (topic.decode(), msg.decode()))

    def subscribe(self, topic, qos=0):
        self.client.subscribe(topic, qos)

    def publish(self, topic, msg, qos=0):
        self.client.publish(topic, msg, qos)

    def disconnect(self):
        self.disconnect()

    def __loop_forever(self, t):
        # print("loop_forever")
        try:
            self.client.ping()
        except:
            return -1

    def __listen(self):
        while True:
            try:
                self.client.wait_msg()
            except OSError as e:
                return -1

    def start(self):
        _thread.start_new_thread(self.__listen, ())
        t = Timer(1)
        t.start(period=20000, mode=t.PERIODIC, callback=self.__loop_forever)
예제 #2
0
def message_received(topic, msg):
    msg = msg.decode("utf-8")
    print("Message received: " + msg)
    morse.enqueue_message(msg)


print("Connecting to " + private.aio_server)
client = MQTTClient(client_id=private.client_id,
                    server=private.aio_server,
                    user=private.aio_user,
                    password=private.aio_key,
                    keepalive=30,
                    ssl=False)
client.set_callback(message_received)
client.connect()
client.subscribe(private.aio_feed)

morse = Morse()
morse.enqueue_message("ok", 'G')

timer = time.ticks_ms()
print("Running...")
while True:
    client.check_msg()
    if time.ticks_diff(time.ticks_ms(), timer) > 30000:
        client.ping()
        timer = time.ticks_ms()
    machine.idle()
    time.sleep_ms(100)