使用 AWS Lambda 和 AWS Greengrass 在边缘站点进行协议转换

sudo apt-get update
sudo apt-get install python-dev
sudo apt-get install python-pip
sudo pip install pymodbus
sudo pip install pycrypto
sudo pip install pyasn1

#

# Copyright 2010-2017 Amazon.com, Inc. or its affiliates.保留所有权利。
#

# ModbusSlaveServer.py
# Runs a modbus slave device in memory for testing purposes.
# This AWS Lambda function allocates registers for the modbus tcp slave and starts
# the server.If an exception occurs, it will wait 5 seconds and try again.
# Since the function is long-lived it will run forever when deployed to a
# Greengrass core. The handler will NOT be invoked in our example since
# the we are executing an infinite loop.

import time
import logging
import sys
#import pymodbus libraries for the server
from pymodbus.server.sync import StartTcpServer
from pymodbus.datastore import ModbusSequentialDataBlock
from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext

# instantiate logger which will log any exceptions to Cloudwatch or Greengrass
# local logs
logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

while True:
try:
#create registy for modbus server
store = ModbusSlaveContext(
di = ModbusSequentialDataBlock(0, [17]*100),
co = ModbusSequentialDataBlock(0, [17]*100),
hr = ModbusSequentialDataBlock(0, [17]*100),
ir = ModbusSequentialDataBlock(0, [17]*100))
context = ModbusServerContext(slaves=store, single=True)

# change default port of modbus from 502 to 5020 as it requires
# root permissions below 1024
StartTcpServer(context, address=("localhost", 5020))
except Exception, e:
logging.info("Error: {0}".format(str(e)))
time.sleep(5)

# this function is never called as it will be configured as long-lived.
def lambda_handler(event, context):
return 'Hello'

#
# Copyright 2010-2017 Amazon.com, Inc. or its affiliates.保留所有权利。
#

# ModbusSlaveSim.py
# This is a simulator script that connects to a modbus slave device and
# writes the CPU temperature for the raspberry pi device to a modbus register.
# If an exception occurs, it will wait 5 seconds and try again.
# Since the function is long-lived it will run forever when deployed to a
# Greengrass core. The handler will NOT be invoked in our example since
# we are executing an infinite loop.

import time
import logging
import sys
import os
# import pymodbus libraries for the simulator client
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
from pymodbus.payload import BinaryPayloadDecoder
from pymodbus.payload import BinaryPayloadBuilder
from pymodbus.constants import Endian
from pymodbus.compat import iteritems

# Default port for modbus slave is typically 502.Using 5020 for simulation to
# avoid root permissions.
client = ModbusClient('127.0.0.1', port=5020)

# instantiate logger which will log any exceptions to Cloudwatch or Greengrass
# local logs
logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

# returns the cpu temperature from the raspberry pi device
def get_temp():
f = open("/sys/class/thermal/thermal_zone0/temp")
CPUTemp = f.read()
f.close()
return float(CPUTemp)/1000.0

# in an infinite loop, this procedure will poll the cpu temperature and write
# it to a local modbus slave device.
def poll_temp():
while True:
try:
client.connect()
builder = BinaryPayloadBuilder(endian=Endian.Big)
builder.add_32bit_float(get_temp())
payload = builder.build()
address = 0
rq = client.write_registers(address, payload, skip_encode=True, unit=1)

except Exception, e:
logging.info("Error: {0}".format(str(3)))
time.sleep(5)

# executing polling on startup.
poll_temp()

# this function is never called as it will be configured as long-lived.
def lambda_handler(event, context):
return 'Hello'

#
# Copyright 2010-2017 Amazon.com, Inc. or its affiliates.保留所有权利。
#

# ModbusToAWSIoT.py
# This is an example script that connects to a modbus slave device to read
# a temperature value and publish to an MQTT Topic in AWS IoT every 5 seconds.
# If an exception occurs, it will wait 5 seconds and try again.
# Since the function is long-lived it will run forever when deployed to a
# Greengrass core. The handler will NOT be invoked in our example since
# we are executing an infinite loop.

import greengrasssdk
import platform
from threading import Timer
import time
import logging
import sys
import json
# import pymodbus libraries for the modbus client
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
from pymodbus.payload import BinaryPayloadDecoder
from pymodbus.payload import BinaryPayloadBuilder
from pymodbus.constants import Endian
from pymodbus.compat import iteritems

# Instantiate the client for your modbus slave device.In this example we are
# using the local IP address where a simulator exists.Change this to your
# desired IP.In addition, the typical default port for Modbus TCP is 502.For
# this example, 5020 was used.
mbclient = ModbusClient('127.0.0.1', port=5020)

# Default port for modbus slave is typically 502.Using 5020 for simulation to
# avoid root permissions.
logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

# Creating a greengrass core sdk client
client = greengrasssdk.client('iot-data')

# in an infinite loop, this procedure will poll the bearing temperature from a
# modbus slave device (simulator) and publish the value to AWS IoT via MQTT.
def poll_temp():
while True:
try:
# connect to modbus slave device
mbclient.connect()
# set the address and number of bytes that will be read on the modbus device
address = 0x00
count = 8
# read the holding register value for the temperature
rr = mbclient.read_holding_registers(address, count, unit=1)
# decode results as a 32 bit float
decoder = BinaryPayloadDecoder.fromRegisters(rr.registers, endian=Endian.Big)
decoded = {
'float': decoder.decode_32bit_float()
}
# publish results to topic in AWS IoT
for name, value in iteritems(decoded):
client.publish(topic='dt/controller/extruder/plc1/rtd', payload=json.dumps({ 'Temp': value}))
except Exception, e:
logging.info("Error: {0}".format(str(e)))

time.sleep(5)

poll_temp()

# This is a dummy handler and will not be invoked
# Instead the code above will be executed in an infinite loop for our example
def function_handler(event, context):
return