def on_message(client, userdata, msg): print( str(datetime.datetime.now()) + ": " + msg.topic + " " + str(msg.payload)) # # Forward the data to Adafruit IO. Replace topic with a valid feed name # feedname = msg.topic.replace("/", "_") print("Publish to Adafruit feedname: " + feedname) # Initialize the client that should connect to io.adafruit.com adafruitClient = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY, service_port=1883) adafruitClient.on_connect = adafruit_connected adafruitClient.connect() adafruitClient.loop() adafruitClient.publish(feedname, msg.payload) adafruitClient.disconnect() def try_connect_to_local_broker(client): print("trying to connect to local broker") connOK = False while (connOK == False): try: client.connect("192.168.1.16", 1883, 60) connOK = True except: connOK = False time.sleep(2)
def create_aio_mqtt_client(): mclient = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. mclient.on_connect = aio_connected mclient.on_message = aio_message mclient.connect() return mclient
def inicia_cliente(): client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.connect() client.loop_background() return client
def start_client_loop(): client = MQTTClient(USER_FEED_NAME, USER_FEED_KEY) client.on_connect = connect_to_feeds client.on_disconnect = disconnect client.on_message = feed_actions feed_loop(client)
def adafruit_mqtt_start(self): if configuration['ADAFRUIT_IO']['ADAFRUIT_IO_CONTROL']=='Enabled': client = MQTTClient(configuration['ADAFRUIT_IO']['ADAFRUIT_IO_USERNAME'], configuration['ADAFRUIT_IO']['ADAFRUIT_IO_KEY']) client.on_connect = self.adafruit_connected client.on_disconnect = self.adafruit_disconnected client.on_message = self.adafruit_message client.connect() client.loop_blocking() else: print("Adafruit_io MQTT client not enabled")
def main(): _init_influxdb_database() client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.on_subscribe = subscribe client.connect() client.loop_blocking()
def startService(): print(">> Assitant Listner service started!") ADAFRUIT_IO_KEY = '8c61ee1ac0f0421f96512e30be6b30dc' ADAFRUIT_IO_USERNAME = '******' client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) client.on_connect = connected client.on_message = message client.connect() client.loop_blocking()
def test_connect(self): # Create MQTT test client. client = MQTTClient(self.get_test_username(), self.get_test_key()) # Verify on_connect handler is called and expected client is provided. def on_connect(mqtt_client): self.assertEqual(mqtt_client, client) client.on_connect = on_connect # Connect and wait until on_connect event is fired. client.connect() self.wait_until_connected(client) # Verify connected. self.assertTrue(client.is_connected())
def get_client(): mqtt_client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message mqtt_client.on_connect = connected mqtt_client.connect() mqtt_client.loop_background() print("Connected to remote mqtt server") return mqtt_client
def init_client(): util.log_info('connecting to adafruit.io. username={}'.format(ADAFRUIT_IO_USERNAME)) client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.connect() client.loop_background() return client
def dataAdafruitHandler(): client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.connect() client.loop_background() while True: value = random.randint(0, 100) print 'Publishing {0} to my-data.'.format(value) client.publish('my-data', value) time.sleep(5)
def on_message(client, userdata, msg): print(str(datetime.datetime.now()) + ": " + msg.topic + " " + str(msg.payload)) # # Forward the data to Adafruit IO. Replace topic with a valid feed name # feedname=msg.topic.replace("/","_") print("Publish to Adafruit feedname: " + feedname) # Initialize the client that should connect to io.adafruit.com adafruitClient = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY,service_port=1883) adafruitClient.on_connect = adafruit_connected adafruitClient.connect() adafruitClient.loop() adafruitClient.publish(feedname,msg.payload)
def test_secure_connect(self): """Test a secure (port 8883, TLS enabled) AIO connection """ # Create MQTT-Secure test client. client = MQTTClient(self.get_test_username(), self.get_test_key()) # Verify on_connect handler is called and expected client is provided. def on_connect(mqtt_client): self.assertEqual(mqtt_client, client) client.on_connect = on_connect # Connect and wait until on_connect event is fired. client.connect() self.wait_until_connected(client) # Verify connected. self.assertTrue(client.is_connected()) self.assertTrue(client._secure)
def start(): # Create an MQTT client instance. client = MQTTClient(IO_USERNAME, IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message # Connect to the Adafruit IO server. client.connect() # Now the program needs to use a client loop function to ensure messages # are sent and received. This command will block foreground processing and # let the MQTT library do its work. client.loop_blocking()
def task2(): # Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected2 client.on_disconnect = disconnected client.on_message = message2 # Connect to the Adafruit IO server. client.connect() # Start a message loop that blocks forever waiting for MQTT messages to be # received. Note there are other options for running the event loop like doing # so in a background thread--see the mqtt_client.py example to learn more. client.loop_blocking()
def test_insecure_connect(self): """Test an insecure (port 1883, TLS disabled) AIO connection """ # Create MQTT-Insecure (non-SSL) test client. client = MQTTClient(self.get_test_username(), self.get_test_key(), secure=False) # Verify on_connect handler is called and expected client is provided. def on_connect(mqtt_client): self.assertEqual(mqtt_client, client) client.on_connect = on_connect # Connect and wait until on_connect event is fired. client.connect() self.wait_until_connected(client) # Verify connected. self.assertTrue(client.is_connected()) # Verify insecure connection established self.assertFalse(client._secure)
def __connect_adafruit(self): username = self.config.get('adafruit_io', 'username') key = self.config.get('adafruit_io', 'key') print('Connecting to Adafruit.IO...') client = MQTTClient(username, key) client.on_connect = self.__on_connected client.on_disconnect = self.__on_disconnected client.on_message = self.__on_message try: client.connect() client.loop_blocking() except Exception as err: print('Error with Adafruit client: %s' % err) client.disconnect()
def loop(): gbl = Vars() while True: try: print("Client loop begun") client = MQTTClient(gbl.name, gbl.key) client.on_connect = connect client.on_disconnect = disconnect client.on_message = action client.connect() client.loop_blocking() except: print("Error", time()) sleep(5)
def on_message(client, userdata, msg): print( str(datetime.datetime.now()) + ": " + msg.topic + " " + str(msg.payload)) # # Forward the data to Adafruit IO. Replace topic with a valid feed name # feedname = msg.topic.replace("/", "_") print("Publish to Adafruit feedname: " + feedname) # Initialize the client that should connect to io.adafruit.com adafruitClient = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY, service_port=1883) adafruitClient.on_connect = adafruit_connected adafruitClient.connect() adafruitClient.loop() adafruitClient.publish(feedname, msg.payload)
def main(): # Create a mqttclient client = MQTTClient(IO_USERNAME, IO_KEY) # Assign handlers for events client.on_connect = connected client.on_disconnect = disconnected client.on_message = message logger.debug('Connect to Adafruit IO server') client.connect() logger.debug('Start background thread for messaging') client.loop_background() temp_buffer = [] hum_buffer = [] while True: humidity, temperature = measure() if humidity is not None and temperature is not None: logger.info('Temperature={0:0.1f}, Humidity={1:0.1f}'.format(temperature, humidity)) temp_buffer.append(temperature) hum_buffer.append(humidity) # Send median of last three records if len(temp_buffer) == BUFFER_SIZE: temp_buffer = sorted(temp_buffer) temp_median = temp_buffer[BUFFER_SIZE // 2] temp_median = round(temp_median, 1) logger.debug('Rounded median of temp_buffer({}) is {}'.format(temp_buffer, temp_median)) publish(client, 'temperature', temp_median) temp_buffer = [] # Send median of last three records if len(hum_buffer) == BUFFER_SIZE: hum_buffer = sorted(hum_buffer) hum_median = hum_buffer[BUFFER_SIZE // 2] hum_median = round(hum_median, 1) logger.debug('Rounded median of hum_buffer({}) is {}'.format(hum_buffer, hum_median)) publish(client, 'humidity', hum_median) hum_buffer = [] sleep(TIME_INTERVAL)
def subscribe(self): def connected(client): print('Connected to Adafruit IO! Listening for {0} changes...'. format(self.feed_id)) client.subscribe(self.feed_id) def subscribe(client, userdata, mid, granted_qos): print('Subscribed to {0} with QoS {1}'.format( self.feed_id, granted_qos[0])) def disconnected(client): print('Disconnected from Adafruit IO!') sys.exit(1) def message(client, feed_id, payload): print('Feed {0} received new value: {1}'.format(feed_id, payload)) # Update device database print('Update database ...') res = json.loads(payload) device = Device(id=str(res["id"]), data=res["data"], name=res["name"], unit=res["unit"]) device.save() print('Data updated') # Device.objects.filter(id=device["id"]).update(data=device["data"], name=device["name"], unit=device["unit"])) # Update weather info # update_weatherinfo() # TODO: Handle value change event ( > 100, < 100) # Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.on_subscribe = subscribe # Connect to the Adafruit IO server. client.connect() client.loop_background()
def _loop_process(self): username = os_getenv("ADAFRUIT_IO_USERNAME"); key = os_getenv("ADAFRUIT_IO_KEY"); print(f"AdafruitFeed::_loop_process::username, key: {username}, {key}"); assert(username); assert(key); ssl.SSLContext.verify_mode = ssl.VerifyMode.CERT_OPTIONAL client = MQTTClient(username, key, secure=False); client.on_connect = self._connect; client.on_disconnect = self._disconnect; client.on_message = self._activate; client.on_subscribe = self._null; print("Adafruit::_loop_process"); client.connect(); client.loop_blocking();
def instance_start(c, name): # Using 'c' instead of 'client' for easier reading/writing #Last field 'name' of client will be used to set '_instance_name' so we can read a unique name inside callback functions logger.info('Setting up instance and connecting: %s', name) c['instance'] = MQTTClient(c['USERNAME'], c['PASSWORD'], c['SERVER'], int(c['PORT']), c['CLIENTID'], c['TOPIC_FMT'], name) # Create MQTTClient instance logger.debug("New instance: %s *PASSWORD* %s %s %s %s %s ",c['USERNAME'], c['SERVER'], int(c['PORT']), c['CLIENTID'], c['TOPIC_FMT'], name) # Setup the callback functions defined below. c['instance'].on_connect = connected c['instance'].on_disconnect = disconnected c['instance'].on_message = message #Setup TLS for basic connection encryption (like a web browser using HTTPS) # - You can probably do other TLS connection types like pre-shared key authentication if you modify this code and add setting variables # For Adafruit, just use normal OS CA lookup bundle file in /etc/ssl/certs/: (Probably OS-dependent location) if c['TLS_SET'] == "1": logger.debug("Set TLS: %s", c['CACERT']) c['instance'].tls_set(c['CACERT']) # If you need more of the TLS settings, feel free to add to config file and here. # Connect to servers # Need to convert these from strings to integers to use for counting c['RETRY_COUNTER'] = int(c['RETRY_COUNTER']) c['MAX_RETRIES'] = int(c['MAX_RETRIES']) while True: #Loop until complete or retry limit hit try: c['instance'].connect() # Try to connect. Some errors might be fatal. except: # Have only seen 'socket.errors', but could be other kinds if c['RETRY_COUNTER'] > c['MAX_RETRIES']: logger.critical('Giving up retries to %s (%s). Terminating process.', c['instance']._service_host, c['instance']._instance_name) for name in settings_dict: if 'instance' in settings_dict[name]: #For each existing instance besides this one settings_dict[name]['instance'].disconnect() # Terminate instance sys.exit(1) logger.error('%s connect error for %s. Retry # %s', str(sys.exc_info()[0]), c['instance']._instance_name, str(c['RETRY_COUNTER'])) c['RETRY_COUNTER'] += 1; # Iterate try time.sleep(5) # Delay before retry else: # Connection Worked. Reset counter and break loop c['RETRY_COUNTER'] = 1; break
def subscribe(self): def connected(client): print('Connected to Adafruit IO! Listening for {0} changes...'. format(self.feed_id)) client.subscribe(self.feed_id) def subscribe(client, userdata, mid, granted_qos): print('Subscribed to {0} with QoS {1}'.format( self.feed_id, granted_qos[0])) def disconnected(client): print('Disconnected from Adafruit IO!') sys.exit(1) def message(client, feed_id, payload): print('Feed {0} received new value: {1}'.format(feed_id, payload)) # Update device database print('Update database ...') # Device.objects.filter(key=feed_id).update(value=payload) # Update weather info # update_weatherinfo() # TODO: Handle value change event ( > 100, < 100) # Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message client.on_subscribe = subscribe # Connect to the Adafruit IO server. client.connect() client.loop_blocking()
def main(): #TimeRealSuelo() #TimeRealAmbiente() if (len(sys.argv) != 3): sys.stderr.write( 'Usage: "{}" $AdafruitIOusername $AdafruitIOkey , los feed estan quemados en el codigo xD\n' .format(sys.argv[0])) os._exit(1) #se leen de los sensores hiloSuelo = threading.Thread(target=TimeRealSuelo) hiloAmbiente = threading.Thread(target=TimeRealAmbiente) hiloSuelo.start() hiloAmbiente.start() #---------------------------------------------- username = sys.argv[1] skey = sys.argv[2] feeds["username"] = username feeds["skey"] = skey client = MQTTClient(username=username, key=skey) client.on_connect = on_connect client.on_disconnect = on_disconnect client.connect() client.loop_background() feeds["client"] = client send_message()
print 'Disconnected from Adafruit IO!' sys.exit(1) def message(client, feed_id, payload): # Message function will be called when a subscribed feed has a new value. # The feed_id parameter identifies the feed, and the payload parameter has # the new value. print 'Feed {0} received new value: {1}'.format(feed_id, payload) # Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message # Connect to the Adafruit IO server. client.connect() # Now the program needs to use a client loop function to ensure messages are # sent and received. There are a few options for driving the message loop, # depending on what your program needs to do. # The first option is to run a thread in the background so you can continue # doing things in your program. client.loop_background() # Now send new values every 10 seconds. print 'Publishing a new message every 10 seconds (press Ctrl-C to quit)...'
p.text("voting experience!\n") p.text("Take me to the booth\n") p.text("and select either general,\n") p.text("if voting in a general\n") p.text("or the party whose primary\n") p.text("you are voting for.\n") p.text("Then, scan the QR code into\n") p.text("the box. Thanks!\n") p.text("If that doesn't work,\n") p.text("try typing this manually:\n") p.text(payload) p.cut() print(payload) vote_client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) vote_client.on_connect = vote_connected vote_client.on_disconnect = disconnected vote_client.on_message = vote_message vote_client.connect() vote_client.loop_background() voter_client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) voter_client.on_connect = voter_connected voter_client.on_disconnect = disconnected voter_client.on_message = voter_message voter_client.connect() voter_client.loop_background() while True: pass
def disconnected(client): # Disconnected function will be called when the client disconnects. print 'Disconnected from Adafruit IO!' sys.exit(1) def message(client, feed_id, payload): # Message function will be called when a subscribed feed has a new value. # The feed_id parameter identifies the feed, and the payload parameter has # the new value. print 'Feed {0} received new value: {1}'.format(feed_id, payload) # Set a global var with the payload then check for it above global msg msg = payload # Create an MQTT client instance client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above client.on_connect = connected client.on_disconnect = disconnected client.on_message = message # Connect to the Adafruit IO server client.connect() ble.initialize() ble.run_mainloop_with(ble_main)
# Define Functions for Threading def send_message(client): while True: if (client.messageSend is not None): client.publish(feed_id=AdafruitIOFeedKey, value=client.messageSend, feed_user=AdafruitIOFeedUsername) time.sleep(10) if __name__ == "__main__": # Create an MQTT client instance. client = MQTTClient(username=AdafruitIOFeedUsername, key=AdafruitIOKey) # Setup the callback functions client.on_connect = on_connect client.on_disconnect = on_disconnect # Setup Control Vars client.messageSend = "0" # Connect to the Adafruit IO server. client.connect() client.loop_background() while not client.is_connected(): print("Esperando conexión") time.sleep(1) # Setup Threading, to publish message every 10 seconds hilo0 = threading.Thread(target=send_message, args=(client, )) hilo0.start()
# Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. #client.subscribe("$SYS/#") # The callback for when a PUBLISH message is received from the server. def on_message(client, userdata, msg): print(msg.topic+" "+str(msg.payload)) def on_publish(client, userdata, mid): print("data sent") def on_disconnect(client, userdata, rc): print("disconnect") client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY,service_port=8883) client.on_connect = on_connect client.on_message = on_message client.on_publish = on_publish client.on_disconnect = on_disconnect client.tls_set("/home/pi/adafruitio-temperature/certs/geotrust.pem") client.connect() #client.loop_background() # Get temperature from sensor #byte1 = 29 #byte2 = 0x00 #temperature = ((byte1 << 8) + byte2) >> 4 #if (temperature & 0x800): # temperature = (temperature & 0x7FF) - 0x800 #temperature = temperature * 0.0625 #temperature = 30
def dash_board(GPIO): #def dash_board(): # Set to your Adafruit IO key & username below lock = threading.Lock() #GPIO.setmode(GPIO.BCM) # Use physical pin numbering #GPIO.setup(17, GPIO.OUT, initial=GPIO.LOW) # Set pin 8 to be an output pin and set initial value to low (off) # Define callback functions which will be called when certain events happen. def connected(client): # Connected function will be called when the client is connected to Adafruit IO. # This is a good place to subscribe to feed changes. The client parameter # passed to this function is the Adafruit IO MQTT client so you can make # calls against it easily. #print('Connected to Adafruit IO! Listening for {0} changes...'.format(FEED_ID)) # Subscribe to changes on a feed named DemoFeed. client.subscribe(ACTEM) client.subscribe(AUTO) client.subscribe(ACON) client.subscribe(DOOR) client.subscribe(HUMID) client.subscribe(SYSTEMON) client.subscribe(LIGHT) def disconnected(client): # Disconnected function will be called when the client disconnects. print('Disconnected from Adafruit IO!') sys.exit(1) def message(client, feed_id, payload): # Message function will be called when a subscribed feed has a new value. # The feed_id parameter identifies the feed, and the payload parameter has # the new value. print('Feed {0} received new value: {1}'.format(feed_id, payload)) if feed_id == 'onoffbutton': print(payload) if payload == "ON": publish_init() glo.start_system = True else: glo.start_system = False publish_off() elif feed_id == 'auto': if payload == 'Auto': print("System has been changed to Auto model") glo.auto_start = True elif payload == 'Manual': print("System has been changed to Manual model") glo.auto_start = False if glo.start_system and not glo.auto_start: if feed_id == "ac": print("feed_id == ac : {} ac_on: {}".format( feed_id == "ac", glo.ac_on)) if glo.ac_on: glo.set_temp = int(payload) print("AC has been changed to " + payload) period = 21.5 + 0.2 * ((33 - glo.set_temp) / 16) glo.ac.ChangeFrequency(1000 / period) glo.ac.ChangeDutyCycle(100 * (period - 20) / period) elif feed_id == "aconoff": if payload == 'ON': glo.ac_on = True client.publish(ACTEM, glo.set_temp) period = 21.5 + 0.2 * ((33 - glo.set_temp) / 16) glo.ac.ChangeFrequency(1000 / period) glo.ac.ChangeDutyCycle(100 * (period - 20) / period) print("AC ON") elif payload == 'OFF': glo.ac_on = False print("AC OFF") glo.ac.ChangeDutyCycle(0) elif feed_id == 'door': if payload == 'Close': print("close door") glo.door.ChangeFrequency(1000 / 21.6) glo.door.ChangeDutyCycle(100 * 1.6 / 21.6) time.sleep(0.37) glo.door.ChangeDutyCycle(0) elif payload == 'Open': glo.door.ChangeFrequency(1000 / 21.4) glo.door.ChangeDutyCycle(100 * 1.4 / 21.4) time.sleep(0.65) glo.door.ChangeDutyCycle(0) elif feed_id == 'light': if payload == 'ON': print(feed_id) print("ON") GPIO.output(26, GPIO.HIGH) #Turn ON elif payload == 'OFF': print(feed_id) print("OFF") GPIO.output(26, GPIO.LOW) elif feed_id == "humidifier": #print(payload) if payload == "0": print(payload) glo.hum.ChangeDutyCycle(0) #GPIO.output(17, GPIO.HIGH) # Turn on elif payload == "1": print(payload) glo.hum.ChangeFrequency(5) glo.hum.ChangeDutyCycle(50) elif payload == "2": glo.hum.ChangeFrequency(8) glo.hum.ChangeDutyCycle(50) elif payload == "3": glo.hum.ChangeFrequency(10) glo.hum.ChangeDutyCycle(50) elif payload == "4": glo.hum.ChangeFrequency(15) glo.hum.ChangeDutyCycle(50) else: glo.hum.ChangeFrequency(20) glo.hum.ChangeDutyCycle(50) def publish_init(): time.sleep(1) lock.acquire() glo.ac_on = True client.publish(ACTEM, 26) client.publish(AUTO, "Auto") time.sleep(1) #client.publish(ACON, "OFF") client.publish(DOOR, "OFF") #client.publish("humidity", glo.humid) time.sleep(1) client.publish(HUMID, 0) glo.hum.ChangeDutyCycle(0) lock.release() def publish_off(): time.sleep(1) #client.publish(SYSTEMON, "ON") client.publish(AUTO, "Manual") glo.auto_start = False lock.acquire() time.sleep(1) client.publish(ACON, "OFF") glo.ac_on = False glo.ac.ChangeDutyCycle(0) time.sleep(1) client.publish(DOOR, "OFF") time.sleep(1) client.publish(LIGHT, "OFF") GPIO.output(26, GPIO.LOW) time.sleep(1) client.publish(HUMID, 0) glo.hum.ChangeDutyCycle(0) lock.release() # Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client.on_connect = connected client.on_disconnect = disconnected client.on_message = message # Connect to the Adafruit IO server. client.connect() client.loop_background() time.sleep(1) client.publish(SYSTEMON, "ON") def update_status(): while glo.code_run: client.publish("humidity", glo.humid) time.sleep(10) client.publish("temperature", glo.temp) time.sleep(10) client.publish("lux", glo.light) time.sleep(10) time.sleep(0.3) t_dash = threading.Thread(target=update_status, name='status') t_dash.start() while glo.code_run: print("system" + str(glo.start_system)) print("auto: " + str(glo.auto_start)) if glo.start_system and glo.auto_start: print("temp: " + str(glo.temp)) lock.acquire() if glo.temp > 30: glo.set_temp = 22 glo.ac_on = True client.publish(ACON, "ON") period = 21.5 + 0.2 * ((33 - glo.set_temp) / 16) glo.ac.ChangeFrequency(1000 / period) glo.ac.ChangeDutyCycle(100 * (period - 20) / period) client.publish(ACTEM, 22) elif glo.temp > 24: glo.set_temp = 25 glo.ac_on = True client.publish(ACON, "ON") period = 21.5 + 0.2 * ((33 - glo.set_temp) / 16) glo.ac.ChangeFrequency(1000 / period) glo.ac.ChangeDutyCycle(100 * (period - 20) / period) client.publish(ACTEM, 25) else: print("Close the AC") client.publish(ACON, "OFF") glo.ac_on = False glo.ac.ChangeDutyCycle(0) time.sleep(1) print("humid: " + str(glo.humid)) if glo.humid < 10: print("Level1") client.publish(HUMID, 5) glo.hum.ChangeFrequency(20) glo.hum.ChangeDutyCycle(50) elif glo.humid < 20: print("Level2") client.publish(HUMID, 3) glo.hum.ChangeFrequency(10) glo.hum.ChangeDutyCycle(50) elif glo.humid < 30: client.publish(HUMID, 1) glo.hum.ChangeFrequency(5) glo.hum.ChangeDutyCycle(50) else: client.publish(HUMID, 0) glo.hum.ChangeDutyCycle(0) time.sleep(1) print("Light: " + str(glo.light)) if glo.light < 500: client.publish(LIGHT, "ON") GPIO.output(26, GPIO.HIGH) else: client.publish(LIGHT, "OFF") GPIO.output(26, GPIO.LOW) lock.release() time.sleep(10) GPIO.cleanup()
def mqtt_disconnected(client): eprint('mqtt disconnected') def mqtt_message(client, feed_id, payload): eprint('mqtt message {}'.format(payload)) if payload == 'work exited': switch_script('mini.fxb') IO_USERNAME = os.environ['IO_USERNAME'] IO_API_KEY = os.environ['IO_API_KEY'] mqtt_client = MQTTClient(IO_USERNAME, IO_API_KEY) mqtt_client.on_connect = mqtt_connected mqtt_client.on_disconnect = mqtt_disconnected mqtt_client.on_message = mqtt_message mqtt_client.connect() mqtt_client.loop_background() dimmer_update_rate = datetime.timedelta(minutes=1) last_dimmer_update_time = datetime.datetime.now() try: blue.light_on() time.sleep(0.33) blue.light_off() red.light_on() time.sleep(0.33) red.light_off()
print('Feed {0} received new value: {1}'.format(feed_id, payload)) if feed_id == 'relay1': if payload == 'ON': GPIO.output(relay1,True) if payload == 'OFF': GPIO.output(relay1,False) if feed_id == 'relay2': if payload == 'ON': GPIO.output(relay2,True) if payload == 'OFF': GPIO.output(relay2,False) if feed_id == 'relay1': if payload == 'ON': GPIO.output(relay1,True) if payload == 'OFF': GPIO.output(relay1,False) # Create an MQTT client instance. client2 = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) # Setup the callback functions defined above. client2.on_connect = connected client2.on_disconnect = disconnected client2.on_message = message # Connect to the Adafruit IO server. client2.connect() # Start a message loop that blocks forever waiting for MQTT messages to be # received. Note there are other options for running the event loop like doing # so in a background thread--see the mqtt_client.py example to learn more. client2.loop_blocking()
elif message.topic == 'dryot/temperature': if _temperature_count == publish_max: _temperature_count = 0 # print('Temperature = ' + payload_str) aio_client.publish('dryot.temperature', payload_str) else: _temperature_count += 1 else: print('Unknown message') # Create an MQTT client instance. aio_client = MQTTClient(adafruit_io_username, adafruit_io_key) # Setup the callback functions defined above. aio_client.on_connect = aio_connected aio_client.on_disconnect = aio_disconnected aio_client.on_message = aio_message # Connect to the Adafruit IO server. aio_client.connect() # Use a client loop function to ensure messages are doing things in the program # In this case we need to subscribe to local MQTT topics and receive data from them aio_client.loop_background() # connect to the Mosquitto MQTT broker mqtt_client = mqtt.Client("DRYOT2AIO") mqtt_client.on_message = mqtt_on_message mqtt_client.connect(mqtt_broker_address)
def disconnected(client): #action when disconnected print('Disconnected from Adafruit IO!') sys.exit(1) def message(client, feed_id, payload): #action when message received print('Success!') global mn #get global mean variable mn = int(payload) #set it to an integer from data received print(mn) client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) #initialize MQTT client.on_connect = connected #setup connect action client.on_disconnect = disconnected #setup disconnect action client.on_message = message #setup message action client.connect() #connect to MQTT client.loop_background() #continue a loop in background while True: #forever loop mean = mn * 4 #set variable mean to the actual mean times 4 if mn > 7: #if actual mean is greater than seven, set colour to green r = 0 g = 255 b = 0 else: #if not greater than seven, set colour to red r = 255 g = 0 b = 0
if payload == "1": print('BULB1 is ON') GPIO.output(BULB1, GPIO.HIGH) a = u.urlopen(api + str(1)) else: print('BULB1 is OFF') GPIO.output(BULB1, GPIO.LOW) a = u.urlopen(api + str(0)) if Feed_id == "bulb2": if payload == "1": print('BULB2 is ON') GPIO.output(BULB2, GPIO.HIGH) a = u.urlopen(api2 + str(1)) else: print('BULB2 is OFF') GPIO.output(BULB2, GPIO.LOW) a = u.urlopen(api2 + str(0)) #Create an MQTT client instance. client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) #Setup the callback functions defined above. client.on_connect = connected_to_adafruit client.on_disconnect = disconnected_from_adafruit client.on_message = message_from_user #Connect to the Adafruit IO server. client.connect() client.loop_blocking()