def vsom_run():
# spark_token = "YWE5NTc0ZGItMjljMy00YWFmLThiY2YtNTE5ZjYxNDhmZmUwZGIwMzg3ZDctNDA3"
# token = vsom_token()
# res = get_snapshot(token)
# files = {'upload_file': res.content}
# r = requests.post("http://173.36.206.19/images/tmp", files=files)
# json = r.json()
# url = "http://173.36.206.19" + json["uri"]
# res = Messages.send(spark_token, "Testing", [url], None, None, "*****@*****.**" )
# pretty_print(res)
client = mqtt_client('173.36.206.30', 7777, 10000)
client.loop_forever()
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()
def run(self):
print self.num
client.loop_forever()
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()
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 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()
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()
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()
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()
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 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!')
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()
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()
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 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()
def mqtt_start():
client = paho.mqtt.client.Client(transport='tcp')
client.username_pw_set("hjpc", "htxzdj")
client.on_connect = on_connect
client.on_message = on_message
client._client_id = clitntID
client.connect(aliHOST, aliPORT, 60)
#client.publish('hjOneLineGet',payload='',qos = 0)
print("pyOneLineServer 初始化结束, 等待请阅请求", flush=True)
client.loop_forever()
def main():
try:
client = paho.mqtt.client.Client(client_id='Juan', clean_session=False)
client.on_connect = on_connect
print("----")
client.message_callback_add('unimet/admin/bd', on_message)
client.connect(host='localhost')
client.loop_forever()
except (Exception, psycopg2.DatabaseError) as error:
print("Ha ocurridso un error", error)
def main():
print("Ctrl+c para salir")
print("Inicializando..")
client = paho.mqtt.client.Client(client_id='Serial-monitor',
clean_session=False)
client.on_connect = on_connect
client.on_message = on_message
client.username_pw_set("usuario", "contrasenya")
client.connect(host=broker_address, port=broker_port)
client.loop_forever()
def main():
client = paho.mqtt.client.Client()
client.on_connect = on_connect
client.message_callback_add('Sambil/rasgos', on_message)
client.message_callback_add('Sambil/usuario', on_message3)
client.message_callback_add('Sambil/torniquete', on_message4)
client.message_callback_add('Sambil/venta', on_message5)
client.message_callback_add('Sambil/mesa', on_message7)
client.message_callback_add('Sambil/acceso', on_message9)
client.connect(host='localhost')
client.loop_forever()
def main():
client = paho.mqtt.client.Client(client_id='[clientid]',
clean_session=False)
client.username_pw_set('[username]', '[password]')
client.on_connect = on_connect
client.on_message = on_message
client.tls_set('/home/credd/ca-certificates.crt',
tls_version=ssl.PROTOCOL_TLSv1_2)
client.tls_insecure_set(True)
client.connect('reddtech.us', 8883, 60)
#client.loop_forever()
client.loop_forever()
def main():
client = paho.mqtt.client.Client(client_id='[clientid]',
clean_session=False)
#client.username_pw_set('[username]', '[password]')
client.on_connect = on_connect
client.on_message = on_message
# debian stretch
client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem',
tls_version=ssl.PROTOCOL_TLSv1_2)
# CentOS 7
# client.tls_set('/etc/ssl/certs/ca-bundle.trust.crt', tls_version=ssl.PROTOCOL_TLSv1_2)
client.connect(host=host, port=8883)
client.loop_forever()
def main():
# Load MQTT configuration from MQTT_Config.yaml
with open(r'MQTT_Config.yaml') as configuration:
config = yaml.load(configuration, Loader=yaml.FullLoader)
print(config)
# Start MQTT subscription listening for data from the tracker.
client = paho.mqtt.client.Client(client_id=str(uuid.getnode()), clean_session=False)
client.username_pw_set(config['MQTT_USER'], config['MQTT_PASS'])
client.on_connect = on_connect
client.on_message = on_message
client.connect(host=config['MQTT_BROKER'], port=config['MQTT_PORT'])
client.subscribe(topic="biketracker/payload")
client.loop_forever()
def main():
msgs = []
for _ in range(21):
msgs.append((
'topic',
b'payload',
1, # QoS == 1
False, # don't retain
))
client = paho.mqtt.client.Client(userdata=msgs)
client.on_publish = _on_publish
client.on_connect = _on_connect
client.connect('127.0.0.1', 1883, 60)
client.loop_forever()
def main():
#print('Attaching Debugger')
# Allow other computers to attach to ptvsd at this IP address and port, using the secret
#ptvsd.enable_attach("my_secret", address = ('0.0.0.0', 3000))
# Pause the program until a remote debugger is attached
#ptvsd.wait_for_attach()
print('Starting MQTT client')
client = paho.mqtt.client.Client(client_id='platformio', clean_session=False)
#with open('/run/secrets/mqtt_username') as username, open('/run/secrets/mqtt_password') as password:
# client.username_pw_set(username.read().strip(), password.read().strip())
client.username_pw_set(os.environ['MQTT_USERNAME'],os.environ['MQTT_PASSWORD'] )
print('On_connect')
client.on_connect = on_connect
client.on_message = on_message
print('TLS + Connect')
with open('ca', 'w+') as ca:
ca.write(os.environ['CA'])
client.tls_set('ca', tls_version=ssl.PROTOCOL_TLSv1_2)
client.connect(host='mqtt', port=8883)
print('Finished setup, starting loop.')
sys.stdout.flush()
client.loop_forever()
def run(self) -> None:
""" start the listener """
logger.info("Starting {name}".format(name=self.conf.sys_name))
logger.info("Initializing LED strip...")
driver = get_driver(self.conf.Strip.driver)
self.strip = driver(
num_leds=self.conf.Strip.num_leds,
max_clock_speed_hz=self.conf.Strip.max_clock_speed_hz)
self.strip.set_global_brightness(self.conf.Strip.initial_brightness)
self.strip.sync_up()
logger.info("Connecting to the MQTT Broker")
client = paho.mqtt.client.Client()
client.on_connect = self.on_connect
client.on_message = self.on_message
if self.conf.MQTT.username is not None:
client.username_pw_set(self.conf.MQTT.username,
self.conf.MQTT.password)
client.connect(self.conf.MQTT.Broker.host, self.conf.MQTT.Broker.port,
self.conf.MQTT.Broker.keepalive)
logger.info("{name} is ready".format(name=self.conf.sys_name))
self.notify_brightness(self.conf.Strip.initial_brightness)
# start a show show to listen for brightness changes and refresh the strip regularly
self.start_show("clear", {})
self.notify_user("off")
try:
signal.signal(
signal.SIGTERM,
self.stop_controller) # attach stop_controller() to SIGTERM
client.loop_forever()
except KeyboardInterrupt:
self.stop_controller()
finally:
logger.critical("MQTTControl.py has exited")
def main(args=None):
"""Archive power records to influxdb."""
mqtt = mqtt_client(Archiver())
mqtt.loop_forever()
{
"measurement": message.topic,
"tags": {},
"time": current_time,
"fields": {
"value": float(message.payload)
}
}
]
logging.info(json_body)
myresult = influx_client.write_points(json_body)
logging.info(myresult)
logging.basicConfig(level=logging.INFO)
try:
logging.info("attaching to influx")
influx_client = InfluxDBClient(host='influxdb', port=8086, database='iot', username='******', password='******')
except:
logging.info("cannot connect to influx")
client = paho.mqtt.client.Client(client_id=CLIENT_ID, clean_session=False)
client.on_connect = lambda self, mosq, obj, rc: self.subscribe(SUBSCRIPTION, QOS)
client.on_message = lambda client, userdata, message: persists(message)
logging.info("attaching to mqtt")
client.connect("mosquitto", 1883, 60)
client.loop_forever()
joystick.camera_servo = cameraServo
joystick.wheels = wheels
# Setup Obstacle Avoidance
obstacle_avoidance.infrared_sensor = infrared_sensor
obstacle_avoidance.ultrasonic = ultrasonic
obstacle_avoidance.wheels = wheels
#obstacle_avoidance.start()
logger.info("Press [CTRL+C] to exit")
try:
# 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.
mqtt.loop_forever(retry_first_connection=True)
except KeyboardInterrupt:
logger.error("Finishing up...")
except:
logger.error("Unexpected Error!")
traceback.print_exc()
finally:
infrared_receiver.stop()
infrared_sensor.stop()
joystick.stop()
obstacle_avoidance.stop()
trSensor.stop()
ultrasonic.stop()
GPIO.cleanup()
mqtt.publish("mutinus/state/status", "OFF", 1, True)
players = { name: 0 for name in player_names }
response = "I'm ready for {}".format(", ".join(player_names))
say(session_id, response)
elif msg.topic == 'hermes/intent/swegmann:addPoints':
print("Adding points")
player_name = slots.get('playerName')
points = int(slots.get('pointsAdded'))
if player_name in players:
players[player_name] += points
say(session_id, "{} now has {} points".format(player_name, players[player_name]))
else:
say(session_id, "I'm not currently counting for {}".format(player_name))
elif msg.topic == 'hermes/intent/swegmann:tellScore':
for (player, points) in sorted(players.items(), key=lambda x:x[1], reverse=True):
say(session_id, "{}, {} points".format(player, points))
mqtt = mqtt.Client()
if __name__ == '__main__':
mqtt.on_connect = on_connect
mqtt.on_message = on_message
mqtt.connect(HOST, PORT)
mqtt.loop_forever()
def main():
mqtt.on_connect = on_connect
mqtt.on_message = on_message
mqtt.username_pw_set(MQTT_USER, MQTT_PASS)
mqtt.connect(MQTT_ADDR, int(MQTT_PORT))
mqtt.loop_forever()
def main():
client = paho.mqtt.client.Client()
client.on_connect = on_connect
client.message_callback_add('sambil/compra/mcadress', on_message)
client.connect(host='localhost')
client.loop_forever()
def main():
client = paho.mqtt.client.Client()
client.on_connect = on_connect
client.message_callback_add('unimet/admin/bd', on_message)
client.connect(host='localhost')
client.loop_forever()
def main():
client = paho.mqtt.client.Client(client_id='client2', clean_session=False)
client.on_connect = OnConnect
client.on_message = OnMessage
client.connect(host='127.0.0.1', port=1884)
client.loop_forever()
