def startServer(muteoutput):
global tv_listings_dict
global tv_channels
global tv_dict
global mute
mute = muteoutput
if os.path.isfile('helpers/lineup.json'):
with open('helpers/lineup.json') as json_data:
tv_json = json.load(json_data)
for chan in tv_json:
tv_channels.append(chan[0])
tv_channels.append(chan[1])
tv_listings_dict[chan[0]] = chan
tv_listings_dict[chan[1]] = chan
else:
tv_channels = []
tv_listings_dict = {}
if 'wpvi' in tv_channels:
tv_channels.append('abc')
tv_listings_dict['abc'] = tv_listings_dict['wpvi']
if 'wtxf' in tv_channels:
tv_channels.append('fox')
tv_listings_dict['fox'] = tv_listings_dict['wtxf']
for tv in tvconfig.tvs:
tv_dict[tv['tv_mac_address']] = tv
clientid = prefHelper.deviceUUID()
myMQTTClient = AWSIoTMQTTClient(clientid)
myMQTTClient.configureEndpoint("afkx1f9takwol.iot.us-east-1.amazonaws.com",
8883)
myMQTTClient.configureCredentials(".auth/root.pem",
".auth/private.pem.key",
".auth/certificate.pem.crt")
myMQTTClient.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
print('starting server...')
myMQTTClient.connect()
myMQTTClient.subscribe("power/" + clientid, 1, power)
myMQTTClient.subscribe("channel/" + clientid, 1, channel)
myMQTTClient.subscribe("speaker/" + clientid, 1, speaker)
myMQTTClient.subscribe("playback/" + clientid, 1, playback)
#myMQTTClient.unsubscribe("myTopic")
#myMQTTClient.disconnect()
print('server running. Pres CTRL + C to stop')
counter = 0
while True:
time.sleep(1)
if counter == 0:
payload = {"uuid": prefHelper.deviceUUID()}
headers = {
'content-type': 'application/json',
'jwt': prefHelper.deviceToken()
}
try:
response = requests.post('https://alexasmarttv.tk/api/v1/ping',
data=json.dumps(payload),
headers=headers)
except:
print('failed to ping')
counter += 1
counter = counter % 900
import os
import json
import cv2
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
from time import sleep
from datetime import date, datetime
root = "/home/matt/"
# AWS IoT certificate based connection
myMQTTClient = AWSIoTMQTTClient("dackrambo")
myMQTTClient.configureEndpoint("a1xrgfi7tw2r2a.iot.ap-southeast-2.amazonaws.com", 8883)
myMQTTClient.configureCredentials(root + ".aws/rootCA.crt",
root + ".aws/2d4288b294-private.pem.key",
root + ".aws/2d4288b294-certificate.pem.crt")
myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
#connect and publish
myMQTTClient.connect()
myMQTTClient.publish("skullcave/info", "connected", 0)
# Set up webcam
webcam = cv2.VideoCapture(0)
# Define a function to handle the callback from the subsciption
def thingdoer(client, userdata, message):
# Decode message from bytes > str > Json, then get 'message'
except socket.error:
#print 'File already running'
sys.exit()
#lock will be handled automatically with garbage collection
get_lock('road_review')
#redis connections
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=0)
client = redis.StrictRedis(connection_pool=pool)
envQueue = RedisQueue.RedisQueue(client, "EnvironmentData")
roadQueue = RedisQueue.RedisQueue(client, "RoadCondition")
# For certificate based connection
myMQTTClient = AWSIoTMQTTClient("RoadReviewerPi")
# For TLS mutual authentication
myMQTTClient.configureEndpoint("a2h72bxx1czemj.iot.us-west-2.amazonaws.com",
8883)
myMQTTClient.configureCredentials(
"/home/pi/Desktop/IOT_THING_RoadReviewPublisher/rootca.pem",
"/home/pi/Desktop/IOT_THING_RoadReviewPublisher/private.pem.key",
"/home/pi/Desktop/IOT_THING_RoadReviewPublisher/certi.txt")
myMQTTClient.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
device_id = 1234
spi = spidev.SpiDev()
topic_shadow_report_document= "$aws/things/"+THING_NAME+"/shadow/update/documents"
topic_shadow_get_report = "$aws/things/"+THING_NAME+"/shadow/get/accepted"
#Subscription intitialization to the Shadow Service
#In here you define the AMAZON IOT Platform values
#You should study the guide availiable at:
#
#https://github.com/aws/aws-iot-device-sdk-python
#
#
myMQTTClient = AWSIoTMQTTClient("xxxxxxxxxxxxxxxxxxxxxxxxx")
myMQTTClient.configureEndpoint("xxxxxxxxxxxxxxxxxxx.iot.eu-west-1.amazonaws.com", 8883)
myMQTTClient.configureCredentials("/home/pi/cert_ire/xxxxxxxxxxxxxxxx.pem", "/home/pi/cert_ire/xxxxxxxxx.pem.key", "/home/pi/cert_ire/xxxxxxxxxxxxxxxxxxxx.pem.crt")
myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 secss
myMQTTClient.connect()
#Subscription to topic to get current temperature from sensor
#Get the current reported temperature
myMQTTClient.subscribe(topic_shadow_get_report, 1, getTemp)
myMQTTClient.subscribe(topic_shadow_report_document,1,printStatus)
myMQTTClient.publish(topic_shadow_ask_report, "" ,0)
time.sleep(3)
#Water Temp and TDS
ser = serial.Serial('/dev/ttyUSB0',9600)
#MQTT
host = "a1hdsuh2fiycts-ats.iot.us-east-1.amazonaws.com"
rootCAPath = ""
certificatePath = ""
privateKeyPath = ""
#Telegram
bot_token = ''
bot_chatID = ''
my_rpi = AWSIoTMQTTClient("basicPubSub")
my_rpi.configureEndpoint(host, 8883)
my_rpi.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
my_rpi.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
my_rpi.configureDrainingFrequency(2) # Draining: 2 Hz
my_rpi.configureConnectDisconnectTimeout(20) # 10 sec
my_rpi.configureMQTTOperationTimeout(20) # 5 sec
my_rpi.connect()
def publishmqtt(watertemp,tds,waterlevel):
message = {}
message["DeviceID"] = "WMS1"
now = datetime.datetime.now()
message["datetime"] = now.isoformat()
message["WaterTemp"] = watertemp
# Import SDK packages
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import time
# For Websocket connection
myMQTTClient = AWSIoTMQTTClient("myClientID", useWebsocket=True)
# Configurations
# For TLS mutual authentication
# For Websocket
myMQTTClient.configureEndpoint("a1zetnmz2w4vck.iot.us-east-2.amazonaws.com",
443)
# For TLS mutual authentication with TLS ALPN extension
# myMQTTClient.configureEndpoint("YOUR.ENDPOINT", 443)
# For Websocket, we only need to configure the root CA
myMQTTClient.configureCredentials("./certificate/aws-iot-rootCA.crt")
# AWS IoT MQTT Client
# myMQTTClient.configureIAMCredentials(obtainedAccessKeyID, obtainedSecretAccessKey, obtainedSessionToken)
# https://console.aws.amazon.com/iam/ --> users --> create access key
myMQTTClient.configureIAMCredentials(
"AKIAIMPUZ4N6PLLCB2VA", "sXWou67p1ZJSKMua3kaOZ7r2BThOonLTkKNA5xQu", "")
myMQTTClient.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
def customCallback(client, userdata, message):
print("Received a new message: ")
#!/usr/bin/python3
# -- This is a demo program for AWS IoT MQTT Topic
# -- It simulates sensors from car that's connected to AWS IoT Core and publish sensor data to a specific MQTT topic
# Author: Randy Lin
import json
import time
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import logging
import random
import time
logging.basicConfig(level = logging.INFO)
#Setup MQTT client and security certificates
mqttc = AWSIoTMQTTClient("MyIoTDevice")
mqttc.configureEndpoint("ChangeToYourEndpoint.ats.iot.cn-north-1.amazonaws.com.cn",8883)
mqttc.configureCredentials(
'./root-CA.crt',
'./MyIoTDevice.private.key',
'./MyIoTDevice.cert.pem'
)
#Connect to IoT Core
mqttc.connect()
logging.info('MQTT Client Connected to IoT Core')
#Send sensor data to IoT Core infinitly
#Sensor data is randomized between 20 to 40
# Import SDK packages
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
# For certificate based connection
myMQTTClient = AWSIoTMQTTClient("rpi")
# For Websocket connection
# myMQTTClient = AWSIoTMQTTClient("rpi", useWebsocket=True)
# Configurations
# For TLS mutual authentication
myMQTTClient.configureEndpoint("arn:aws:iot:eu-north-1:100732055442:thing/rpi", 8883)
# For Websocket
# myMQTTClient.configureEndpoint("arn:aws:iot:eu-north-1:100732055442:thing/rpi", 443)
# For TLS mutual authentication with TLS ALPN extension
# myMQTTClient.configureEndpoint("arn:aws:iot:eu-north-1:100732055442:thing/rpiT", 443)
myMQTTClient.configureCredentials("AmazonRootCA1.pem", "13816e7464-private.pem.key", "13816e7464-certificate.pem.crt")
# For Websocket, we only need to configure the root CA
# myMQTTClient.configureCredentials("AmazonRootCA1.pem")
myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
myMQTTClient.connect()
myMQTTClient.publish("myTopic", "myPayload", 0)
myMQTTClient.subscribe("myTopic", 1, customCallback)
myMQTTClient.unsubscribe("myTopic")
myMQTTClient.disconnect()
if not args.useWebsocket and (not args.certificatePath
or not args.privateKeyPath):
parser.error("Missing credentials for authentication.")
exit(2)
# Port defaults
port = args.port
if args.useWebsocket and not args.port: # When no port override for WebSocket, default to 443
port = 443
if not args.useWebsocket and not args.port: # When no port override for non-WebSocket, default to 8883
port = 8883
# Init AWSIoTMQTTClient
myAWSIoTMQTTClient = None
if args.useWebsocket:
myAWSIoTMQTTClient = AWSIoTMQTTClient(args.clientId, useWebsocket=True)
myAWSIoTMQTTClient.configureEndpoint(args.host, port)
myAWSIoTMQTTClient.configureCredentials(args.rootCAPath)
else:
myAWSIoTMQTTClient = AWSIoTMQTTClient(args.clientId)
myAWSIoTMQTTClient.configureEndpoint(args.host, port)
myAWSIoTMQTTClient.configureCredentials(args.rootCAPath,
args.privateKeyPath,
args.certificatePath)
# 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
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10 # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
def colorWipe(strip, color):
"""Wipe color across display a pixel at a time."""
for i in range(strip.numPixels()):
strip.setPixelColor(i, color)
strip.show()
# AWS IoT certificate based connection
myMQTTClient = AWSIoTMQTTClient("project_client")
myMQTTClient.configureEndpoint(
"a3i8q8ljdrqz7m-ats.iot.us-west-1.amazonaws.com", 8883)
myMQTTClient.configureCredentials(
"/home/pi/Desktop/CmpE181/connect_device_package/AmazonRootCA1.pem",
"/home/pi/Desktop/CmpE181/connect_device_package/20a07069bd-private.pem.key",
"/home/pi/Desktop/CmpE181/connect_device_package/20a07069bd-certificate.pem.crt"
)
myMQTTClient.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
#connect and publish
myMQTTClient.connect()
myMQTTClient.publish("temp", "connected", 0)
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
topic = sys.argv[5]
payload = sys.argv[7]
qos = int(sys.argv[6])
host = sys.argv[4] # enter host endpoint
port = 8883
client_id = str(uuid.uuid4())
ca_path = sys.argv[1] # path to CA
cert_path = sys.argv[2] # path to Cert
key_path = sys.argv[3] # path to Private Key
aws_iot_client = AWSIoTMQTTClient(client_id)
aws_iot_client.configureEndpoint(host, port)
aws_iot_client.configureCredentials(ca_path, key_path, cert_path)
aws_iot_client.configureAutoReconnectBackoffTime(1, 32, 20)
aws_iot_client.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
aws_iot_client.configureDrainingFrequency(2) # Draining: 2 Hz
aws_iot_client.configureConnectDisconnectTimeout(10) # 10 sec
aws_iot_client.configureMQTTOperationTimeout(5) # 5 sec
aws_iot_client.connect()
time.sleep(2)
messageJson = '{"message": "' + payload + '"}'
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import boto3
import botocore
from time import sleep
import json
import sys
host = "XXXXXXXXXXXXXXXXXXXXX.us-east-1.amazonaws.com"
rootCAPath = "rootca.pem"
certificatePath = "certificate.pem.crt"
privateKeyPath = "private.pem.key"
my_rpi = AWSIoTMQTTClient("farm1-cam")
my_rpi.configureEndpoint(host, 8883)
my_rpi.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
my_rpi.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
my_rpi.configureDrainingFrequency(2) # Draining: 2 Hz
my_rpi.configureConnectDisconnectTimeout(10) # 10 sec
my_rpi.configureMQTTOperationTimeout(10) # 5 sec
def takepic():
from picamera import PiCamera
camera = PiCamera()
try:
sleep(3)
import datetime as datetime
now = datetime.datetime.now()
timestring = now.strftime("%d-%m-%YT%H:%M:%S")
print ("Taking photo " +timestring)
full_path = '/home/pi/Desktop/AgriPi/photo_'+timestring+'.jpg'
filename = 'photo_'+timestring+'.jpg'
rootCAPath = "root-CA.crt"
certificatePath = "HouseyTest.cert.pem"
privateKeyPath = "HouseyTest.private.key"
# Configure logging, only for analysing the log of Mqtt client
# (I probably don't need this for now because I've been using MQTT.fx for testing)
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Init AWSIoTMQTTClient
myAWSIoTMQTTClient = AWSIoTMQTTClient("basicPubSub") # Client name
# Configure with certificate setting
myAWSIoTMQTTClient.configureEndpoint(host, 8883)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
# 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(5) # 5 sec
# Connect and subscribe to AWS IoT
myAWSIoTMQTTClient.connect() # Mqtt Client connect
# set subscribe topic
def main():
parser = argparse.ArgumentParser()
AllowedActions = ['both', 'publish', 'subscribe']
parser.add_argument("-l",
"--logging",
action="store",
dest="logging_level",
help="Set logging level for MQ",
default="info")
parser.add_argument(
"-b",
"--batch_messages",
action="store",
dest="batch_messages",
help=
"Set batching of messages instead of sending single lines. Give batch size in bytes",
default="0")
parser.add_argument("-e",
"--endpoint",
action="store",
required=True,
dest="host",
help="Your AWS IoT custom endpoint")
parser.add_argument("-r",
"--rootCA",
action="store",
required=True,
dest="rootCAPath",
help="root_ca.pem")
parser.add_argument("-c",
"--cert",
action="store",
dest="certificatePath",
help="aa6562034b-certificate.pem.crt")
parser.add_argument("-k",
"--key",
action="store",
dest="privateKeyPath",
help="aa6562034b-private.pem.key")
parser.add_argument("-p",
"--port",
action="store",
dest="port",
type=int,
help="Port number override")
parser.add_argument("-id",
"--clientId",
action="store",
dest="clientId",
default="serial-data-simulator",
help="Targeted client id")
parser.add_argument(
"-t",
"--topic",
action="store",
dest="topic",
default="rules/DataToDynamo/teknoware/telemetry/RaspberryPI3",
help="Targeted topic")
parser.add_argument("-m",
"--mode",
action="store",
dest="mode",
default="both",
help="Operation modes: %s" % str(AllowedActions))
args = parser.parse_args()
if not args.certificatePath or not args.privateKeyPath:
parser.error("Missing credentials for authentication.")
exit(2)
level = LEVELS.get(args.logging_level, logging.NOTSET)
logging.basicConfig(level=level)
logging.debug('Using debug logging ...')
logging.info('Using info logging ...')
AWSIotClient = AWSIoTMQTTClient(args.clientId)
AWSIotClient.configureEndpoint(args.host, args.port)
AWSIotClient.configureCredentials(args.rootCAPath, args.privateKeyPath,
args.certificatePath)
AWSIotClient.configureAutoReconnectBackoffTime(1, 32, 20)
AWSIotClient.configureOfflinePublishQueueing(
4, 0) # Infinite offline Publish queueing
AWSIotClient.configureDrainingFrequency(2) # Draining: 2 Hz
AWSIotClient.configureConnectDisconnectTimeout(10) # 10 sec
AWSIotClient.configureMQTTOperationTimeout(5) # 5 sec
serialData = SerialData()
serialDataConsumer = SerialDataConsumer(
amqp_url='amqp://*****:*****@localhost:5672/%2F',
iot_client=AWSIotClient,
target_topic=args.topic,
serial_data=serialData,
batch_messages=args.batch_messages)
try:
logging.info('Establishing AWS IoT Connection ...')
AWSIotClient.connect()
if args.mode == 'both' or args.mode == 'subscribe':
AWSIotClient.subscribe(
args.topic, 1,
serialDataConsumer.on_iot_client_message_received)
time.sleep(2) # TODO: ensure the connection by using callbacks
serialDataConsumer.run()
except KeyboardInterrupt:
serialDataConsumer.stop()
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import time
from datetime import date, datetime
myMQTTClient = AWSIoTMQTTClient("new_Client")
myMQTTClient.configureEndpoint("ap6thgx18rs03.iot.us-west-2.amazonaws.com", 8883)
myMQTTClient.configureCredentials("/Users/said_/Desktop/AWS/test/bigTest/CA.pem", "/Users/said_/Desktop/AWS/test/bigTest/baac1e25c3-private.pem.key", "/Users/said_/Desktop/AWS/test/bigTest/baac1e25c3-certificate.pem.crt")
myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
time.sleep(2) #wait for 2 secs
connecting_time = time.time() + 10
if time.time() < connecting_time: #try connecting to AWS for 10 seconds
myMQTTClient.connect()
myMQTTClient.publish("DHT11/info", "connected", 0)
print("MQTT Client connection success!")
else:
print("Error: Check your AWS details in the program")
time.sleep(2) #wait for 2 secs
while 1: #Infinite Loop
now = datetime.utcnow() #get date and time
current_time = now.strftime('%Y-%m-%dT%H:%M:%SZ') #get current time in string format
time.sleep(2) #Wait for 2 sec then update the values
def customCallback(client, userdata, message):
print("Received a new message: ")
print(message.payload)
print("from topic: ")
print(message.topic)
print("--------------\n\n")
# Read in command-line parameters
useWebsocket = False
host = ""
rootCAPath = "./root-CA.crt"
certificatePath = "./.cert.pem"
privateKeyPath = "./.private.key"
myAWSIoTMQTTClient = AWSIoTMQTTClient("subscribe")
myAWSIoTMQTTClient.configureEndpoint(host, 8883)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath,
certificatePath)
# 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(5) # 5 sec
# Connect and subscribe to AWS IoT
myAWSIoTMQTTClient.connect()
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import time
loop = True;
def customCallback(client, userdata, message):
print("Received a new message: ")
print(message.payload)
print("from topic: ")
print(message.topic)
myMQTTClient.publish("myTopicPublish", "Chris Recived", 0)
print("--------------\n\n")
loop = False;
myMQTTClient = AWSIoTMQTTClient("Chris_Macbook")
myMQTTClient.configureEndpoint("a1g9fizbnjxy2u.iot.us-west-2.amazonaws.com", 443)
myMQTTClient.configureCredentials("/Users/yuxuanwu/Desktop/IoT/Amazon_Root_CA_1.pem", "/Users/yuxuanwu/Desktop/IoT/cf09431bee-private.pem.key", "/Users/yuxuanwu/Desktop/IoT/cf09431bee-certificate.pem.crt")
# For Websocket, we only need to configure
myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) #
myMQTTClient.connect()
#myMQTTClient.publish("myTopic", "Chris IoT Test", 0)
myMQTTClient.subscribe("myTopicListen", 1, customCallback)
while loop:
time.sleep(1)
door_state = bool(int(open("/sys/fs/security_door/door_state").read()))
states.update({'door_state': door_state})
# Enable Alarm if armed
if states['arm_state'] and door_state:
states.update({'alarm_state': True})
if __name__ == '__main__':
# Start Display Thread
display.start()
display.set_screen(MessageScreen('Starting...'))
print('Started Display Thread')
# Init MQTT
mqtt = AWSIoTMQTTClient(config['DEVICE']['id'])
mqtt_config = config['MQTT']
mqtt.configureEndpoint(mqtt_config.get('Host'), mqtt_config.getint('Port'))
mqtt.configureCredentials(mqtt_config['Root Certificate'],
mqtt_config['Private Key Path'],
mqtt_config['Certificate Path'])
# Set MQTT Configuration
mqtt.configureAutoReconnectBackoffTime(
1, 32,
20) # 1 Second (Auto Reconnect), 32 Seconds (Back-off), 20 (Stable)
mqtt.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
mqtt.configureDrainingFrequency(2) # Draining: 2 Hz
logger = None
if sys.version_info[0] == 3:
logger = logging.getLogger("core") # Python 3
else:
logger = logging.getLogger("AWSIoTPythonSDK.core") # Python 2
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Init AWSIoTMQTTClient
myAWSIoTMQTTClient = None
if useWebsocket:
myAWSIoTMQTTClient = AWSIoTMQTTClient("basicPubSub", useWebsocket=True)
myAWSIoTMQTTClient.configureEndpoint(host, 443)
myAWSIoTMQTTClient.configureCredentials(rootCAPath)
else:
myAWSIoTMQTTClient = AWSIoTMQTTClient("basicPubSub")
myAWSIoTMQTTClient.configureEndpoint(host, 8883)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath,
certificatePath)
# 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(5) # 5 sec
print('voltage')
voltage = robot.voltage()
voltage = send_json(voltage)
myMQTT.publish('from_robot', voltage, 0)
elif data == 'distance':
print('distance')
distance = robot.distance()
distance = send_json(distance)
myMQTT.publish('from_robot', distance, 0)
else:
pass
key_dir = '/home/pi/aaa_mikes_gopigo/keys/'
myMQTT = AWSIoTMQTTClient('Leonard')
myMQTT.configureEndpoint('a111amujev1y9r.iot.us-west-2.amazonaws.com', 8883)
myMQTT.configureCredentials(key_dir + 'root-CA.crt',
key_dir + 'Leonard.private.key',
key_dir + 'Leonard.cert.pem')
myMQTT.configureOfflinePublishQueueing(-1)
myMQTT.configureDrainingFrequency(2)
myMQTT.configureConnectDisconnectTimeout(10)
myMQTT.connect()
myMQTT.subscribe('to_robot', 1, action)
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
if not config.useWebsocket and not config.port:
port = 8883
# Configure logging
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.INFO)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Init AWSIoTMQTTClient
myAWSIoTMQTTClient = None
if config.useWebsocket:
myAWSIoTMQTTClient = AWSIoTMQTTClient(config.clientId, useWebsocket=True)
myAWSIoTMQTTClient.configureEndpoint(config.host, config.port)
myAWSIoTMQTTClient.configureCredentials(config.rootCAPath)
else:
myAWSIoTMQTTClient = AWSIoTMQTTClient(config.clientId)
myAWSIoTMQTTClient.configureEndpoint(config.host, config.port)
myAWSIoTMQTTClient.configureCredentials(config.rootCAPath,
config.privateKeyPath,
config.certificatePath)
# AWSIoTMQTTClient connection configuration
myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTClient.configureMQTTOperationTimeout(10) # 5 sec
jobsClient = AWSIoTMQTTThingJobsClient(config.clientId,
def set_certificate_authentication_id(self, client_id):
"""Set Certificate Client ID from Constants."""
MQTT_Certificate_Client = AWSIoTMQTTClient(client_id)
return MQTT_Certificate_Client
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
myMQTTClient = AWSIoTMQTTClient("Device34")
myMQTTClient.configureEndpoint("a1trumz0n7avwt.iot.us-west-2.amazonaws.com",
8883)
myMQTTClient.configureCredentials("data/root-CA.txt", "data/device34.key",
"data/device34.txt")
myMQTTClient.configureOfflinePublishQueueing(-1)
myMQTTClient.configureDrainingFrequency(2)
myMQTTClient.configureConnectDisconnectTimeout(10)
myMQTTClient.configureMQTTOperationTimeout(5)
myMQTTClient.connect()
# Update Device Status Connected / Disconnecred
###############################################
def updateDeviceStatus(deviceStatus):
JSONPayload = '{"recordType": "Device","deviceStatus":"'+deviceStatus +'"}'
myAWSIoTMQTTClient.publish(awsTopicPrefix + thingName,JSONPayload,1)
########################################
#======================================
# AWS IoT SDK - MQTT Client connection
#======================================
myAWSIoTMQTTClient = AWSIoTMQTTClient(thingName)
myAWSIoTMQTTClient.configureEndpoint(awsEndpoint, awsPortNumber)
myAWSIoTMQTTClient.configureCredentials(awsRootCAPath, awsIoTPrivateKeyPath,awsIoTCertificatePath)
myAWSIoTMQTTClient.configureMQTTOperationTimeout(5)
# Last will payload for disconnection
lastWillPayload = '{"recordType":"Device","deviceStatus":"Disconnected"}'
myAWSIoTMQTTClient.configureLastWill(awsTopicPrefix + thingName, lastWillPayload, 0)
# Connect
myAWSIoTMQTTClient.connect()
updateDeviceStatus("Connected")
dateTimeObj = datetime.now()
print("Device is connected at "+ str(datetime.now()))
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
from time import sleep
from datetime import date, datetime
CLIENT_NAME = ""
TOPIC = ""
# Broker path is under AWS IoT > Settings (at the bottom left)
BROKER_PATH = "a2hyr29arhu1ac-ats.iot.us-east-1.amazonaws.com"
ROOT_CA_PATH = './AmazonRootCA1.pem'
PRIVATE_KEY_PATH = './14e764a6a2-private.pem.key'
CERTIFICATE_PATH = './14e764a6a2-certificate.pem.crt'
IoTclient = AWSIoTMQTTClient(CLIENT_NAME)
IoTclient.configureEndpoint(BROKER_PATH, 8883)
IoTclient.configureCredentials(ROOT_CA_PATH, PRIVATE_KEY_PATH,
CERTIFICATE_PATH)
# Allow the device to queue infinite messages
IoTclient.configureOfflinePublishQueueing(-1)
# Number of messages to send after a connection returns
IoTclient.configureDrainingFrequency(2) # 2 requests/second
# How long to wait for a [dis]connection to complete (in seconds)
IoTclient.configureConnectDisconnectTimeout(10)
# How long to wait for publish/[un]subscribe (in seconds)
IoTclient.configureMQTTOperationTimeout(5)
# Details about thing
THING_ID = "thing22"
CLIENT_ID = "MyRpi"
CERTIFICATE_PATH = "./certificates"
ENDPOINT = "akbmorjah98q5.iot.ap-southeast-1.amazonaws.com"
# Change to your topics here
UPDATE_TOPIC = "$aws/things/" + THING_ID + "/shadow/update"
DELTA_TOPIC = "$aws/things/" + THING_ID + "/shadow/update/delta"
ROOT_CA = CERTIFICATE_PATH + "/rootCA.pem"
PRIVATE_KEY = CERTIFICATE_PATH + "/private.key.pem"
CERTIFICATE_CRT = CERTIFICATE_PATH + "/certificate.crt.pem"
# Configuration for AWS IoT
myMQTTClient = AWSIoTMQTTClient(CLIENT_ID)
myMQTTClient.configureEndpoint(ENDPOINT, 8883)
myMQTTClient.configureCredentials(ROOT_CA, PRIVATE_KEY, CERTIFICATE_CRT)
myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
myMQTTClient.enableMetricsCollection()
# Connect to MQTT broker
connected = myMQTTClient.connect()
print("Connected:-", connected)
def publish_sensor_data(interval):
try:
print("from topic: ")
print(message.topic)
print("--------------\n\n")
host = "XXX.amazonaws.com"
rootCAPath = "root-CA.crt"
certificatePath = "XXX.cert.pem"
privateKeyPath = "XXX.private.key"
port = 8883
clientId = "client_name"
pub_topic = "publish_topic_name"
sub_topic = "subscribe_topic_name"
# Init AWSIoTMQTTClient
myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId)
myAWSIoTMQTTClient.configureEndpoint(host, port)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath,
certificatePath)
# 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(5) # 5 sec
# Connect and subscribe to AWS IoT
myAWSIoTMQTTClient.connect()
myAWSIoTMQTTClient.subscribe(sub_topic, 1, customCallback)
def __init__(self):
# Read in command-line parameters
parser = argparse.ArgumentParser()
parser.add_argument(
"-e",
"--endpoint",
action="store",
default="a3cezb6rg1vyed-ats.iot.us-west-2.amazonaws.com",
dest="host",
help="Your AWS IoT custom endpoint")
parser.add_argument("-r",
"--rootCA",
action="store",
default="{}/root-CA.crt".format(PATH_TO_HOME),
dest="rootCAPath",
help="Root CA file path")
parser.add_argument(
"-c",
"--cert",
action="store",
default="{}/PL-student.cert.pem".format(PATH_TO_HOME),
dest="certificatePath",
help="Certificate file path")
parser.add_argument(
"-k",
"--key",
action="store",
default="{}/PL-student.private.key".format(PATH_TO_HOME),
dest="privateKeyPath",
help="Private key file path")
parser.add_argument("-p",
"--port",
action="store",
dest="port",
type=int,
help="Port number override")
parser.add_argument("-w",
"--websocket",
action="store_true",
dest="useWebsocket",
default=False,
help="Use MQTT over WebSocket")
parser.add_argument("-id",
"--clientId",
action="store",
dest="clientId",
default="pl19-99",
help="Targeted client id")
parser.add_argument("-t",
"--topic",
action="store",
dest="topic",
default="pl19/event",
help="Event topic")
parser.add_argument("-m",
"--mode",
action="store",
dest="mode",
default="both",
help="Operation modes: %s" % str(AllowedActions))
parser.add_argument("-M",
"--message",
action="store",
dest="message",
default="Hello World!",
help="Message to publish")
args = parser.parse_args()
self.host = args.host
self.rootCAPath = args.rootCAPath
self.certificatePath = args.certificatePath
self.privateKeyPath = args.privateKeyPath
self.port = args.port
self.useWebsocket = args.useWebsocket
self.clientId = args.clientId
self.topic = args.topic
if args.mode not in AllowedActions:
parser.error("Unknown --mode option %s. Must be one of %s" %
(args.mode, str(AllowedActions)))
exit(2)
if args.useWebsocket and args.certificatePath and args.privateKeyPath:
parser.error(
"X.509 cert authentication and WebSocket are mutual exclusive. Please pick one."
)
exit(2)
if not args.useWebsocket and (not args.certificatePath
or not args.privateKeyPath):
parser.error("Missing credentials for authentication.")
exit(2)
# Port defaults
if args.useWebsocket and not args.port: # When no port override for WebSocket, default to 443
self.port = 443
if not args.useWebsocket and not args.port: # When no port override for non-WebSocket, default to 8883
self.port = 8883
# Configure logging
streamHandler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
# Init AWSIoTMQTTClient
self.mqtt_client = None
self.mqtt_client = AWSIoTMQTTClient(self.clientId)
self.mqtt_client.configureEndpoint(self.host, self.port)
self.mqtt_client.configureCredentials(self.rootCAPath,
self.privateKeyPath,
self.certificatePath)
# AWSIoTMQTTClient connection configuration
self.mqtt_client.configureAutoReconnectBackoffTime(1, 32, 20)
self.mqtt_client.configureOfflinePublishQueueing(
-1) # Infinite offline Publish queueing
self.mqtt_client.configureDrainingFrequency(2) # Draining: 2 Hz
self.mqtt_client.configureConnectDisconnectTimeout(10) # 10 sec
self.mqtt_client.configureMQTTOperationTimeout(5) # 5 sec
payloadInfo = json.loads(packet.payload)
humidity = payloadInfo["humidity"]
print("humidity:", str(humidity))
humidity = int(humidity)
if humidity < 85:
stop2()
else:
go2()
try:
#while True:
GPIO.setwarnings(False)
setup()
#AwsReyna ultrasonic connection
myMQTTClient = AWSIoTMQTTClient("ReynaPI")
myMQTTClient.configureEndpoint("a3te7fgu4kv468-ats.iot.us-west-1.amazonaws.com",8883)
myMQTTClient.configureCredentials("/home/pi/Certificates/rootCA.pem","/home/pi/Certificates/d626c8c838-private.pem.key","/home/pi/Certificates/d626c8c838-certificate.pem.crt")
myMQTTClient.configureAutoReconnectBackoffTime(1,32,20)
myMQTTClient.configureOfflinePublishQueueing(-1)
myMQTTClient.configureDrainingFrequency(2)
myMQTTClient.configureConnectDisconnectTimeout(10)
myMQTTClient.configureMQTTOperationTimeout(5)
myMQTTClient.configureAutoReconnectBackoffTime(1,32,20)
#connect and subscribe
myMQTTClient.connect()
distance=0
while True:
def setupMQTT():
# Usage
usageInfo = """Usage:
Use certificate based mutual authentication:
python basicPubSub.py -e <endpoint> -r <rootCAFilePath> -c <certFilePath> -k <privateKeyFilePath>
Use MQTT over WebSocket:
python basicPubSub.py -e <endpoint> -r <rootCAFilePath> -w
Type "python basicPubSub.py -h" for available options.
"""
# Help info
helpInfo = """-e, --endpoint
Your AWS IoT custom endpoint
-r, --rootCA
Root CA file path
-c, --cert
Certificate file path
-k, --key
Private key file path
-w, --websocket
Use MQTT over WebSocket
-h, --help
Help information
"""
# Read in command-line parameters
useWebsocket = False
host = "a19zzgl8s6zfsq.iot.us-east-1.amazonaws.com"
rootCAPath = "rootCA.crt"
certificatePath = "88df1a0b0b-certificate.pem.crt"
privateKeyPath = "88df1a0b0b-private.pem.key"
try:
opts, args = getopt.getopt(sys.argv[1:], "hwe:k:c:r:", ["help", "endpoint=", "key=","cert=","rootCA=", "websocket"])
#if len(opts) == 0:
#raise getopt.GetoptError("No input parameters!")
for opt, arg in opts:
if opt in ("-h", "--help"):
print(helpInfo)
exit(0)
if opt in ("-e", "--endpoint"):
host = arg
if opt in ("-r", "--rootCA"):
rootCAPath = arg
if opt in ("-c", "--cert"):
certificatePath = arg
if opt in ("-k", "--key"):
privateKeyPath = arg
if opt in ("-w", "--websocket"):
useWebsocket = True
except getopt.GetoptError:
print(usageInfo)
exit(1)
# Missing configuration notification
missingConfiguration = False
if not host:
print("Missing '-e' or '--endpoint'")
missingConfiguration = True
if not rootCAPath:
print("Missing '-r' or '--rootCA'")
missingConfiguration = True
if not useWebsocket:
if not certificatePath:
print("Missing '-c' or '--cert'")
missingConfiguration = True
if not privateKeyPath:
print("Missing '-k' or '--key'")
missingConfiguration = True
if missingConfiguration:
exit(2)
# Configure logging
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Init AWSIoTMQTTClient
global myAWSIoTMQTTClient
if useWebsocket:
myAWSIoTMQTTClient = AWSIoTMQTTClient("basicPubSub", useWebsocket=True)
myAWSIoTMQTTClient.configureEndpoint(host, 443)
myAWSIoTMQTTClient.configureCredentials(rootCAPath)
else:
myAWSIoTMQTTClient = AWSIoTMQTTClient("basicPubSub")
myAWSIoTMQTTClient.configureEndpoint(host, 8883)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
# 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(5) # 5 sec
# Connect and subscribe to AWS IoT
myAWSIoTMQTTClient.connect()
myAWSIoTMQTTClient.subscribe("sensor_data/temperature/", 1, customCallback)
myAWSIoTMQTTClient.subscribe("sensor_data/sonar/", 1, customCallback)
myAWSIoTMQTTClient.subscribe("sensor_data/gas/", 1, customCallback)
myAWSIoTMQTTClient.subscribe("sensor_data/flame/", 1, customCallback)
