def radio_status(ctx):
"""Get radio statistics.
Returns: TxSuccessCnt, TxErrCnt, RxSuccessCnt, RxTimeOutCnt, RxErrCnt,
Rssi, Snr.
"""
lora = Rak811()
(
tx_success_cnt, tx_err_cnt,
rx_success_cnt, rx_timeout_cnt, rx_err_cnt,
rssi, snr
) = lora.radio_status
if ctx.obj['VERBOSE']:
click.echo('TxSuccessCnt: {}'.format(tx_success_cnt))
click.echo('TxErrCnt: {}'.format(tx_err_cnt))
click.echo('RxSuccessCnt: {}'.format(rx_success_cnt))
click.echo('RxTimeOutCnt: {}'.format(rx_timeout_cnt))
click.echo('RxErrCnt: {}'.format(rx_err_cnt))
click.echo('RSSI: {}'.format(rssi))
click.echo('SNR: {}'.format(snr))
else:
click.echo('{} {} {} {} {} {} {}'.format(
tx_success_cnt, tx_err_cnt,
rx_success_cnt, rx_timeout_cnt, rx_err_cnt,
rssi, snr
))
lora.close()
def rx_stop(ctx):
"""Stop LoraP2P RX."""
lora = Rak811()
lora.rx_stop()
if ctx.obj['VERBOSE']:
click.echo('LoraP2P RX stopped.')
lora.close()
def clear_radio_status(ctx):
"""Clear radio statistics."""
lora = Rak811()
lora.clear_radio_status()
if ctx.obj['VERBOSE']:
click.echo('Radio statistics cleared.')
lora.close()
def sleep(ctx):
"""Enter sleep mode."""
lora = Rak811()
lora.sleep()
if ctx.obj['VERBOSE']:
click.echo('Sleeping')
lora.close()
def test_instantiate_params(mock_serial):
"""Test that Rak811 passes parameters passed to RackSerial."""
port = '/dev/ttyAMA0'
timeout = 5
lora = Rak811(port=port, timeout=timeout)
mock_serial.assert_called_once_with(port=port, timeout=timeout)
lora.close()
def rxc(ctx):
"""Set module in LoraP2P receive mode."""
lora = Rak811()
lora.rxc()
if ctx.obj['VERBOSE']:
click.echo('Module set in receive mode.')
lora.close()
def send(ctx, port, confirm, binary, data, json):
"""Send LoRaWan message and check for downlink."""
if binary:
try:
data = bytes.fromhex(data)
except ValueError:
click.echo('Invalid binary data')
return
lora = Rak811()
try:
lora.send(data, confirm=confirm, port=port)
except Rak811Error as e:
print_exception(e)
lora.close()
return
if ctx.obj['VERBOSE']:
click.echo('Message sent.')
if lora.nb_downlinks:
downlink = lora.get_downlink()
downlink['data'] = downlink['data'].hex()
if json:
click.echo(dumps(downlink, indent=4))
elif ctx.obj['VERBOSE']:
click.echo('Downlink received:')
click.echo('Port: {}'.format(downlink['port']))
if downlink['rssi']:
click.echo('RSSI: {}'.format(downlink['rssi']))
click.echo('SNR: {}'.format(downlink['snr']))
click.echo('Data: {}'.format(downlink['data']))
else:
click.echo(downlink['data'])
elif ctx.obj['VERBOSE']:
click.echo('No downlink available.')
lora.close()
def test_rx(frequency):
pass
lora = Rak811()
lora.hard_reset()
lora.mode = Mode.LoRaP2P
lora.rf_config = {'sf': 9, 'freq': frequency, 'pwr': 16}
print('config created')
wait = 30
lora.rxc()
while True:
print(f'LoRa set to receive; waiting for {wait}s')
lora.rx_get(wait)
while lora.nb_downlinks > 0:
message = lora.get_downlink()
data = message['data']
print(data)
print(type(data))
print('RSSI: {}, SNR: {}'.format(message['rssi'], message['snr']))
def reload(ctx):
"""Set LoRaWan or LoRaP2P configurations to default."""
lora = Rak811()
lora.reload()
if ctx.obj['VERBOSE']:
click.echo('Configuration reloaded.')
lora.close()
def wake_up(ctx):
"""Wake up."""
lora = Rak811()
lora.wake_up()
if ctx.obj['VERBOSE']:
click.echo('Alive!')
lora.close()
def test_rak_rec_command():
lora = Rak811()
wait_time = 20
lora.mode = Mode.LoRaP2P
lora.rx_get(wait_time)
def get_config(ctx, key):
"""Get LoraWan configuration."""
lora = Rak811()
try:
click.echo(lora.get_config(key))
except Rak811Error as e:
print_exception(e)
lora.close()
def signal(ctx):
"""Get (RSSI,SNR) from latest received packet."""
lora = Rak811()
(rssi, snr) = lora.signal
if ctx.obj['VERBOSE']:
click.echo('RSSI: {0} - SNR: {1}'.format(rssi, snr))
else:
click.echo('{} {}'.format(rssi, snr))
lora.close()
def link_cnt(ctx):
"""Get up & downlink counters."""
lora = Rak811()
(uplink, downlink) = lora.link_cnt
if ctx.obj['VERBOSE']:
click.echo('Uplink: {0} - Downlink: {1}'.format(uplink, downlink))
else:
click.echo('{} {}'.format(uplink, downlink))
lora.close()
def join_abp(ctx):
"""Join the configured network in ABP mode."""
lora = Rak811()
try:
lora.join_abp()
if ctx.obj['VERBOSE']:
click.echo('Joined in ABP mode')
except Rak811Error as e:
print_exception(e)
lora.close()
def test_instantiate_default(mock_serial):
"""Test that Rak811 can be instantiated.
Check for basic initialisation and teardown of the RackSerial.
"""
lora = Rak811()
assert isinstance(lora._serial, Rak811Serial)
mock_serial.assert_called_once_with()
lora.close()
mock_serial.return_value.close.assert_called_once()
def hard_reset(ctx):
"""Hardware reset of the module.
Hard reset should not be required in normal operation. It needs to be
issued once after host boot, or module restart.
"""
lora = Rak811()
lora.hard_reset()
if ctx.obj['VERBOSE']:
click.echo('Hard reset complete')
lora.close()
def reset(ctx, reset_type):
"""Reset Module or LoRaWan stack."""
lora = Rak811()
if reset_type == 'module':
lora.reset(Reset.Module)
else:
lora.reset(Reset.LoRa)
if ctx.obj['VERBOSE']:
click.echo('{0} reset complete.'.format(
'Module' if reset_type == 'module' else 'LoRa'))
lora.close()
def band(ctx, band):
"""Get/Set LoRaWan region."""
lora = Rak811()
if band is None:
click.echo(lora.band)
else:
band = band.upper()
lora.band = band
if ctx.obj['VERBOSE']:
click.echo('LoRaWan region set to {0}.'.format(band))
lora.close()
def recv_ex(ctx, recv_ex):
"""RSSI & SNR report on receive."""
lora = Rak811()
if recv_ex is None:
click.echo('Enabled' if lora.recv_ex == RecvEx.Enabled else 'Disabled')
else:
lora.recv_ex = (RecvEx.Enabled
if recv_ex == 'enable' else RecvEx.Disabled)
if ctx.obj['VERBOSE']:
click.echo('RSSI & SNR report on receive {0}.'.format(
'Enabled' if recv_ex == 'enable' else 'Disabled'))
lora.close()
def dr(ctx, dr):
"""Get/Set next send data rate."""
lora = Rak811()
if dr is None:
click.echo(lora.dr)
else:
try:
lora.dr = dr
if ctx.obj['VERBOSE']:
click.echo('Data rate set to {0}.'.format(dr))
except Rak811Error as e:
print_exception(e)
lora.close()
def mode(ctx, mode):
"""Get/Set mode to LoRaWan or LoRaP2P."""
lora = Rak811()
if mode is None:
click.echo('LoRaWan' if lora.mode == Mode.LoRaWan else 'LoRaP2P')
else:
mode = mode.lower()
if mode == 'lorawan':
lora.mode = Mode.LoRaWan
else:
lora.mode = Mode.LoRaP2P
if ctx.obj['VERBOSE']:
click.echo('Mode set to {0}.'.format(
'LoRaWan' if mode == 'lorawan' else 'LoRaP2P'))
lora.close()
def set_config(ctx, key_values):
"""Set LoraWAN configuration.
\b
Arguments are specified as KEY=VALUE pairs, e.g.:
set-config app_eui='APP_EUI' app_key='APP_KEY'
"""
lora = Rak811()
kv_args = dict(key_values)
try:
lora.set_config(**kv_args)
if ctx.obj['VERBOSE']:
click.echo('LoRaWan parameters set')
except Rak811Error as e:
print_exception(e)
lora.close()
def abp_info(ctx):
"""Get ABP info.
When using OTAA, returns the necessary info to re-join in ABP mode. The
following tuple is returned: (NetworkID, DevAddr, Nwkskey, Appskey)
"""
lora = Rak811()
(nwk_id, dev_addr, nwks_key, apps_key) = lora.abp_info
if ctx.obj['VERBOSE']:
click.echo('NwkId: {}'.format(nwk_id))
click.echo('DevAddr: {}'.format(dev_addr))
click.echo('Nwkskey: {}'.format(nwks_key))
click.echo('Appskey: {}'.format(apps_key))
else:
click.echo('{} {} {} {}'.format(nwk_id, dev_addr, nwks_key, apps_key))
lora.close()
def txc(ctx, cnt, interval, binary, data):
"""Send LoRaP2P message."""
if binary:
try:
data = bytes.fromhex(data)
except ValueError:
click.echo('Invalid binary data')
return
lora = Rak811()
try:
lora.txc(data, cnt=cnt, interval=interval)
except Rak811Error as e:
print_exception(e)
lora.close()
return
if ctx.obj['VERBOSE']:
click.echo('Message sent.')
lora.close()
def rf_config(ctx, key_values):
"""Get/Set LoraP2P configuration.
\b
Without argument, returns:
frequency, sf, bw, cr, prlen, pwr
\b
Otherwhise set rf_config, Arguments are specified as KEY=VALUE pairs:
freq: frequency in MHz (860.000-929.900)
sf: strength factor (6-12)
bw: bandwidth (0:125KHz, 1:250KHz, 2:500KHz)
cr: coding rate (1:4/5, 2:4/6, 3:4/7, 4:4/8)
prlen: preamble length default (8-65535)
pwr: Tx power (5-20)
E.g.: rf-config freq=860.100 sf=7 pwr=16
"""
lora = Rak811()
config = dict(key_values)
if config == {}:
# No parameters: returns rc_config
config = lora.rf_config
if ctx.obj['VERBOSE']:
click.echo('Frequency: {}'.format(config['freq']))
click.echo('SF: {}'.format(config['sf']))
click.echo('BW: {}'.format(config['bw']))
click.echo('CR: {}'.format(config['cr']))
click.echo('PrLen: {}'.format(config['prlen']))
click.echo('Power: {}'.format(config['pwr']))
else:
click.echo('{} {} {} {} {} {}'.format(
config['freq'], config['sf'], config['bw'], config['cr'],
config['prlen'], config['pwr']
))
else:
# At least a parameter, set rc_config
lora.rf_config = config
if ctx.obj['VERBOSE']:
click.echo('rf_config set: ' + ', '.join('{}={}'.format(k, v) for
k, v in config.items()))
lora.close()
def rx_get(ctx, timeout, json):
"""Get LoraP2P message."""
lora = Rak811()
lora.rx_get(timeout)
if lora.nb_downlinks:
rx = lora.get_downlink()
rx['data'] = rx['data'].hex()
if json:
click.echo(dumps(rx, indent=4))
elif ctx.obj['VERBOSE']:
click.echo('Message received:')
if rx['rssi']:
click.echo('RSSI: {}'.format(rx['rssi']))
click.echo('SNR: {}'.format(rx['snr']))
click.echo('Data: {}'.format(rx['data']))
else:
click.echo(rx['data'])
elif ctx.obj['VERBOSE']:
click.echo('No message available.')
lora.close()
def sen
frame = LppFrame()
frame.add_temperature(0, raw_temp)
frame.add_humitidy(1, humidity)
frame.add_pressure(2, pressure)
frame.add_
buffer = frame.bytes()
#print(buffer)
lora = Rak811()
lora.hard_reset()
lora.mode = Mode.LoRaWan
lora.band = 'EU868'
lora.set_config(app_eui='70B3D57ED001C921',
app_key='55B77F583763DCFE02AC75DB77CDD4B1')
lora.join_otaa()
lora.dr = 5
lora.send(bytes(buffer))
lora.close()
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
SPDX-License-Identifier: Apache-2.0
"""
from random import randint
from sys import exit
from time import sleep
from rak811 import Mode, Rak811
from ttn_secrets import APP_EUI, APP_KEY
lora = Rak811()
# Most of the setup should happen only once...
print('Setup')
lora.hard_reset()
lora.mode = Mode.LoRaWan
lora.band = 'EU868'
lora.set_config(app_eui=APP_EUI, app_key=APP_KEY)
print('Joining')
lora.join_otaa()
# Note that DR is different from SF and depends on the region
# See: https://docs.exploratory.engineering/lora/dr_sf/
# Set Data Rate to 5 which is SF7/125kHz for EU868
lora.dr = 5
def version(ctx):
"""Get module version."""
lora = Rak811()
click.echo(lora.version)
lora.close()
