def __init__(self):
#Starts and connect MQTT client to AWS MQTT Broker
self.mqtt = Mqtt()
self.mqtt.connect()
#Stats loading data
self.loadData()
def run_route_planner():
"""Runs the whole program."""
# Initialize global settings and screen.
settings = Settings()
pygame.init()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Route Planner 1.1")
# Make a next button.
next_button = Button(settings, screen, "Next")
# Hard coded map.
world = World(settings.map_width, settings.map_height)
"""world.matrix = [["601000", "100100", "100010", "100001", "100000", "100000"],
["100000", "100000", "100100", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"]]"""
world.matrix = [["601000", "500100", "310010", "610001", "600000", "610000"],
["530000", "400000", "310000", "510000", "530000", "100000"],
["100000", "100000", "100000", "530000", "620000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"],
["100000", "100000", "100000", "100000", "100000", "100000"]]
# Create nodes for the world matrix.
nodes = Nodes(world.matrix)
# Make a new robot instance.
robot = Robot()
# Init and subscribe to mqtt broker.
mqtt = Mqtt(settings.broker, settings.get_client_id(),
settings.username, settings.password, settings.topic)
buttons = []
# Print out nodes to check if algoritm is correct.
""" for node in nodes.nodes_dict:
print(node + " : ", nodes.nodes_dict[node]) """
while True:
# main loop
rf.update_map(world.matrix, nodes, mqtt.msgs, robot)
rf.check_events(settings, robot, buttons, next_button, mqtt)
rf.update_robot_route(world.matrix, nodes.nodes_dict, robot)
buttons = rf.update_screen(screen, settings, world.matrix,
nodes, next_button, robot)
"""for node in nodes.nodes_dict:
print(node + " : ", nodes.nodes_dict[node])"""
# if no more tasks are left, the mission is complete.
if len(robot.goals) == 0:
print("Mission Complete!")
mqtt.client.loop_stop()
mqtt.client.disconnect()
break
def __init__(self):
self.__topic = "topic/audio_transmission"
root_ca = "./certs/RootCA.pem"
key = "./certs/xxxxxxxx-private.pem.key"
cert = "./certs/xxxxxxxx-certificate.pem.crt"
endpoint = "xxxxxxxxxxx-ats.iot.ap-northeast-1.amazonaws.com"
self.__mqtt = Mqtt(root_ca, key, cert, endpoint)
def main():
# Fetch the arguments from command line
args = build_argparser().parse_args()
# Connect to the MQTT server and return MQTT client
mqtt = Mqtt()
mqtt.connect()
# Perform inference on the input stream
infer_on_stream(args, mqtt)
mqtt.disconnect()
def setup_mqtt():
try:
m = Mqtt(MQTT_CLIENT_NAME, MQTT_BROKER)
m.connect()
except OSError as ose:
logger.print_error("MQTT Setup Failed!")
raise
return m
async def __setup_mqtt(self):
hw.log.debug("Setting up mqtt ...")
if hw.MQTT and hw.WIFI:
from mqtt import Mqtt
mqtt = Mqtt(dev.opc)
dev.OPERATORS.append(mqtt)
dev.CONSUMERS.append(mqtt)
dev.opc.set_mqtt(mqtt)
mqtt.setup()
def setup():
host = 'iot'
port = 1883
topics = [
"TEMP/TEMPSENSOR", "HUM/TEMPSENSOR", "HUM/#", "TEMP/#",
"NIGHTLAMP2/state", "KINDLE/#", "phones/#", "printer/#", "LUX/state",
"DESK/state"
]
# CONFIG
return Mqtt(host, port, topics, [to_influx], _json=False)
def __init__(self, configFilename):
self.startTime = datetime.now()
self.logger = self.getLogger()
self.logger.info("Reading configuration file '%s'..." % configFilename)
self.init(configFilename)
self.terminated = False
self.mqtt = Mqtt(self)
self.createThreads()
self._intervalDict = {}
self.sensors = {}
def main():
parametros = validacao_parametros()
global dynamodb
global mqtt
mqtt = Mqtt(parametros['broker'], parametros['user'],
parametros['password'], parametros['topic'], on_connect)
dynamodb = Dynamo(parametros['dynamodb'])
subscriber()
def transform(self, data):
if self.counter == 0:
print('main_state: mqtt/up')
config = data['config']
broker_address = config.state['broker_address']
device_name = config.state['device_name']
main_topic = config.state['main_topic']
mqtt = Mqtt(device_name, main_topic)
if mqtt.connect(broker_address):
data['mqtt_server'] = mqtt
return 'main/loop_once'
else:
self.counter += 1
if self.counter >= MAX_TRIES:
config.delete()
machine.reset()
def __init__(self, commandList):
self.__commandList = commandList
config = json.load(open('./config.json', 'r'))
logFile = "./log/{}".format(config["appName"])
logger = Logger(config["appName"],
config["logLevel"],
filename=logFile)
port = 8883
self.__topic = config["topic"]
self.__mqtt = Mqtt(logger, config["endPoint"], port, config["rootCA"],
config["certificate"], config["privateKey"],
config["clientId"])
self.__mqtt.subscribe(self.__topic + "/Request", self.__callback)
self.__result = None
self.__loop()
def __init__(self):
self.wifi = Wifi(
ssid=CONFIG["WIFI_SSID"],
password=CONFIG["WIFI_PASSWORD"],
gmt=CONFIG["GMT"],
)
self.mqtt = Mqtt(
ip=CONFIG["MQTT_IP"],
user=CONFIG["MQTT_USER"],
password=CONFIG["MQTT_PASS"],
keepalive=CONFIG["MQTT_KEEPALIVE"],
)
self.mqtt.set_last_will(
topic=CONFIG["LW_TOPIC"],
msg=ujson.dumps(CONFIG["LW_MSG_OFFLINE"]),
retain=CONFIG["LW_RETAIN"],
qos=CONFIG["LW_QOS"],
)
self.dht22 = DHT22(Pin(CONFIG["DHT22_PIN"]))
self.is_sending_synchronizate = False
def main():
parametros = validacao_parametros()
global mqtt
global logs
mqtt = Mqtt(parametros['broker'], parametros['user'],
parametros['password'], parametros['topic'])
logs = Logs(parametros['group'], parametros['stream'])
scheduler = sched.scheduler(time.time, time.sleep)
schedule_it(scheduler, int(parametros['messages']),
int(parametros['seconds']), publisher)
mqtt.connect()
mqtt.client.loop_start()
scheduler.run()
mqtt.client.loop_stop()
mqtt.client.disconnect()
import uasyncio as asyncio
from sensor import SensorProcess
from consumer import DefaultConsumer
import dev
logging._level = logging.DEBUG
opc = Controller()
sp = SensorProcess()
def_consumer = DefaultConsumer()
ops = []
wifi = Wifi('ybb-home')
ops.append(wifi)
ops.append(SysOp(opc))
ops.append(def_consumer)
mqtt = Mqtt(opc)
ops.append(mqtt)
opc.setup(ops)
opc.set_mqtt(mqtt)
consumers = []
consumers.append(def_consumer)
consumers.append(mqtt)
print(opc.commands.keys())
async def test():
await wifi.async_connect()
print(mqtt.get_info())
mqtt.setup()
else:
return tryDecode
def mqtt2telegram(topic, payload):
logging.debug('mqtt2telegram: ' + topic)
topic = topic.replace('_', ' ')
parser = getParser(topic)
payload = parser(topic, payload)
logging.debug('Sending to Telegram ...')
msg = """<b>mqtt2telegram:</b> <i>{}</i>
{}
""".format(topic, payload)
logging.info(msg)
bot.sendMsgToOwner(msg)
BROKERHOST = os.getenv('MQTTHOST')
BROKERPORT = int(os.getenv('MQTTPORT'))
USERNAME = os.getenv('MQTTUSERNAME')
PASSWORD = os.getenv('MQTTPASSWORD')
mqtt = Mqtt(BROKERHOST, BROKERPORT, USERNAME, PASSWORD)
mqtt.setCallback(mqtt2telegram)
mqtt2telegram('Status', 'Bot (re-)initialized!')
mqtt.loop_forever()
mqtt2telegram('Status', 'Bot shutdown ...')
avg = create_average_sensor('Temp Average', '°C', [sen1, sen2], icon='mdi:thermometer-lines',
**standard_config)
registry.add_component(avg)
wavg, weights = create_weighted_average_sensor('Temp Weight Average', '°C', 0, 200, 1, 100, [sen1, sen2],
icon='mdi:thermometer-lines', **standard_config)
registry.add_component(wavg)
for w in weights:
registry.add_component(w, send_updates=False)
climate = Climate('Boiler', wavg, state_change_func=climate_state_change, mqtt=mqtt,
availability_topic=availability_topic, auto_discovery=auto_discovery)
registry.add_component(climate)
if not auto_discovery:
logging.info("HA config:\n{}".format(registry.create_config()))
return registry, func_limiter
if __name__ == "__main__":
setup_logging()
with Mqtt(mqtt_host='localhost') as mqtt:
registry, func_limiter = create_components(mqtt)
with registry:
while True:
registry.send_updates()
sleep_for(1)
func_limiter.clear()
dis = Display(10, 10)
bor = Board(10, 10)
bor.fill(False)
def abc(data):
global bor
bor.data = [(ord(d) > 128) for d in data]
dr = Driver("192.168.1.214", 6454)
#dr = Driver("xd-table.local", 6454)
dr.callbacks.append(abc)
#dr.callbacks.append(call)
dr.start_listening()
dr.calibrate()
m = Manager(bor)
mqtt = Mqtt("127.0.0.1", 1883, m, dr)
#ui = UdpInterface(on_press, 4444)
set_start = datetime.now()
get_start = datetime.now()
try:
while not exit_flag:
time.sleep(1.0 / set_hz)
dt = (datetime.now() - set_start).total_seconds()
set_start = datetime.now()
if (datetime.now() - get_start).total_seconds() > (1.0 / get_hz):
get_start = datetime.now()
# dr.get_touchscreen()
effect = m.get()
from mqtt import Mqtt
from commands.temp import Temp
from commands.cams import Cams
from commands.cry import Cry
from commands.set import Set
from api import ApiServer
from mail import MailServer
from tg import Telegram
from util import import_env, log
if __name__ == "__main__":
import_env()
mqtt = Mqtt()
telegram = Telegram()
telegram.start()
temp_command = Temp(telegram=telegram, mqtt=mqtt)
cams_command = Cams(telegram=telegram)
cry_command = Cry(telegram=telegram, mqtt=mqtt)
set_command = Set(telegram=telegram, mqtt=mqtt)
api_server = ApiServer(telegram=telegram)
api_server.start()
mail_server = MailServer()
mail_server.start()
try:
door = Door(gpio(config.gpio_door_sensor),
open_callback=on_door_open,
close_callback=on_door_close)
lock_control = lock_ctrl.Lock_ctrl(IO_latch=gpio(config.gpio_electric_strike),
IO_closer=gpio(config.gpio_door_closer))
keypad = Keypad(dev=serial.Serial(config.keypad_dev, 9600), on_key=on_key)
keypad.start()
reader_door = NFCreader.NFCreader(dev=config.outside_reader_dev,
on_card=card_on_door)
reader_exit = NFCreader.NFCreader(dev=config.inside_reader_dev,
on_card=card_on_exit)
beep_door = beeper.Beeper(reader_door.beep)
beep_exit = beeper.Beeper(reader_exit.beep)
interpreter = Interpreter(opener=lock_control.latch,
public=lock_control.public,
beeper_inside=beep_exit.beep_by_style,
beeper_outside=beep_door.beep_by_style)
hmac_calculator = hmac.new(config.hmac_key, digestmod='sha512')
validator = Validator(hmac_calculator)
mqtt = Mqtt(addr=config.mqtt_broker,
name=config.door_name,
validator=validator,
interpreter=interpreter)
reader_exit.start()
reader_door.start()
logging.info('Started at {}'.format(datetime.datetime.now().isoformat()))
panel_thread.start()
fanout_thread = Fanout(cmd_queue, fanout_queues_list)
fanout_thread.start()
ctl_thread = ControlThread(logic_board_out, raw_bypass_queue,
cmd_to_control_queue)
ctl_thread.start()
if 'link' in cfg and cfg['link']['url']:
linker_thread = Linker(cfg['link']['url'], cmd_to_linker_queue)
linker_thread.start()
if 'mqtt' in cfg and cfg['mqtt']['url']:
mqtt_thread = Mqtt(cfg['mqtt']['url'], cfg['mqtt']['port'],
cfg['mqtt']['use_ssl'], cfg['mqtt']['validate_cert'],
cfg['mqtt']['user'], cfg['mqtt']['passwd'],
cmd_to_mqtt_queue, cmd_queue)
mqtt_thread.start()
panel_status_thread = PanelStatus(panel_in, cmd_queue, raw_bypass_queue)
panel_status_thread.start()
cron_thread = CronCommands(cmd_queue)
cron_thread.start()
sleep_thread = SleepThread(cmd_queue)
sleep_thread.start()
# webservice / flask
app = Flask("SeviControl")
app.logger.setLevel(logging.DEBUG)
if __name__ != '__main__':
gunicorn_logger = logging.getLogger('gunicorn.error')
app.logger.info('loglevel is ' + str(app.logger.level))
app.logger.info('set loglevel to ' + str(gunicorn_logger.level))
# app.logger.handlers = gunicorn_logger.handlers
app.logger.setLevel(gunicorn_logger.level)
app.logger.info('set loglevel to ' + str(logging.DEBUG))
app.logger.setLevel(logging.DEBUG)
app.logger.info('loglevel is ' + str(app.logger.level))
else:
app.logger.info('loglevel is ' + app.logger.info.level)
todoist_api = todoist.TodoistAPI(TODOIST_TOKEN)
mqtt = Mqtt(BROKERHOST, BROKERPORT, USERNAME, PASSWORD, topics=[], log=app.logger)
mqtt.loop_start()
def verify_headers(headers):
return headers.get('USER-AGENT') == 'Todoist-Webhooks'
def verify_hmac(req):
request_hmac = req.headers.get('X-Todoist-Hmac-Sha256')
key = bytes(TODOIST_CLIENT_SECRET, 'latin-1')
calculated_hmac = hmac.new(key, msg=req.get_data(),
digestmod=hashlib.sha256).digest()
calculated_hmac = base64.b64encode(calculated_hmac)
calculated_hmac = calculated_hmac.decode('ascii')
app.logger.info('Comparing ' + calculated_hmac + ' with ' + request_hmac)
import ubinascii
import time
import machine
import json
from connect import Connect
from led_pwm import LedPwm
from lcd import Lcd
from temperature_dht11 import TemperatureSensor as Dht
from mqtt import Mqtt
dht = Dht(4)
led = LedPwm(2)
lcd = Lcd(spi=1, cs=2, dc=15, rst=0, bl=12)
config = json.loads(open('config.json').read())
client_id = ubinascii.hexlify(machine.unique_id())
try:
mqtt = Mqtt(client_id, config['broker_ip'])
except:
mqtt = False
while True:
# Connect to wifi
Connect.check_and_reconnect()
try:
data = {
'temperature': dht.read_temp_and_hum()[0],
'humidity': dht.read_temp_and_hum()[1]
}
print(str(time.localtime()) + ' ' + str(data))
if not mqtt:
try:
mqtt = Mqtt(client_id, config['broker_ip'])
'location': style[0]
})
def publish_status(status_manager):
print("publish status", status_manager.status)
mqtt.simple_send("doors/status", status_manager.status, retain=True)
mqtt.simple_send("status/doorserver/public",
status_manager.public,
retain=True)
mqtt.simple_send("status/doorserver/locked",
not status_manager.open,
retain=True)
mqtt.simple_send("status/doorserver/occupied",
status_manager.occupied,
retain=True)
hmac_calculator = hmac.new(config.hmac_key, digestmod='sha512')
validator = Validator(hmac_calculator)
status = StatusManager(on_change=publish_status)
interpreter = Interpreter(status_manager=status,
open_door=open_door,
close_door=close_door,
alarm_door=alarm_door)
mqtt = Mqtt(addr=config.mqtt_broker,
validator=validator,
interpreter=interpreter,
status_manager=status)
mqtt.start()
import aiohttp
from connect_box import ConnectBox
from connect_box.exceptions import ConnectBoxConnectionError
from mqtt import Mqtt
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
ROUTERPASSWORD = os.getenv('ROUTERPASSWORD')
BROKERHOST = os.getenv('MQTTHOST')
BROKERPORT = int(os.getenv('MQTTPORT'))
USERNAME = os.getenv('MQTTUSERNAME')
PASSWORD = os.getenv('MQTTPASSWORD')
mqtt = Mqtt(BROKERHOST, BROKERPORT, USERNAME, PASSWORD, topics=[])
mqtt.waitForConnection()
mqtt.publish('failcloud/connectbot', 'Hello from experiment.mqtt4connectbox python script!')
# via https://github.com/fabaff/python-connect-box/blob/master/example.py
buffer = {}
def aliasify(dev):
if dev.mac == '8C:45:00:69:E9:17':
dev.hostname = 'IKEA TRADFRI'
elif dev.mac == 'A0:28:ED:86:36:46':
dev.hostname = 'think7plus'
return dev
def __init__(self):
self.sensores = Sensores()
self.sender = Sender()
#self.database = DataBase()
self.mqtt = Mqtt()
self.Config = ConfigParser.ConfigParser()
def __init__(self):
#Gets args
ap = argparse.ArgumentParser()
ap.add_argument("-s",
"--simulated",
type=int,
help="simulated environment")
args = vars(ap.parse_args())
#Starts and connect MQTT client to AWS MQTT Broker
self.mqtt = Mqtt()
self.mqtt.connect()
#Simulation case 1:
#Internal temperature from NODEMCU
#Internal humidity from potentiometer
#Air conditioner from NODEMCU
#External temperature from potentiometer
if args["simulated"] == 1:
self.internalSensor = SimulatedEnvironment(None)
self.internalSensor.start()
self.airCondControl = self.internalSensor
self.externalSensor = self.internalSensor
#Simulation case 2:
#Internal temperature from NODEMCU
#Internal humidity from DHT22
#Air conditioner from NODEMCU
#External temperature from DHT22
elif args["simulated"] == 2:
self.internalSensor = SimulatedEnvironment(Dht22(22))
self.internalSensor.start()
self.airCondControl = self.internalSensor
self.externalSensor = Dht22(23)
self.externalSensor.start()
#Simulation case 3:
#Internal temperature from DHT22(1)
#Internal humidity from DHT22(1)
#Air conditioner from NODEMCU
#External temperature from DHT22(2)
else:
self.internalSensor = Dht22(22)
self.internalSensor.start()
self.airCondControl = SimulatedEnvironment(None)
self.airCondControl.start()
self.externalSensor = Dht22(23)
self.externalSensor.start()
#Read initial data from sensors
self.current_in_temp = self.internalSensor.read("IN_TEMP")
self.current_in_hum = self.internalSensor.read("IN_HUM")
self.current_ex_temp = self.externalSensor.read("EX_TEMP")
#Publish initial data on respective topics
self.mqtt.publish("pgcc008/problem01/sensor/internal/temperature",
self.current_in_temp)
self.mqtt.publish("pgcc008/problem01/sensor/internal/humidity",
self.current_in_hum)
self.mqtt.publish("pgcc008/problem01/sensor/internal/air_cond_state",
self.air_cond_interaction)
self.mqtt.publish("pgcc008/problem01/sensor/external/temperature",
self.current_ex_temp)
print("[DEVICE] Control System started")
#CATC------ importamos las sigueintes librerias
import threading
import logging
import time
import os
import sys
#CATC importamos de otros programas
from mqtt import Mqtt
from audio import Sonido
from comandos import Comandos
from datetime import datetime
from globals import *
#CATC imvocamos ala clase Mqtt y le enviamos parametros
cli = Mqtt("proyectos", "proyectos980", "167.71.243.238", 1883, USER_ID_1,
USER_ID_2, USER_ID_3)
#CATC igualamos una funciones a utilizar
com = Comandos()
aud = Sonido()
#CATC configuramos la fucion Alive para estar avisando en elsevidor
#CATC que nos encontremaos activos
def alive(delay=com.delay_a()):
while True:
alive = com.command_alive() + bytes(str(cli.carnet()), 'utf-8')
cli.client.publish(str(cli.topicalive()), alive)
time.sleep(delay)
def mqttConnect():
m = Mqtt(queue, con)
m.connect()
import threading
import logging
import time
import os
import sys
from mqtt import Mqtt
from audio import Sonido
from comandos import Comandos
from datetime import datetime
cli = Mqtt("proyectos", "proyectos980", "167.71.243.238", 1883)
com = Comandos()
aud = Sonido()
def alive(delay=com.delay_a()):
while True:
alive = com.command_alive() + bytes(str(cli.carnet()), 'utf-8')
cli.client.publish(str(cli.topicalive()), alive)
time.sleep(delay)
t1 = threading.Thread(name='alive', target=alive, daemon=True)
listaHilos = []
#Luego de configurar cada hilo, se inicializan
t1.start()
for i in listaHilos:
i.start()
#Loop principal: leer los datos de los sensores y enviarlos al broker en los topics adecuados cada cierto tiempo
def __init__(self):
self.mqtt = Mqtt()
self.mqtt.set_on_message(self._on_message)
