def start_mqtt(self):
try:
self.c = MQTTClient(self.clients, net.server)
self.c.connect()
except:
self.c = MQTTClient(self.clients, self.server)
self.c.connect()
try:
print("mulai mqtt")
self.c.set_callback(self.sub_cb)
self.c.subscribe(self.topic)
self.c.subscribe(b"waktu")
self.c.subscribe(b"nyala_pada_1")
self.c.subscribe(b"nyala_pada_2")
self.c.subscribe(b"nyala_pada_3")
self.c.subscribe(b"nyala_pada_4")
self.c.subscribe(b"mati_pada_1")
self.c.subscribe(b"mati_pada_2")
self.c.subscribe(b"mati_pada_3")
self.c.subscribe(b"mati_pada_4")
print("Connected to %s, subscribed to %s topic" %
(self.server, self.topic))
while 1:
self.timer.deinit()
self.state = "terhubung"
self.c.wait_msg()
except:
print("pedot")
self.state = "terputus"
self.timer.init(period=1000, callback=self.tim)
def connect(mqtt_user="******", mqtt_pass="******"):
global client
client = MQTTClient(client_id, mqtt_server, 1883)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def start_process():
mac = ubinascii.hexlify(network.WLAN().config('mac'), ':').decode()
try:
set_wifi()
client = MQTTClient("umqtt_client", "10.0.0.233")
connect_server(client)
print("-------press ctrl-c to stop the polling")
# create and publish control message
control_message = {"mac": mac}
client.publish(MQTT_CONTROL_CHANNEL, json.dumps(control_message))
print("Publish control message : " + str(control_message))
print()
time.sleep(5)
client.check_msg()
# process configuration
sensors = process_configuration()
while True:
for sensor in sensors:
publish_data_message(client, sensor)
# catches the ctrl-c command, which breaks the loop above
except KeyboardInterrupt:
print("Continuous polling stopped")
finally:
client.disconnect()
def connect_and_subscribe():
global CLIENT_ID, BROKER_ADDRESS, ROOT_TOPIC, client, SWITCH_PIN
try:
SWITCH_PIN.value(0)
client = MQTTClient(CLIENT_ID, BROKER_ADDRESS)
client.set_callback(received)
client.connect()
time.sleep(2)
print("connecting")
client.subscribe(ROOT_TOPIC + b'#')
print('Connected to %s MQTT broker, subscribed to %s topic' % (BROKER_ADDRESS, ROOT_TOPIC))
SWITCH_PIN.value(1)
client.publish(ROOT_TOPIC + b'version', 'Version 2021.091')
return client
except:
SWITCH_PIN.value(1)
time.sleep(1)
SWITCH_PIN.value(0)
time.sleep(1)
SWITCH_PIN.value(1)
time.sleep(1)
SWITCH_PIN.value(0)
time.sleep(1)
SWITCH_PIN.value(1)
time.sleep(1)
SWITCH_PIN.value(0)
return None
def connect_and_subscribe():
global client_id, topic_led
client = MQTTClient(client_id, Config.mqtt_server, user=Config.mqtt_user, password=Config.mqtt_pass)
client.set_callback(sub_cb)
client.connect(clean_session=False)
client.subscribe(topic_led)
return client
def connect_mqtt():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server)
#client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return client
def connect():
global CLIENT_ID, SERVER, PORT, USERNAME, PASSWORD, TOPIC_PUB
client = MQTTClient(CLIENT_ID, SERVER, PORT, USERNAME, PASSWORD)
client.set_callback(sub_cb)
client.connect()
client.subscribe(TOPIC_SUB)
return client
def connect_and_subscribe(self):
client = MQTTClient(self.client_id, self.mqtt_server)
client.set_callback(self.sub_cb)
client.connect()
client.subscribe(self.topic_sub)
print('MQTT: Connected to %s MQTT broker, subscribed to %s topic' %
(self.mqtt_server, self.topic_sub))
return client
def connect_and_subscribe():
global client, client_id, mqtt_server, topic_sub, topic_subLed
client = MQTTClient(client_id, mqtt_server)
client.set_callback(sub_CheckTopics)
client.connect()
client.subscribe(topic_subLed)
print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_subLed))
return client
def connect_and_subscribe():
global CLIENT_ID, SERVER, PORT, USERNAME, PASSWORD, TOPIC_PUB
client=MQTTClient(CLIENT_ID, SERVER,PORT , USERNAME, PASSWORD)
client.set_callback(sub_cb)
client.connect()
client.subscribe(TOPIC_SUB)
print('Connected to %s MQTT broker, subscribed to %s topic' % (SERVER, TOPIC_SUB))
return client
def __init__(self,config="mqtt.txt"):
self.user = None
self.password = None
self.root = b""
self.config = config
self.enable = True
self.load_config()
self.mqtt = MQTTClient("pylinky",self.server,user=self.user,password=self.password,keepalive=60)
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('Connected1 to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
return client
def connect():
global client_id, mqtt_server
client = MQTTClient(client_id, mqtt_server)
client.connect()
print('Connected to %s MQTT broker ' % (mqtt_server))
return client
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id, mqtt_server)
client.set_callback(sub_cb)
client.connect()
for i in subscribe_list:
client.subscribe(i)
print('Connected to %s MQTT broker, subscribed to %s topic\n' % (mqtt_server, i))
return client
def connect_and_subscribe(CLIENT_ID, MQTT_SERVER):
client = MQTTClient(CLIENT_ID, MQTT_SERVER)
client.set_callback(subscrition_callback)
client.connect()
client.subscribe("client/{}/check".format(CLIENT_ID))
print("Connected to MQTT broker {}".format(MQTT_SERVER))
return client
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub, topic_pub
client = MQTTClient(client_id, mqtt_server, 1883, 'janus', 'Janus506')
client.set_last_will(topic_pub, '{\"msg\":\"offline\"}')
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 connect_and_subscribe(i):
try:
client = MQTTClient(CLIENT_ID, MQTT_SERVER)
client.connect()
print('Connected to %s MQTT broker, published to "%s" topic' % (MQTT_SERVER, TOPIC_PUB))
return client
except:
err_msg = 'MQTT broker connection error'
restart_and_reconnect(i, err_msg)
def mqtt_connect_and_subscribe():
global client_id, mqtt_server, adafruit_user, adafruit_iokey, topic_sub
client = MQTTClient(client_id=client_id,
server=mqtt_server,
user=adafruit_user,
password=adafruit_iokey)
client.connect()
print('Verbonden met %s mqtt-broker.' % mqtt_server)
return client
def connect_and_subscribe():
client = MQTTClient(client_id, MQTT_SERVER)
client.set_callback(sub_cb)
client.connect()
client.subscribe('servo')
print('Connected to MQTT')
client.publish('esp32', 'connected!')
return client
def connect(self):
try:
self.client = MQTTClient(self.CLIENT_ID, self.__server)
self.client.set_callback(self.__sub_cb)
self.client.connect()
self.client.subscribe(self.__sub_topic)
self.__connection = True
return self.client
except Exception:
return None
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id,
mqtt_server,
user='******',
password='******')
client.set_callback(sub_cb)
client.connect()
client.subscribe(topic_sub)
return client
def connect(self):
client_id = ubinascii.hexlify(machine.unique_id())
if MyClient.connection is None:
MyClient.connection = MQTTClient(client_id, self.host)
MyClient.connection.set_callback(self.sub_callback)
MyClient.connection.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
return self.connection
def connect_and_subscribe():
global SERVER, TOPIC
server = SERVER
# c = MQTTClient(CLIENT_ID, server,0,username,password) #create a mqtt client
c = MQTTClient(CLIENT_ID, server, 0) #create a mqtt client
c.set_callback(sub_cb) #set callback
c.connect() #connect mqtt
c.subscribe(TOPIC) #client subscribes to a topic
print("Connected to %s, subscribed to %s topic" % (server, TOPIC))
return c
def connect_and_subscribe():
global client_id, MQTT_SERVER, topic_sub
client = MQTTClient(client_id,
MQTT_SERVER,
user=MQTT_USER,
password=MQTT_PASSWORD)
client.set_callback(sub_cb)
client.connect()
# client.subscribe(topic_sub)
print('Connected to %s MQTT broker' % MQTT_SERVER)
return client
def connect_and_subscribe(subtopic):
global client_id, mqtt_server, mqtt_port, mqtt_user, mqtt_password, topic_sub
client = MQTTClient(client_id, mqtt_server, mqtt_port, mqtt_user,
mqtt_password, keepalive)
client.set_callback(sub_cb)
client.connect()
subscribeTotopic = topic_sub + subtopic
client.subscribe(subscribeTotopic)
print('Connected to %s MQTT broker' % (mqtt_server))
print('subscribed to %s topic' % (subscribeTotopic))
return client
def mqtt_connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id, mqtt_server)
client.connect()
print('Verbonden met %s mqtt-broker.' % mqtt_server)
return client
def connect_and_subscribe():
client = MQTTClient(client_id=client_id,
server=mqtt_server,
port=mqtt_port,
user=mqtt_user,
password=mqtt_password)
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 connect_mqtt(mqtt_server_addr: str, mqtt_login: str, mqtt_password: str) -> MQTTClient:
# import usocket
# ip = usocket.getaddrinfo('blackpearl.local', 9000)[0][-1][0]
#ip = usocket.getaddrinfo('www.micropython.org', 80)[0][-1][0]
client_id = ubinascii.hexlify(machine.unique_id())
print('MQTTBROKER: %s' %mqtt_server_addr)
client = MQTTClient(client_id, mqtt_server_addr, port=1883, user=mqtt_login, password=mqtt_password)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server_addr))
return client
def connect_and_subscribe():
global client_id, mqtt_server, topic_sub
client = MQTTClient(client_id, mqtt_server)
#client.set_callback(sub_cb)
client.connect()
print('Connected to %s MQTT broker' % (mqtt_server))
oled.fill(0)
oled.text('Conn. MQTT broker', 0, 0)
oled.text(mqtt_server, 0, 12)
oled.show()
sleep(5)
return client
def connect_mqtt():
global client_id, mqtt_server
print("Cliente ID: %s" % (client_id))
#client = MQTTClient(client_id, mqtt_server)
client = MQTTClient(client_id,
mqtt_server,
1883,
user="******",
password="******")
client.connect()
print("Conectado ao broker MQTT %s" % (mqtt_server))
return client
