def send_data(data_raw):
print("Unpacking raw data...")
data = ustruct.unpack('lifff', data_raw)
loc, sensor_type, temp, press, hum = data
print("Location of measured reading: ", loc)
print("Sensor type: ", sensor_dict[sensor_type])
print("Temperature: %.2f C" % (temp)) ## Print temperature to console
print("Pressure: %.2f hPa" % (press)) ## Print pressure to console
print("Humidity: %.2f %%" % (hum)) ## Print humidity to console
print("\n")
print("Sending data up to MQTT server...")
client = MQTTClient("7a9e85d9-c8ed-40fd-becb-20de9fec2fe3", "io.adafruit.com",user="******", password="******", port=1883)
client.connect()
print("Sending temperature...\n")
client.publish(topic="yoplocheo/feeds/{}_{}_temperature".format(loc_dict[loc], sensor_dict[sensor_type]), msg=str(temp), retain = True)
utime.sleep_ms(1000)
print("Sending pressure...\n")
client.publish(topic="yoplocheo/feeds/{}_{}_pressure".format(loc_dict[loc], sensor_dict[sensor_type]), msg=str(press), retain = True)
utime.sleep_ms(1000)
print("Sending hum...\n")
client.publish(topic="yoplocheo/feeds/{}_{}_humidity".format(loc_dict[loc], sensor_dict[sensor_type]), msg=str(hum), retain = True)
utime.sleep_ms(1000)
print("Data sent.\n")
gc.collect()
class Pycom1:
def __init__(self):
self.x = '0'
def sub_cb(self, topic, msg):
self.x = str(msg)
def wifi_enable(self):
wlan = WLAN(mode=WLAN.STA)
wlan.connect("thingQbator",
auth=(WLAN.WPA2, "C1sco12345"),
timeout=5000)
while not wlan.isconnected():
machine.idle()
print("\nConnected to Wifi\n")
def mqtt_enable(self):
self.client = MQTTClient("pycom1", "173.39.91.118", port=1883)
self.client.set_callback(self.sub_cb)
self.client.connect()
self.client.subscribe(topic="qbator/call_temp")
def run(self):
while True:
self.client.check_msg()
if self.x.strip("b'") == '1':
print(self.x)
self.client.publish(topic="qbator/temp",
msg=str(int(t_sensor.temperature())))
self.client.publish(topic="qbator/hum",
msg=str(int(t_sensor.humidity())))
else:
continue
def send_to_thingspeak(datapoints):
mean_data = DataPoint.mean(datapoints)
thingspeak_data = mean_data.to_thingspeak()
print('sending data\n{}'.format(thingspeak_data))
success = False
number_of_retries = 3
while not success and number_of_retries > 0:
try:
client_id = binascii.hexlify(machine.unique_id())
client = MQTTClient(client_id,
'mqtt.thingspeak.com',
user='******',
password=MQTT_API_KEY,
port=8883,
ssl=True)
client.connect()
client.publish(
topic='channels/379710/publish/{}'.format(MQTT_WRITE_API_KEY),
msg=thingspeak_data)
client.disconnect()
success = True
except OSError as e:
print('network error: {}'.format(e.errno))
number_of_retries -= 1
pass
return success
class PublishPeriodicly():
"""发布对象
该类用于管理信息发布逻辑。可以通过在构造是设置interval参数，实现以一定的频率进行信息发布。
该类的pubInfo方法是可以被连续调用. 通过内部的定时器可以实现在连续调用时以一定频率Pub。
本质上是对数据流的降采样过程。
"""
def __init__(self,interval=1000):
"""构造函数
:param interval: 发布信息的周期, defaults to 1000
:type interval: int, optional
"""
self.__interval=interval
self.__MQTTC = MQTTClient("openmv", server="ali.cnworkshop.xyz", port=20000)
self.__MQTTC.connect()
self.__InnerCounter=pyb.millis()
def pubInfo(self,info):
"""发布信息
该函数可以被重复调用。但是会按照预设的周期发布信息。在两次有效发布之间的调用会立即返回。
:param info: 要发布到MQTT Broker 的信息
:type info: str
"""
if pyb.millis()-self.__InnerCounter >self.__interval:
print("pub%s"%info)
self.__InnerCounter=pyb.millis()
self.__MQTTC.publish("openmv/data",info)
def run(self):
# Now we setup our MQTT client
client = MQTTClient(self.io_id,
"io.adafruit.com",
user=self.io_user,
password=self.io_key,
port=self.port)
client.set_callback(self.message_callback)
client.connect()
client.subscribe(topic="{0}/feeds/sensors".format(self.io_user))
while True:
if self.sensor_on:
data = self.read_data()
print(" >", data)
client.publish(topic="{0}/feeds/temperature".format(
self.io_user),
msg=str(data[0]))
client.publish(topic="{0}/feeds/humidity".format(self.io_user),
msg=str(data[1]))
client.publish(topic="{0}/feeds/pressure".format(self.io_user),
msg=str(data[2]))
utime.sleep(self.update_frequency)
client.check_msg()
utime.sleep(1) # Check messages only once per second
class IotConnection:
def __init__(self, client_id, server):
self.client_id = client_id
self.client = MQTTClient(client_id, server, port=1883, keepalive=60)
self.client.set_callback(sub_cb)
self.client.set_last_will('backend/1/1/status/heartbeat',
'down',
retain=False,
qos=0)
self.client.connect()
self.client.publish(topic='backend/1/1/status/heartbeat',
msg='up',
qos=1)
def send_temperature(self, topic, value, unique_id):
data = {
"temperature": {
"value": str(value),
"unique_id": str(unique_id)
}
}
json_data = json.dumps(data)
print(topic, json_data)
self.client.publish(topic=topic, msg=json_data)
def send_humidity(self, topic, value, unique_id):
data = {"humidity": {"value": str(value), "unique_id": str(unique_id)}}
json_data = json.dumps(data)
print(topic, json_data)
self.client.publish(topic=topic, msg=json_data)
class MessageBuffer:
def __init__(self, broker, topic):
#def settimeout(duration):
# pass
self._broker = broker
self._topic = topic
self._client = MQTTClient("pytrack", self._broker, port=1883)
#self._client.settimeout = settimeout
self._client.connect()
self._chrono = Timer.Chrono()
self._chrono.start()
print("Connected to MQTT broker %s"%self._broker)
#self._client.publish(self._topic, "Hello!")
#_thread.start_new_thread(self._loop, [.1]) # ever loop with small delay
#self._alarm = Timer.Alarm(self._handler, 0.01 , periodic=True)
pass
def send(self, message):
print('out->', message)
self._client.publish(self._topic, message)
def get_timeout(self):
return self._chrono.read()
class MyMqtt:
def __init__(self):
secrets = ujson.load(open("secret.json", "r"))
self.secrets = secrets
self.user = self.secrets["MQTT_USER"]
self.password = secrets["MQTT_PASSWORD"]
self.group = self.secrets["MQTT_GROUP"]
self.client = MQTTClient("device_id",
"io.adafruit.com",
user=self.user,
password=self.password,
port=1883)
self.client.set_callback(sub_cb)
self.client.connect()
self.client.subscribe(
topic="{}/feeds/{}.{}".format(self.user, self.group, "led"))
def send_value(self, value, feed="button"):
# print('Sending {} to Adafruit or pretending to'.format(value))
self.client.publish(topic="{}/feeds/{}.{}".format(
self.user, self.group, feed),
msg='{}'.format(value))
return value
class MQTTDevice:
def __init__(self,
topic_online,
true_message="true",
false_message="false"):
self.true_message = true_message
self.false_message = false_message
self.client = MQTTClient(MQTT_CLIENT_ID_RANDOM,
MQTT_BROKER_ADDRESS,
port=MQTT_PORT,
keepalive=KEEP_ALIVE_TIME_SEC)
self.next_scheduled_ping_time = 0
self._client_setup(topic_online)
def _client_setup(self, topic_online):
self.client.set_last_will(topic_online, self.false_message)
self.client.connect()
self.client.publish(topic_online, self.true_message)
self.setup_subscriptions()
# override this method in subclass
# set callback and subscriptions
def setup_subscriptions(self):
pass
def _ping(self):
if (self.next_scheduled_ping_time < utime.time()):
self.client.ping()
self.next_scheduled_ping_time = utime.time() + PING_EVERY_SEC
#run method has to be called every execution cycle
def run(self):
self._ping()
self.client.check_msg()
def MQTTClientInit():
global mqttmsg
# wifi configuration
WIFI_SSID = 'LAPTOP-BHHF3UMN 4817'
WIFI_PASS = '******'
def sub_cb(topic, msg):
print(msg)
wlan = WLAN(mode=WLAN.STA)
wlan.connect(WIFI_SSID, auth=(WLAN.WPA2, WIFI_PASS), timeout=5000)
while not wlan.isconnected():
machine.idle()
print("Connected to WiFi\n")
client = MQTTClient("lights11", "io.adafruit.com",user="******", password="******", port=1883)
client.set_callback(sub_cb)
client.connect()
client.subscribe(topic="Yunwei/feeds/lights")
while True:
print("Sending "+mqttmsg)
client.publish(topic="Yunwei/feeds/lights", msg=mqttmsg)
time.sleep(5)
#print("Sending 222")
#client.publish(topic="Yunwei/feeds/lights", msg=mqttmsg)
client.check_msg()
time.sleep(5)
class Iot(object):
client_id = ubinascii.hexlify(machine.unique_id())
client = None
def __init__(self, *args, **kwargs):
super(Iot, self).__init__(*args, **kwargs)
try:
print('mqtt running')
self.client = MQTTClient(self.client_id,
"mqtt.eclipse.org",
keepalive=0)
self.client.connect()
self.client.set_callback(self.on_message)
self.client.subscribe(b"sooko/lampu")
while True:
self.client.wait_msg()
except:
print('mqtt stoped')
Wifi().disconnect()
machine.reset()
def on_message(self, topic, msg):
print(topic, msg)
if msg == b"on":
self.grenn_on()
self.client.publish(b"loger", b"saya hidup")
elif msg == b"off":
self.grenn_off()
self.client.publish(b"loger", b"saya mati")
def grenn_on(self):
Pin(2, Pin.OUT).value(0)
def grenn_off(self):
Pin(2, Pin.OUT).value(1)
def setupClient():
global client
client = MQTTClient("Pycom",
"io.adafruit.com",
user="******",
password="******",
port=1883)
client.connect()
def sub_mqtt_Connect():
client = MQTTClient("lopy", "192.168.2.1", port=1883)
client.set_callback(sub_mqtt)
client.connect()
client.subscribe(topic="distancia")
print("Suscrito...")
while True:
client.check_msg()
def connect_server():
global client
client = MQTTClient(client_id=UBIDOTS_DEVICE_LABEL,
server=UBIDOTS_BROKER_URL,
port=UBIDOTS_BROKER_PORT,
user=UBIDOTS_TOKEN,
password=UBIDOTS_PASSWORD)
client.connect()
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id, mqtt_server)
client.set_callback(sub_cb)
client.connect()
client.subscribe(topic_sub)
print('Connected to %s MQTT broker, subscribed to %s topic' %
(mqtt_server, topic_sub))
return client
def sendData(data):
client = MQTTClient(TiCo.id,
TiCo.broker_url,
user=TiCo.user,
password=TiCo.password,
port=1883)
client.set_callback(sub_cb)
client.connect()
#client.subscribe(topic=TiCo.topic)
print(data)
client.publish(topic=TiCo.topic, msg=str(data))
def Conexion_MQTT():
client_id = ubinascii.hexlify(m.unique_id())
mqtt_server = 'broker.hivemq.com'
port_mqtt = 1883
user_mqtt = ''
pswd_mqtt = ''
client = MQTTClient(client_id, mqtt_server,port_mqtt,user_mqtt,pswd_mqtt)
client.set_callback(form_sub)
client.connect()
client.subscribe(topic_publish.encode())
return client
def main(server=SERVER):
client = MQTTClient(CLIENT_ID, server)
client.set_callback(sub_cb)
client.connect()
client.subscribe(b"messages")
adc = ADC(0) # create ADC object on ADC pin
while True:
tstadc = adc.read()
client.publish(b'messages', tstadc)
time.sleep_ms(200)
c.disconnect()
class Board:
def __init__(self):
self.id = ubinascii.hexlify(machine.unique_id()).decode("utf-8")
print("machine id: {}".format(self.id))
self.mqtt = MQTTClient(self.id, MQTT_HOST, MQTT_PORT, MQTT_USER,
MQTT_PASSWORD)
self.led = Led()
self.lightsensor = Lightsensor()
self.dispatcher = {}
self.dispatcher["{}/led/rgb".format(
self.id)] = lambda rgb: self.led.set_rgb(rgb["red"], rgb["green"],
rgb["blue"])
self.dispatcher["{}/led/ping".format(
self.id)] = lambda msg: self.led.ping()
def process_message(self, topic, msg):
topic_str = topic.decode("utf-8")
msg_str = msg.decode("utf-8")
if topic_str in self.dispatcher:
self.dispatcher[topic_str](ujson.loads(msg_str))
def publish_lightlevel(self, alarm):
self.mqtt.publish(topic="lightdata",
msg=ujson.dumps({
"lightlevel":
self.lightsensor.get_lightlevel(),
"board_id":
self.id
}))
def run(self):
self.mqtt.set_callback(self.process_message)
self.mqtt.connect()
self.mqtt.subscribe("{}/led/rgb".format(self.id))
self.mqtt.subscribe("{}/led/ping".format(self.id))
self.mqtt.publish(topic="board_discovery",
msg=ujson.dumps({"id": self.id}))
alarms = []
alarms.append(
Timer.Alarm(handler=self.publish_lightlevel, s=5, periodic=True))
try:
while True:
self.mqtt.wait_msg()
machine.idle()
finally:
for alarm in alarms:
alarm.cancel()
self.mqtt.disconnect()
def main():
if (read_config() < 1):
base.print_error('[config.json]: no targets found in config.json file')
exit(-1)
mqtt = MQTTClient(config, base)
mqtt.connect()
scanner = Scanner(config, base)
while (True):
scanner.scan(config['interface'], mqtt_client=mqtt)
time.sleep(config['interval'])
def data(msg, PASSWD):
import setting
import ujson
from mqtt import MQTTClient
global answer
answer = 'OK'
IOTHUB = setting.get('iothub')
DEVICE = setting.get('iotdevicename')
KEY = setting.get('iotdevicesecret')
USER = IOTHUB + '/' + DEVICE + '/api-version=2016-11-14'
print('--------------MQTT----------')
print('DEVICE: ', DEVICE)
print('IOTHUB: ', IOTHUB)
print('USER: '******'PASSWD: ', PASSWD)
c = MQTTClient(
DEVICE, IOTHUB, 8883, USER, PASSWD, 0, True
) # client_id, server, port=0, user=None, password=None, keepalive=0, ssl=False, ssl_params={})
c.set_callback(sub_cb)
try:
c.connect()
print('--------------PUBLISH----------')
print('DEVICE: ', 'devices/' + DEVICE + '/messages/events/')
print('MSG: ', msg)
c.publish('devices/' + DEVICE + '/messages/events/', msg, False,
1) # topic, msg, retain=False, qos=0
c.subscribe('$iothub/twin/res/#', 1) # topic, qos=0
c.publish('$iothub/twin/GET/?$rid=2', '', False, 1)
c.wait_msg()
dictr = {}
dictr["RSSI"] = setting.get('RSSI')
dictr["health"] = setting.get('health')
dictr["hwid"] = setting.get('hwid')
dictr["VBat"] = setting.get('VBat')
dictr["FWversion"] = setting.get('FWversion')
dictr["FWnumber"] = setting.get('FWnumber')
try:
dict = ujson.loads(answer)
print('RX TWIN MSG: ', dict)
dict_rep = dict["reported"]
keyp = dict_rep["keypresses"] + 1
dictr["keypresses"] = keyp
except:
dictr["keypresses"] = 1
print('TX TWIN MSG: ', dictr)
reported = ujson.dumps(dictr)
c.publish('$iothub/twin/PATCH/properties/reported/?$rid=1', reported,
False, 1)
c.disconnect()
except ():
answer = 'ERROR'
return answer
class MessageBuffer:
def __init__(self, broker, topic):
#def settimeout(duration):
# pass
self._queue = []
self._broker = broker
self._topic = topic
self._client = MQTTClient("pytrack", self._broker, port=1883)
self._busy = False
#self._client.settimeout = settimeout
self._client.connect()
self._chrono = Timer.Chrono()
self._chrono.start()
print("Connected to MQTT broker %s"%self._broker)
self._client.publish(self._topic, "Hello!")
_thread.start_new_thread(self._loop, [.001]) # ever loop with small delay
pass
def push(self, message):
self._queue.append(message)
print('in <-', message)
pass
def pull(self):
global inactivity_timer
n = len(self._queue)
if n > 0:
self._busy = True
#try:
message = self._queue.pop(0)
print('out->', message)
self._client.publish(self._topic, message)
#except MQTTException:
# print('MQTT Exception raised')
self._chrono.reset()
self._busy = False
def _loop(self, delay):
while True:
if not self._busy:
self.pull()
time.sleep(delay)
def get_timeout(self):
return self._chrono.read()
def mqtt_connect():
"""Start the mqtt connection and return the connection object
"""
try:
if log:
print("starting mqtt connection to: {}:{}".format(broker, port))
client = MQTTClient(client_id, broker, user="", password="", port=port)
client.connect()
if log: print("mqtt connected!")
return client
except BaseException as err:
if log: print("error connecting mqtt: {}".format(err.args))
return
class Broker():
def __init__(self):
self.ip, self.client_id, self.topic, self.msg = self.getJsonInfo()
self.client = MQTTClient(self.client_id, self.ip)
time.sleep(3)
self.client.connect()
def objectDetected(self):
self.client.publish(self.topic, self.msg)
def getJsonInfo(self):
with open("settings.json") as file:
data = ujson.loads(file.read())
return (data["brokerIp"], data["clientId"], data["topic"], data["msg"])
def main(server=SERVER):
client = MQTTClient(CLIENT_ID, server, port=1883)
client.set_callback(sub_cb)
client.connect()
client.subscribe('messages_esp')
adc = ADC(0)
while True:
client.check_msg()
adcValue = adc.read()
messageAdc = {"adcValue": str(adcValue)}
client.publish('message_esp', ujson.dumps(messageAdc))
time.sleep(2)
client.disconnect()
def Conexion_MQTT():
client_id = b"Covid_" + ubinascii.hexlify(unique_id())
#client_id = b"covid"
mqtt_server = '10.50.1.153'
port_mqtt = 1883
user_mqtt = None #Si su servidor no necesita usuario escribe None sin comillas
pswd_mqtt = None #Si su servidor no necesita contraseña escribe None sin comillas
client = MQTTClient(client_id, mqtt_server, port_mqtt, user_mqtt,
pswd_mqtt)
client.set_callback(form_sub)
client.connect()
client.subscribe(b'SAL_DA')
print('Conectado a %s' % mqtt_server)
return client
def mqtt_connect():
global client
try:
tools.debug("Connecting MQTT", "v")
client = MQTTClient("gtw001_" + str(int(utime.time())),
globalVars.mqtt_url,
user=globalVars.mqtt_user,
password=globalVars.mqtt_psw,
port=1883)
client.set_callback(response_callback)
client.connect()
client.subscribe(topic=globalVars.mqtt_topic)
return client
except BaseException as e:
checkError("Error connecting to MQTT", e)
def Conexion_MQTT():
#client_id = b"Covid" + ubinascii.hexlify(machine.unique_id())
client_id = b"prueba"
mqtt_server = '10.50.1.153'
#mqtt_server = 'mantenimiento.elite.local'
port_mqtt = 1883
user_mqtt = None #Si su servidor no necesita usuario escribe None sin comillas
pswd_mqtt = None #Si su servidor no necesita contraseña escribe None sin comillas
client = MQTTClient(client_id, mqtt_server,port_mqtt,user_mqtt,pswd_mqtt)
client.set_callback(form_sub)
client.connect(True)
client.subscribe(b'SAL_DA')
print('Conectado a %s' % mqtt_server)
client.set_last_will(b'SAL_DA',b'Desconexión Inesperada')
return client
def connect_mqtt():
"""Connect to MQTT server and subscribe to command topics"""
client = MQTTClient(config.MQTT_CLIENT,
config.MQTT_SERVER,
user="",
password="",
port=config.MQTT_PORT)
client.set_callback(subscribe_commands)
client.connect()
print("Connected MQTT server at {}:{}".format(config.MQTT_SERVER,
config.MQTT_PORT))
client.subscribe(topic=config.TOPIC_COMMANDS)
print("Listening on topic '{}'".format(config.TOPIC_COMMANDS))
return client
def publish_thingsboard(token, UNIQUE_ID, data, password=''):
from mqtt import MQTTClient
import gc
import json
import machine
import utime
client = MQTTClient(UNIQUE_ID,
"iot.ier.unam.mx",
port=1883,
user=token,
password=password)
client.settimeout = settimeout
client.connect()
print(json.dumps(data))
client.publish('v1/devices/me/telemetry', json.dumps(data))
client.disconnect()
def main(server="test.mosquitto.org"):
c = MQTTClient("umqtt_clientc", server)
c.set_callback(sub_cb)
c.connect()
c.subscribe(b"mhermans/lights/#")
while True:
if True:
# Blocking wait for message
c.wait_msg()
else:
# Non-blocking wait for message
c.check_msg()
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep(1)
c.disconnect()
# MQTT Example.
# This example shows how to use the MQTT library.
#
# 1) Copy the mqtt.py library to OpenMV storage.
# 2) Install the mosquitto client on PC and run the following command:
# mosquitto_sub -h test.mosquitto.org -t "openmv/test" -v
#
import time, network
from mqtt import MQTTClient
SSID='mux' # Network SSID
KEY='j806fVnT7tObdCYE' # Network key
# Init wlan module and connect to network
print("Trying to connect... (may take a while)...")
wlan = network.WINC()
wlan.connect(SSID, key=KEY, security=wlan.WPA_PSK)
# We should have a valid IP now via DHCP
print(wlan.ifconfig())
client = MQTTClient("openmv", "test.mosquitto.org", port=1883)
client.connect()
while (True):
client.publish("openmv/test", "Hello World!")
time.sleep(1000)
from mqtt import MQTTClient
#c = MQTTClient("huzzah", "broker.hivemq.com", port=1883)
c = MQTTClient("huzzah", "test.mosquitto.org", port=1883)
c.connect()
c.publish(b"mhermans/lights/1", b"0,0,0")
c.disconnect()
