Пример #1
1
  client.subscribe("Meshcat")

def on_message(client, userdata, msg):
  print_log(datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S') + " | message received!")
  try:
    message = json.loads(msg.payload)
  except ValueError:
    print_log("Invalid message format!")
    return
  station_secret = message["id_secret"]
  sensor = message["sensor"]
  value = message["value"]
  format_date = message["datetime"].split("+")[0]
  timestamp = datetime.strptime(format_date, '%Y-%m-%dT%H:%M:%S')
  sid = db.get_id_from_secret(station_secret)
  if (sid and sensor != "ACC" and sensor != "STR"):
    db.insert_data(sid, sensor, value, timestamp)
  if (not sid):
    sid = "-"
    #sid = db.new_station(station_secret)
    #print_log("Add new sensor with ID " + str(sid))
  print_log("receive: sid: {} | sensor: {} | value: {} | timestamp: {}".format(sid,sensor,value,timestamp))

mqtt = mqtt.Client()
mqtt.on_connect = on_connect
mqtt.on_message = on_message

mqtt.connect("localhost", 1883)

mqtt.loop_forever()
Пример #2
1
    time.sleep(2)
    client.publish("user/bob/location", "home", retain=True, qos=1)
    client.publish("user/bob/location", "work", retain=True, qos=1)

    # Subscribing in on_connect() means that if we lose the connection and
    # reconnect then subscriptions will be renewed.
    client.subscribe("user/bob/location")

# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
    print(msg.topic+" "+str(msg.payload))
    time.sleep(2)

def on_log(*args):
    print args


client = client.Client()
client.on_connect = on_connect
client.on_message = on_message
client.on_log = on_log
client.username_pw_set("bob", password=None)
client.connect("localhost", 8000, 60)


# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
client.loop_forever()
Пример #3
0
    def handle(self):
        headers = self.request.recv(1024).strip().split('\r\n')
        valid = 'Connection: Upgrade' in headers and 'Upgrade: websocket' in headers
        if not valid: return self.request.sendall(HTTP_400)
        request_key = str(' ').join([
            header.split(' ').pop() for header in headers
            if 'Sec-WebSocket-Key' in header
        ])
        response_key = base64.standard_b64encode(
            hashlib.sha1(request_key + WEBSOCKET_HASH).digest())
        self.request.sendall(HTTP_101 % response_key)
        # def connect_mqtt_to_websocket( self ) :
        handler, connected = self, True

        def subscribe(client, userdata, flags, code):
            client.subscribe('raspberry/status')

        def receive(client, userdata, message):
            try:
                handler.send_frame(message.payload)
            except:
                connected = False  # TODO?

        client = paho.mqtt.client.Client()
        client.on_connect = subscribe
        client.on_message = receive
        client.connect('192.168.0.10', 1883)
        while connected:
            client.loop_forever()
Пример #4
0
def main():
    client = paho.mqtt.client.Client("Emiliano", False)
    client.qos = 0
    client.connect(host='127.0.0.1')
    meanEntrada = 10
    stdEntrada = 2
    tempMax = 12
    horaBase = datetime.datetime.now().replace(minute=0, second=0)
    personasPorHora = np.random.normal(meanEntrada, stdEntrada)
    horaBase = horaBase + datetime.timedelta(hours=1)

    while True:
        hora = horaBase + datetime.timedelta(seconds=1)
        horaBase = horaBase + datetime.timedelta(seconds=1)
        temp = int(np.random.uniform(0, 151))
        payload = {"fecha": str(hora), "Temperatura": str(temp)}

        client.publish('casa/cocina/nevera', json.dumps(payload), qos=0)
        print(payload)
        if temp >= 100:
            payload = {
                "fecha": str(hora),
                "Temperatura": str(temp),
                "Agua": "El agua ya ha hervido"
            }
            print(payload)
            client.publish('casa/cocina/nevera', json.dumps(payload), qos=0)

        time.sleep(0.5)
Пример #5
0
def main():
	client = paho.mqtt.client.Client("fridge", False)
	client.qos = 0
	client.connect(host = "localhost")
	minTemp = 8
	maxTemp = 12
	minIce = 0
	maxIce = 10
	Actualtime = datetime.datetime.now().replace(minute = 0, second = 0, microsecond = 0)
	sendIceData = True

	while(True):
		temperature = round(random.uniform(minTemp, maxTemp), 2)
		data = {
			"date": str(Actualtime),
			"temperature": str(temperature)
		}
		client.publish("house/kitchen/fridge", json.dumps(data), qos = 0)
		print(data)

		if(sendIceData):
			iceCapacity = round(random.uniform(minIce, maxIce), 2)
			data = {
			"date": str(Actualtime),
			"ice_capacity": str(iceCapacity)
			}
			client.publish("house/kitchen/fridge", json.dumps(data), qos = 0)
			print(data)
		
		Actualtime += datetime.timedelta(minutes = 5)
		sendIceData = not sendIceData
		time.sleep(5)
Пример #6
0
def main():
    ollaEnUso = True
    mensajeExitoso = "El agua está hirviendo"
    mensajeFallido = "El agua no está hirviendo"
    cont = 0
    client = paho.mqtt.client.Client("Olla", False)
    client.qos = 2
    client.on_connect = on_connect
    client.connect('localhost')
    hora = datetime.datetime.now()
    while cont < 100 and ollaEnUso:
        minTemp = 50
        maxTemp = 150
        temp = np.random.uniform(minTemp, maxTemp)
        payload = {"Temperatura_Olla": str(round(temp, 2)), "Fecha": str(hora)}
        if ollaEnUso:
            if temp > 100:
                payload["mensaje"] = mensajeExitoso
            else:
                payload["mensaje"] = mensajeFallido
        client.publish('Casa/Cocina/temperatura_olla',
                       json.dumps(payload),
                       qos=0)
        cont += 1
        print(payload)
        time.sleep(1)
        hora = hora + datetime.timedelta(seconds=1)
Пример #7
0
def main():
    client = paho.mqtt.client.Client("Emiliano", False)
    client.qos = 0
    client.connect(host='127.0.0.1')
    meanEntrada = 10
    stdEntrada = 2
    tempMax = 12
    horaBase = datetime.datetime.now().replace(minute=0, second=0)
    personasPorHora = np.random.normal(meanEntrada, stdEntrada)
    horaBase = horaBase + datetime.timedelta(hours=1)

    while True:
        hora = horaBase + datetime.timedelta(minutes=5)
        horaBase = horaBase + datetime.timedelta(minutes=5)
        temp = int(np.random.normal(8, tempMax + 1))
        payload = {"fecha": str(hora), "Temperatura": str(temp)}
        hielo = {
            "fecha": str(hora),
            "Capacidad": str(int(np.random.uniform(0, 11)))
        }
        client.publish('casa/cocina/nevera', json.dumps(payload), qos=0)
        print(payload)
        if int(hora.minute) % 10 == 0:
            print(hielo)
            client.publish('casa/cocina/nevera', json.dumps(hielo), qos=0)
        time.sleep(0.5)
Пример #8
0
def connect_server():
    try:
        ws = create_connection("ws://" + address + ":" + port + "/rpi")
        print("connect to " + address + ":" + port)
        ws.send(json_send)
    except Exception as e:
        print(e)
        ws.close()
        exit()
    while True:
        result = ws.recv()
        bno, rno = result.split(',')
        mqtt = mqtt.Client("mypub")
        mqtt.connect("localhost", 1883)
        if bno == 1 and rno == 1:
            mqtt.publish('motor', 1)
        elif bno == 1 and rno == 2:
            mqtt.publish('motor', 2)
        elif bno == 2 and rno == 1:
            mqtt.publish('motor', 3)
        elif bno == 2 and rno == 2:
            mqtt.publish('motor', 4)
        print("The message is published.")
        print("open bno:" + bno + " rno:" + rno)
    ws.close()
Пример #9
0
def _init_mqtt_client(
    # *, SyntaxError on python3.5
    host: str,
    port: int,
    username: typing.Optional[str],
    password: typing.Optional[str],
    disable_tls: bool,
) -> paho.mqtt.client.Client:
    # https://pypi.org/project/paho-mqtt/
    client = paho.mqtt.client.Client()
    client.on_connect = _mqtt_on_connect
    if not disable_tls:
        client.tls_set(
            ca_certs=None)  # enable tls trusting default system certs
    _LOGGER.info(
        "connecting to MQTT broker %s:%d (TLS %s)",
        host,
        port,
        "disabled" if disable_tls else "enabled",
    )
    if username:
        client.username_pw_set(username=username, password=password)
    elif password:
        raise ValueError("Missing MQTT username")
    client.connect(host=host, port=port)
    return client
Пример #10
0
def main():
    mensajeAlerta = "¡No deben haber más de 5 personas en la Sala! por favor retirense"
    cont = 0
    client = paho.mqtt.client.Client("contadorPersonas", False)
    client.qos = 0
    client.on_connect = on_connect
    client.connect(host='localhost', port=1883)
    hora = datetime.datetime.now()
    while cont < 100:
        minPer = 0
        maxPer = 10
        personas = np.random.uniform(minPer, maxPer)
        payload = {
            "Cantidad Personas": str(round(personas)),
            "Fecha": str(hora)
        }
        if personas > 5:
            payload["mensaje"] = mensajeAlerta
        client.publish(topic='Casa/Sala/contador_personas',
                       payload=json.dumps(payload),
                       qos=0)
        cont += 1
        print(payload)
        time.sleep(1)
        hora = hora + datetime.timedelta(seconds=60)
Пример #11
0
    def __init__(self, *args, **kwargs):
        QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
        self.setupUi(self)
        client = paho.mqtt.client.Client(client_id='andres',
                                         clean_session=False)
        client.on_connect = on_connect
        client.on_message = on_message
        client.connect(host='localhost', port=1883)
        client.loop_start()

        self.luz.setText(b)
        self.temperatura_2.setText(b)
        self.salen.setText(b)
        self.entran.setText(b)
        self.adentro.setText(b)

        self.encendidoaire.clicked.connect(self.aireon)
        self.arribaaire.clicked.connect(self.airearriba)
        self.abajoaire.clicked.connect(self.aireabajo)
        self.encendidotv.clicked.connect(self.tvon)
        self.canalmas.clicked.connect(self.tvmas)
        self.canalmenos.clicked.connect(self.tvmenos)
        self.volumenmas.clicked.connect(self.tvvolmas)
        self.volumenmenos.clicked.connect(self.tvvolmenos)
        self.salen.setText(b)
        self.entran.setText(b)
        self.adentro.setText(b)
        self.labsdos.clicked.connect(self.luz2)
        self.labsuno.clicked.connect(self.luz1)
Пример #12
0
def main():
	client = paho.mqtt.client.Client(client_id='client3', clean_session=False)
	client.on_connect = on_connect
	client.on_message = on_message
	client.username_pw_set('caio', 'senha')
	client.connect(host='192.168.20.105', port=1883)
	client.loop_forever()
Пример #13
0
def main():
    client = paho.mqtt.client.Client("Emiliano", False)
    client.qos = 0
    client.connect(host='127.0.0.1')
    meanEntrada = 10
    stdEntrada = 2
    tempMax = 12
    horaBase = datetime.datetime.now().replace(minute=0, second=0)
    personasPorHora = np.random.normal(meanEntrada, stdEntrada)
    horaBase = horaBase + datetime.timedelta(hours=1)

    while True:
        hora = horaBase + datetime.timedelta(minutes=1)
        horaBase = horaBase + datetime.timedelta(minutes=1)
        cantPersonas = int(np.random.uniform(0, 11))
        payload = {
            "fecha": str(hora),
            "cantidad de personas": str(cantPersonas)
        }

        client.publish('casa/cocina/sala', json.dumps(payload), qos=0)
        print(payload)
        if cantPersonas > 5:
            payload = {
                "fecha": str(hora),
                "cantidad de personas": str(cantPersonas),
                "Alerta": "Demasiadas personas dentro de la habitación"
            }
            print(payload)
            client.publish('casa/cocina/sala', json.dumps(payload), qos=0)

        time.sleep(0.5)
Пример #14
0
def mqrecv():
	client = paho.mqtt.client.Client(client_id='192.168.0.110', clean_session=False)
	client.username_pw_set('DGB1', '12345678')
	client.on_connect = on_connect
	client.on_message = on_message
	client.connect(host='192.168.0.158', port="1883")
	client.loop_forever()
Пример #15
0
def MQTT_Proyector(estado): 
    global test
    falcon_logger.info("Solicitando cambio estado proyector a %s" % estado)

    if (config.MQTT.POWER_CHECK):
        cur_stat=Estado_Proyector()
        if (estado == cur_stat):
            falcon_logger.info("El protector ya esta en %s. No hago nada" % estado)
            return estado
    else:
        falcon_logger.info("Power Control desactivado")

    falcon_logger.info("Enviando mensaje MQTT %sbroadlink/replay proyectoron" % test )
    try:
        falcon_logger.info("Estableciendo conexion con %s:%s" % (config.MQTT.HOST,config.MQTT.PORT))
        client.connect(host=config.MQTT.HOST, port=config.MQTT.PORT)
        client.publish("%sbroadlink/record" % test,"proyectoron" )
        if (estado=="OFF"):
            time.sleep(1)
            client.publish("%sbroadlink/record" % test,"proyectoron" )
            falcon_logger.error("Enviando mensaje MQTT %sbroadlink/replay proyectoron" % test )
        client.disconnect()
    except Exception as e:
        falcon_logger.error("Error al conectar a MQTT. Mensaje no enviado %s" % str(e))
        return 9,"Error de conexion"
    return 0,"ok"
    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()
Пример #17
0
def main():
    client = paho.mqtt.client.Client(client_id='escaner WI-FI',
                                     clean_session=False)
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(host='127.0.0.1', port=1883)
    client.loop_forever()
    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()
Пример #19
0
def main():
    client = paho.mqtt.client.Client(client_id="albert-subs",
                                     clean_session=False)
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(host=SETTINGS.BROKER_HOST, port=1883)
    client.loop_forever()
Пример #20
0
def start_sensor(config):

    sensor = DFRobotAS3935(I2C_ADDRESS,
                           bus=config('sensor', 'bus'),
                           capacitance=config('sensor', 'capacitance'),
                           location=Location[config('sensor', 'location').upper()],
                           disturber_detection=config('sensor', 'disturber_detection'))

    mqtt = create_client(config)
    try:
        logging.info('Starting MQTT notifier.')
        mqtt.connect(config('mqtt', 'broker'), config('mqtt', 'port'))

        if sensor.reset():
            logging.info('Sensor initialized.')
            GPIO.add_event_detect(IRQ_PIN, GPIO.RISING, callback=mk_callback_handler(sensor, mqtt, config))
            logging.info('Starting lightning detection...')
            mqtt.publish(f'{config("mqtt", "topic")}/status', payload='online', qos=0, retain=True)
            start_ping(config, mqtt)
            mqtt.loop_forever()
        else:
            logging.fatal('Sensor initialization failed.')

    except Exception as e:
        logging.error(e)
        logging.exception('Unable to connect to MQTT broker!')
Пример #21
0
def main():
	client = paho.mqtt.client.Client("cookingPot", False)
	client.qos = 0
	client.connect(host = "localhost")
	minTemp = 0
	maxTemp = 150
	Actualtime = datetime.datetime.now().replace(minute = 0, second = 0, microsecond = 0)

	while(True):
		temperature = round(random.uniform(minTemp, maxTemp), 2)
		data = {
			"date": str(Actualtime),
			"temperature": str(temperature)
		}
		client.publish("house/kitchen/cooking_pot", json.dumps(data), qos = 0)
		print(data)

		if(temperature >= 100):
			for i in range(60):
				data = {
				"date": str(Actualtime),
				"message": "The water boild"
				}
				client.publish("house/kitchen/cooking_pot", json.dumps(data), qos = 0)
				print(data)
				Actualtime += datetime.timedelta(seconds = 1)
		else:
			Actualtime += datetime.timedelta(minutes = 1)
		
		time.sleep(1)
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 main():
    client = paho.mqtt.client.Client("alexaEco", False)
    client.qos = 0
    client.connect(host="localhost")
    Actualtime = datetime.datetime.now().replace(minute=0,
                                                 second=0,
                                                 microsecond=0)
    minTemp = 0
    maxTemp = 1

    url = "https://api.openweathermap.org/data/2.5/weather?"
    api_key = "127782c6cbdc7abdbed266714daeeade"
    city = "Caracas,VE"

    querystring = url + "appid=" + api_key + "&q=" + city
    response = requests.get(querystring)
    jsonRes = response.json()
    temperature = round(jsonRes["main"]["temp"] - 273.15, 2)

    while (True):
        operation = bool(random.getrandbits(1))

        if (operation):
            temperature += round(random.uniform(minTemp, maxTemp), 2)
        else:
            temperature -= round(random.uniform(minTemp, maxTemp), 2)
        temperature = round(temperature, 2)
        data = {"date": str(Actualtime), "temperature": str(temperature)}
        client.publish("house/living_room/alexa_eco", json.dumps(data), qos=0)
        print(data)

        Actualtime += datetime.timedelta(minutes=3)

        time.sleep(3)
Пример #24
0
def main():
    cont = 0
    client = paho.mqtt.client.Client("Nevera", False)
    client.qos = 2
    client.on_connect = on_connect
    client.connect('localhost')
    hora = datetime.datetime.now()
    while cont < 100:
        meanTemp = 10
        stndTemp = 2
        minHielo = 0
        maxHielo = 10
        temp = np.random.normal(meanTemp, stndTemp)
        hielo = np.random.uniform(minHielo, maxHielo)
        payload = {
            "Temperatura_nevera": str(round(temp, 2)),
            "Cantidad_de_Hielo": str(round(hielo)),
            "Fecha": str(hora)
        }
        client.publish('Casa/Cocina/temperatura_nevera',
                       json.dumps(payload),
                       qos=0)
        cont += 1
        print(payload)
        time.sleep(1)
        hora = hora + datetime.timedelta(seconds=300)
Пример #25
0
def main():
    client = paho.mqtt.client.Client("Emiliano", False)
    client.qos = 0
    client.connect(host='127.0.0.1')
    meanEntrada = 10
    stdEntrada = 2
    tempMax = 12
    horaBase = datetime.datetime.now().replace(minute=0, second=0)
    personasPorHora = np.random.normal(meanEntrada, stdEntrada)
    horaBase = horaBase + datetime.timedelta(hours=1)

    while True:
        hora = horaBase + datetime.timedelta(minutes=30)
        horaBase = horaBase + datetime.timedelta(minutes=30)

        url = "http://api.openweathermap.org/data/2.5/weather?q=Caracas&appid=6cf9ae43293928ec740fd51b2c9c524a"
        data = requests.get(url).json()

        temp = int(data['main']['temp']) - 273

        payload = {
            "fecha": str(hora),
            "Temperatura de Caracas ": str(temp)
        }

        client.publish('casa/cocina/sala', json.dumps(payload), qos=0)
        print(payload)

        time.sleep(0.5)
def main():
    client = paho.mqtt.client.Client("personCounter", False)
    client.qos = 0
    client.connect(host="localhost")
    minPer = 0
    maxPer = 10
    Actualtime = datetime.datetime.now().replace(minute=0,
                                                 second=0,
                                                 microsecond=0)

    while (True):
        persons = round(random.uniform(minPer, maxPer), 0)
        data = {"date": str(Actualtime), "persons": str(persons)}
        client.publish("house/living_room/person_counter",
                       json.dumps(data),
                       qos=0)
        print(data)

        if (persons > 5):
            data = {
                "date": str(Actualtime),
                "message": "Maximum number of people exceeded"
            }
            client.publish("house/living_room/person_counter",
                           json.dumps(data),
                           qos=0)
            print(data)

        Actualtime += datetime.timedelta(minutes=1)
        time.sleep(1)
Пример #27
0
def main():
    client = paho.mqtt.client.Client(client_id='Sala-subs',
                                     clean_session=False)
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect('localhost', port=1883)
    client.loop_forever()
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()
Пример #29
0
def main():
    cont = 0
    resp = requests.get(
        'http://api.openweathermap.org/data/2.5/weather?q=Caracas&appid=746872ff706ff4ebf8cd394c72541b42'
    )
    print(resp.json()["main"]["temp"])
    # Conversión de Kelvin a Celsius
    temp = int(resp.json()["main"]["temp"]) - 273.15
    print(temp)
    client = paho.mqtt.client.Client("Alexa", False)
    client.qos = 2
    client.on_connect = on_connect
    client.connect('localhost')
    hora = datetime.datetime.now()
    while cont < 100:
        tempDelta = np.random.normal(1, 0.5)
        payload = {
            "Temperatura Caracas": str(round(temp + tempDelta, 2)),
            "Fecha": str(hora)
        }
        client.publish('Casa/Sala/alexa_echo', json.dumps(payload), qos=0)
        cont += 1
        print(payload)
        time.sleep(1)
        hora = hora + datetime.timedelta(seconds=300)
Пример #30
0
def main():
    client = paho.mqtt.client.Client(client_id=MQTT_CLIENT_ID,
                                     clean_session=False)
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(host=MQTT_HOST)
    client.loop_forever()
Пример #31
0
def main():
	client = paho.mqtt.client.Client(client_id='123', clean_session=False)
	#client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	#client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='45.35.48.219')
	client.loop_forever()
Пример #32
0
def main():
    ledRGB.loadInit()
    client = paho.mqtt.client.Client(client_id='pythonIGM',
                                     clean_session=False)
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(host='192.168.1.198', port=1883)
    client.loop_forever()
 def connect(self, topic: str):
     self.__topic = topic
     client = paho.mqtt.client.Client()
     client.username_pw_set(mqtt_user, mqtt_password)
     client.on_connect = self.on_connect
     client.on_message = self.on_message
     client.connect(self.__host, 1883, 60)
     client.loop_start()
Пример #34
0
def main():	
    client = paho.mqtt.client.Client(client_id='Actividad Sambil',clean_session=False)
    client.on_connect = on_connect
    client.message_callback_add('Sambil/Camaras/#', on_message_C)
    client.message_callback_add('Sambil/Estacionamiento/#', on_message_A)
    client.message_callback_add('Sambil/Mesa/#', on_message_M)
    client.message_callback_add('Sambil/Tienda/#', on_message_T)
    client.connect(host='localhost') 
    client.loop_forever()
Пример #35
0
	def _write_topic(self, topic, value):
		client = paho.mqtt.client.Client()
		notifications = []
		client.on_connect = lambda c,d,f,r: c.subscribe('N/#', 0)
		client.connect(TestHost)
		client.loop_start()
		client.on_message = lambda c,d,msg: notifications.append(msg)
		client.publish(topic, json.dumps({'value': value}))
		time.sleep(1)
		client.loop_stop(True)
		self.assertTrue(len(notifications) > 0)
		topic = 'N' + topic[1:]
		v = None
		for n in notifications:
			if n.topic == topic:
				v = int(json.loads(n.payload)['value'])
		self.assertEqual(v, value)
Пример #36
0
	def test_notifications(self):
		client = paho.mqtt.client.Client()
		notifications = []
		client.on_connect = lambda c,d,f,r: c.subscribe('N/#', 0)
		client.connect(TestHost)
		client.loop_start()
		time.sleep(2) # wait for retained messages
		client.on_message = lambda c,d,msg: notifications.append(msg)
		time.sleep(2)
		client.loop_stop(True)
		self.assertTrue(len(notifications) > 0)
		for n in notifications:
			action, system_id, service_type, device_instance, path = n.topic.split('/', 4)
			self.assertEqual(action, 'N')
			self.assertEqual(system_id, TestPortalId)
			# If the statements below raise an exception, the test will fail
			di = int(device_instance)
			v = json.loads(n.payload)['value']
Пример #37
0
	def test_request(self):
		client = paho.mqtt.client.Client()
		notifications = []
		client.on_connect = lambda c,d,f,r: c.subscribe('N/#', 0)
		client.connect(TestHost)
		client.loop_start()
		time.sleep(2) # wait for retained messages
		client.on_message = lambda c,d,msg: notifications.append(msg)
		topic = 'R/{}/settings/0/Settings/Vrmlogger/LogInterval'.format(TestPortalId)
		client.publish(topic, '')
		time.sleep(1)
		client.loop_stop(True)
		self.assertTrue(len(notifications) > 0)
		topic = 'N' + topic[1:]
		for n in notifications:
			if n.topic == topic:
				v = int(json.loads(n.payload)['value'])
				break
		else:
			raise Exception('Topic not found')
Пример #38
0
phone app sends to mosquitto broker

we subscribe on that broker and send http to update.py
"""

import json, restkit, logging
import paho.mqtt.client

logging.basicConfig(level=logging.INFO, format="%(asctime)-15s %(message)s")
log = logging.getLogger()

config = json.load(open('priv.json'))
updateServer = restkit.Resource("http://bang:9033/update")

client = paho.mqtt.client.Client("map-receiver")
client.connect("localhost")
log.info('connected to %s', client._host)
# need more auth here, to be able to read
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 = {
        Thread.__init__(self)
        self.topic = topic
        self.payload = payload
        self.daemon = True

    def run(self):
        session = models.get_session()
        store_entry = Store()
        store_entry.payload = self.payload.decode("utf-8")
        store_entry.topic = self.topic
        session.add(store_entry)
        session.commit()


# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
    thread = WriteMessage(msg.topic, msg.payload)
    thread.start()

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect("localhost", 1883, 60)

# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
client.loop_forever()
Пример #40
0
def new(host, port, keep_alive):
  client = paho.mqtt.client()
  client.subscribe("devnet/2")
  client.connect(host, port, keep_alive)
  client.on_message = on_message
Пример #41
0
			pin = int(path[2])
			pin_storage[pin] = str(msg.payload)
			conn.sendall(hw("vw", pin, str(msg.payload)))
	
	for old, pin in translate_topic:
		old_topic = u"%s/%s" % (TOPIC, old)
		if old_topic == msg.topic:
			pin_storage[pin] = str(msg.payload)
			log(u"Write topic %s to vw/%s, val %s" % (old_topic, pin, str(msg.payload)))
			conn.sendall(hw("vw", pin, str(msg.payload)))

# Main code
log('Connecting to MQTT broker %s:%d' % (MQTT_SERVER, MQTT_PORT))
try:
    mqtt = mqtt.Client(MQTT_CLIENT)
    mqtt.connect(MQTT_SERVER, MQTT_PORT, 60)
    mqtt.on_message = on_mqtt_message
except:
    log("Can't connect")
    sys.exit(1)

mqtt.subscribe("%s/#" % TOPIC)

log('Connecting to %s:%d' % (SERVER, PORT))
try:
    conn = socket.create_connection((SERVER, PORT), 3)
except:
    log("Can't connect")
    sys.exit(1)

if NODELAY != 0:
Пример #42
0
def mqtt_client(host, port, keep_alive):
  client = paho.mqtt.client.Client()
  client.subscribe("devnet/2")
  client.on_message = on_message
  client.connect(host, port, keep_alive)
  return client
Пример #43
0
        [tlv.T_PROP_VALUE, value.encode("utf8")], ]
    tlv.dumptlv(tlvdata)
    hsc_sock.sendto(tlv.hmactlv(tlv.gettlv(tlvdata), hsckey), ("255.255.255.255",UDP_PORT))
    hsc_sock.sendto(tlv.hmactlv(tlv.gettlv(tlvdata), hsckey), (MCAST_GROUP,UDP_PORT))
    if '$ip' in device['attrs']:
        hsc_sock.sendto(tlv.hmactlv(tlv.gettlv(tlvdata), hsckey), (device['attrs']['$ip'],UDP_PORT))



client = paho.mqtt.client.Client()
client.on_connect = on_connect
client.on_message = on_message

if config.has_option('mqtt', 'username'):
    client.username_pw_set(config.get('mqtt', 'username'), config.get('mqtt', 'password'))
client.connect(config.get('mqtt', 'host'), config.getint('mqtt', 'port', fallback=1883), config.getint('mqtt', 'keepalive', fallback=60))

client.loop_start()

class Application(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.winfo_toplevel().title("HAm MQTT Viewer/Commander")
        self.pack()
        self.devices_order = []
        if config.has_option('preferences', 'devices_order'):
            for deviceId in config.get('preferences', 'devices_order').split(','):
                if deviceId.startswith('-'):
                    deviceId = deviceId[1:]
                    devices[deviceId]={'$deviceId': deviceId, 'attrs':{}, 'properties':{}, '__collapsed': True}
                self.devices_order.append(deviceId)
Пример #44
0
# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER, False)

GPIO.setup(ACTUATOR,GPIO.OUT)
GPIO.output(ACTUATOR, False)

#broker configurations
IP = '192.168.0.103'
PORT = 1884
TOPIC_ACT = "impress/demo"
TOPIC_SUB = "impress/action"
CLIENT_NAME = 'RASPBERRY'

 # Connect to MQTT broker.
client = client.Mosquitto(CLIENT_NAME)
client.connect(IP,PORT,60)


class Th(Thread):

        def __init__ (self, num):
                Thread.__init__(self)
                self.num = num
                def on_connect(client, data, rc):
                    client.subscribe(TOPIC_SUB)
                   print("Connection returned result: " + str(rc))
                def on_message(client, userdata, msg):
                    message = str(msg.payload)
                    arrMessage = message.split(";")
                    print(arrMessage[0]);
Пример #45
0
# MQTT topic
TOPIC = 'sensor'

if __name__ == '__main__':

    f = open('./agent.yaml', 'r')

    conf = yaml.load(f)
    cpe = conf['cpe']
    location = conf['location']
    mqtt = conf['mqtt']
    topic = mqtt['topic']

    client = client.Client()
    client.connect(host=mqtt['host'], port=mqtt['port'], keepalive=60)

    # FTDI driver
    ftdi_list = os.listdir('/dev/serial/by-id')

    dev_list = []
    for ftdi in ftdi_list:
        path = '/dev/serial/by-id/{}'.format(ftdi)
        tty = os.path.realpath(path)  # symbolic link
        ser = serial.Serial(tty)
        usb = tty.split('/')[2]
        dev_list.append((ftdi, usb, ser))

    while True:
        for dev in dev_list:
            usb = dev[1]