コード例 #1
0
def AWS_SHADOW_Initialize():  #TODO Test this
    try:
        subprocess.call('./copyCertificates.sh')
    except:
        CA_CERTIFICATE = "Certificates/root-CA.crt"
        PRIVATE_KEY = "Certificates/device-private.pem.key"
        DEVICE_CERTIFICATE = "Certificates/device-certificate.pem.crt"
    # AWS IoT certificate based connection---------------------------------------
    myShadowClient = AWSIoTMQTTShadowClient(
        CLIENT)  #this can be any arbitrary string
    myShadowClient.configureEndpoint(AWS_SERVER,
                                     PORT)  #endpoint and port number
    myShadowClient.configureCredentials(
        CA_CERTIFICATE, PRIVATE_KEY, DEVICE_CERTIFICATE
    )  #root ca and certificate used for secure connection

    myShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    #connect, subscribe and publish----------------------------------------------------------
    myShadowClient.connect()
    shadowHandler = myShadowClient.createShadowHandlerWithName(
        THING_NAME, True)
    myMQTTClient = myShadowClient.getMQTTConnection()
    AWS_MQTT_subscribe(myMQTTClient, None)
    return (shadowHandler, myMQTTClient)
コード例 #2
0
 def __init__(self,
              host,
              rootCAPath,
              certPath,
              privateKeyPath,
              clientId,
              deviceName,
              port=8883,
              useWebsocket=False):
     super().__init__(host, rootCAPath, certPath, privateKeyPath, clientId,
                      port, useWebsocket)
     __shadow = AWSIoTMQTTShadowClient(self.clientId)
     __shadow.configureEndpoint(self.host,
                                self.port)  # Setting URL-ENDPOINT & Port
     __shadow.configureCredentials(
         self.rootCAPath, self.privateKeyPath,
         self.certificatePath)  # Cert file setting
     __shadow.configureConnectDisconnectTimeout(
         10)  # CONNACK wait time (sec)
     __shadow.configureMQTTOperationTimeout(5)  # QoS1 publish (sec)
     print('start connct shadow')
     __shadow.connect()
     print('shadow connect')
     self.shadowHandler = __shadow.createShadowHandlerWithName(
         deviceName, True)
     return
コード例 #3
0
def update_shadow(endpoint, thingName, kinesisStreamName, rootCAPath):

    port = 8883

    certificatePath = "./principals/" + thingName + ".cert.pem"
    privateKeyPath = "./principals/" + thingName + ".private.key"

    clientId = thingName

    myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId)
    myAWSIoTMQTTShadowClient.configureEndpoint(endpoint, port)
    myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)

    # AWSIoTMQTTShadowClient configuration
    myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    # Connect to AWS IoT
    myAWSIoTMQTTShadowClient.connect()

    # Create a deviceShadow with persistent subscription
    deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(thingName, True)

    # Delete shadow JSON doc
    deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)

    JSONPayload = '{"state":{"desired":{"property": "iot-analyzer"}}}'
    deviceShadowHandler.shadowUpdate(JSONPayload, customShadowCallback_Update, 5)

    JSONPayload = '{"state":{"reported":{"property": "iot-analyzer", "kinesis_stream": "' + kinesisStreamName + '"}}}'
    deviceShadowHandler.shadowUpdate(JSONPayload, customShadowCallback_Update, 5)
コード例 #4
0
class DeviceShadowClient(object):
    def __init__(self, deviceName):
        self.clientId = deviceName
        self.rootCAPath = "devices/config/root-CA.crt"
        self.privateKeyPath = "devices/config/" + deviceName + ".private.key"
        self.certificatePath = "devices/config/" + deviceName + ".cert.pem"
        self.host = "a3w259c8e2kscd-ats.iot.us-east-1.amazonaws.com"
        self.port = 8883

        self.shadowClient = AWSIoTMQTTShadowClient(self.clientId)
        self.shadowClient.configureEndpoint(self.host, self.port)
        self.shadowClient.configureCredentials(self.rootCAPath,
                                               self.privateKeyPath,
                                               self.certificatePath)

        self.shadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
        self.shadowClient.configureConnectDisconnectTimeout(10)
        self.shadowClient.configureMQTTOperationTimeout(5)

        self.shadowClient.connect()

        self.handler = self.shadowClient.createShadowHandlerWithName(
            self.clientId, True)

    def updateShadow(self, jsonPayload):
        self.handler.shadowUpdate(jsonPayload, onResponse, 5)

    def getShadow(self, callback):
        self.handler.shadowGet(callback, 5)
コード例 #5
0
ファイル: common.py プロジェクト: rveshovda/pifog
def setup_aws_shadow_client(host, rootCAPath, privateKeyPath, certificatePath, device_name):
    # 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 AWSIoTMQTTShadowClient
    shadow = AWSIoTMQTTShadowClient(device_name + "-client")
    shadow.configureEndpoint(host, 8883)
    shadow.configureCredentials(rootCAPath, privateKeyPath, certificatePath)

    # AWSIoTMQTTShadowClient configuration
    shadow.configureAutoReconnectBackoffTime(1, 32, 20)
    shadow.configureConnectDisconnectTimeout(10)  # 10 sec
    shadow.configureMQTTOperationTimeout(5)  # 5 sec

    #Last Will
    shadow.configureLastWill('my/things/' + device_name + '/update', '{"state":{"reported":{"connected":"false"}}}', 1)

    # Connect to AWS IoT
    shadow.connect()

    # Create a deviceShadow with persistent subscription
    client = shadow.createShadowHandlerWithName(device_name, True)

    return shadow, client
コード例 #6
0
def create_shadow_client(host, ca_file, private_file, cert_file, thing_name):
    client = AWSIoTMQTTShadowClient(thing_name)
    client.configureCredentials(ca_file, private_file, cert_file)
    client.configureEndpoint(host, 8883)
    client.configureConnectDisconnectTimeout(10)  # 10 sec
    client.configureMQTTOperationTimeout(5)  # 5 sec
    return client
コード例 #7
0
ファイル: habhubgate.py プロジェクト: gfrenzel/habitathub
def main():
    try:
        config = readConfigFile()

        awsShadowClient = AWSIoTMQTTShadowClient(clientId)
        awsShadowClient.configureEndpoint(host, 8883)
        awsShadowClient.configureCredentials(rootCAPath, privateKeyPath,
                                             certificatePath)

        awsShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
        awsShadowClient.configureConnectDisconnectTimeout(10)
        awsShadowClient.configureMQTTOperationTimeout(5)

        awsShadowClient.connect()
        deviceShadowHandler = awsShadowClient.createShadowHandlerWithName(
            thingName, True)
        deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)

        client.begin()
        if config is not None:
            sendConfigData(config, None)
        while True:
            config = loop(config, deviceShadowHandler)
    except (KeyboardInterrupt):
        print('Interrupt received')
    except (RuntimeError):
        print('Snap! Bye Bye')
    finally:
        cleanup(config)
コード例 #8
0
ファイル: main.py プロジェクト: Dacode45/hodoor
def main():
    setupPins()
    # For certificate based connection
    myShadowClient = AWSIoTMQTTShadowClient(os.environ['AWS_CLIENT_ID'])
    # For Websocket connection
    # myShadowClient = AWSIoTMQTTClient("myClientID", useWebsocket=True)
    # Configurations
    # For TLS mutual authentication
    myShadowClient.configureEndpoint(os.environ['AWS_ENDPOINT'], 8883)
    # For Websocket
    # myShadowClient.configureEndpoint("YOUR.ENDPOINT", 443)
    myShadowClient.configureCredentials(os.environ['AWS_ROOTCA'], os.environ['AWS_PRIVATE_KEY'], os.environ['AWS_CERTIFICATE'])
    # For Websocket, we only need to configure the root CA
    # myShadowClient.configureCredentials("YOUR/ROOT/CA/PATH")
    myShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    myShadowClient.connect()
    # Create a device shadow instance using persistent subscription
    Bot = myShadowClient.createShadowHandlerWithName("Bot", True)

    # Delete shadow JSON doc
    Bot.shadowDelete(customShadowCallback_Delete, 5)

    # PUT ALL your code for handling buttons and such in here.
    while True:
        input_state = GPIO.input(17)
        if input_state == True:
            print('Button Pressed')
            JSONPayload = '{"state":{"desired":{"property":"' + str(os.environ['WEBCAM_LINK']) + '"}}}'
            print JSONPayload
            Bot.shadowUpdate(JSONPayload, customShadowCallback_Update, 5)
       	    time.sleep(1)
	time.sleep(0.2)
コード例 #9
0
ファイル: AVM20.py プロジェクト: dhrone/pyASH
    def _iotConnect(self, endpoint, thingName, rootCAPath, certificatePath,
                    privateKeyPath, region):
        ''' Establish connection to the AWS IOT service '''
        # Init AWSIoTMQTTShadowClient
        myAWSIoTMQTTShadowClient = None
        myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient('pyASHdenTV')
        myAWSIoTMQTTShadowClient.configureEndpoint(endpoint, 8883)
        myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath,
                                                      privateKeyPath,
                                                      certificatePath)

        # AWSIoTMQTTShadowClient configuration
        myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
        myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(
            10)  # 10 sec
        myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

        # Connect to AWS IoT
        myAWSIoTMQTTShadowClient.connect()

        # Create a deviceShadow with persistent subscription
        deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(
            thingName, True)

        # Delete shadow JSON doc
        deviceShadowHandler.shadowDelete(self._deleteCallback, 5)

        # Listen on deltas
        deviceShadowHandler.shadowRegisterDeltaCallback(self._deltaCallback)

        return deviceShadowHandler
コード例 #10
0
ファイル: iot-bed.py プロジェクト: igeeks/iot-bed
def main():

    endpoint = os.environ.get("IOT_ENDPOINT", None)
    thing_name = os.environ.get("THING_NAME", None)
    ble_address = os.environ.get("BLE_ADDRESS", None)
    pretend = os.environ.get("BLE_PRETEND", "false").lower() == "true"

    if endpoint is None:
        raise Exception("IOT_ENDPOINT env not set")
    if thing_name is None:
        raise Exception("THING_NAME env not set")
    if ble_address is None:
        raise Exception("BLE_ADDRESS env not set")

    ble = sertaBLEController(ble_address, pretend)

    client = AWSIoTMQTTShadowClient(thing_name)
    client.configureEndpoint(endpoint, 8883)
    client.configureCredentials("root-CA.crt", "device-key.pem", "device.pem")

    client.configureAutoReconnectBackoffTime(1, 32, 20)
    client.configureConnectDisconnectTimeout(10)  # 10 sec
    client.configureMQTTOperationTimeout(5)  # 5 sec

    client.connect()

    shadow = client.createShadowHandlerWithName(thing_name, True)
    shadowCallbackContainer_IoTBed = shadowCallbackContainer(shadow, ble)
    shadow.shadowRegisterDeltaCallback(
        shadowCallbackContainer_IoTBed.customShadowCallback_Delta)

    # Loop forever
    while True:
        time.sleep(0.1)
コード例 #11
0
ファイル: metering.py プロジェクト: npahucki/water-monitor
    def __create_shadow_client(self):
        max_offline_queue_size = int(
            (60 / self.__update_interval_secs) * 24 * 10)  # 10 Days worth
        client = AWSIoTMQTTShadowClient(self.__client_id)
        client.configureEndpoint(AWS_IOT_ENDPOINT, 8883)
        client.configureCredentials(
            CAFilePath="certs/AmazonRootCA1.pem",
            KeyPath="certs/device/private.pem.key",
            CertificatePath="certs/device/certificate.pem.crt")
        client.configureConnectDisconnectTimeout(30)
        client.configureMQTTOperationTimeout(30)
        client.configureAutoReconnectBackoffTime(1, 128, 20)

        # Shared connection with shadow
        mqtt_client = client.getMQTTConnection()
        mqtt_client.configureOfflinePublishQueueing(
            max_offline_queue_size, AWSIoTPythonSDK.MQTTLib.DROP_OLDEST)
        mqtt_client.configureDrainingFrequency(2)  # Draining: 2 Hz

        logger.debug('Connecting to IOT Cloud MQTT Server....')
        client.connect()
        self.__shadow_client = client
        self.__mqtt_client = mqtt_client

        for reader in self.__readers:
            shadow = self.__shadow_client.createShadowHandlerWithName(
                reader.name, True)
            shadow.shadowGet(self.__shadow_cb, 60)
            shadow.shadowRegisterDeltaCallback(self.__shadow_cb)
            self.__shadows[reader.name] = shadow

        logger.info('Connected to IOT Cloud, shadows created')
        return client
コード例 #12
0
def init_device_shadow_handler(args):
    host = args.get("host")
    rootCAPath = args.get("rootCAPath")
    certificatePath = args.get("certificatePath")
    privateKeyPath = args.get("privateKeyPath")
    port = args.get("port")
    useWebsocket = args.get("useWebsocket")
    thingName = args.get("thingName")
    clientId = args.get("clientId")

    if not clientId:  # Use thingName as clientId if not provided separately
        clientId = thingName

    if useWebsocket and certificatePath and privateKeyPath:
        print(
            "X.509 cert authentication and WebSocket are mutual exclusive. Please pick one."
        )
        exit(2)

    if not useWebsocket and (not certificatePath or not privateKeyPath):
        print("Missing credentials for authentication.")
        exit(2)

    # Port defaults
    if useWebsocket and not port:  # When no port override for WebSocket, default to 443
        port = 443
    if not useWebsocket and not port:  # When no port override for non-WebSocket, default to 8883
        port = 8883

    # Init AWSIoTMQTTShadowClient
    myAWSIoTMQTTShadowClient = None
    if useWebsocket:
        myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId,
                                                          useWebsocket=True)
        myAWSIoTMQTTShadowClient.configureEndpoint(host, port)
        myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath)
    else:
        myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId)
        myAWSIoTMQTTShadowClient.configureEndpoint(host, port)
        myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath,
                                                      privateKeyPath,
                                                      certificatePath)

    # AWSIoTMQTTShadowClient configuration
    myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    # Connect to AWS IoT
    myAWSIoTMQTTShadowClient.connect()

    # Create a deviceShadow with persistent subscription
    deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(
        thingName, True)

    # Delete existing shadow JSON doc
    deviceShadowHandler.shadowDelete(shadow_delete_callback, 5)

    return deviceShadowHandler
コード例 #13
0
ファイル: awsiot.py プロジェクト: mjoldfield/yauiotl
class shadowClient:
    def __init__(self, certDir, logLevel=logging.WARNING, clientID=None):

        if clientID == None:
            clientID = platform.node() + '.' + str(os.getpid())

        self.clientID = clientID

        self.client = AWSIoTMQTTShadowClient(clientID)

        self.configureLogging(logLevel)

        self.configureConnection(certDir)

    def configureConnection(self, certDir):

        configPath = uniqglob(certDir + '*config.json')
        with open(configPath) as json_data:
            endpoint = json.load(json_data)

            port = 8883

            if 'host' in endpoint:
                host = endpoint['host']
            else:
                sys.exit("host not defined in %s" % (configPath))

            if 'port' in endpoint:
                port = int(endpoint['port'])

            self.client.configureEndpoint(host, port)

        rootCAPath = uniqglob(certDir + '*rootCA*')
        prvKeyPath = uniqglob(certDir + '*.private.key*')
        certPath = uniqglob(certDir + '*.cert.*')

        self.client.configureCredentials(rootCAPath, prvKeyPath, certPath)

        self.client.configureAutoReconnectBackoffTime(1, 32, 20)
        self.client.configureConnectDisconnectTimeout(10)  # 10 sec
        self.client.configureMQTTOperationTimeout(5)  # 5 sec

    def configureLogging(self, logLevel):
        logger = logging.getLogger('AWSIoTPythonSDK.core')
        logger.setLevel(logLevel)

        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

        streamHandler = logging.StreamHandler()
        streamHandler.setFormatter(formatter)
        logger.addHandler(streamHandler)

    def connect(self):
        return self.client.connect()

    def createShadow(self, name):
        isPersistent = True  # for better performance (?!)
        return self.client.createShadowHandlerWithName(name, isPersistent)
コード例 #14
0
 def configureMQTTClient(self):
     mqttClient = AWSIoTMQTTShadowClient(self.thingName)
     mqttClient.configureEndpoint(self.host, self.port)
     mqttClient.configureCredentials(self.rootCAPath, self.privateKeyPath, self.certificatePath)
     mqttClient.configureAutoReconnectBackoffTime(1, 32, 20)
     mqttClient.configureConnectDisconnectTimeout(10)
     mqttClient.configureMQTTOperationTimeout(5)
     return mqttClient
コード例 #15
0
ファイル: AWShome.py プロジェクト: masomel/py-iot-apps
def createIoT():
    iot = AWSIoTMQTTShadowClient('AWSHome', useWebsocket=True)
    iot.configureEndpoint('a236biar7596mr.iot.us-east-1.amazonaws.com', 443)
    iot.configureCredentials(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'root-CA.pem'))
    iot.configureConnectDisconnectTimeout(10)  # 10 sec
    iot.configureMQTTOperationTimeout(5)  # 5 sec
    iot.connect()
    return iot
コード例 #16
0
def createIoT():
    iot = AWSIoTMQTTShadowClient('RaspberryPi',
                                 useWebsocket=True)  # I think the first arg is the name of the IoT thing in aws
    iot.configureEndpoint('a3lujo7s13ykr5.iot.us-east-1.amazonaws.com', 443)  # REST endpoint
    iot.configureCredentials(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'root-CA.pem'))  # CA certificate
    iot.configureConnectDisconnectTimeout(10)  # 10 sec
    iot.configureMQTTOperationTimeout(5)  # 5 sec
    iot.connect()
    return iot
コード例 #17
0
def create_iot():
    iot = AWSIoTMQTTShadowClient(clientId, useWebsocket=True)
    iot.configureEndpoint(host, port)
    iot.configureCredentials(rootCAPath)
    iot.configureAutoReconnectBackoffTime(1, 32, 20)
    iot.configureConnectDisconnectTimeout(10)
    iot.configureMQTTOperationTimeout(5)
    iot.connect()
    return iot
コード例 #18
0
def lambda_handler(event, context):
    global myAWSIoTMQTTShadowClient, myDeviceShadow
    """ Route the incoming request based on type (LaunchRequest, IntentRequest,
    etc.) The JSON body of the request is provided in the event parameter.
    """
    #print ('RECEIVED EVENT: ' + json.dumps(event, separators=(',', ':')))
    if 'session' in event:
        print("event.session.application.applicationId=" +
              event['session']['application']['applicationId'])
        """
        Uncomment this if statement and populate with your skill's application ID to
        prevent someone else from configuring a skill that sends requests to this
        function.
        """
        # if (event['session']['application']['applicationId'] !=
        #     "amzn1.ask.skill.b2d37e60-ecae-4beb-aed0-adf69fe456a4"):
        #     raise ValueError("Invalid Application ID")
        if event['session']['new'] and 'requestId' in event['request']:
            on_session_started({'requestId': event['request']['requestId']},
                               event['session'])
        if 'request' in event:
            # Init AWSIoTMQTTClient
            myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(
                shadowName + "_Lambda_" + event['request']['requestId'][-12:])
            myAWSIoTMQTTShadowClient.configureEndpoint(host, 8883)
            myAWSIoTMQTTShadowClient.configureCredentials(
                rootCAPath, privateKeyPath, certificatePath)

            # AWSIoTMQTTClient connection configuration
            myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(
                1, 32, 20)
            myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(
                10)  # 10 sec
            myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec
            # Connect to AWS IoT Shadow
            myAWSIoTMQTTShadowClient.connect()
            myDeviceShadow = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(
                shadowName, True)
            myDeviceShadow.shadowGet(IoTShadowCallback_Get, 5)
            # JSONPayload = '{ "state" : {'+\
            # '"desired": {'+\
            # '"LivingRoomLight":"", '+\
            # '"BedRoomLight": "", '+\
            # '"KitchenLight": "" '+\
            # '} '+\
            # '} '+\
            # '}'
            # myDeviceShadow.shadowUpdate(JSONPayload, IoTShadowCallback_Update, 5)
            while GetStatus == "":
                ready = ""
            if event['request']['type'] == "LaunchRequest":
                return on_launch(event['request'], event['session'])
            elif event['request']['type'] == "IntentRequest":
                return on_intent(event['request'], event['session'])
            elif event['request']['type'] == "SessionEndedRequest":
                return on_session_ended(event['request'], event['session'])
コード例 #19
0
def shadow_connect():
	global myShadowClient
	myShadowClient = AWSIoTMQTTShadowClient(thingName)
	myShadowClient.configureEndpoint(host, 8883)
	myShadowClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
	myShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
	myShadowClient.configureConnectDisconnectTimeout(10)
	myShadowClient.configureMQTTOperationTimeout(5)

	myShadowClient.connect()
コード例 #20
0
ファイル: thingload.py プロジェクト: ac-schmitt/thingload
def createIoTShadowClient(endpoint, thingname, keyPath, certPath, rootCaPath):
    # For certificate based connection
    myShadowClient = AWSIoTMQTTShadowClient(thingname)
    # Configurations
    # For TLS mutual authentication
    myShadowClient.configureEndpoint(endpoint, config.aws_iot_port())
    myShadowClient.configureCredentials(rootCaPath, keyPath, certPath)
    myShadowClient.configureConnectDisconnectTimeout(10)
    myShadowClient.configureMQTTOperationTimeout(5)
    return myShadowClient
コード例 #21
0
def shadow_connect(): #連接shadow
	global myShadowClient
	# read GGC Host Address from file
	myShadowClient = AWSIoTMQTTShadowClient(clientId2)
	myShadowClient.configureEndpoint(host, 8883)
	myShadowClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
	myShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
	myShadowClient.configureConnectDisconnectTimeout(10)
	myShadowClient.configureMQTTOperationTimeout(5)

	myShadowClient.connect()
コード例 #22
0
def connectTurbineIoTAttempt(ep, port, rootca, key, cert, timeoutSec,
                             retryLimit):
    global awsIoTMQTTClient, awsShadowClient, turbineDeviceShadow

    awsShadowClient = AWSIoTMQTTShadowClient(cfgThingName)
    awsShadowClient.configureEndpoint(ep, int(port))
    awsShadowClient.configureCredentials(rootca, key, cert)
    awsIoTMQTTClient = awsShadowClient.getMQTTConnection()

    # AWSIoTMQTTClient connection configuration
    awsIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
    awsIoTMQTTClient.configureOfflinePublishQueueing(
        -1)  # Infinite offline Publish queueing
    awsIoTMQTTClient.configureDrainingFrequency(2)  # Draining: 2 Hz
    awsIoTMQTTClient.configureConnectDisconnectTimeout(timeoutSec)  #seconds
    awsIoTMQTTClient.configureMQTTOperationTimeout(timeoutSec)  #seconds
    awsIoTMQTTClient.configureConnectDisconnectTimeout(timeoutSec)
    awsIoTMQTTClient.configureMQTTOperationTimeout(timeoutSec)
    awsIoTMQTTClient.onOnline = awsIoTClientOnConnectCallback
    awsIoTMQTTClient.onOffline = awsIoTClientOnDisconnectCallback

    # Attempt to connect
    for attempt in range(0, retryLimit):
        try:
            awsIoTMQTTClient.connect()
        except Exception as e:
            print(str(e))
            continue
        break

    # Shadow config
    awsShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    awsShadowClient.configureConnectDisconnectTimeout(timeoutSec)
    awsShadowClient.configureMQTTOperationTimeout(timeoutSec)

    for attempt in range(0, retryLimit):
        try:
            if awsShadowClient.connect():
                print("AWS IoT shadow topic subscribed")
        except Exception as e:
            print(str(e))
            continue
        break

    turbineDeviceShadow = awsShadowClient.createShadowHandlerWithName(
        cfgThingName, True)
    turbineDeviceShadow.shadowRegisterDeltaCallback(shadowCallbackDelta)

    # Subscribe to the command topics
    cmdTopic = str("cmd/windfarm/turbine/" + cfgThingName + "/#")
    awsIoTMQTTClient.subscribe(cmdTopic, 1, customCallbackCmd)
    print("AWS IoT Command Topic Subscribed: " + cmdTopic)

    return True
コード例 #23
0
	def connection_AWS_IOT(self):
		shadow_host = "a1wxijaxbxg469.iot.ap-northeast-2.amazonaws.com"
		myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(pfc_conf.PFC_AWS_IOT_CLIENT_ID)
		myAWSIoTMQTTShadowClient.configureEndpoint(shadow_host, 8883)
		myAWSIoTMQTTShadowClient.configureCredentials(pfc_conf.CA_PATH, pfc_conf.PRIVATE_KEY_PATH, pfc_conf.CERTIFICATE_PATH)
		myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(30)
		myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(30)
		myAWSIoTMQTTShadowClient.connect()
		mc = myAWSIoTMQTTShadowClient.getMQTTConnection()
		mc.configureOfflinePublishQueueing(-1)
		self.IOT_SHADOW_CLIENT = myAWSIoTMQTTShadowClient
		self.PFC_SHADOW = myAWSIoTMQTTShadowClient.createShadowHandlerWithName("PFC_v_0001", True)
コード例 #24
0
def start():
    print("Connecting IoT, endpoint:" + str(config.iot_endpoint))
    logging.info("----- START OF THE IoT LOG -----")
    try:
        dir = os.path.dirname(os.path.realpath(__file__))

        rootCAPath = dir + "/root-CA.crt"
        certificatePath = dir + "/" + config.name +".cert.pem"
        privateKeyPath = dir + "/" + config.name + ".private.key"

        streamHandler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        streamHandler.setFormatter(formatter)

        global myAWSIoTMQTTClient
        myAWSIoTMQTTClient = AWSIoTMQTTShadowClient(config.name)
        myAWSIoTMQTTClient.configureEndpoint(config.iot_endpoint, 8883)
        myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
        
        # AWSIoTMQTTClient connection configuration
        myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
        myAWSIoTMQTTClient.configureConnectDisconnectTimeout(30)  # 30 sec
        myAWSIoTMQTTClient.configureMQTTOperationTimeout(10)  # 5 sec
        

        # Connect and subscribe to AWS IoT
        myAWSIoTMQTTClient.connect(10)
        
        print("Creating shadows")
        global deviceShadowHandler

        deviceShadowHandler = myAWSIoTMQTTClient.createShadowHandlerWithName(config.name, True)
        
        global Connection
        Connection = myAWSIoTMQTTClient.getMQTTConnection()
        Connection.configureAutoReconnectBackoffTime(1, 32, 20)
        Connection.configureDrainingFrequency(2)  # Draining: 2 Hz
        Connection.configureConnectDisconnectTimeout(30)  # 30 sec
        Connection.configureMQTTOperationTimeout(10)  # 10 sec
          
        Connection.subscribe("global", 1, customCallback)
        
        
        SendMSG('{"to": "server", "client-id": "1", "info": "start-up"}')
        
        control.update_status()
        
    except Exception as e:
        logging.exception("Error IoT: " + str(e))
        print("Error IoT: ", e)
        import traceback
        traceback.print_exc()
コード例 #25
0
def shadowUpdate(body):
    # Create, configure, and connect a shadow client.
    myShadowClient = AWSIoTMQTTShadowClient(SHADOW_CLIENT)
    myShadowClient.configureEndpoint(HOST_NAME, 8883)
    myShadowClient.configureCredentials(ROOT_CA, PRIVATE_KEY, CERT_FILE)
    myShadowClient.configureConnectDisconnectTimeout(10)
    myShadowClient.configureMQTTOperationTimeout(5)
    myShadowClient.connect()

    # Create a programmatic representation of the shadow.
    myDeviceShadow = myShadowClient.createShadowHandlerWithName(
        SHADOW_HANDLER, True)

    myDeviceShadow.shadowUpdate(body, myShadowUpdateCallback, 5)
コード例 #26
0
def ConnectAWS():
    myAWSIoTMQTTShadowClient = None
    myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient("RaspberryPi")
    myAWSIoTMQTTShadowClient.configureEndpoint(host, 443)
    myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath, privateKeyPath,
                                                  certificatePath)
    myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec
    myAWSIoTMQTTShadowClient.connect()
    deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(
        thingName, True)

    return deviceShadowHandler
コード例 #27
0
def getClient(host, rootCAPath, privateKeyPath, certificatePath, clientId):
    # Init AWSIoTMQTTShadowClient
    myAWSIoTMQTTShadowClient = None
    myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId)
    myAWSIoTMQTTShadowClient.configureEndpoint(host, 8883)
    myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath, privateKeyPath,
                                                  certificatePath)

    # AWSIoTMQTTShadowClient configuration
    myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    return myAWSIoTMQTTShadowClient
コード例 #28
0
class IoTCommunicator(object):
    def __init__(self, device):
        self.mqttc = AWSIoTMQTTShadowClient(thingName)
        self.mqttc.configureEndpoint(
            'a2soq6ydozn6i0-ats.iot.us-west-2.amazonaws.com', 8883)
        self.mqttc.configureCredentials(
            './certificates/AmazonRootCA1.pem',
            './certificates/' + thingName + '.private.key',
            './certificates/' + thingName + '.cert.pem')
        self.mqttc.configureConnectDisconnectTimeout(10)
        self.mqttc.configureMQTTOperationTimeout(5)
        self.device_shadow = self.mqttc.createShadowHandlerWithName(
            thingName, True)
        self.device_shadow = self.mqttc.createShadowHandlerWithName(
            thingName, True)
        self.device_shadow.on_message = self.on_message
        self.device_shadow.json_encode = self.json_encode
        self.device = device

    def json_encode(self, string):
        return json.dumps(string)

    def on_message(self, message, response, token):
        print(message)

    def on_delta(self, message, response, token):
        print("delta %s" % message)
        loaded_message = json.loads(message)
        new_state = loaded_message["state"]["state"]
        self.device.set_light(new_state)
        self.send_shadow_update()

    def start_communication(self):
        print("About to connect")
        self.mqttc.connect()
        print('Connected')
        self.device_shadow.shadowRegisterDeltaCallback(self.on_delta)

        loop_count = 0
        while True:
            self.send_shadow_update()
            loop_count += 1
            time.sleep(5)

    def send_shadow_update(self):
        message = {"state": {"reported": {"state": self.device.light_state}}}
        message_json = json.dumps(message)
        self.device_shadow.shadowUpdate(message_json, self.on_message, 5)
        print('Shadow Update Sent')
        print('Published state %s\n' % message_json)
コード例 #29
0
def makeAWSConnections():
	global myAWSIoTMQTTClient, myAWSIoTMQTTShadowClient, deviceShadowHandler, myAWSIoTMQTTClientVibration, \
		myAWSIoTMQTTShadowClientVibration, myAWSIoTMQTTClientLoad, myAWSIoTMQTTShadowClientLoad, \
		myAWSIoTMQTTClientTemp, myAWSIoTMQTTShadowClientTemp, myOnOfflineCallback, myOnOnlineCallback, batteryStatus
	
	myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId, useWebsocket=True)
	myAWSIoTMQTTShadowClient.configureEndpoint(host, 443)
	myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath)
	# AWSIoTMQTTShadowClient configuration
	myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
	myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
	myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec
	myAWSIoTMQTTShadowClient.onOffline = myOnOfflineCallback
	myAWSIoTMQTTShadowClient.onOnline = myOnOnlineCallback
	# Connect and subscribe to AWS IoT
	myAWSIoTMQTTShadowClient.connect(60)
	myAWSIoTMQTTClient = myAWSIoTMQTTShadowClient.getMQTTConnection()
	
	
	myAWSIoTMQTTShadowClientVibration = AWSIoTMQTTShadowClient(clientId + "Vibration", useWebsocket=True)
	myAWSIoTMQTTShadowClientVibration.configureEndpoint(host, 443)
	myAWSIoTMQTTShadowClientVibration.configureCredentials(rootCAPath)
	# AWSIoTMQTTShadowClient configuration
	myAWSIoTMQTTShadowClientVibration.configureAutoReconnectBackoffTime(1, 32, 20)
	myAWSIoTMQTTShadowClientVibration.configureConnectDisconnectTimeout(10)  # 10 sec
	myAWSIoTMQTTShadowClientVibration.configureMQTTOperationTimeout(5)  # 5 sec
	# Connect and subscribe to AWS IoT
	myAWSIoTMQTTShadowClientVibration.connect(60)
	myAWSIoTMQTTClientVibration = myAWSIoTMQTTShadowClientVibration.getMQTTConnection()
	
	
	myAWSIoTMQTTShadowClientLoad = AWSIoTMQTTShadowClient(clientId + "Load", useWebsocket=True)
	myAWSIoTMQTTShadowClientLoad.configureEndpoint(host, 443)
	myAWSIoTMQTTShadowClientLoad.configureCredentials(rootCAPath)
	# AWSIoTMQTTShadowClient configuration
	myAWSIoTMQTTShadowClientLoad.configureAutoReconnectBackoffTime(1, 32, 20)
	myAWSIoTMQTTShadowClientLoad.configureConnectDisconnectTimeout(10)  # 10 sec
	myAWSIoTMQTTShadowClientLoad.configureMQTTOperationTimeout(5)  # 5 sec
	# Connect and subscribe to AWS IoT
	myAWSIoTMQTTShadowClientLoad.connect(60)
	myAWSIoTMQTTClientLoad = myAWSIoTMQTTShadowClientLoad.getMQTTConnection()
	
	
	myAWSIoTMQTTShadowClientTemp = AWSIoTMQTTShadowClient(clientId + "Temp", useWebsocket=True)
	myAWSIoTMQTTShadowClientTemp.configureEndpoint(host, 443)
	myAWSIoTMQTTShadowClientTemp.configureCredentials(rootCAPath)
	
	# AWSIoTMQTTShadowClient configuration
	myAWSIoTMQTTShadowClientTemp.configureAutoReconnectBackoffTime(1, 32, 20)
	myAWSIoTMQTTShadowClientTemp.configureConnectDisconnectTimeout(10)  # 10 sec
	myAWSIoTMQTTShadowClientTemp.configureMQTTOperationTimeout(5)  # 5 sec
	# Connect and subscribe to AWS IoT
	myAWSIoTMQTTShadowClientTemp.connect(60)
	myAWSIoTMQTTClientTemp = myAWSIoTMQTTShadowClientTemp.getMQTTConnection()
	
	# Create a deviceShadow with persistent subscription
	deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName("aircraftEngine", True)
	deviceShadowHandler.shadowUpdate(json.dumps(shadowObject), customShadowCallback_Update, 5) # 5 sec
	deviceShadowHandler.shadowRegisterDeltaCallback(customShadowCallback_Delta) # Updates motor thrust
コード例 #30
0
def switch(onoff):
    host = "a2gwyx8959iy18.ats.iot.cn-north-1.amazonaws.com.cn"
    thingName = "kmplc01"
    rootCAPath = "cert/root-CA.crt"
    certificatePath = "cert/certificate.pem.crt"
    privateKeyPath = "cert/private.pem.key"
    clientId = "randomID1" + str(random.randint(10000, 99999))
    port = 443
    useWebsocket = True

    # 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 AWSIoTMQTTShadowClient
    myAWSIoTMQTTShadowClient = None
    if useWebsocket:
        myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId,
                                                          useWebsocket=True)
        myAWSIoTMQTTShadowClient.configureEndpoint(host, port)
        myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath)
    else:
        myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId)
        myAWSIoTMQTTShadowClient.configureEndpoint(host, port)
        myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath,
                                                      privateKeyPath,
                                                      certificatePath)

    # AWSIoTMQTTShadowClient configuration
    myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
    myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
    myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

    # Connect to AWS IoT
    myAWSIoTMQTTShadowClient.connect()

    deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(
        thingName, True)

    # Update shadow in a loop
    JSONPayload = '{"state":{"desired":{"status":' + "\"" + onoff + "\"" + '}}}'
    print(JSONPayload)
    deviceShadowHandler.shadowUpdate(JSONPayload, customShadowCallback_Update,
                                     5)
コード例 #31
0
 def createMqttClients(self, iotConfig):
     mqShadowClient = AWSIoTMQTTShadowClient(iotConfig['thingName'])
     mqShadowClient.configureEndpoint(iotConfig["iotHost"],
                                      iotConfig["iotPort"])
     mqShadowClient.configureCredentials(iotConfig["rootCert"],
                                         iotConfig["thingPrivateKey"],
                                         iotConfig["thingCert"])
     mqShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
     mqShadowClient.configureConnectDisconnectTimeout(10)
     mqShadowClient.configureMQTTOperationTimeout(10)
     mqShadowClient.connect()
     mqClient = mqShadowClient.getMQTTConnection()
     self._logger.info("mqtt client connected to iot host {}".format(
         iotConfig["iotHost"]))
     return (mqShadowClient, mqClient)
コード例 #32
0
ファイル: iot-aws-test.py プロジェクト: nedbert/home-projects
import json

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient

#for cert based connection
myShadowClient = AWSIoTMQTTShadowClient("raspberry-pi")

myShadowClient.configureEndpoint("a1xugslbalqdxo.iot.us-east-1.amazonaws.com", 8883)

myShadowClient.configureCredentials("/home/pi/python_mqtt/aws-iot-certs/rootCA.pem.crt",
                                    "/home/pi/python_mqtt/aws-iot-certs/c6417d9f55-private.pem.key",
                                    "/home/pi/python_mqtt/aws-iot-certs/c6417d9f55-certificate.pem.crt")

#myShadowClient.configureConnectionDisconnectTimeout(10)
myShadowClient.configureMQTTOperationTimeout(5)

myShadowClient.connect()
myDeviceShadow = myShadowClient.createShadowHandlerWithName("Bot", True)

payload = json.dumps({
    "state":{
        "reported": {
            "this_thing_is_alive": "I am Raspberry"
            }
        }
    })

#myDeviceShadow.shadowGet(customCallback, 5)
#myDeviceShadow.shadowUpdate(payload, shadowUpdate, 5)
myMQTTClient = myShadowClient.getMQTTConnection()
コード例 #33
0
class ThermoSimAppGUI:

    _usage = """Usage:

    Make sure that you put all your credentials under: ./certs/
    with the following naming conventions:
    Root CA file: *CA.crt
    Certificate file (not required if using MQTT over WebSocket): *.pem.crt
    Private key file (not required if using MQTT over WebSocket): *.pem.key

    Use X.509 certificate based mutual authentication:
    python ThermostatSimulatorApp -e <endpoint>

    Use MQTT over WebSocket:
    python ThermostatSimulatorApp -e <endpoint> -w

    Type "python ThermostatSimulatorApp -h" for detailed command line options.


    """

    _helpInfo = """Available command line options:
    -e, --endpoint: Your custom AWS IoT custom endpoint
    -w, --websocket: Use MQTT over websocket
    -h, --help: Help infomation


    """

    def __init__(self):
        # Init data members
        # Connection related
        self._endpoint = ""
        self._rootCAFilePathList = ""
        self._certificateFilePathList = ""
        self._privateKeyFilePathList = ""
        self._useWebsocket = False
        self._AWSIoTMQTTShadowClient = None
        self._thermostatSimulatorShadowHandler = None
        # GUI related
        self._tkRootHandler = tkinter.Tk()
        self._reportedDataVariable = None
        self._reportedDataDisplayBox = None
        self._desiredDataVariable = None
        self._desiredDataDisplayBox = None
        self._setTemperatureInputBox = None
        self._setTemperatureButton = None
        # Check command line inputs
        if not self._checkInputs():
            raise ValueError("Malformed/Missing command line inputs.")
        # Create and configure AWSIoTMQTTShadowClient
        self._AWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient("ThermostatSimulatorApp", useWebsocket=self._useWebsocket)
        if self._useWebsocket:
            self._AWSIoTMQTTShadowClient.configureEndpoint(self._endpoint, 443)
            self._AWSIoTMQTTShadowClient.configureCredentials(self._rootCAFilePathList[0])
        else:
            self._AWSIoTMQTTShadowClient.configureEndpoint(self._endpoint, 8883)
            self._AWSIoTMQTTShadowClient.configureCredentials(self._rootCAFilePathList[0], self._privateKeyFilePathList[0], self._certificateFilePathList[0])
        self._AWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 128, 20)
        self._AWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)
        self._AWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)
        # Set keepAlive interval to be 1 second and connect
        # Raise exception if there is an error in connecting to AWS IoT
        self._AWSIoTMQTTShadowClient.connect(5)
        self._thermostatSimulatorShadowHandler = self._AWSIoTMQTTShadowClient.createShadowHandlerWithName("room", True)
        # Generate GUI
        self._packModule()

    # Validate command line inputs
    # Return False there is any malformed inputs
    # Return True if all the necessary inputs have been discovered
    def _checkInputs(self):
        gotEoughInputs = True
        # Check command line inputs
        try:
            opts, args = getopt.getopt(sys.argv[1:], "hwe:", ["endpoint=", "websocket", "help"])
            if len(opts) == 0:
                raise getopt.GetoptError("No input parameters")
            for opt, arg in opts:
                if opt in ("-e", "--endpoint"):
                    self._endpoint = arg
                if opt in ("-w", "--websocket"):
                    self._useWebsocket = True
                if opt in ("-h", "--help"):
                    print(self._helpInfo)
                    gotEoughInputs = False
        except getopt.GetoptError:
            print(self._usage)
            gotEoughInputs = False
        # Check credential files
        if gotEoughInputs:
            self._rootCAFilePathList = glob.glob("./certs/*CA.crt")
            if self._useWebsocket:
                gotEoughInputs = gotEoughInputs and len(self._rootCAFilePathList) != 0
                if not gotEoughInputs:
                    print("Missing rootCA in ./certs/")
            else:
                self._certificateFilePathList = glob.glob("./certs/*.pem.crt")
                self._privateKeyFilePathList = glob.glob("./certs/*.pem.key")
                gotEoughInputs = gotEoughInputs and len(self._rootCAFilePathList) != 0 and len(self._certificateFilePathList) != 0 and len(self._privateKeyFilePathList) != 0
                if not gotEoughInputs:
                    print("Missing rootCA, certificate or private key in ./certs/")
        return gotEoughInputs

    def _packModule(self):
        self._tkRootHandler.title("ThermostatSimulatorApp")
        self._tkRootHandler.geometry("500x250")
        self._tkRootHandler.resizable(width=False, height=False)
        # Pack all frames
        baseFrame = tkinter.Frame(self._tkRootHandler)
        temperatureFrame = tkinter.Frame(baseFrame)
        temperatureFrame.pack(side="top")
        controlPanelFrame = tkinter.Frame(baseFrame)
        controlPanelFrame.pack(side="bottom")
        baseFrame.pack()
        # Pack all modules for temperature frame
        self._reportedDataVariable = tkinter.StringVar()
        self._reportedDataVariable.set("XX.X F")
        reportedDataTag = tkinter.Label(temperatureFrame, text="Reported Temperature:", justify="left")
        self._reportedDataDisplayBox = tkinter.Label(temperatureFrame, textvariable=self._reportedDataVariable, font=("Arial", 55), justify="left")
        #
        self._desiredDataVariable = tkinter.StringVar()
        self._desiredDataVariable.set("XX.X F")
        desiredDataTag = tkinter.Label(temperatureFrame, text="Desired Temperature:", justify="left")
        self._desiredDataDisplayBox = tkinter.Label(temperatureFrame, textvariable=self._desiredDataVariable, font=("Arial", 55), justify="left")
        #
        reportedDataTag.pack()
        self._reportedDataDisplayBox.pack()
        desiredDataTag.pack()
        self._desiredDataDisplayBox.pack()
        # Create a callback pool
        self._callbackPoolHandler = ThermoSimAppCallbackPool(self._tkRootHandler, self._reportedDataDisplayBox, self._thermostatSimulatorShadowHandler, self._reportedDataVariable, self._desiredDataVariable)
        # Pack all modules for control panel frame
        self._setTemperatureInputBox = tkinter.Entry(controlPanelFrame)
        self._setTemperatureInputBox.pack(sid="left")
        self._setTemperatureButton = tkinter.Button(controlPanelFrame, text="SET", command=lambda: self._callbackPoolHandler.buttonCallback(self._setTemperatureInputBox, self._desiredDataVariable))
        self._setTemperatureButton.pack()

    def runApp(self):
        # Start and run the app
        self._tkRootHandler.after(500, self._callbackPoolHandler.sendShadowGetForReportedTemperature)  # per 500ms
        self._tkRootHandler.after(500, self._callbackPoolHandler.updateReportedTemperatureDataVariable)  # per 500ms
        self._tkRootHandler.mainloop()
コード例 #34
0
ファイル: AWSIOT_Client.py プロジェクト: mpidgeon/Trial
aws_secret_access_key= open('keys.txt').readlines()[1].split(None, 1)[0])

s3.download_file('littercam','device-'+str(mac)+'/devicename.txt', 'devicename.txt')
devicename = open('devicename.txt').readline().split(None, 1)[0]


print(devicename)

ShadowClient = AWSIoTMQTTShadowClient("")

ShadowClient.configureEndpoint("a1oa9tg9lcso0.iot.eu-west-1.amazonaws.com", 8883)
ShadowClient.configureCredentials(get_rootca(),
get_private(),get_cert())
ShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
ShadowClient.configureConnectDisconnectTimeout(30)  # 10 sec
ShadowClient.configureMQTTOperationTimeout(10)  # 5 sec
ShadowClient.connect()
deviceShadowHandler = ShadowClient.createShadowHandlerWithName(devicename, True)
#shadowCallbackContainer_Bot = shadowCallbackContainer(deviceShadowHandler)
#deviceShadowHandler.shadowRegisterDeltaCallback(shadowCallbackContainer_Bot.customShadowCallback_Delta)




# MQTT Connection establishement
myMQTTClient = AWSIoTMQTTClient(devicename)
myMQTTClient.configureEndpoint("a1oa9tg9lcso0.iot.eu-west-1.amazonaws.com", 8883)
myMQTTClient.configureCredentials(get_rootca(),
get_private(),get_cert())

コード例 #35
0
logger.addHandler(streamHandler)

# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
if useWebsocket:
	myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId, useWebsocket=True)
	myAWSIoTMQTTShadowClient.configureEndpoint(host, 443)
	myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath)
else:
	myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(clientId)
	myAWSIoTMQTTShadowClient.configureEndpoint(host, 8883)
	myAWSIoTMQTTShadowClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)

# AWSIoTMQTTShadowClient configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10)  # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5)  # 5 sec

# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()

# Create a deviceShadow with persistent subscription
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(thingName, True)

# Listen on deltas
deviceShadowHandler.shadowRegisterDeltaCallback(customShadowCallback_Delta)

# Loop forever
while True:
	time.sleep(1)