def _processLinkCheckReq(self, device, command, request, lsnr):
"""Process a link check request
Args:
device (Device): Sending device
command (LinkCheckReq): LinkCheckReq object
"""
# We assume 'margin' corresponds to the
# absolute value of LNSR, as an integer.
# Set to zero if negative.
margin = max(0, round(lsnr))
# If we are processing the first request,
# gateway count must be one, we guess.
gwcnt = 1
# Create the LinkCheckAns response and encode. Set fcntdown
command = LinkCheckAns(margin=margin, gwcnt=gwcnt)
# Queue the command if required
if self.config.macqueueing:
self._queueMACCommand(device.deveui, command)
return
frmpayload = command.encode()
fcntdown = device.fcntdown + 1
# Create the downlink message. Set fport=0,
# encrypt with NwkSKey and encode
message = MACDataDownlinkMessage(device.devaddr,
device.nwkskey,
fcntdown,
self.config.adrenable,
'',
0,
frmpayload,
acknowledge=True)
message.encrypt(device.nwkskey)
data = message.encode()
gateway = self.lora.gateway(device.gw_addr)
if gateway is None:
log.info(
"Could not find gateway for gateway {gw_addr} for device "
"{devaddr}",
gw_addr=device.gw_addr,
devaddr=devaddrString(device.devaddr))
return
# Create GatewayMessage and Txpk objects, send immediately
request = GatewayMessage(version=1,
token=0,
remote=(gateway.host, gateway.port))
device.rx = self.band.rxparams((device.tx_chan, device.tx_datr))
txpk = self._txpkResponse(device, data, gateway, immediate=True)
# Update the device fcntdown
device.update(fcntdown=fcntdown)
# Send the RX2 window message
self.lora.sendPullResponse(request, txpk[2])
def start(self, netserver):
"""Load all application interfaces and start them.
Args:
netserver (NetServer): The network server
"""
self.netserver = netserver
# Get all concrete application interface objects
appinterfaces = yield AppInterface.all()
for appinterface in appinterfaces:
# Get the interface, set the appinterface
interface = yield appinterface.interfaces.get()
if interface:
interface.appinterface = appinterface
self.interfaces.append(interface)
# Start the interfaces
for interface in self.interfaces:
log.info("Starting application interface id {id}: {name}",
id=interface.appinterface.id,
name=interface.name)
interface.start(self.netserver)
if not interface.started:
log.error("Could not start application interface "
"id {id}",
id=interface.appinterface.id)
def _sendJoinResponse(self, request, rxpk, gateway, app, device):
"""Send a join response message
Called if a join response message is to be sent.
Args:
request: request (GatewayMessage): Received gateway message object
app (Application): The requested application object
device (Device): The requesting device object
"""
# Get receive window parameters and
# set dlsettings field
device.rx = self.band.rxparams((device.tx_chan, device.tx_datr),
join=True)
dlsettings = 0 | self.band.rx1droffset << 4 | device.rx[2]['index']
# Create the Join Response message
log.info("Sending join response for devaddr {devaddr}",
devaddr=devaddrString(device.devaddr))
response = JoinAcceptMessage(app.appkey, app.appnonce,
self.config.netid, device.devaddr,
dlsettings, device.rx[1]['delay'])
data = response.encode()
txpk = self._txpkResponse(device, data, gateway, rxpk.tmst)
# Send the RX1 window messages
self.lora.sendPullResponse(request, txpk[1])
# Send the RX2 window message
self.lora.sendPullResponse(request, txpk[2])
def _processADRRequests(self):
"""Updates devices with target data rate, and sends ADR requests.
This method is called every adrcycletime seconds as a looping task.
"""
# If we are running, return
if self.adrprocessing is True:
returnValue(None)
self.adrprocessing = True
devices = yield Device.all()
sendtime = time.time()
for device in devices:
# Check this device is enabled
if not device.enabled:
continue
# Check ADR is enabled
if not device.adr:
continue
# Set the target data rate
target = device.getADRDatarate(self.band, self.config.adrmargin)
# If no target, or the current data rate is the target, continue
if target is None:
continue
# Set the device adr_datr
yield device.update(adr_datr=target)
# Only send a request if we need to change
if device.tx_datr == device.adr_datr:
continue
# If we are queueing commands, create the command and add to the queue.
# Replace any existing requests.
if self.config.macqueueing:
log.info("Queuing ADR MAC Command")
command = self._createLinkADRRequest(device)
self._dequeueMACCommand(device.deveui, command)
self._queueMACCommand(device.deveui, command)
continue
# Check we have reached the next scheduled ADR message time
scheduled = sendtime + self.config.adrmessagetime
current = time.time()
if current < scheduled:
yield txsleep(scheduled - current)
# Refresh and send the LinkADRRequest
sendtime = time.time()
yield self._sendLinkADRRequest(device)
self.adrprocessing = False
def _pollInboundMessages(self):
"""Poll Azure IOT hub for inbound messages and forward
them to the Network Server"""
# If we are running, return
if self.polling is True:
returnValue(None)
log.info("Azure IoT HTTPS interface '{name}' commencing "
"polling loop", name=self.name)
self.polling = True
# Get the applications associated with this interface.
apps = yield Application.find(where=['appinterface_id = ?', self.appinterface.id])
if apps is None:
self.polling = False
returnValue(None)
# Loop through the applications
for app in apps:
# Poll all devices associated with this app
devices = yield Device.find(where=['appeui = ?', app.appeui])
if devices is None:
returnValue(None)
for device in devices:
# Use the device appname property for the Azure devid,
# if it exists. Otherwise, use the device name property
devid = device.appname if device.appname else device.name
# Form the url, headers and parameters
url = 'https://{}/devices/{}/messages/devicebound'.format(
self.iothost, devid)
resuri = '{}/devices/{}'.format(self.iothost, devid)
headers = {'Authorization': self._iotHubSasToken(resuri)}
params = {'api-version': self.API_VERSION}
# Make the request, catch any exceptions
try:
r = requests.get(url, headers=headers,
params=params, timeout=self.TIMEOUT)
except requests.exceptions.RequestException:
log.debug("Application interface {name} could not poll "
"Azure IOT Hub {host} for device ID {device}",
name=self.name, host=self.iothost, device=devid)
continue
# Response code 204 indicates there is no data to be sent.
if r.status_code == 204:
continue
# Response code 200 means we have data to send to the device
elif r.status_code == 200:
appdata = r.content
self.netserver.inboundAppMessage(device.devaddr, appdata)
self.polling = False
def _processLinkADRAns(self, device, command):
"""Process a link ADR answer
Returns three ACKS: power_ack, datarate_ack, channelmask_ack
Args:
device (Device): Sending device
command (LinkADRAns): LinkADRAns object
"""
# Not much to do here - we will know if the device had changed datarate via
# the rxpk field.
log.info("Received LinkADRAns from device {devaddr}",
devaddr=devaddrString(device.devaddr))
def __init__(self, config):
"""NetServer initialisation method.
Args:
database (Database): Database configuration object
"""
log.info("Initialising the server")
self.message_cache = []
self.task = {}
self.commands = []
self.adrprocessing = False
self.config = config
self.otarange = set(
xrange(self.config.otaastart, self.config.otaaend + 1))
self.band = eval(self.config.freqband)()
def _sendLinkADRRequest(self, device, command):
"""Send a Link ADR Request message
Called if an ADR change is required for this device.
Args:
device: (Device): Target device
command (LinkADRReq): Link ADR Request object
"""
frmpayload = command.encode()
# Create the downlink message. Increment fcntdown, set fport=0,
# encrypt with NwkSKey and encode
fcntdown = device.fcntdown + 1
log.info("Sending ADR Request to devaddr {devaddr}",
devaddr=devaddrString(device.devaddr))
message = MACDataDownlinkMessage(device.devaddr, device.nwkskey,
fcntdown, self.config.adrenable, '',
0, frmpayload)
message.encrypt(device.nwkskey)
data = message.encode()
gateway = self.lora.gateway(device.gw_addr)
if gateway is None:
log.info(
"Could not find gateway for gateway {gw_addr} for device "
"{devaddr}",
gw_addr=device.gw_addr,
devaddr=devaddrString(device.devaddr))
returnValue(None)
# Create GatewayMessage and Txpk objects, send immediately
request = GatewayMessage(version=1,
token=0,
remote=(gateway.host, gateway.port))
device.rx = self.band.rxparams((device.tx_chan, device.tx_datr))
txpk = self._txpkResponse(device, data, gateway, immediate=True)
# Update the device fcntdown
device.update(fcntdown=fcntdown)
# Send the RX2 window message
self.lora.sendPullResponse(request, txpk[2])
def _processJoinRequest(self, message, app, device):
"""Process an OTA Join Request message from a LoraWAN device
This method checks the message devnonce and integrity code (MIC).
If the devnonce has not been seen before, and the MIC is valid,
we have a valid join request, and we can create the session
keys and assign an OTA device address.
Args:
message (JoinRequestMessage): The join request message object
app (Application): The requested application object
device (Device): The requesting device object
Returns:
True on success, False otherwise.
"""
# Perform devnonce check
if not device.checkDevNonce(message):
log.info(
"Join request message from {deveui} failed message "
"devnonce check.",
deveui=euiString(message.deveui))
returnValue(False)
# Perform message integrity check.
if not message.checkMIC(app.appkey):
log.info(
"Message from {deveui} failed message "
"integrity check.",
deveui=euiString(message.deveui))
returnValue(False)
# Assign DevEUI, NwkSkey and AppSKey.
device.appeui = app.appeui
device.nwkskey = self._createSessionKey(1, app, message)
device.appskey = self._createSessionKey(2, app, message)
# If required, obtain a OTA devaddr for the device
if device.devaddr is None:
device.devaddr = yield self._getFreeOTAAddress()
returnValue(device.devaddr is not None)
def start(self):
"""Start the netserver.
Sets up scheduled tasks and start listening on the required
interfaces.
"""
log.info("Starting the server")
# Setup scheduled tasks
# 1. ADR Requests
self.task['processADRRequests'] = task.LoopingCall(
self._processADRRequests)
if self.config.adrenable:
self.task['processADRRequests'].start(self.config.adrcycletime)
# 2. Message cache
self.task['cleanMessageCache'] = task.LoopingCall(
self._cleanMessageCache)
self.task['cleanMessageCache'].start(
max(10, self.config.duplicateperiod * 2))
# 3. MAC Command queue
self.task['manageMACCommandQueue'] = task.LoopingCall(
self._manageMACCommandQueue)
if self.config.macqueueing:
self.task['manageMACCommandQueue'].start(
self.config.macqueuelimit / 2)
# Start the web server
log.info("Starting the web server")
self.webserver = WebServer(self)
try:
self.webserver.start()
except CannotListenError:
log.error("Error starting the web server: cannot listen.")
reactor.stop()
# Start server network interfaces:
# LoRa gateway interface
log.info("Starting the LoRaWAN interface")
self.lora = LoraWAN(self)
try:
self.lora.start()
except CannotListenError:
log.error("Error opening LoRa interface UDP port {port}",
port=self.config.port)
reactor.stop()
# Application interfaces
interfaceManager.start(self)
def inboundAppMessage(self, devaddr, appdata, acknowledge=False):
"""Sends inbound data from the application interface to the device
Args:
devaddr (int): 32 bit device address (DevAddr)
appdata (str): packed application data
acknowledge (bool): Acknowledged message
"""
log.info("Inbound message to devaddr {devaddr}",
devaddr=devaddrString(devaddr))
# Retrieve the active device
device = yield self._getActiveDevice(devaddr)
if device is None:
log.error("Cannot send to unregistered device address {devaddr}",
devaddr=devaddrString(devaddr))
returnValue(None)
# Check the device is enabled
if not device.enabled:
log.error(
"Inbound application message for disabled device "
"{deveui}",
deveui=euiString(device.deveui))
returnValue(None)
# Get the associated application
app = yield Application.find(where=['appeui = ?', device.appeui],
limit=1)
if app is None:
log.error(
"Inbound application message for {deveui} - "
"AppEUI {appeui} does not match any configured applications.",
deveui=euiString(device.deveui),
appeui=device.appeui)
returnValue(None)
# Find the gateway
gateway = self.lora.gateway(device.gw_addr)
if gateway is None:
log.error(
"Could not find gateway for inbound message to "
"{devaddr}.",
devaddr=devaddrString(device.devaddr))
returnValue(None)
# Increment fcntdown
fcntdown = device.fcntdown + 1
# Piggyback any queued MAC messages in fopts
fopts = ''
device.rx = self.band.rxparams((device.tx_chan, device.tx_datr),
join=False)
if self.config.macqueueing:
# Get all of this device's queued commands: this returns a list of tuples (index, command)
commands = [(i, c[2]) for i, c in enumerate(self.commands)
if device.deveui == c[1]]
for (index, command) in commands:
# Check if we can accommodate the command. If so, encode and remove from the queue
if self.band.checkAppPayloadLen(device.rx[1]['datr'],
len(fopts) + len(appdata)):
fopts += command.encode()
del self.commands[index]
else:
break
# Create the downlink message, encrypt with AppSKey and encode
response = MACDataDownlinkMessage(device.devaddr,
device.nwkskey,
device.fcntdown,
self.config.adrenable,
fopts,
int(app.fport),
appdata,
acknowledge=acknowledge)
response.encrypt(device.appskey)
data = response.encode()
# Create Txpk objects
txpk = self._txpkResponse(device,
data,
gateway,
itmst=int(device.tmst),
immediate=False)
request = GatewayMessage(version=2,
gatewayEUI=gateway.eui,
remote=(gateway.host, gateway.port))
# Save the frame count down
device.update(fcntdown=fcntdown)
# Send RX1 window message
self.lora.sendPullResponse(request, txpk[1])
# If Class A, send the RX2 window message
self.lora.sendPullResponse(request, txpk[2])
def processPushDataMessage(self, request, gateway):
"""Process a PUSH_DATA message from a LoraWAN gateway
Args:
request (GatewayMessage): the received gateway message object
gateway (Gateway): the gateway that sent the message
Returns:
True on success, otherwise False
"""
if not request.rxpk:
request.rxpk = []
for rxpk in request.rxpk:
# Decode the MAC message
message = MACMessage.decode(rxpk.data)
if message is None:
log.info(
"MAC message decode error for gateway {gateway}: message "
"timestamp {timestamp}",
gateway=gateway.host,
timestamp=str(rxpk.time))
returnValue(False)
# Check if thisis a duplicate message
if self._checkDuplicateMessage(message):
returnValue(False)
# Join Request
if message.isJoinRequest():
# Get the application using appeui
app = yield Application.find(
where=['appeui = ?', message.appeui], limit=1)
#app = next((a for a in self.applications if
# a.appeui == message.appeui), None)
if app is None:
log.info(
"Message from {deveui} - AppEUI {appeui} "
"does not match any configured applications.",
deveui=euiString(message.deveui),
appeui=message.appeui)
returnValue(False)
# Find the Device
device = yield Device.find(
where=['deveui = ?', message.deveui], limit=1)
if device is None:
#log.info("Message from unregistered device {deveui}",
# deveui=euiString(message.deveui))
#returnValue(False)
# TODO save device to database (cheng)
device = Device(deveui=message.deveui,
name='smk_node',
devclass='A',
enabled=True,
otaa=True,
devaddr=None,
devnonce=[],
appeui=message.appeui,
nwkskey='',
appskey='',
fcntup=0,
fcntdown=0,
fcnterror=False,
snr=[],
snr_average=0)
#device.save()
else:
# Check the device is enabled
if not device.enabled:
log.info("Join request for disabled device {deveui}.",
deveui=euiString(device.deveui))
returnValue(False)
# Process join request
joined = yield self._processJoinRequest(message, app, device)
if joined:
# Update the ADR measures
if self.config.adrenable:
device.updateSNR(rxpk.lsnr)
yield device.update(tx_chan=rxpk.chan,
tx_datr=rxpk.datr,
devaddr=device.devaddr,
nwkskey=device.nwkskey,
appskey=device.appskey,
time=rxpk.time,
tmst=rxpk.tmst,
gw_addr=gateway.host,
fcntup=0,
fcntdown=0,
fcnterror=False,
devnonce=device.devnonce,
snr=device.snr,
snr_average=device.snr_average)
log.info(
"Successful Join request from DevEUI {deveui} "
"for AppEUI {appeui} | Assigned address {devaddr}",
deveui=euiString(device.deveui),
appeui=euiString(app.appeui),
devaddr=devaddrString(device.devaddr))
# Send the join response
device.save()
self._sendJoinResponse(request, rxpk, gateway, app, device)
returnValue(True)
else:
log.info(
"Could not process join request from device "
"{deveui}.",
deveui=euiString(device.deveui))
returnValue(False)
# LoRa message. Check this is a registered device
device = yield self._getActiveDevice(message.payload.fhdr.devaddr)
if device is None:
log.info(
"Message from device using unregistered address "
"{devaddr}",
devaddr=devaddrString(message.payload.fhdr.devaddr))
returnValue(False)
# Check the device is enabled
if not device.enabled:
log.info("Message from disabled device {devaddr}",
devaddr=devaddrString(message.payload.fhdr.devaddr))
returnValue(False)
# Check frame counter
if not device.checkFrameCount(message.payload.fhdr.fcnt,
self.band.max_fcnt_gap,
self.config.fcrelaxed):
log.info("Message from {devaddr} failed frame count check.",
devaddr=devaddrString(message.payload.fhdr.devaddr))
log.debug(
"Received frame count {fcnt}, device frame count {dfcnt}",
fcnt=message.payload.fhdr.fcnt,
dfcnt=device.fcntup)
yield device.update(fcntup=device.fcntup,
fcntdown=device.fcntdown,
fcnterror=device.fcnterror)
returnValue(False)
# Perform message integrity check.
if not message.checkMIC(device.nwkskey):
log.info(
"Message from {devaddr} failed message "
"integrity check.",
devaddr=devaddrString(message.payload.fhdr.devaddr))
returnValue(False)
# Update SNR reading and device
device.updateSNR(rxpk.lsnr)
yield device.update(tx_chan=rxpk.chan,
tx_datr=rxpk.datr,
fcntup=device.fcntup,
fcntdown=device.fcntdown,
fcnterror=device.fcnterror,
time=rxpk.time,
tmst=rxpk.tmst,
adr=bool(message.payload.fhdr.adr),
snr=device.snr,
snr_average=device.snr_average,
gw_addr=gateway.host)
# Set the device rx window parameters
device.rx = self.band.rxparams((device.tx_chan, device.tx_datr),
join=False)
# Process MAC Commands
commands = []
# Standalone MAC command
if message.isMACCommand():
message.decrypt(device.nwkskey)
commands = [MACCommand.decode(message.payload.frmpayload)]
# Contains piggybacked MAC command(s)
elif message.hasMACCommands():
commands = message.commands
for command in commands:
if command.isLinkCheckReq():
self._processLinkCheckReq(device, command, request,
rxpk.lsnr)
elif command.isLinkADRAns():
self._processLinkADRAns(device, command)
# TODO: add other MAC commands
# Process application data message
if message.isUnconfirmedDataUp() or message.isConfirmedDataUp():
# Find the app
app = yield Application.find(
where=['appeui = ?', device.appeui], limit=1)
if app is None:
log.info(
"Message from {devaddr} - AppEUI {appeui} "
"does not match any configured applications.",
devaddr=euiString(device.devaddr),
appeui=device.appeui)
returnValue(False)
# Decrypt frmpayload
message.decrypt(device.appskey)
appdata = str(message.payload.frmpayload)
port = message.payload.fport
# Route the data to an application server via the configured interface
log.info("Outbound message from devaddr {devaddr}",
devaddr=devaddrString(device.devaddr))
interface = interfaceManager.getInterface(app.appinterface_id)
if interface is None:
log.error(
"No outbound interface found for application "
"{app}",
app=app.name)
elif not interface.started:
log.error(
"Outbound interface for application "
"{app} is not started",
app=app.name)
else:
self._outboundAppMessage(interface, device, app, port,
appdata)
# Send an ACK if required
if message.isConfirmedDataUp():
yield self.inboundAppMessage(device.devaddr,
'',
acknowledge=True)
