def setup_client(self):
if self._mqtt is None:
accessKey = self._settings.get(["broker", "awsaccesskey"])
secretAccessKey = self._settings.get([
"broker", "secretawsaccesskey"
])
if (not accessKey or not secretAccessKey):
return
os.environ["AWS_ACCESS_KEY_ID"] = accessKey
os.environ["AWS_SECRET_ACCESS_KEY"] = secretAccessKey
clientId = self._settings.get(["publish", "baseTopic"])
host = self._settings.get(["broker", "url"])
port = 443
broker_tls = self._settings.get(["broker", "tls"], asdict=True)
rootCAPath = broker_tls.get('ca_certs')
# NOTE it's critical that the AWSIoTMQTTClient is constructed _before_ the socket is monkey patched with the default proxy, otherwise Paho (the MQTT client) just blocks when trying to connect to 127.0.0.1
myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId, useWebsocket=True)
myAWSIoTMQTTClient.configureEndpoint(host, port)
myAWSIoTMQTTClient.configureCredentials(rootCAPath)
# AWSIoTMQTTClient connection configuration
myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 3200, 20)
myAWSIoTMQTTClient.configureOfflinePublishQueueing(
-1
) # Infinite offline Publish queueing
myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myAWSIoTMQTTClient.configureConnectDisconnectTimeout(30) # 30 seconds
myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 seconds
myAWSIoTMQTTClient.onOffline = self._on_mqtt_disconnect
myAWSIoTMQTTClient.onOnline = self._on_mqtt_connect
myAWSIoTMQTTClient.onMessage = self._on_mqtt_message
self._mqtt = myAWSIoTMQTTClient
def setupAWSClient(config_json):
logger.debug("setting up device connection to AWS")
# Init AWSIoTMQTTClient
global AWSIOT_CLIENT
AWSIOT_CLIENT = AWSIoTMQTTClient(config_json["awsIoT"]["clientId"])
AWSIOT_CLIENT.configureEndpoint(config_json["awsIoT"]["endpoint"],
config_json["awsIoT"]["port"])
AWSIOT_CLIENT.configureCredentials(
config_json["awsIoT"]["rootCACertFile"],
config_json["awsIoT"]["privateKeyFile"],
config_json["awsIoT"]["certificateFile"])
# AWSIoTMQTTClient connection configuration
AWSIOT_CLIENT.configureAutoReconnectBackoffTime(1, 32, 20)
# Infinite offline Publish queueing
#AWSIOT_CLIENT.configureOfflinePublishQueueing(-1)
#AWSIOT_CLIENT.configureDrainingFrequency(2) # Draining: 2 Hz
AWSIOT_CLIENT.configureConnectDisconnectTimeout(10) # 10 sec
AWSIOT_CLIENT.configureMQTTOperationTimeout(5) # 5 sec
# track connection status
AWSIOT_CLIENT.onOnline = onClientConnected
AWSIOT_CLIENT.onOffline = onClientDisconnected
myClient.onOnline = myOnOnlineCallback
def myOnOfflineCallback():
# print a message to the console
print("MQTT client disconnected and offline")
# also send a MQTT message to the sensors/info topic
myClient.publishAsync(
"sensors/info",
'{{"sensor":"{:s}","timestamp":"{:s}","info":"MQTT client offline"}}'.
format(sensor_id, get_local_timestamp()), 1)
time.sleep(10)
# Register the function defined above to be called when the MQTT goes online
myClient.onOffline = myOnOfflineCallback
# tell the client to connect with AWS
# use 2400 seconds for the keep-alive which is much longer than the
# time between data sends, so the connection doesn't drop between
# each data send (publish)
myClient.connectAsync(keepAliveIntervalSecond=2400)
# seems to need a few seconds before the connection is ready to use
time.sleep(10)
# define a message publish acknowledgement callback function,
# called automatically when an acknowledgement of successful message
# publication is received when quality of service QoS is 1 (which requests ACKs)
def myPubackCallback(mid):
print("Message ID {:d} sent and acknowledged".format(mid))
# Set aws access key
os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
# AWSIoTMQTTClient connection configuration
myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTClient.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTClient.configureMQTTOperationTimeout(10) # 5 sec
# AWSIoTMQTTClient onOnline and onOffline configuration
myAWSIoTMQTTClient.onOnline = myOnOnlineCallback
myAWSIoTMQTTClient.onOffline = myOnOfflineCallback
# Create an S3 client
s3 = boto3.client('s3')
# BME280 sensor
i2c = busio.I2C(board.SCL, board.SDA)
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
image = 'last_picture_taken.jpg'
# Start functions in threads
threading.Thread(target=take_pic, args=[True], name="camera").start()
threading.Thread(target=read_sensor, args=[True], name="sensor").start()
# Connect and subscribe to AWS IoT
connected_flag = False
def offline():
print('aws iot is offline.')
# Init AWSIoTMQTTClient
device = AWSIoTMQTTClient(clientId)
device.configureEndpoint(host, 80)
device.configureCredentials(caPath, keyPath, certPath)
# AWSIoTMQTTClient connection configuration
device.configureAutoReconnectBackoffTime(1, 32, 20)
device.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
device.configureDrainingFrequency(2) # Draining: 2 Hz
device.configureConnectDisconnectTimeout(10) # 10 sec
device.configureMQTTOperationTimeout(5) # 5 sec
device.onOffline = offline
# Connect and subscribe to AWS IoT
try:
print('AWS IoT connecting...')
device.connect(1200)
print('AWS IoT connected')
device.subscribe(iotConfig.controlSubscribeTo, 1, customCallback)
device.subscribe("rebootCommandguyi", 1, customCallback)
device.subscribe("controlsignal", 1, customCallback)
# publish to AWS IoT
status = {"status": 'connected'}
device.publish(iotConfig.controlPublishTo, json.dumps(status), 1)
time.sleep(1)
except:
print('Received message on topic %s: %s\n' %
(message.topic, message.payload))
except Exception as e:
print(e)
def onOffline():
global connected
print('Lost connection.')
connected = False
# Iterate through all connection options for the core and use the first successful one
myAWSIoTMQTTClient = AWSIoTMQTTClient(CLIENT_ID)
myAWSIoTMQTTClient.onMessage = onMessage
myAWSIoTMQTTClient.onOffline = onOffline
connected = False
def greengrass_run():
global groupCA
global connectivityInfoList
global connected
#############################################
## DISCOVER
#############################################
if connected == True:
message = {'message': "Hello from IoT Device!"}
def newMessage(client, userdata, message):
global cursor
j = json.loads(message.payload.decode('utf-8'))
data = {'ts': j['ts'], 'd': j['d'], 'h': j['h']}
while True:
try:
cursor.execute(ins, data)
db.commit()
except mariadb.errors.DataError as e:
print("DataError: {} ... skipping.".format(e))
traceback.print_exc()
except mariadb.errors.DatabaseError as e:
print("DatabaseError: {} ... reconnecting.".format(e))
db.reconnect(attempts=99999, delay=1)
cursor = db.cursor()
continue
except Exception as e:
print("Error handling new sensor message!")
traceback.print_exc()
#print("{}: inserted new reading at {} of {}ºF and {}%".format(message.topic, time.ctime(j['ts']), j['d'], j['h']))
break
awsiot.onOffline = mqttConnect
mqttConnect()
while True:
#if not awsiot._mqtt_core._internal_async_client._paho_client._thread or not awsiot._mqtt_core._internal_async_client._paho_client._thread.is_alive():
time.sleep(1)
logger.info("done.")
except:
logging.exception("Caught Exception in on_alexa_control_message()")
if __name__ == '__main__':
myMQTTClient = AWSIoTMQTTClient(CLIENT_ID)
myMQTTClient.configureEndpoint(AWS_IOT_ENDPOINT, 8883)
myMQTTClient.configureCredentials(ROOT_CA_CERT, DEV_CERT_PRIV, DEV_CERT)
myMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
myMQTTClient.configureOfflinePublishQueueing(-1)
myMQTTClient.configureDrainingFrequency(2)
myMQTTClient.configureConnectDisconnectTimeout(10)
myMQTTClient.configureMQTTOperationTimeout(5)
myMQTTClient.onOnline = on_online
myMQTTClient.onOffline = on_offline
myMQTTClient.connect()
time.sleep(2)
logger.info("connexted to {} as {}".format(AWS_IOT_ENDPOINT, CLIENT_ID))
myMQTTClient.subscribe(SUBSCRIPTION_TOPIC, 1, on_alexa_control_message)
logger.info("subscribed topic: {}".format(SUBSCRIPTION_TOPIC))
while True:
time.sleep(1)
def main():
signal.signal(signal.SIGINT, signal_handler)
print(device_id)
########################
### #AWS IoT MQTT client setup
global mqttClient
mqttClient = AWSIoTMQTTClient(device_id)
#Setup del client mqtt di aws iot
mqttClient.disableMetricsCollection()
mqttClient.configureEndpoint(endpoint, 8883)
mqttClient.configureCredentials(
rootCAPath,
privateKeyPath,
certificatePath,
)
# Backoff per riconnessione in caso di mancanza di connessione
mqttClient.configureAutoReconnectBackoffTime(1, 32, 20)
# Coda dei messaggi in caso di mancanza di connessione
# Infinite offline Publish queueing
mqttClient.configureOfflinePublishQueueing(-1)
mqttClient.configureDrainingFrequency(10) # Draining: 2 Hz
mqttClient.configureConnectDisconnectTimeout(10) # 10 sec
mqttClient.configureMQTTOperationTimeout(5) # 5 sec
#callback in caso di mancanza di connessione
mqttClient.onOffline = disconnessoAInternet
#############################
#### DEVICE SHADOW setup
global shadowClient
shadow = AWSIoTMQTTShadowClient(shadow_clientId, awsIoTMQTTClient=mqttClient)
shadowClient = shadow.createShadowHandlerWithName(thingName, True)
shadowClient.shadowRegisterDeltaCallback(shadowDeltaCallback)
#############################
connect() #avvia il tentativo di connessione (ASYNC)
#iscrizione al topic di richiesta info
mqttClient.subscribe("pcTelemetry/{}/infoRequest".format(device_id), 1, infoRequest)
## Avvia 3 thread:
# - uno pubblica una misurazione ogni 10s
# - uno pubblica un array di 30 misurazioni. Con una misurazione ogni secondo
# - uno pubblica una misurazione ogni 2 min. Misurazioni possibili: batteria, spazio Disco
t1 = threading.Thread(target=detailData, args=(parametri, 1))
t2 = threading.Thread(target=liveData, args=(parametri, 10))
t3 = threading.Thread(target=slowUpdateData, args=(parametri, 120))
t1.setDaemon(True)
t2.setDaemon(True)
t3.setDaemon(True)
t1.start()
t2.start()
t3.start()
while True:
time.sleep(1)
endpoint = 'endpoint...'
topic = 'testTopic/testClient'
qos = 1
myMQTTClinet = AWSIoTMQTTClient('testClient')
myMQTTClinet.disableMetricsCollection()
myMQTTClinet.configureEndpoint(endpoint, 8883)
myMQTTClinet.configureCredentials('cert/rootCA.pem', 'cert/priv.pem.key',
'cert/cert.pem.crt')
myMQTTClinet.configureAutoReconnectBackoffTime(15, 180, 30)
myMQTTClinet.configureOfflinePublishQueueing(-1)
myMQTTClinet.configureConnectDisconnectTimeout(10)
myMQTTClinet.configureDrainingFrequency(1)
myMQTTClinet.configureMQTTOperationTimeout(5)
myMQTTClinet.onOnline = _onOnline
myMQTTClinet.onOffline = _onOffline
#-------------------- Other setup -------------------
#logging.getLogger("AWSIoTPythonSDK.core").setLevel("DEBUG")
#logging.getLogger("AWSIoTPythonSDK.core").addHandler(logging.StreamHandler())
totalMsgToSend = 20
#-------------------- Main code ----------------------
message = 'message number (from 100): {}' #for have a message number different from the id generated when publish
if mqttConnect():
for i in range(100, (100 + totalMsgToSend)):
sendMsg(message.format(i))
time.sleep(20)
time.sleep(10)
