def ping(self, host, verbose):
ser = self.myserial
self.create_packet_session()
mycmd = 'AT+QPING=1,\"' + host + '\",4,4' # Context, host, timeout, pingnum
rmutils.write(
ser, mycmd,
delay=6) # Write a ping command; Wait timeout plus 2 seconds
def get_psm_info(self, verbose):
ser = self.myserial
# Check on urc setting
psmsettings = rmutils.write(ser, 'AT+CGEREP?', verbose=verbose) # Check if urc enabled
# Check general Power Savings setting
rmutils.write(ser, 'AT+UPSV?', verbose=verbose) # Get general power savings config
return super().get_psm_info('+UCPSMS', 2, 2, verbose)
def udp_echo(self, host, port, echo_delay, echo_wait, verbose=True):
echo_host = '35.212.147.4'
echo_port = '3030'
listen_port = '3032'
ser = self.myserial
# Create a packet session in case there is not one
self.create_packet_session()
# Close socket if open
rmutils.write(ser, 'AT#SL=1,0,' + listen_port + ',0', delay=1)
rmutils.write(ser, 'AT#SH=1', delay=1)
# Create UDP socket for sending and receiving
mycmd = 'AT#SD=1,1,' + echo_port + ',"' + echo_host + '",0,' + listen_port + ',1,0,1'
rmutils.write(ser, mycmd, delay=1)
# Send our UDP packet
udppacket = str(
'{"delay":' + str(echo_delay * 1000) + ', "ip":' + self.my_ip
+ ',"port":' + listen_port + '}' + chr(26))
rmutils.write(ser, 'AT#SSEND=1', udppacket, delay=1) # Sending packets to socket
aerisutils.print_log('Sent Echo command to remote UDP server')
# Wait for data
if echo_wait > 0:
echo_wait = round(echo_wait + echo_delay)
# Wait for data to come in; handle case where we go to sleep
rmutils.wait_urc(ser, echo_wait, self.com_port, returnonreset=True,
returnonvalue='APP RDY')
# Try to read data
rmutils.write(ser, 'AT#SRECV=1,1500,1', delay=1)
def udp_echo(self, host, port, echo_delay, echo_wait, verbose=True):
ser = self.myserial
echo_host = '35.212.147.4'
port = '3030'
write_sock = '0' # Use socket 0 for sending
if self.udp_listen(port, 0, verbose=verbose): # Open listen port
aerisutils.print_log('Listening on port: ' + port)
else:
return False
# Open UDP socket to the host for sending echo command
rmutils.write(ser, 'AT+QICLOSE=0', delay=1,
verbose=verbose) # Make sure no sockets open
mycmd = 'AT+QIOPEN=1,0,\"UDP\",\"' + echo_host + '\",' + port + ',0,1'
rmutils.write(
ser, mycmd, delay=1,
verbose=verbose) # Create UDP socket connection as a client
sostate = rmutils.write(ser, 'AT+QISTATE=1,0',
verbose=verbose) # Check socket state
if "UDP" not in sostate: # Try one more time with a delay if not connected
sostate = rmutils.write(ser,
'AT+QISTATE=1,0',
delay=1,
verbose=verbose) # Check socket state
# Send data
udppacket = str('{"delay":' + str(echo_delay * 1000) + ', "ip":"' +
self.my_ip + '","port":' + str(port) + '}')
#udppacket = str('Echo test!')
# print('UDP packet: ' + udppacket)
mycmd = 'AT+QISEND=0,' + str(len(udppacket))
rmutils.write(ser, mycmd, udppacket, delay=0,
verbose=verbose) # Write udp packet
rmutils.write(ser, 'AT+QISEND=0,0',
verbose=verbose) # Check how much data sent
aerisutils.print_log('Sent echo command: ' + udppacket)
if echo_wait == 0:
# True indicates we sent the echo
return True
else:
echo_wait = round(echo_wait + echo_delay)
vals = rmutils.wait_urc(
ser,
echo_wait,
self.com_port,
returnonreset=True,
returnonvalue='OK'
) # Wait up to X seconds to confirm data sent
#print('Return: ' + str(vals))
vals = rmutils.wait_urc(
ser,
echo_wait,
self.com_port,
returnonreset=True,
returnonvalue='+QIURC:'
) # Wait up to X seconds for UDP data to come in
vals = super().parse_response(vals, '+QIURC:')
print('Return: ' + str(vals))
if len(vals) > 2 and int(vals[2]) == len(udppacket):
return True
else:
return False
def gps_config(self):
ser = self.myserial
# Enable GPSOneExtra
rmutils.write(ser, 'AT+QGPSXTRA=1')
# Download and save GPSOneExtra data file
print('Downloading GPSOneExtra data file.')
#url = 'http://xtrapath1.izatcloud.net/xtra2.bin'
url = 'http://xtrapath4.izatcloud.net/xtra2.bin'
r = requests.get(url, allow_redirects=True)
src_path = str(pathlib.Path.home()) + '/'
f = open(src_path + 'xtra2.bin', 'wb')
f.write(r.content)
f.close()
# Upload to the module
self.file_upload(src_path, 'UFS:', 'xtra2.bin')
# Inject time
from datetime import datetime, timezone
my_datetime = datetime.now(timezone.utc).strftime("%Y/%m/%d,%H:%M:%S")
rmutils.write(ser, 'AT+QGPSXTRATIME=0,"' + my_datetime + '",1,1,3500')
# Inject data file
rmutils.write(ser, 'AT+QGPSXTRADATA="UFS:xtra2.bin"')
# Now we can delete the data file from the file system
rmutils.write(ser, 'AT+QFDEL="UFS:xtra2.bin"')
# Now turn on gps
rmutils.write(ser, 'AT+QGPS=1')
return True
def list_app(self):
ser = self.myserial
mycmd = 'AT+QFLST="EUFS:/datatx/*"'
#mycmd = 'AT+QFLST="EUFS:*"'
rmutils.write(ser, mycmd)
#rmutils.wait_urc(ser, 20, self.com_port)
return True
def sms_wait(self, time, verbose):
rmutils.write(
self.myserial,
'AT+QURCCFG="urcport","usbat"') # Send URCs to USB AT port
rmutils.write(self.myserial,
'AT+CNMI=2,1,0,1,0') # Enable URC notifications
return super().sms_wait(time, verbose)
def enable_psm(self, tau_time, atime, verbose=True):
ser = self.myserial
super().enable_psm(tau_time, atime, verbose)
rmutils.write(ser, 'AT+QCFG="psm/urc",1',
verbose=verbose) # Enable urc for PSM
aerisutils.print_log(
'PSM is enabled with TAU: {0} s and AT: {1} s'.format(
str(tau_time), str(atime)))
def delete_app(self, filename):
ser = self.myserial
#filename = 'oem_app_disable.ini'
#filename = 'program.bin'
path = '/datatx/' + filename
mycmd = 'AT+QFDEL="EUFS:' + path + '"'
rmutils.write(ser, mycmd)
return True
def lookup(self, host, verbose):
ser = self.myserial
self.create_packet_session()
rmutils.write(ser, 'AT+QIDNSCFG=1') # Check DNS server
mycmd = 'AT+QIDNSGIP=1,\"' + host + '\"'
rmutils.write(ser, mycmd, timeout=0) # Write a dns lookup command
rmutils.wait_urc(
ser, 4, self.com_port
) # Wait up to 4 seconds for results to come back via urc
def close_socket(self, socket_id = None, verbose=True):
ser = self.myserial
if socket_id is None:
for i in range(7):
# Close socket
mycmd = 'AT+USOCL=' + str(i)
rmutils.write(ser, mycmd, verbose=verbose)
else:
mycmd = 'AT+USOCL=' + str(socket_id)
rmutils.write(ser, mycmd, verbose=verbose)
def udp_listen(self,
listen_port,
listen_wait,
verbose=True,
returnbytes=False):
'''Starts listening for UDP packets.
Parameters
----------
listen_port : int
The port on which to listen.
listen_wait : int
Greater than zero if this method should wait for that many seconds for received packets.
If less than or equal to zero, this method will return a boolean type.
verbose : bool, optional
returnbytes : bool, optional
If True, returns bytes, instead of a string.
Returns
-------
s : bool
False if a packet data session was not active, or if setting up the UDP socket failed.
True if the modem successfully started listening for packets.
m : str or bytes
Any URCs that arrived while listening for packets.
'''
ser = self.myserial
read_sock = '1' # Use socket 1 for listen
if self.create_packet_session(verbose=verbose):
aerisutils.print_log('Packet session active: ' + self.my_ip)
else:
return False
# Open UDP socket for listen
mycmd = 'AT+QIOPEN=1,' + read_sock + ',"UDP SERVICE","127.0.0.1",0,' + str(
listen_port) + ',1'
rmutils.write(ser, mycmd, delay=1,
verbose=verbose) # Create UDP socket connection
sostate = rmutils.write(ser,
'AT+QISTATE=1,' + read_sock,
verbose=verbose) # Check socket state
if "UDP" not in sostate: # Try one more time with a delay if not connected
sostate = rmutils.write(ser,
'AT+QISTATE=1,' + read_sock,
delay=1,
verbose=verbose) # Check socket state
if "UDP" not in sostate:
return False
# Wait for data
if listen_wait > 0:
return rmutils.wait_urc(
ser,
listen_wait,
self.com_port,
returnonreset=True,
returnbytes=returnbytes
) # Wait up to X seconds for UDP data to come in
return True
def download_app(self):
ser = self.myserial
#filename = 'oem_app_disable.ini'
filename = 'oem_app_path.ini'
mycmd = 'AT+QFDWL="EUFS:/datatx/' + filename + '"'
rmutils.write(ser, mycmd)
char = ''
while char is not None:
char = self.getc()
print('Char: ' + str(char))
return True
def create_packet_session(self):
ser = self.myserial
#rmutils.write(ser, 'AT#SCFG?') # Prints Socket Configuration
#constate = rmutils.write(ser, 'AT#SGACT?', verbose=self.verbose) # Check if we are already connected
if not self.get_packet_info(): # Check if already in a packet sessiion
rmutils.write(ser, 'AT#SGACT=1,1', delay=1, verbose=self.verbose) # Activate context / create packet session
# constate = rmutils.write(ser, 'AT#SGACT?', verbose=self.verbose) # Verify that we connected
# self.parse_connection_state(constate)
if not self.get_packet_info():
return False
response = rmutils.write(ser, 'AT+CGPADDR=1', delay=1)
self.get_module_ip(response)
return True
def get_psm_info(self, verbose):
ser = self.myserial
psmsettings = rmutils.write(
ser, 'AT+QPSMCFG?',
verbose=verbose) # Check PSM feature mode and min time threshold
vals = super().parse_response(psmsettings, '+QPSMCFG:')
print('Minimum seconds to enter PSM: ' + vals[0])
print('PSM mode: ' + self.psm_mode(int(vals[1])))
# Check on urc setting
psmsettings = rmutils.write(ser, 'AT+QCFG="psm/urc"',
verbose=verbose) # Check if urc enabled
vals = super().parse_response(psmsettings, '+QCFG: ')
print('PSM unsolicited response codes (urc): ' + vals[1])
# Query settings
return super().get_psm_info('+QPSMS', 2, 10, verbose)
def udp_echo(self, host, port, echo_delay, echo_wait, verbose=True):
ser = self.myserial
echo_host = host
listen_port = port
udp_socket = 0
# echo_host = '195.34.89.241' # ublox echo server
# port = '7' # ublox echo server port
# Make sure we have a packet session
self.create_packet_session(verbose=verbose)
# Close our read socket
self.close_socket(udp_socket, verbose)
# Create a UDP socket
mycmd = 'AT+USOCR=17,' + str(listen_port)
socket_id = (super().get_values_for_cmd(mycmd,'+USOCR:'))[0]
#print('Socket ID = ' + str(socket_id))
# Send data
udppacket = str(
'{"delay":' + str(echo_delay * 1000) + ', "ip":"'
+ self.my_ip + '","port":' + str(listen_port) + '}')
mycmd = 'AT+USOST=' + str(socket_id) + ',"' + echo_host + '",' + str(port) + ',' + str(len(udppacket))
rmutils.write(ser, mycmd, udppacket, delay=0, verbose=verbose) # Write udp packet
aerisutils.print_log('Sent echo command: ' + udppacket, verbose)
# Always wait long enough to verify packet sent
vals = rmutils.wait_urc(ser, 5, self.com_port, returnonvalue='OK', verbose=verbose)
#print('Return: ' + str(vals))
if echo_wait == 0:
# True indicates we sent the echo
return True
else:
# Wait for data
echo_wait = round(echo_wait + echo_delay)
# vals = rmutils.wait_urc(ser, echo_wait, self.com_port, returnonreset=True,
# returnonvalue='APP RDY') # Wait up to X seconds for UDP data to come in
vals = rmutils.wait_urc(ser, echo_wait, self.com_port, returnonreset=True,
returnonvalue='+UUSORF:', verbose=verbose)
#print('Return: ' + str(vals))
mycmd = 'AT+USORF=0,' + str(len(udppacket))
#vals = rmutils.write(ser, mycmd, verbose=verbose) # Read from socket
vals = (super().get_values_for_cmd(mycmd,'+USORF:'))
#print('Return: ' + str(vals))
if len(vals) > 3 and int(vals[3]) == len(udppacket):
return True
else:
return False
def network_config_ec25(self):
ser = self.myserial
# Set scan sequence to LTE
rmutils.write(ser, 'AT+QCFG="nwscanseq",04')
# Set scan mode to LTE
rmutils.write(ser, 'AT+QCFG="nwscanmode",3,1')
# Quectel - Service Domain 1 = PS; 2 = CS & PS
rmutils.write(ser, 'AT+QCFG="servicedomain",2,1')
#rmutils.write(ser, 'AT+QCFG="servicedomain",1,1')
# Quectel - Enable roaming 2 = enabled
rmutils.write(ser, 'AT+QCFG="roamservice",2,1')
return True
def create_packet_session(self, verbose=True):
ser = self.myserial
rmutils.write(ser, 'AT+CGDCONT=1,"IP","' + self.apn + '"', verbose=verbose)
rmutils.write(ser, 'AT+CGACT=1,1', verbose=verbose) # Activate context / create packet session
constate = rmutils.write(ser, 'AT+CGDCONT?', verbose=verbose) # Check if we are already connected
if not self.parse_constate(constate): # Returns packet session info if in session
rmutils.write(ser, 'AT+CGACT=1,1', verbose=verbose) # Activate context / create packet session
constate = rmutils.write(ser, 'AT+CGDCONT?', verbose=verbose) # Verify that we connected
self.parse_constate(constate)
if not self.parse_constate(constate):
return False
return True
def load_app(self, path, filename):
ser = self.myserial
#filename = 'oem_app_path.ini'
#filename = 'program.bin'
#path = '/home/pi/share/pio-bg96-1/.pio/build/bg96/' + filename
stats = os.stat(path + filename)
filesize = stats.st_size
print('Size of file is ' + str(stats.st_size) + ' bytes')
f = open(path + filename, 'rb')
mycmd = 'AT+QFUPL="EUFS:/datatx/' + filename + '",' + str(filesize)
rmutils.write(ser, mycmd)
i = 0
while i < filesize:
self.putc(f.read(1))
i += 1
f.close()
rmutils.wait_urc(
ser, 5, self.com_port
) # Wait up to 5 seconds for results to come back via urc
return True
def file_upload(self, src_path, dst_path, filename):
ser = self.myserial
# Ensure source file exists
stats = os.stat(src_path + filename)
filesize = stats.st_size
print('Size of file is ' + str(stats.st_size) + ' bytes')
# Open source file for reading
f = open(src_path + filename, 'rb')
# Issue upload command to destination path
#mycmd = 'AT+QFUPL="EUFS:/datatx/' + filename+ '",' + str(filesize)
mycmd = 'AT+QFUPL="' + dst_path + filename + '",' + str(filesize)
rmutils.write(ser, mycmd)
i = 0
while i < filesize:
self.putc(f.read(1))
i += 1
f.close()
rmutils.wait_urc(
ser, 5, self.com_port
) # Wait up to 5 seconds for results to come back via urc
return True
def http_get(self, url, verbose):
url_values = urlsplit(url) # Parse URL to get Host & Path
if url_values.netloc:
host = url_values.netloc
path = url_values.path
else:
host = url_values.path
path = '/'
ser = self.myserial
self.create_packet_session()
rmutils.write(ser, 'AT#HTTPCFG=0,\"' + host + '\",80,0,,,0,120,1') # Establish HTTP Connection
rmutils.write(ser, 'AT#HTTPQRY=0,0,\"' + path + '\"', delay=2) # Send HTTP Get
rmutils.write(ser, 'AT#HTTPRCV=0', delay=2) # Receive HTTP Response
rmutils.write(ser, 'AT#SH=1', delay=2) # Close socket
def test(ctx, timeout, psmtau, psmat, delay):
"""Test PSM mode
\f
"""
echo_host = '35.212.147.4'
echo_port = 3030
echo_delay = delay
echo_wait = 4
# Enable PSM
my_module.enable_psm(psmtau, psmat, verbose=ctx.obj['verbose'])
time.sleep(1.0) # Sleep to allow enable to complete
# Make sure network allowed the configuration we asked for
psm_settings = my_module.get_psm_info(ctx.obj['verbose'])
if 'tau_network' not in psm_settings:
exit()
tau_network = int(psm_settings['tau_network'])
if tau_network - psmtau > 120:
my_module.disable_psm(verbose=ctx.obj['verbose'])
aerisutils.print_log('Network settings not within tolerance.')
return False
aerisutils.print_log('Network tau: ' + str(tau_network))
# Get ready to do some timing
start_time = time.time()
elapsed_time = 0
aerisutils.print_log('Starting test for {0} seconds'.format(timeout))
while elapsed_time < timeout:
#my_module.udp_echo(delay, 4, verbose=ctx.obj['verbose'])
success = my_module.udp_echo(echo_host, echo_port, echo_delay, echo_wait, verbose=ctx.obj['verbose'])
aerisutils.print_log('Success: ' + str(success))
rmutils.wait_urc(my_module.myserial, timeout, my_module.com_port, returnonreset=True, returnonvalue='APP RDY',
verbose=ctx.obj['verbose']) # Wait up to X seconds for app rdy
time.sleep(5.0) # Sleep in case it helps telit be able to connect
my_module.init_serial(ctx.obj['comPort'], ctx.obj['apn'], verbose=ctx.obj['verbose'])
rmutils.write(my_module.myserial, 'ATE0', verbose=ctx.obj['verbose']) # Turn off echo
aerisutils.print_log('Connection state: ' + str(my_module.get_packet_info(verbose=ctx.obj['verbose'])))
elapsed_time = time.time() - start_time
# Do some cleanup tasks
my_module.disable_psm(verbose=ctx.obj['verbose'])
aerisutils.print_log('Finished test')
def gps_time(self):
ser = self.myserial
# Inject time
from datetime import datetime, timezone
my_datetime = datetime.now(timezone.utc).strftime("%Y/%m/%d,%H:%M:%S")
rmutils.write(ser, 'AT+QGPSXTRATIME=0,"' + my_datetime + '",1,1,3500')
# Check if GPSOneExtra is enabled
rmutils.write(ser, 'AT+QGPSXTRA?')
# Check GPSOneExtra data file
rmutils.write(ser, 'AT+QGPSXTRADATA?')
return True
def file_list(self):
ser = self.myserial
# User file system
mycmd = 'AT+QFLST="UFS:*"'
rmutils.write(ser, mycmd)
# Extended User file system
mycmd = 'AT+QFLST="EUFS:*"'
rmutils.write(ser, mycmd)
# Extended User file system - threadx
mycmd = 'AT+QFLST="EUFS:/datatx/*"'
rmutils.write(ser, mycmd)
return True
def udp_listen(self, listen_port, listen_wait, verbose=True):
ser = self.myserial
udp_socket = 0
if self.create_packet_session(verbose=verbose):
aerisutils.print_log('Packet session active: ' + self.my_ip)
else:
return False
# Close our read socket
self.close_socket(udp_socket, verbose)
# Open UDP socket
socket_id = (super().get_values_for_cmd('AT+USOCR=17','+USOCR:'))[0]
print('Socket ID = ' + str(socket_id))
# Listen on udp socket port
mycmd = 'AT+USOLI=' + str(socket_id) + ',' + str(listen_port)
val = rmutils.write(ser, mycmd, verbose=verbose)
# Wait for data up to X seconds
if listen_wait > 0:
rmutils.wait_urc(ser, listen_wait, self.com_port, returnonreset=True)
return True
def udp_listen(self, listen_wait, verbose):
ser = self.myserial
read_sock = '1' # Use socket 1 for listen
if self.create_packet_session():
aerisutils.print_log('Packet session active: ' + self.my_ip)
else:
return False
# Open UDP socket for listen
rmutils.write(ser, 'AT#SLUDP=1,1,3030', delay=1) # Starts listener
rmutils.write(ser, 'AT#SS', delay=1)
if listen_wait > 0:
rmutils.wait_urc(ser, listen_wait, self.com_port, returnonreset=True) # Wait up to X seconds for UDP data to come in
rmutils.write(ser, 'AT#SS', delay=1)
return True
def fw_update(self):
ser = self.myserial
modem = XMODEM(self.getc, self.putc)
# stream = open('/home/pi/share/fw/0bb_stg1_pkg1-0m_L56A0200_to_L58A0204.bin', 'rb')
stream = open('/home/pi/share/fw/0bb_stg2_L56A0200_to_L58A0204.bin', 'rb')
rmutils.write(ser, 'AT+UFWUPD=3')
rmutils.wait_urc(ser, 20, self.com_port)
modem.send(stream)
stream.close()
ser.flushOutput()
rmutils.wait_urc(ser, 20, self.com_port)
# print(stream)
rmutils.write(ser, 'AT+UFWINSTALL')
rmutils.write(ser, 'AT+UFWINSTALL?')
def network_config(self, mod, b25, bfull, gsm, catm, catnb, verbose):
print("Mod: " + mod)
if mod is 'ec25':
print("Configuring ec25")
return self.network_config_ec25()
ser = self.myserial
# Set scan sequence
rmutils.write(ser, 'AT+QCFG="nwscanseq",020301,1')
if gsm and not catm:
# Set scan mode to auto
rmutils.write(ser, 'AT+QCFG="nwscanmode",1,1')
elif gsm:
# Set scan mode to auto
rmutils.write(ser, 'AT+QCFG="nwscanmode",0,1')
# Quectel - IoT operating mode - auto
rmutils.write(ser, 'AT+QCFG="iotopmode",2,1')
elif catm:
# Set scan mode to LTE only
rmutils.write(ser, 'AT+QCFG="nwscanmode",3,1')
# Quectel - IoT operating mode - CAT-M only
rmutils.write(ser, 'AT+QCFG="iotopmode",0,1')
# Quectel - IoT operating mode - NB only
#rmutils.write(ser, 'AT+QCFG="iotopmode",1,1')
else:
# Set scan mode to auto
rmutils.write(ser, 'AT+QCFG="nwscanmode",0,1')
# Quectel - IoT operating mode - auto
rmutils.write(ser, 'AT+QCFG="iotopmode",2,1')
if bfull:
# Set enabled bands with all
rmutils.write(ser, 'AT+QCFG="band",f,400b0e189f,b0e189f,1')
elif b25:
# Set enabled bands with band 2, 12, 25
rmutils.write(ser, 'AT+QCFG="band",F,1000802,802,1')
else:
# Set enabled bands with band 2, 12 no band 25
rmutils.write(ser, 'AT+QCFG="band",F,802,802,1')
# Quectel - Service Domain 1 = PS; 2 = CS & PS
rmutils.write(ser, 'AT+QCFG="servicedomain",2,1')
#rmutils.write(ser, 'AT+QCFG="servicedomain",1,1')
# Quectel - Enable roaming 2 = enabled
rmutils.write(ser, 'AT+QCFG="roamservice",2,1')
def gps_disable(self):
ser = self.myserial
# Disable / end gps
rmutils.write(ser, 'AT+QGPSEND')
return True
def gps_enable(self):
ser = self.myserial
# Now turn on gps
rmutils.write(ser, 'AT+QGPS=1')
return True
