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 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 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 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)
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 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 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_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 mqtt_client(MQTT_HOST, callback, subtopic):
assert type(subtopic) is list
mqtt = MQTTClient(CLIENT_ID, MQTT_HOST)
if callback:
mqtt.set_callback(callback)
connect_mqtt(mqtt)
for topic in subtopic:
log('Subscribing to %s' % topic)
mqtt.subscribe(topic)
return mqtt
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 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))
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(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()
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
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 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 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 setup_mqtt():
global client
client = MQTTClient(client_id=config.CLIENT_ID,
server=config.AWS_HOST,
port=config.AWS_PORT,
keepalive=10000,
ssl=True,
ssl_params={
"certfile": config.AWS_CLIENT_CERT,
"keyfile": config.AWS_PRIVATE_KEY,
"ca_certs": config.AWS_ROOT_CA
})
client.set_callback(sub_callback)
client.connect()
client.subscribe(config.TOPIC)
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()
def main():
print("starting")
time.sleep(1.0)
# Since open-drain on() means relays OFF and off() means Relays ON
RELAY1.on()
RELAY2.on()
client = MQTTClient("relays1", "192.168.1.145", port=1883)
client.settimeout = settimeout
client.connect()
client.set_callback(switch)
client.subscribe("switching/#")
while True:
client.check_msg()
print("waiting")
time.sleep(1.0)
def main():
pycom.heartbeat(False) # Quito parpadeo
pycom.rgbled(0x000000)
wifiOn()
client = MQTTClient('d:89g41g:pycom:device_py', '89g41g.messaging.internetofthings.ibmcloud.com', user='******', password='******', port=1883) # CAMBIAR IP POR LA DEL SERVIDOR ACTUAL
client.set_callback(callback_function)
client.connect()
print("Conectado al servidor: 89g41g.internetofthings.ibmcloud.com")
pycom.rgbled(0x05ff16) # Mostramos un led verde para indicar que la conexión se realizó adecuadamente
time.sleep(2) # Durante dos segundos
pycom.rgbled(0x000000) # Apagamos la luz verde
_thread.start_new_thread(thread_sensores, (client, "thread_sensores", 5, )) # Hilo sensores
_thread.start_new_thread(thread_config, (client, "thread_config",)) # Hilo config
def mqtt_listen(server=MQTT_BROKER):
global mqttc
mqttc = MQTTClient("umqtt_client", server)
mqttc.set_callback(sub_cb)
mqttc.connect()
mqttc.subscribe(b"sensor/#")
while True:
if True:
# Blocking wait for message
mqttc.wait_msg()
else:
# Non-blocking wait for message
mqttc.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)
mqttc.disconnect()
def run(self):
# Setup MQTT client
client = MQTTClient(client_id=self.io_id,
server="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:
# transitory time
for i in range(0, 9):
self.read_data()
utime.sleep(2)
data = self.read_data()
client.publish(topic="{0}/feeds/temperature".format(
self.io_user),
msg=str("{0:0.1f}".format(data[0])))
client.publish(topic="{0}/feeds/humidity".format(self.io_user),
msg=str("{0:0.1f}".format(data[1])))
client.publish(topic="{0}/feeds/pressure".format(self.io_user),
msg=str("{0:0.1f}".format(data[2] / 100)))
if self.battery:
client.publish(topic="{0}/feeds/battery".format(
self.io_user),
msg=str("{0:0.1f}".format(data[3])))
print(" >{0} - battery: {1}".format(data[0:3], data[3]))
else:
print(" >{0}".format(data[0:3]))
utime.sleep(self.update_frequency)
client.check_msg()
utime.sleep(1)
def run_gate():
global on_for_update
c = MQTTClient("gate_client", secrets.MQTT_BROKER)
c.set_callback(device_control)
try:
c.connect(clean_session=False)
c.publish(topic.GATE_STATUS, msg_payload())
c.subscribe(topic.GATE_UPDATE, qos=1)
c.check_msg()
c.disconnect()
flash_led(LED1)
except OSError as e:
print("mqtt error", e)
if not on_for_update:
switch_off()
webrepl.start()
class Board:
def __init__(self, components):
self.led = components["pycom_led"]()
self.validate_components()
self.mqtt = MQTTClient("b1", "<host>", user="******", password="******", port=1883)
def validate_components(self):
set_intensity = getattr(self.led, "set_intensity", None)
if set_intensity is None or not callable(set_intensity):
raise Exception("led missing method set_intensity")
set_status = getattr(self.led, "set_status", None)
if set_status is None or not callable(set_status):
raise Exception("led missing method set_status")
def process_message(self, topic, msg):
topic_str = topic.decode("utf-8")
msg_str = msg.decode("utf-8")
if topic_str == "b1/led/intensity":
self.led.set_intensity(float(msg_str))
if topic_str == "b1/led/status":
self.led.set_status(msg_str)
def run(self):
self.mqtt.set_callback(self.process_message)
self.mqtt.connect()
self.mqtt.subscribe("b1/led/intensity")
self.mqtt.subscribe("b1/led/status")
alarms = []
try:
while True:
self.mqtt.wait_msg()
machine.idle()
finally:
for alarm in alarms:
alarm.cancel()
self.mqtt.disconnect()
def main(server=SERVER):
c = MQTTClient(CLIENT_ID,
server,
user="******",
password="******",
port=1883)
# Subscribed messages will be delivered to this callback
c.set_callback(sub_cb)
c.connect()
c.subscribe(TOPIC)
print("Connected to %s, subscribed to %s topic" % (server, TOPIC))
try:
while 1:
c.wait_msg()
oled.fill(0)
oled.text('Waiting msg.', 10, 10)
oled.text('string', 10, 32)
oled.show()
finally:
c.disconnect()
def run(self, wlan):
# Setup MQTT client
client = MQTTClient(client_id=self.io_id,
server="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 and wlan.isconnected():
data = self.read_data()
print(" >", data)
client.publish(topic="{0}/feeds/tank-1".format(self.io_user),
msg=str(data))
utime.sleep(self.update_frequency)
elif not wlan.isconnected():
machine.reset()
client.check_msg()
utime.sleep(1)
def send_server():
global sd
from network import WLAN
from mqtt import MQTTClient
import machine
import time
def sub_cb(topic, msg):
print(msg)
wlan = WLAN(mode=WLAN.STA)
wlan.connect("Android", auth=(WLAN.WPA2, "123456789a"), timeout=5000)
while not wlan.isconnected():
machine.idle()
print("Connected to Wifi\n")
client = MQTTClient("FiPy",
"129.241.91.125",
user="******",
password="******",
port=1883)
client.set_callback(sub_cb)
client.connect()
client.subscribe(topic="Fuelfighter")
last = None
packetTemp = None
copy_counter = 0
while True:
stime = (ut() + 500) // 1000
if "server.txt" in ls('/sd') and stime != last:
last = stime
file = open('/sd/server.txt', 'r')
packet = file.read()
file.close()
if packet != packetTemp:
client.publish(topic="Fuelfighter", msg=packet)
client.check_msg()
