resubscribe_future.add_done_callback(on_resubscribe_complete)
def on_resubscribe_complete(resubscribe_future):
resubscribe_results = resubscribe_future.result()
print("Resubscribe results: {}".format(resubscribe_results))
for topic, qos in resubscribe_results['topics']:
if qos is None:
sys.exit("Server rejected resubscribe to topic: {}".format(topic))
endPt = "a37g54y6ddcht7-ats.iot.us-east-1.amazonaws.com"
clientId = "samples-client-id"
event_loop_group = io.EventLoopGroup(1)
host_resolver = io.DefaultHostResolver(event_loop_group)
client_bootstrap = io.ClientBootstrap(event_loop_group, host_resolver)
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=endPt,
cert_filepath="Certificates/cdc357b6af-certificate.pem.crt",
pri_key_filepath="Certificates/cdc357b6af-private.pem.key",
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=clientId,
clean_session=False,
keep_alive_secs=6)
print("Connecting to {} with client ID '{}'...".format(endPt, clientId))
def main():
#AWS CONNECTION
event_loop_group = io.EventLoopGroup(1)
host_resolver = io.DefaultHostResolver(event_loop_group)
client_bootstrap = io.ClientBootstrap(event_loop_group, host_resolver)
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=ENDPOINT,
cert_filepath=PATH_TO_CERT,
pri_key_filepath=PATH_TO_KEY,
client_bootstrap=client_bootstrap,
ca_filepath=PATH_TO_ROOT,
client_id=CLIENT_ID,
clean_session=False,
keep_alive_secs=6
)
print("Connecting to {} with client ID '{}'...".format(
ENDPOINT, CLIENT_ID))
# Make the connect() call
connect_future = mqtt_connection.connect()
# Future.result() waits until a result is available
connect_future.result()
print("Connected!")
"""
Tasks API
"""
creds = None
# The file token.json stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.json'):
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.json', 'w') as token:
token.write(creds.to_json())
service = build('tasks', 'v1', credentials=creds)
# Call the Tasks API
results = service.tasklists().list(maxResults=10).execute()
items = results.get('items', [])
previous_task_count = 0
current_task_count = 0
while True:
previous_task_count = current_task_count
current_task_count = 0
tasks = []
if not items:
print('No task lists found.')
else:
print('Task lists:')
for item in items:
lists = service.tasks().list(tasklist=item['id'], showCompleted=False).execute().get('items')
if lists is not None:
current_task_count += len(lists)
tasks.append(lists)
#print(u'{0} ({1})'.format(item['title'], item['id']))
print('total tasks' , current_task_count)
#if current task count has decreased
if(current_task_count < previous_task_count):
print('Begin Publish')
for i in range(5):
message = {"h" : 200, "s": 255, 'v': 255, "client": 'ec2'}
mqtt_connection.publish(topic=TOPIC, payload=json.dumps(message), qos=mqtt.QoS.AT_LEAST_ONCE)
print("Published: '" + json.dumps(message) + "' to the topic: " + "'lamp/state'")
time.sleep(1)
print('Ending')
disconnect_future = mqtt_connection.disconnect()
disconnect_future.result()
def device_main():
"""
main loop for dummy device
"""
global device_name, mqtt_connection, shadow_client
sensor = SenseHat()
init_info = arg_check()
device_name = init_info['device_name']
iot_endpoint = init_info['endpoint']
rootca_file = init_info['certs'][0]
private_key_file = init_info['certs'][1]
certificate_file = init_info['certs'][2]
logger.info("device_name: %s", device_name)
logger.info("endpoint: %s", iot_endpoint)
logger.info("rootca cert: %s", rootca_file)
logger.info("private key: %s", private_key_file)
logger.info("certificate: %s", certificate_file)
# Spin up resources
event_loop_group = io.EventLoopGroup(1)
host_resolver = io.DefaultHostResolver(event_loop_group)
client_bootstrap = io.ClientBootstrap(event_loop_group, host_resolver)
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=iot_endpoint,
cert_filepath=certificate_file,
pri_key_filepath=private_key_file,
client_bootstrap=client_bootstrap,
ca_filepath=rootca_file,
client_id=device_name,
clean_session=False,
keep_alive_secs=KEEP_ALIVE)
connected_future = mqtt_connection.connect()
shadow_client = iotshadow.IotShadowClient(mqtt_connection)
connected_future.result()
print("Check latest Shadow status")
get_accepted_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_accepted(
request=iotshadow.GetShadowSubscriptionRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_get_shadow_accepted)
get_rejected_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_rejected(
request=iotshadow.GetShadowSubscriptionRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_get_shadow_rejected)
# Wait for subscriptions to succeed
get_accepted_subscribed_future.result()
get_rejected_subscribed_future.result()
publish_get_future = shadow_client.publish_get_shadow(
request=iotshadow.GetShadowRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE)
# Ensure that publish succeeds
publish_get_future.result()
logger.info("Subscribing to Shadow Delta events...")
delta_subscribed_future, _ = shadow_client.subscribe_to_shadow_delta_updated_events(
request=iotshadow.ShadowDeltaUpdatedSubscriptionRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_shadow_delta_updated)
# Wait for subscription to succeed
delta_subscribed_future.result()
logger.info("Subscribing to Shadow Update responses...")
update_accepted_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_accepted(
request=iotshadow.UpdateShadowSubscriptionRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_update_shadow_accepted)
update_rejected_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_rejected(
request=iotshadow.UpdateShadowSubscriptionRequest(device_name),
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_update_shadow_rejected)
# Wait for subscriptions to succeed
update_accepted_subscribed_future.result()
update_rejected_subscribed_future.result()
# Start sending dummy data
topic = BASE_TOPIC + device_name
logging.info("topic: %s", topic)
while True:
now = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
humi = sensor.temperature
temp = sensor.humidity
payload = {
"DEVICE_NAME": device_name,
"TIMESTAMP": now,
"TEMPERATURE": int(temp),
"HUMIDITY": int(humi)
}
logger.debug(" payload: %s", payload)
mqtt_connection.publish(topic=topic,
payload=json.dumps(payload),
qos=mqtt.QoS.AT_LEAST_ONCE)
time.sleep(wait_time)
def main():
# Parse command line arguments
parser, args = parse_args()
global count
count = args.count
# set log level
io.init_logging(getattr(io.LogLevel, args.verbosity), 'stderr')
# Print MAC address
print(gma())
# Initialize and Calibrate Gas Sensor 1x
mq = MQ()
# Initial the dht device, with data pin connected to:
dht_device = adafruit_dht.DHT22(PIN_DHT)
# Initialize Light Sensor
ls = LightSensor(PIN_LIGHT)
# Initialize PIR Sensor
pir = MotionSensor(PIN_PIR)
led = LED(PIN_PIR_LED)
# Spin up resources
event_loop_group = io.EventLoopGroup(1)
host_resolver = io.DefaultHostResolver(event_loop_group)
client_bootstrap = io.ClientBootstrap(event_loop_group, host_resolver)
# Set MQTT connection
mqtt_connection = set_mqtt_connection(args, client_bootstrap)
print("Connecting to {} with client ID '{}'...".format(
args.endpoint, args.client_id))
connect_future = mqtt_connection.connect()
# Future.result() waits until a result is available
connect_future.result()
print("Connected!")
# # Subscribe (this will pull in messages down from other devices)
# print("Subscribing to topic '{}'...".format(args.topic))
# subscribe_future, packet_id = mqtt_connection.subscribe(
# topic=args.topic,
# qos=mqtt.QoS.AT_LEAST_ONCE,
# callback=on_message_received)
#
# subscribe_result = subscribe_future.result()
# print("Subscribed with {}".format(str(subscribe_result['qos'])))
while True:
led.off()
# Create message payload
payload_dht = get_sensor_data_dht(dht_device)
payload_gas = get_sensor_data_gas(mq)
payload_light = get_sensor_data_light(ls)
payload_motion = get_sensor_data_motion(pir, led)
payload = {
"device_id": gma(),
"ts": time.time(),
"data": {
"temp": payload_dht["temp"],
"humidity": payload_dht["humidity"],
"lpg": payload_gas["lpg"],
"co": payload_gas["co"],
"smoke": payload_gas["smoke"],
"light": payload_light["light"],
"motion": payload_motion["motion"]
}
}
# Don't send bad messages!
if payload["data"]["temp"] is not None \
and payload["data"]["humidity"] is not None \
and payload["data"]["co"] is not None:
# Publish Message
message_json = json.dumps(payload,
sort_keys=True,
indent=None,
separators=(',', ':'))
try:
mqtt_connection.publish(topic=args.topic,
payload=message_json,
qos=mqtt.QoS.AT_LEAST_ONCE)
except mqtt.SubscribeError as err:
print(".SubscribeError: {}".format(err))
except exceptions.AwsCrtError as err:
print("AwsCrtError: {}".format(err))
else:
time.sleep(args.frequency)
else:
print("sensor failure...retrying...")
