def registerOfflineSubscriber():
"""Just a durable client to trigger queuing"""
client = paho.mqtt.client.Client("sub-qos1-offline", clean_session=False)
client.connect("localhost", port=port)
client.subscribe("test/publish/queueing/#", 1)
client.loop()
client.disconnect()
def run(self):
client = paho.mqtt.client.Client("broker-monitor")
client.connect("localhost", port=port)
client.message_callback_add("$SYS/broker/store/messages/count",
self.store_count)
client.message_callback_add("$SYS/broker/store/messages/bytes",
self.store_bytes)
client.message_callback_add("$SYS/broker/publish/messages/dropped",
self.publish_dropped)
client.subscribe("$SYS/broker/store/messages/#")
client.subscribe("$SYS/broker/publish/messages/dropped")
while True:
expect_drops = cq.get()
self.cq.task_done()
if expect_drops == "quit":
break
first = time.time()
while self.stored < 0 or self.stored_bytes < 0 or (
expect_drops and self.dropped < 0):
client.loop(timeout=0.5)
if time.time() - 10 > first:
print("ABORT TIMEOUT")
break
if expect_drops:
self.rq.put((self.stored, self.stored_bytes, self.dropped))
else:
self.rq.put((self.stored, self.stored_bytes, 0))
self.stored = -1
self.stored_bytes = -1
self.dropped = -1
client.disconnect()
def run(self):
client = paho.mqtt.client.Client("broker-monitor")
client.connect("localhost", port=port)
client.message_callback_add("$SYS/broker/store/messages/count", self.store_count)
client.message_callback_add("$SYS/broker/store/messages/bytes", self.store_bytes)
client.message_callback_add("$SYS/broker/publish/messages/dropped", self.publish_dropped)
client.subscribe("$SYS/broker/store/messages/#")
client.subscribe("$SYS/broker/publish/messages/dropped")
while True:
expect_drops = cq.get()
self.cq.task_done()
if expect_drops == "quit":
break
first = time.time()
while self.stored < 0 or self.stored_bytes < 0 or (expect_drops and self.dropped < 0):
client.loop(timeout=0.5)
if time.time() - 10 > first:
print("ABORT TIMEOUT")
break
if expect_drops:
self.rq.put((self.stored, self.stored_bytes, self.dropped))
else:
self.rq.put((self.stored, self.stored_bytes, 0))
self.stored = -1
self.stored_bytes = -1
self.dropped = -1
client.disconnect()
def registerOfflineSubscriber():
"""Just a durable client to trigger queuing"""
client = paho.mqtt.client.Client("sub-qos1-offline", clean_session=False)
client.connect("localhost", port=port)
client.subscribe("test/publish/queueing/#", 1)
client.loop()
client.disconnect()
def state_checker(client, gates):
#0 - k3 - M1 - opening
#1 - k5 - M1 - closing
#2 - k6 - M2 - opening
#3 - k8 - M2 - closing
#4 - l6 - Limit switch open
#5 - l7 - Limit switch close
print('woop')
time.sleep(1)
state_fun = gates.unknown_state(read_pin())
state = ''
prev_state = ''
pins = np.zeros([6])
prev_pins = np.empty_like(pins)
params1 = [0.0001, 0.5, 0, 0, 1, 0, 0, 0]
params2 = [0.0001, 0.5, 0, 0, 1, 0, 0, 0]
params4 = [0.0001, 0.5, 0, 0, 1, 0, 0, 0]
params_mot = [0.0001, 0.5, 0, 0, 1, 0, 0, 0]
state_pos = 0
state_neg = 0
while True:
pins = read_pin()
M00 = pins[0]
M01 = pins[1]
M11 = pins[3]
M00_filt, params1 = kalm_filt_iter(M00, params1)
M01_filt, params2 = kalm_filt_iter(M01, params2)
M11_filt, params4 = kalm_filt_iter(M11, params4)
mot = 2 * M00_filt - M01_filt - M11_filt
mot_filt, params_mot = kalm_filt_iter(mot, params_mot)
mot_pos, state_pos = hist_th(mot_filt, 0.15, 0.05, state_pos)
mot_neg, state_neg = hist_th(-mot_filt, 0.15, 0.05, state_neg)
mot = mot_pos - mot_neg
if (mot == 1):
pins[0:4] = 0, 1, 0, 1
elif (mot == -1):
pins[0:4] = 1, 0, 1, 0
else:
pins[0:4] = 0, 0, 0, 0
state_fun = state_fun(np.rint(pins))
state = gates.state
# with open('pin_log.csv','a') as f:
# writer = csv.writer(f)
# writer.writerow([read_pin()[0:4],time.time()])
client.loop(0.01)
if (state == prev_state):
pass
else:
client.publish("state", str(state))
prev_state = state
if str(pins) == str(prev_pins):
pass
else:
#client.publish("pins",str(pins))
print(str(pins))
prev_pins = pins
def loop(mqtt):
runLoop = True
while runLoop:
try:
mqtt.loop()
time.sleep(10)
except KeyboardInterrupt:
logger.info("Shutting down due to keyboard interrupt...")
runLoop = False
except RuntimeError as e:
logger.info("Shutting down due to runtime error %s" % str(e))
runLoop = False
def main():
mqtt = MQTT('raspberry')
mqtt.connect('169.254.180.85')
led17 = LED(17)
led27 = LED(27)
led22 = LED(22)
led18 = LED(18)
led23 = LED(23)
led24 = LED(24)
mqtt.subscribe('30,45,5,5', led_cb(led27))
mqtt.subscribe('30,45,5,5', led_cb(led24))
mqtt.subscribe('30,75,5,5', led_cb(led23))
mqtt.subscribe('30,105,5,5', led_cb(led22))
mqtt.subscribe('30,135,5,5', led_cb(led17))
mqtt.subscribe('30,135,5,5', led_cb(led18))
mqtt.loop()
def main():
global tmr
try:
print("init arduino.")
gui.clear()
mqtt_parse = MQTT_ADDR.split(":")
print("connecting to : " + MQTT_ADDR)
mqtt.on_connect = on_connect
mqtt.on_message = on_message
mqtt.connect(str(mqtt_parse[0]), int(mqtt_parse[1]))
tmr = Timer(60, on_timer)
tmr.start()
while True:
#process mqtt message
mqtt.loop()
#check the push button
#button_status = GPIO.input(BUTTON_GPIO)
if gui.check():
gui.update_status()
if (gui.buttonclick01_change) and (gui.buttonclick01_status
== 1):
gui.buttonclick01_change = False
mqtt.publish('snips/doorbell/' + SITE_ID,
'{"command":"ring"}')
print("ring")
except KeyboardInterrupt:
print("End.")
gui.clear()
#doorbell_seeyou('',False)
except:
print("Unexpected error:", sys.exc_info()[0])
def state_checker(client,gates):
print('woop')
state_fun = gates.unknown_state(read_pins())
state = ''
prev_state = ''
_counter = 0
while True:
pins = read_pins()
state_fun = state_fun(pins)
state = gates.state
if(state == prev_state):
_counter+=1
#print(_counter)
if(_counter%1000==0):
client.publish("garage/check","im ok too " + str(_counter))
time.sleep(0.1)
pass
else:
client.publish("garage/state",str(state))
print(state,pins)
prev_state = state
sys.stdout.flush()
client.loop(0.01)
def main():
global previous_status
global button_status
try:
mqtt_parse = MQTT_ADDR.split(":")
print("connecting to : " + MQTT_ADDR)
mqtt.on_connect = on_connect
mqtt.on_message = on_message
mqtt.connect(str(mqtt_parse[0]), int(mqtt_parse[1]))
print("push button on GPIO " + str(BUTTON_GPIO))
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON_GPIO, GPIO.IN)
while True:
#process mqtt message
mqtt.loop()
#check the push button
button_status = GPIO.input(BUTTON_GPIO)
if (button_status == False) and (button_status != previous_status):
mqtt.publish('snips/doorbell/' + SITE_ID, '{"command":"ring"}')
previous_status = button_status
if button_status:
previous_status = button_status
except KeyboardInterrupt:
print("End.")
doorbell_seeyou('', False)
except:
print("Unexpected error:", sys.exc_info()[0])
finally:
GPIO.cleanup()
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--graphite-server")
parser.add_argument("--mqtt-server")
parser.add_argument("--mqtt-port", type=int, default=1883)
args = parser.parse_args()
print("Initializing graphite...")
graphitesend.init(graphite_server=args.graphite_server,
prefix="mqtt",
system_name="")
last_by_device = {}
def on_msg(msg: paho.mqtt.client.MQTTMessage):
nonlocal last_by_device
topic = msg.topic
if not topic.startswith("gosund/"):
return
parts = topic.split('/', 3)
if len(parts) < 4:
return
(devp1, topic, devp2, t) = parts
if topic != "tele":
return
prefix = devp1 + "." + devp2
if t == "SENSOR":
payload = json.loads(msg.payload)
energy = payload["ENERGY"]
data = {
prefix + ".power": energy["Power"],
prefix + ".current": energy["Current"],
prefix + ".power_factor": energy["Factor"],
prefix + ".voltage": energy["Voltage"],
}
# kWh -> Ws
total = energy["Total"] * 1000 * 3600
time = datetime.datetime.strptime(payload["Time"],
"%Y-%m-%dT%H:%M:%S")
if devp2 in last_by_device:
dev_data = last_by_device[devp2]
else:
dev_data = {}
last_by_device[devp2] = dev_data
if "time" in dev_data and dev_data["time"] < time and dev_data[
"total"] <= total:
data[prefix + ".power2"] = \
(total - dev_data["total"]) / (time - dev_data["time"]).total_seconds()
else:
print("Fixing time to " + str(time) + " from " + str(dev_data))
dev_data["time"] = time
dev_data["total"] = total
graphitesend.send_dict(data)
elif t == "STATE":
payload = json.loads(msg.payload)
graphitesend.send_dict({
prefix + ".vcc": payload["Vcc"],
})
def on_msg0(cl, userdata, msg: paho.mqtt.client.MQTTMessage):
try:
on_msg(msg)
except:
traceback.print_exc()
client = paho.mqtt.client.Client()
client.on_message = on_msg0
print("Connecting mqtt...")
client.connect(args.mqtt_server, args.mqtt_port)
print("Subscribing...")
client.subscribe("gosund/#", 0)
print("Subscribed!")
while True:
client.loop()
import paho.mqtt.client as mqtt
mqtt = mqtt.Client("python_pub") # mqtt client object
mqtt.connect("local host", 1883) # mqtt server connect
mqtt.publish("IoT-P", "led on") # Topic and message
mqtt.publish("IoT-P", "led off")
mqtt.loop(2) # timeout 2sec
# Display the completed canvas on Inky wHAT
inky_display.set_image(img)
inky_display.show()
print(message)
# Following Sections MQTT to Keep Live
def on_subscribe(mosq, obj, mid, granted_qos):
print("Subscribed OK")
# Set callbacks
paho.on_message = on_message
paho.on_connect = on_connect
paho.on_subscribe = on_subscribe
# Connect and subscribe
print("Connecting to " + host + "/" + topic)
paho.connect(host, port, 60)
paho.subscribe(topic, 0)
# Wait forever, receiving messages
rc = 0
while rc == 0:
rc = paho.loop()
print("rc: " + str(rc))
print(msg.payload)
client.subscribe("/mqttitude/#", 0)
def on_message(mosq, obj, msg):
payload = json.loads(msg.payload)
log.info("got message %r %r", msg.topic, payload)
try:
userFromTopic = config['mqttTopic'][msg.topic]
except KeyError:
log.warn("ignoring unknown topic")
return
if 'lon' not in payload:
log.info("ignoring")
return
record = {
"timestamp" : int(payload['tst']),
"user" : userFromTopic,
"longitude" : float(payload['lon']),
"latitude" : float(payload['lat']),
"source" : "mqttitude",
}
for attr in ['alt', 'batt', 'acc']:
if attr in payload:
record[attr] = payload[attr]
log.info(repr(record))
updateServer.post(payload=json.dumps(record))
log.info("posted message")
client.on_message = on_message
while True:
client.loop()
def on_message(mosq, obj, msg):
payload = json.loads(msg.payload)
log.info("got message %r %r", msg.topic, payload)
try:
userFromTopic = config['mqttTopic'][msg.topic]
except KeyError:
log.warn("ignoring unknown topic")
return
if 'lon' not in payload:
log.info("ignoring")
return
record = {
"timestamp": int(payload['tst']),
"user": userFromTopic,
"longitude": float(payload['lon']),
"latitude": float(payload['lat']),
"source": "mqttitude",
}
for attr in ['alt', 'batt', 'acc']:
if attr in payload:
record[attr] = payload[attr]
log.info(repr(record))
updateServer.post(payload=json.dumps(record))
log.info("posted message")
client.on_message = on_message
while True:
client.loop()
time.sleep(1)
print('init %d' % get_mac())
last_data_time = int(time.time() * 1000)
#send_pin_status()
while True:
#print('loop')
try:
#if last_data_time + 100 < int(time.time() * 1000):
#ser = serial.Serial('/dev/ttyACM0')
#ser.timeout = 1
ser.write('a') # read_analog
data = ser.readline().strip()
if data:
pinvalues = {}
for i, v in enumerate(data.split(',')):
pinvalues[str(i)] = v
payload = {'data': pinvalues, 'type': 'sensorvalue'}
mqtt.publish('/hydroots/client/%d' % get_mac(),
bytearray(json.dumps(payload)))
#last_data_time = int(time.time() * 1000)
print('analog read success')
except Exception as e:
data = {'type': 'ack'}
mqtt.publish('/hydroots/client/%d' % get_mac(),
bytearray(json.dumps(data)))
print('exception during read')
mqtt.loop(timeout=1)
time.sleep(1)
def main():
root = Tk()
#============================TEMPERATURA SALA===================================
temperatura_sala = Frame(root, highlightbackground="blue",highlightthickness=2, padx=20, pady=20)
temperatura_sala.pack(side=LEFT)
temperatura_title_sala = Label(temperatura_sala, text='Temperatura da Sala')
temperatura_title_sala["font"] = ("Helvetica", "14", "bold")
temperatura_title_sala.pack()
temperatura_message_sala = Label(temperatura_sala, text='Valor do Sensor')
temperatura_message_sala["font"] = ("Helvetica", "12")
temperatura_message_sala.pack()
#============================FIM TEMPERATURA SALA================================
#============================TEMPERATURA QUARTO===================================
temperatura_quarto = Frame(root, highlightbackground="blue",highlightthickness=2, padx=20, pady=20)
temperatura_quarto.pack(side=LEFT)
temperatura_title_quarto = Label(temperatura_quarto, text='Temperatura do Quarto')
temperatura_title_quarto["font"] = ("Helvetica", "14", "bold")
temperatura_title_quarto.pack()
temperatura_message_quarto = Label(temperatura_quarto, text='Valor do Sensor')
temperatura_message_quarto["font"] = ("Helvetica", "12")
temperatura_message_quarto.pack()
#============================FIM TEMPERATURA QUARTO================================
#============================SENSOR DE UMIDADE================================================
umidade = Frame(root, highlightbackground="blue",highlightthickness=2, padx=20, pady=20)
umidade.pack(side=LEFT)
umidade_title = Label(umidade, text='Umidade da Sala')
umidade_title["font"] = ("Helvetica", "14", "bold")
umidade_title.pack()
umidade_message = Label(umidade, text='Valor do Sensor')
umidade_message["font"] = ("Helvetica", "12")
umidade_message.pack()
#============================FIM SENSOR DE UMIDADE============================================
#============================PORTAO================================================
portao = Frame(root, highlightbackground="blue",highlightthickness=2,padx=20, pady=20)
portao.pack(side=BOTTOM)
portao_title = Label(portao, text='Portão da Frente')
portao_title["font"] = ("Helvetica", "14", "bold")
portao_title.pack()
portao_message = Label(portao, text='Valor do Sensor')
portao_message["font"] = ("Helvetica", "12")
portao_message.pack()
portao_button = Button(portao)
portao_button["text"] = "Abrir!"
portao_button["font"] = ("Helvetica", "10")
portao_button["width"] = 7
portao_button["command"] = on_button_portao
portao_button.pack(side=BOTTOM)
#============================FIM PORTAO============================================
#============================LAMPADA================================================
lampada = Frame(root, highlightbackground="blue",highlightthickness=2,padx=20, pady=20)
lampada.pack(side=BOTTOM)
lampada_title = Label(lampada, text='Lampada')
lampada_title["font"] = ("Helvetica", "14", "bold")
lampada_title.pack()
lampada_message = Label(lampada, text='Valor do Sensor')
lampada_message["font"] = ("Helvetica", "12")
lampada_message.pack()
lampada_button = Button(lampada)
lampada_button["text"] = "Ligar!"
lampada_button["font"] = ("Helvetica", "10")
lampada_button["width"] = 7
lampada_button["command"] = on_button_lampada
lampada_button.pack(side=BOTTOM)
#============================FIM LAMPADA============================================
while True:
root.update()
client.loop(.1)
temperatura_message_sala.configure(text=temperatura_message_sala_var)
temperatura_message_quarto.configure(text=temperatura_message_quarto_var)
umidade_message.configure(text=umidade_message_var)
if portao_message_var:
portao_message.configure(text='Portão Aberto')
portao_button.configure(text='Fechar!')
elif not portao_message_var:
portao_message.configure(text='Portão Fechado')
portao_button.configure(text='Abrir!')
if lampada_message_var:
lampada_message.configure(text='Lâmpada Ligada')
lampada_button.configure(text='Desligar!')
elif not lampada_message_var:
lampada_message.configure(text='Lâmpada Desligada')
lampada_button.configure(text='Ligar!')
hx.tare()
mqtt = mqtt.Client("Pi1") # MQTT Client Name
mqtt.connect("192.168.137.1", 1883) # MQTT Broker Add
isSit = "false"
mqtt.publish("Pi1", "{\"s1_isSit\":false}") # initialization
while True:
try:
val = hx.get_weight(5)
print(val)
if val > 20: # load over 20Kg
if isSit != "true":
mqtt.publish("Pi1", "{\"s1_isSit\":true}")
isSit = "true"
else: # load under 20Kg
if isSit != "false":
mqtt.publish("Pi1", "{\"s1_isSit\":false}")
isSit = "false"
hx.power_down()
hx.power_up()
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
cleanAndExit()
mqtt.loop(5)
parser.add_argument(
'topic',
type=str,
help=
'Topic mask to unpublish retained messages from. For example: "/devices/my-device/#"'
)
args = parser.parse_args()
client = paho.mqtt.client.Client(client_id=None,
clean_session=True,
protocol=paho.mqtt.client.MQTTv31)
if args.username:
client.username_pw_set(args.username, args.password)
client.connect(args.host, args.port)
client.on_message = on_mqtt_message
client.subscribe(args.topic)
influx_client = InfluxDBClient('localhost', 8086, database='mqtt_data')
db_writer = DBWriterThread(influx_client, daemon=True)
db_writer.start()
while 1:
rc = client.loop()
if rc != 0:
break
def main():
root = Tk()
root.title("MQTT")
#============================Temperatura+++++===================================
temperatura_sala = Frame(root)
temperatura_sala.pack(side=LEFT)
temperatura_title_sala = Label(temperatura_sala, text='Temperatura')
temperatura_title_sala["font"] = ("Helvetica", "14", "bold")
temperatura_title_sala.pack()
temperatura_status = Label(temperatura_sala, text='---')
temperatura_status['font'] = ('Helvetica', 12)
temperatura_status.pack()
temperatura_message_sala = Label(temperatura_sala, text='Valor do Sensor')
temperatura_message_sala["font"] = ("Helvetica", "12")
temperatura_message_sala.pack()
temperatura_sala_button = Button(temperatura_sala)
temperatura_sala_button["text"] = "Ligar!"
temperatura_sala_button["font"] = ("Helvetica", "10")
temperatura_sala_button["width"] = 7
temperatura_sala_button["command"] = on_button_temperatura1
temperatura_sala_button.pack(side=LEFT)
temperatura_sala_button_1 = Button(temperatura_sala)
temperatura_sala_button_1['text'] = '+'
temperatura_sala_button_1['font'] = ('Helvetica', 10)
temperatura_sala_button_1['width'] = 2
temperatura_sala_button_1['command'] = on_button_temperatura1_aumentar
temperatura_sala_button_1.pack(side=RIGHT, anchor="n")
temperatura_sala_button_2 = Button(temperatura_sala)
temperatura_sala_button_2['text'] = '-'
temperatura_sala_button_2['font'] = ('Helvetica', 10)
temperatura_sala_button_2['width'] = 2
temperatura_sala_button_2['command'] = on_button_temperatura1_diminuir
temperatura_sala_button_2.pack(side=RIGHT, anchor="s")
#============================Sensor de Umidade==================================
umidade = Frame(root, padx=40, pady=10)
umidade.pack(side=LEFT)
umidade_title = Label(umidade, text='Umidade')
umidade_title["font"] = ("Helvetica", "14", "bold")
umidade_title.pack()
umidade_status = Label(umidade, text='---')
umidade_status["font"] = ("Helvetica", "12")
umidade_status.pack()
umidade_message = Label(umidade, text='Valor do Sensor')
umidade_message["font"] = ("Helvetica", "12")
umidade_message.pack()
umidade_button = Button(umidade)
umidade_button["text"] = "Ligar!"
umidade_button["font"] = ("Helvetica", "10")
umidade_button["width"] = 7
umidade_button["command"] = on_button_umidade
umidade_button.pack(side=BOTTOM)
#============================Lâmpada===========================================
lampada = Frame(root, padx=40, pady=10)
lampada.pack(side=LEFT)
lampada_title = Label(lampada, text='Lampada')
lampada_title["font"] = ("Helvetica", "14", "bold")
lampada_title.pack()
lampada_message = Label(lampada, text='Status')
lampada_message["font"] = ("Helvetica", "12")
lampada_message.pack()
lampada_button = Button(lampada)
lampada_button["text"] = "Ligar!"
lampada_button["font"] = ("Helvetica", "10")
lampada_button["width"] = 7
lampada_button["command"] = on_button_lampada
lampada_button.pack(side=BOTTOM)
#============================TV================================================
tv = Frame(root, padx=40, pady=10)
tv.pack(side=LEFT)
tv_title = Label(tv, text='TV')
tv_title["font"] = ("Helvetica", "14", "bold")
tv_title.pack()
tv_message = Label(tv, text='Status')
tv_message["font"] = ("Helvetica", "12")
tv_message.pack()
tv_channel = Label(tv, text='Valor')
tv_channel["font"] = ("Helvetica", "12")
tv_channel.pack()
tv_volume = Label(tv, text='Valor')
tv_volume["font"] = ("Helvetica", "12")
tv_volume.pack()
tv_button = Button(tv)
tv_button['text'] = 'Ligar!'
tv_button['font'] = ('Helvetica', 10)
tv_button['width'] = 7
tv_button['command'] = on_button_tv
tv_button.pack(side=LEFT)
tv_button_1 = Button(tv)
tv_button_1['text'] = 'C+'
tv_button_1['font'] = ('Helvetica', 10)
tv_button_1['width'] = 2
tv_button_1['command'] = on_button_tv_canal_mais
tv_button_1.pack(side=LEFT)
tv_button_2 = Button(tv)
tv_button_2['text'] = 'C-'
tv_button_2['font'] = ('Helvetica', 10)
tv_button_2['width'] = 2
tv_button_2['command'] = on_button_tv_canal_menos
tv_button_2.pack(side=LEFT)
tv_button_3 = Button(tv)
tv_button_3['text'] = 'V+'
tv_button_3['font'] = ('Helvetica', 10)
tv_button_3['width'] = 2
tv_button_3['command'] = on_button_tv_volume_mais
tv_button_3.pack(side=RIGHT)
tv_button_4 = Button(tv)
tv_button_4['text'] = 'V-'
tv_button_4['font'] = ('Helvetica', 10)
tv_button_4['width'] = 2
tv_button_4['command'] = on_button_tv_volume_menos
tv_button_4.pack(side=RIGHT)
#=======================Geladeira=++==========================================
geladeira = Frame(root, padx=40, pady=0)
geladeira.pack(side=LEFT)
geladeira_title = Label(geladeira, text='Geladeira')
geladeira_title["font"] = ("Helvetica", "14", "bold")
geladeira_title.pack()
geladeira_message = Label(geladeira, text='Status')
geladeira_message["font"] = ("Helvetica", "12")
geladeira_message.pack()
while True:
root.update()
client.loop(.1)
umidade_message.configure(text=umidade_message_var)
tv_message.configure(text=tv_message_var)
temperatura_message_sala.configure(text=temperatura1_message_var)
geladeira_message.configure(text=geladeira_message_var)
client.publish("/Dispositivos/Umidade/1", umidade_message_var)
client.publish("/Dispositivos/Temperatura/1", temperatura1_message_var)
if not temperatura1_message_var:
temperatura_status.configure(text='Status: Offline', fg='red')
temperatura_sala_button.configure(text='Ligar')
elif temperatura1_message_var:
temperatura_status.configure(text='Status: Online', fg='green')
temperatura_sala_button.configure(text='Desligar')
if not umidade_message_var:
umidade_status.configure(text="Status: Offline", fg="red")
umidade_button.configure(text='Ligar')
elif umidade_message_var:
umidade_status.configure(text="Status: Online", fg="green")
umidade_button.configure(text='Desligar')
if tv_message_var:
tv_message.configure(text='Status: Ligada2', fg='green')
tv_button.configure(text='Desligar')
tv_channel.configure(text='Canal: ' + str(tv_canal_var))
tv_volume.configure(text='Volume: ' + str(tv_volume_var))
elif not tv_message_var:
tv_message.configure(text='Status: Desligada', fg='red')
tv_button.configure(text='Ligar')
tv_channel.configure(text='Canal: --')
tv_volume.configure(text='Volume: --')
if lampada_message_var:
lampada_message.configure(text='Status: Ligada', fg='green')
lampada_button.configure(text='Desligar')
elif not lampada_message_var:
lampada_message.configure(text='Status: Desligada', fg='red')
lampada_button.configure(text='Ligar')
if geladeira_message_var:
geladeira_message.configure(text='Status: Aberta', fg='green')
elif not geladeira_message_var:
geladeira_message.configure(text='Status: Fechada', fg='red')
proc.parse_config('enable')
# initialize the Processor
device = '/dev/video0'
if len(argv) > 1:
device = argv[1]
proc.init(device)
# setup a callback
#def my_handler(proc, image, closure):
# extract results
for symbol in proc.results:
# do something useful with results
print 'DATA', symbol.type, '=', '"%s"' % symbol.data, st
#proc.set_data_handler(my_handler)
mqtt.publish("yuhu", '%s' % symbol.data)
mqtt.loop(2)
# enable the preview window
proc.visible = True
# initiate scanning
proc.active = True
try:
# keep scanning until user provides key/mouse input
proc.user_wait()
except zbar.WindowClosed, e:
pass
mqtt.loop(2)
import paho.mqtt.client as mqtt
mqtt = mqtt.Client("sss")
mqtt.username_pw_set("username", "password")
mqtt.connect("xxx.xxx.xxx.xxx", 1883)
mqtt.publish("mainTopic/subTopic", "Payload메시지")
print("Published!")
mqtt.loop()
print("Exit")
