class SigFoxSender:
def __init__(self):
# init Sigfox for RCZ1 (Europe)
self.sigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)
# create a Sigfox socket
self.socket = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)
# make the socket blocking
self.socket.setblocking(True)
# configure it as uplink only
self.socket.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)
print('SigFox socket created')
print('MAC: {} - ID: {} - RSSI: {} - PAC: {}'.format(
hexlify(self.sigfox.mac()).decode(),
hexlify(self.sigfox.id()).decode(), self.sigfox.rssi(),
hexlify(self.sigfox.pac()).decode()))
def getSignalStrength(self):
return self.sigfox.rssi()
def transformValue(self, value):
# divide by 10 (convention as high values are expected at some point):
transformed = value / 10
# cast value to int:
transformed = int(transformed)
# avoid negative values:
transformed = 0 if (transformed < 0) else transformed
# as we are packing the value in a single byte, make it 255 as max value:
transformed = 255 if (transformed > 255) else transformed
# return transformed value:
return transformed
def packMesageForSigFox(self, ozone, temperature, humidity):
# casting floats to ints in values array (only ozone values):
values = [self.transformValue(x) for x in ozone]
# adding temperature and humidity to values array (casted to ints):
values.append(int(temperature))
values.append(int(humidity))
# returning array packed for sigfox
# sigfox custom grammar to use: ozone1::uint:8 ozone2::uint:8 ozone3::uint:8 ozone4::uint:8 ozone5::uint:8 ozone6::uint:8 ozone7::uint:8 ozone8::uint:8 ozone9::uint:8 ozone10::uint:8 temperature::uint:8 humidity::uint:8
return struct.pack('B' * len(values), *values)
# return struct.pack('>BBBBBBBBBB', ozone..., int(temperature), int(humidity))
def sendMessage(self, message):
return self.socket.send(message)
def sendValues(self, ozone, temperature, humidity):
res = self.sendMessage(
self.packMesageForSigFox(ozone, temperature, humidity))
return res
sigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)
# create a Sigfox socket
s = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)
# make the socket blocking
s.setblocking(True)
# wait for a downlink after sending the uplink packet
s.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)
# send some bytes
pycom.rgbled(0x7f7f00) # yellow
try:
s.send(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))
pycom.rgbled(0x007f00) # green
time.sleep(1)
except:
pycom.rgbled(0x7f0000) # red
time.sleep(1)
received = s.recv(8)
print(received)
if received:
pycom.rgbled(0x007f00) # green
else:
pycom.rgbled(0x7f0000) # red
print(sigfox.rssi())
time.sleep(4)
s.close()
current_fragment['data'] = payload
current_fragment['timeout'] = timeout
current_fragment['downlink_enable'] = True
current_fragment['ack_received'] = False
current_fragment['fragment_size'] = len(payload)
current_fragment['sending_start'] = 0
try:
pycom.rgbled(0x7700CC) # purple
print("Sending: {}".format(payload))
current_fragment['sending_start'] = chrono.read()
s.send(payload)
response = s.recv(downlink_mtu)
current_fragment['sending_end'] = chrono.read()
current_fragment['send_time'] = current_fragment[
'sending_end'] - current_fragment['sending_start']
current_fragment['rssi'] = sigfox.rssi()
print("response -> {}".format(response))
decode_response = ''.join("{:08b}".format(int(byte))
for byte in response)
print('decode_response -> {}'.format(decode_response))
current_fragment['ack'] = decode_response if decode_response else ""
current_fragment['ack_received'] = True
except OSError as e:
current_fragment['sending_end'] = chrono.read()
current_fragment['send_time'] = current_fragment[
'sending_end'] - current_fragment['sending_start']
current_fragment['rssi'] = sigfox.rssi()
current_fragment['ack'] = ""
current_fragment['ack_received'] = False
print('Error number {}, {}'.format(e.args[0], e))
# Loop 0 to (config x 10),
# config should be 100 as per test protocol,
# this takes very long
# config = 1 takes about 127 seconds
# config = 5 takes about 624 seconds
# it seems after 30 frames (ie config = 3), RSA finished the test
elif test == "DL - GFSK Receiver":
print("NB: Test Mode TX-BPSK has to be executed just before this test.")
# print("Run test_mode(BPSK) before GFSK ... ")
# sigfox.test_mode( SFX_TEST_MODE_TX_BPSK, 3)
# print("... done. Click on \"Start send GFSK\" in RSA now")
# sleep(2)
# print("Run test_mode(GFSK) ...")
test_mode(SFX_TEST_MODE_RX_GFSK, 30) # 30 seconds timeout
# print("... done.")
print("rssi", sigfox.rssi())
################################################################################
####################### Network Emulator tests #######################
################################################################################
elif test == "NE-Uplink":
# print("a")
# #send(bytes([1,2,3,4,5,6,7,8,9,0xa,0xb,0xc]))
# send(bytes([7]))
# print("b")
r = machine.rng() & 0xff
print("reconfiguring sigfox to use public key")
sigfox.public_key(True)
num_messages = 1
for b in range(0, num_messages):
x = utime.time()
t = x[0:4]
z = x[4:6]
rssi = x[6:8]
# b'5f59ebe4' b'0000' b'ff75'
# b'5f59ec42' b'0000' b'ff72'
# TODO: how to convert
print("received=",
hexlify(x),
" time=",
hexlify(t),
" zero=",
hexlify(z),
" rssi=",
hexlify(rssi),
sep='')
print("rssi", sigfox.rssi())
ct_recv += 1
else:
s.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False) # uplink only
m = i + bytes([0x01]) + g + r
print("send", hexlify(m))
s.send(m)
pycom.rgbled(0x000011)
ct_send += 1
except Exception as e:
pycom.rgbled(0x110000)
print("failed", e)
ct_fail += 1
time.sleep(2)
print("ct=", ct, "(send,recv,fail)=", ct_send, ct_recv, ct_fail)
signal_strength = -500 # default value
if low_power_consumption_mode == 0:
print("send strength test message")
try:
error_position = "send"
sigfox_network.send(bytes([255, 255, 0]))
error_position = "send2"
if low_power_consumption_mode == 0:
print("waiting for feedback message")
error_position = "recv"
sigfox_network.recv(32)
error_position = "rssi"
signal_strength = sigfox.rssi()
except:
# every error will stop strength test
signal_strength = -500
if low_power_consumption_mode == 0:
print(
"error while waiting for signal strength test (position=%s)" %
(error_position))
if low_power_consumption_mode == 0:
print("received signal stregth: %s" % (str(signal_strength)))
if signal_strength < rssi_dbm_limit:
if low_power_consumption_mode == 0:
print("ERROR: signal stregth below limit: %s < %s" %
(str(signal_strength), str(rssi_dbm_limit)))