def main(): i = 0 app_id = "radhemicrochip" access_key = "ttn-account-v2.anvcRy7edUgm8sQuhWfd4YXBCq6X6c2BFU54fgSm5E8" handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) # using application manager client #app_client = handler.application() #my_app = app_client.get() #print(my_app) #my_devices = app_client.devices() #print(my_devices) while(True): i = i + 1 print("Sending request number (%d)" % i) send_ttn_request(mqtt_client) conn.close()
def connectToTTN(): logging.info("Connecting to TTN broker") handler = ttn.HandlerClient(app_id, access_key) ttnClient = handler.data() ttnClient.set_uplink_callback(ttn_callback) ttnClient.connect() logging.info("Connected to TTN broker")
def main(config, block=False): """ Set up a TTN pubsub connection and register a callback. If block is True, the function will enter into a sleeping infinite loop. """ app_id = config["TTN_APP_ID"] access_key = config["TTN_APP_ACCESS_KEY"] assert app_id is not None assert access_key is not None handler = ttn.HandlerClient(app_id, access_key) logging.info(f"setting up client for {app_id}") mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) if not block: return mqtt_client logging.info("connecting MQTT client") try: mqtt_client.connect() logging.info("waiting on new connections") while True: time.sleep(1) except KeyboardInterrupt: logging.info("keyboard interrupt caught, exiting") return None except Exception as exc: logging.exception(exc) finally: logging.info("closing existing MQTT client") mqtt_client.close()
def __init__(self, app_id, access_key): handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(TTNMQTTClient.uplink_callback) mqtt_client.connect()
def main(): i = 0 app_id = "microchipuno" access_key = "ttn-account-v2.Y3Sk5dTSbvnYEd3xpts99kuURsBUzTuE8iFhUJCvPfQ" handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) # using application manager client #app_client = handler.application() #my_app = app_client.get() #print(my_app) #my_devices = app_client.devices() #print(my_devices) while (True): i = i + 1 print("Sending request number (%d)" % i) send_ttn_request(mqtt_client) conn.close()
def main(): ini_file_path = "../../config/temp-sensors.ini" # The configuration file path will become a command-line argument config = configparser.ConfigParser() config.read(ini_file_path) connection = config['ttn-explore.mqtt.connection'] app_id = connection['username'] # This is the Application ID for this integration at TTN access_key = connection['password'] # This is the my-python-client application access key def uplink_callback(msg, client): print("Received uplink from ", msg.dev_id) print(msg) print("Making the TTN handler") handler = ttn.HandlerClient(app_id, access_key) print("Get data using mqtt client") # using mqtt client mqtt_client = handler.data() # type: MQTTClient mqtt_client.set_uplink_callback(uplink_callback) print("Connecting....") mqtt_client.connect() wait_seconds = 60 * 60 * 24 print(f"Now wait for {wait_seconds} seconds after connect") while True: time.sleep(600) print("Continue polling...") print("Close the client") mqtt_client.close()
def __init__(self, app_id, access_key): logging.debug("app id: {}".format(app_id)) ttnHandler = ttn.HandlerClient(app_id, access_key) self._mqtt_client = ttnHandler.data() def _uplink_callback(message, client): logging.debug("uplink message received from {}".format( message.dev_id)) logging.debug(str(message)) if not message.payload_raw: logging.warning("message without payload, skipping...") return try: payload = base64.b64decode(message.payload_raw) logging.debug("payload: {}".format(payload.hex('-').upper())) device_id = bytes.fromhex(message.hardware_serial) logging.debug("device_id: {}".format(device_id.hex())) self._handle_message(payload, device_id, message) except Exception as e: logging.error( "exception during message handling: {}".format(e)) logging.error(traceback.format_exc()) self._mqtt_client.set_uplink_callback(_uplink_callback)
def main(): if os.path.isfile(f_secrets): with open(f_secrets, "r") as f: secrets = json.loads(f.read()) app_id = secrets['app_id'] app_key = secrets['app_key'] else: print("cannot find file with APP ID and KEY") exit(1) print("APP ID: ", app_id) print("APP KEY:", app_key) if os.path.isfile(f_tracker): with open(f_tracker, "r") as f: global dev_urls dev_urls = json.loads(f.read()) print("URLS: ", json.dumps(dev_urls, indent=2)) with open(f_logging, 'a') as fl: print(json.dumps(dev_urls), file=fl) ttncli = ttn.HandlerClient(app_id, app_key) mqttcli = ttncli.data() mqttcli.set_uplink_callback(uplink_callback) mqttcli.connect() while 1: time.sleep(10)
def initTTNclient(self): self.app_id = 'assignment' self.access_key = 'ttn-account-v2.tJXg3gyYmMBzO4lELeFiL1uOVghBvaJb_c9ncAG-wPA' handler = ttn.HandlerClient(self.app_id, self.access_key) self.mqtt_client = handler.data() self.mqtt_client.set_uplink_callback(self.uplink_callback) self.mqtt_client.connect()
def main(): parser = argparse.ArgumentParser() parser.add_argument('secrets', type=str, help="JSON file with secrets for TTN and KeyCloak.") parser.add_argument('datastreams', type=str, help="JSON file with OGC datastream URLs.") args = parser.parse_args() with open(args.secrets, "r") as f: secrets = json.loads(f.read()) # create auth stuff if 'keycloak' in secrets: kc = secrets['keycloak'] rt = '' if os.path.isfile(f_refresh_token): with open(f_refresh_token, "r") as rtf: rt = rtf.readlines() if len(rt) == 0: rt = get_refresh_token(kc['url'], kc['id_client'], kc['id_secret'], kc['username'], kc['password']) with open(f_refresh_token, "w") as rtf: rtf.write(rt) at = get_access_token(kc['url'], kc['id_client'], kc['id_secret'], rt) global auth_header auth_header = get_auth_header(at) logging.debug("AUTH HEADER: %s", json.dumps(auth_header)) else: logging.warn("No KeyCloak credentials found, skipping ...") if 'ttn' not in secrets: logging.critical("No TTN credentials found!") exit(1) with open(args.datastreams, "r") as f: global datastreams datastreams = json.loads(f.read()) logging.debug("URLS: %s", json.dumps(datastreams, indent=2)) with open(f_logging, 'a') as fl: print(json.dumps(datastreams), file=fl) # connect to TTN ttncli = ttn.HandlerClient(secrets['ttn']['app_id'], secrets['ttn']['app_key']) mqttcli = ttncli.data() mqttcli.set_uplink_callback(uplink_callback) mqttcli.connect() # keep program alive and wait for uplink callbacks while 1: sleep(10)
def connect(self): print('Connecting to TTN MQTT broker') handler = ttn.HandlerClient(self.app_id, self.access_key) # Start MQTT client and wire event callbacks. mqtt_client = self.mqtt_client = handler.data() mqtt_client._MQTTClient__client.enable_logger() mqtt_client.set_connect_callback(self.connect_callback) mqtt_client.set_close_callback(self.disconnect_callback) mqtt_client.set_uplink_callback(self.uplink_callback) mqtt_client.connect()
def __init__(self, conn_obj): self.app_id = conn_obj["app_id"] self.access_key = conn_obj["access_key"] self.device_id = conn_obj["device_id"] self.msg_queue = queue.Queue() self.handler = ttn.HandlerClient(self.app_id, self.access_key) self.mqtt_client = self.handler.data() self.mqtt_client.set_uplink_callback(self.__uplink_callback) self.mqtt_client.set_connect_callback(self.__connect_callback)
def func1(): while (True): print("-----func1 opn------------") handler = ttn.HandlerClient(app_id, access_key) mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) mqtt_client.connect() time.sleep(28800) mqtt_client.close() print("-----func1 close------------")
def uplink_listener(self): print("Uplink listener is running...") app_id = "geoloracja" access_key = "ttn-account-v2.cxnYXM8WxBx65iUHiI8KqNcpFFmGKtud5jEU-TtaiAo" handler = ttn.HandlerClient(app_id, access_key) while True: client = handler.data() client.set_uplink_callback(self.uplink_callback) client.connect() sleep(self.delay) client.close()
def ttn_connect(): handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) mqtt_client.connect() print("Connect to ttn!") a = 0 while (True): a += 1
def __init__(self, message_received_callback): app_id = "iot_arnaudaymeric_2020" access_key = "ttn-account-v2.2ZR7Kvt7lkJEVqDmK9QF4RCgsCX3DAmFTB7i8Oysu64" handler = ttn.HandlerClient(app_id, access_key) self.app_client = handler.application() self.mqtt_client = handler.data() self.mqtt_client.set_uplink_callback(message_received_callback) self.mqtt_client.set_connect_callback(connect_callback) self.mqtt_client.set_downlink_callback(downlink_callback) print(self.app_client.get())
def mqtt_get_data(): print("Starting") with open('./config.json') as json_data: config = json.load(json_data) print(config['app_id']) print(config['access_key']) handler = ttn.HandlerClient(config['app_id'], config['access_key']) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) mqtt_client.connect() while True: time.sleep(60)
def downlink(deviceName): if not session.get('loggedIn'): return redirect(url_for('login')) else: app_id = "geoloracja" access_key = "ttn-account-v2.cxnYXM8WxBx65iUHiI8KqNcpFFmGKtud5jEU-TtaiAo" handler = ttn.HandlerClient(app_id, access_key) client = handler.data() client.connect() client.send(deviceName, "AQ==") client.close() flash(u'Wysłano zapytanie o obecną lokalizację') return redirect(url_for('mydevices'))
def run(self): handler = ttn.HandlerClient(self.app_id, self.access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(self.uplink_callback) logger.info(f"Start listening on '{self.app_id}'") mqtt_client.connect() try: while True: time.sleep(10) except KeyboardInterrupt: logger.info("Closing MQTT client") mqtt_client.close()
def initMQTTclientTTN(self): path = "../keys/" values = MQTTClient.readFromCSVFile(path + "TTNkeys.txt") self.app_id = values["appID"] self.access_key = values["accessKey"] self.cert_file = values["certFile"] handler = ttn.HandlerClient(self.app_id, self.access_key, cert_path=path + self.cert_file) self.mqtt_client = handler.data() self.mqtt_client.set_uplink_callback(self.uplink_callback) self.mqtt_client.connect()
def run(app_id, access_key): logger.info(f"Start client on '{app_id}'\n") handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) mqtt_client.connect() try: while True: time.sleep(10) except KeyboardInterrupt: logger.info("Closing client, bye") mqtt_client.close()
def app_connect(self): def uplink_callback(msg, client): print() print("Received uplink from ", msg.dev_id) msg_dict = dictify(msg) print(msg_dict) # forward msg into queue # self.q.put(msg_dict) self.handler = ttn.HandlerClient(self.ttn_app_id, self.ttn_key) self.mqtt_client = self.handler.data() self.mqtt_client.set_uplink_callback(uplink_callback) self.mqtt_client.connect()
def send_downlink(device_id, msg): ''' Send a downlink to a device. ''' handler = ttn.HandlerClient(app_id, access_key) mqtt_client = handler.data() mqtt_client.connect() mqtt_client.send(dev_id=device_id, pay=msg, port=1, conf=False, sched="replace") mqtt_client.close() print("[DEBUG] Downlink " + str(msg) + " has been sent to device '" + device_id + "'")
def fetch(self): def uplink_callback(msg, client): format_date = datetime.strptime(msg.metadata.time[:-5], '%Y-%m-%dT%H:%M:%S.%f') self.storeInput('TTN', msg.dev_id, msg.payload_fields.wifi, format_date.timestamp()) handler = ttn.HandlerClient(self.app_id, self.access_key) mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) while True: mqtt_client.connect() time.sleep(60) mqtt_client.close()
def main(): args = get_args() logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) # Connect to application API handler = ttn.HandlerClient(app_id=args.app_id, app_access_key=args.access_key) app = handler.application() # List Devices # https://github.com/TheThingsNetwork/api/blob/master/handler/handler.proto#L91 for device in app.devices(): LOGGER.info("Device '%s'", device.dev_id) print(device_to_site(device, app_id=args.app_id)) print(device_to_sensor(device, app_id=args.app_id))
def register_device_in_ttn(app_id, access_key_file, app_eui, device_eui): """Register Clair TTN nodes in the TTN. \b APP_ID is the TTN application id. ACCESS_KEY_FILE is the file that contains the access key of the TTN application. APP_EUI is the TTN app EUI. DEVICE_EUI is the TTN device EUI. """ access_key = access_key_file.read().rstrip('\n') application_client = ttn.HandlerClient(app_id, access_key).application() for dev_eui in device_eui: device_id = str(ers.ErsDeviceUUID(bytes.fromhex(dev_eui))) ttn_device = _create_ttn_device(dev_eui, app_eui) application_client.register_device(device_id, ttn_device)
def main(): """Config""" getConfiguration() """TTN""" handler = ttn.HandlerClient(ttn_app_id, ttn_access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(ttn_uplink_callback) mqtt_client.connect() """Telegram""" # Create the Updater and pass it your bot's token. updater = telegram.ext.Updater(telegram_token) dispatcher = updater.dispatcher dispatcher.add_handler(CommandHandler("start", sendLastLocation)) dispatcher.add_handler(CommandHandler("pos", sendLastLocation)) dispatcher.add_handler(CommandHandler("live", sendLiveLocation)) dispatcher.add_handler(CommandHandler("stats", sendStats)) dispatcher.add_handler(CommandHandler("watch", sendWatchdog)) updater.start_polling() updater.idle()
def main(): ini_file_path = "../../config/temp-sensors.ini" # The configuration file path will become a command-line argument config = configparser.ConfigParser() config.read(ini_file_path) connection = config['ttn-explore.mqtt.connection'] app_id = connection['username'] # This is the Application ID for this integration at TTN access_key = connection['password'] # This is the my-python-client application access key def uplink_callback(msg, client): print("Received uplink from ", msg.dev_id) print(msg) print("Making the TTN handler") handler = ttn.HandlerClient(app_id, access_key) print("Get data using mqtt client") # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) print("Connecting....") mqtt_client.connect() WAIT_SECONDS = 20 print(f"Now wait for {WAIT_SECONDS} seconds after connect") time.sleep(WAIT_SECONDS) print("Close the client") mqtt_client.close() # using application manager client print("Get data using application manager client") app_client = handler.application() print("Got client, now get the application") my_app = app_client.get() print(my_app) print("Now get a list of my devices") my_devices = app_client.devices() print(my_devices)
def main(): print("Transparent bridge starting...") # Configuring TTN broker app_id = config.MQTT_TTN_USER access_key = config.MQTT_TTN_PASS handler = ttn.HandlerClient(app_id, access_key) mqtt_client = handler.data() # Setting callback mqtt_client.set_uplink_callback(uplink_callback) # Connect mqtt_client.connect() print("Connection completed") print("Waiting messages from broker...") # Sleep forever while (True): time.sleep(60) mqtt_client.close()
import time import ttn import json app_id = "<your TTN application id>" access_key = "<your TTN application access key>" def uplink_callback(msg, client): print('wind_analog: ', msg.payload_fields.analog_in_5) print('temp: ', msg.payload_fields.temperature_1) print('press: ', msg.payload_fields.barometric_pressure_3) print('humid: ', msg.payload_fields.relative_humidity_2) handler = ttn.HandlerClient(app_id, access_key) # using mqtt client mqtt_client = handler.data() mqtt_client.set_uplink_callback(uplink_callback) while True: mqtt_client.connect() time.sleep(60) # mqtt_client.close() # using application manager client app_client = handler.application() my_app = app_client.get() # print(my_app) my_devices = app_client.devices()