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)