def lte_connect():
lte = LTE()
lte.init()
#some carriers have special requirements, check print(lte.send_at_cmd("AT+SQNCTM=?")) to see if your carrier is listed.
#when using verizon, use
#lte.init(carrier=verizon)
#when usint AT&T use,
#lte.init(carrier=at&t)
#some carriers do not require an APN
#also, check the band settings with your carrier
lte.attach(band=2, apn="vzwinternet")
print("attaching..", end='')
while not lte.isattached():
time.delay(0.25)
print('.', end='')
print(lte.send_at_cmd('AT!="fsm"')) # get the System FSM
print("attached!")
lte.connect()
print("connecting [##", end='')
while not lte.isconnected():
time.sleep(0.25)
print('#', end='')
#print(lte.send_at_cmd('AT!="showphy"'))
print(lte.send_at_cmd('AT!="fsm"'))
print("] connected!")
print(socket.getaddrinfo('pycom.io', 80))
lte.deinit()
def whoami(verbose=False, veryverbose=False):
import machine
import binascii
import os
uid = binascii.hexlify(machine.unique_id())
name = os.uname().sysname.lower() + '-' + uid.decode("utf-8")[-4:]
print(name)
print(os.uname())
if verbose:
print("type", fw_type())
for attr in dir(os.uname()):
if attr[0] != '_':
# filter out __class__
print(attr, getattr(os.uname(), attr))
if veryverbose:
if os.uname().nodename == 'GPy' or os.uname().nodename == 'FiPy':
from network import LTE
lte = LTE()
ver = lte.send_at_cmd('ATI1').split('\r\n')[2]
prot = 'unknown'
import re
if re.search('^LR5', ver):
prot = 'CAT-M1'
elif re.search('^LR6', ver):
prot = 'NB-IoT'
print('Sequans FW', ver, prot)
class SQNS:
"""Synopsis::
sq = SQNS()
sq.info()
sq.firmware_info()
sq.at('showphy')
"""
def __init__(self):
from network import LTE
self.lte = LTE()
self.at('RRC:setDbgPerm full')
def at(self, command):
"""
:param command:
"""
self.raw('AT!="{}"'.format(command))
def raw(self, command):
"""
:param command:
"""
print('Sending command {}'.format(command))
print(self.lte.send_at_cmd(command))
def imei(self):
""" """
self.at('AT+CGSN=1')
def info(self):
""" """
# https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/8
self.at('AT')
self.at('ATI')
self.at('ATZ')
def firmware_info(self):
""" """
import sqnsupgrade
sqnsupgrade.info(verbose=True, debug=True)
def unbrick(self):
""" """
raise NotImplementedError('https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/21')
def sendData(dataList, deviceKey):
# ******************** Hologram endpoint Definition
HOST = "cloudsocket.hologram.io"
PORT = 9999
TOPIC = "SENSOR_DATA"
blink(1, 0xffffff) # blink white
# Set up LTE connection
lte = LTE()
lte.init()
print("Resetting LTE modem ... ", end="")
lte.send_at_cmd('AT^RESET')
print("Reset OK")
time.sleep(1)
# While the configuration of the CGDCONT register survives resets,
# the other configurations don't. So just set them all up every time.
print("Configuring LTE ", end='')
# Changed this from origninal
lte.send_at_cmd('AT+CGDCONT=1,"IP","hologram"')
print(".", end='')
# changed band from 28 to 4. I dont know what earfcn=9410 is;
lte.send_at_cmd('AT!="RRC::addscanfreq band=4 dl-earfcn=9410"')
print(".", end='')
# lte.send_at_cmd
# Do the attach (Enable radio functionality and attach to the LTE network authorized by the inserted SIM card)
lte.attach()
print("attaching..", end='')
while not lte.isattached():
blink(1, 0x0000ff) # blue
print('.', end='')
# print(lte.send_at_cmd('AT!="fsm"')) # get the System FSM
print("attached!")
# Do the connect (Start a data session and obtain and IP address)
lte.connect()
print("connecting [##", end='')
while not lte.isconnected():
time.sleep(1)
print('#', end='')
print("] connected!")
blink(1, 0x00ff00) # Green
# **** Send data to hologram
bodyData = buildData(dataList)
lteSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lteSocket.connect(socket.getaddrinfo(HOST, PORT)[0][-1])
data = '{"k": "%s", "d": "{%s}", "t": "%s"}' % (deviceKey, bodyData, TOPIC)
print("Send Data:", data)
lteSocket.send(data)
# Clean up and close connection
lteSocket.close()
lte.deinit()
print("Disconnected")
blink(1, 0xff0000) # red
at("AT+CEREG=?") # in E-UTRAN: i) Active Time value and ii) the extended periodic TAU value that are allocated to the UE by the network
at("AT+CEREG?")
at("AT+CGREG=?") # in GERAN/UTRAN : i) Active Time value, ii) the extended periodic RAU value and iii) the GPRS READY timer value that are allocated to the UE by the network
at("AT+CGREG?")
at("AT")
print("is_connected", lte.isconnected())
print("ue_coverage", lte.ue_coverage())
print("iccid", lte.iccid())
print("time", lte.time())
print(lte.send_at_cmd('AT!="IP::ping 8.8.8.8"'))
at('AT+CGMI')
# PYCOM
at('AT+CGMM')
# FiPy
at('AT+CGMR')
# UE5.0.0.0d
# imei
at('AT+CGSN=0')
at('AT+CGSN=1')
at('AT+CGSN=2')
at('AT+CGSN=3')
# +CGSN: "00"
class StartIoT:
def __init__(self, network=LTE_M):
self._network = network
self.lte = LTE()
try:
self.lte.deinit()
self.lte.reset()
except:
pass
sleep(5)
self.lte.init()
sleep(5)
self._assure_modem_fw()
def _assure_modem_fw(self):
response = self.lte.send_at_cmd('ATI1')
if response != None:
lines = response.split('\r\n')
fw_id = lines[1][0:3]
is_nb = fw_id == 'UE6'
if is_nb:
print('Modem is using NB-IoT firmware (%s/%s).' % (lines[1], lines[2]))
else:
print('Modem in using LTE-M firmware (%s/%s).' % (lines[1], lines[2]))
if not is_nb and self._network == NB_IOT:
print('You cannot connect using NB-IoT with wrong modem firmware! Please re-flash the modem with the correct firmware.')
raise WrongNetwork
if is_nb and self._network == LTE_M:
print('You cannot connect using LTE-M with wrong modem firmware! Please re-flash the modem with the correct firmware.')
raise WrongNetwork
else:
print('Failed to determine modem firmware. Rebooting device...')
reset() # Reboot the device
def send_at_cmd_pretty(self, cmd):
print('>', cmd)
response = self.lte.send_at_cmd(cmd)
if response != None:
lines = response.split('\r\n')
for line in lines:
if len(line.strip()) != 0:
print('>>', line)
else:
print('>> No response.')
return response
def connect(self):
# NB-IoT
if (self._network == NB_IOT):
self.send_at_cmd_pretty('AT+CFUN=0')
self.send_at_cmd_pretty('AT+CEMODE=0')
self.send_at_cmd_pretty('AT+CEMODE?')
self.send_at_cmd_pretty('AT!="clearscanconfig"')
self.send_at_cmd_pretty('AT!="addscanfreq band=%s dl-earfcn=%s"' % (BAND, EARFCN))
self.send_at_cmd_pretty('AT+CGDCONT=1,"IP","%s"' % APN)
self.send_at_cmd_pretty('AT+COPS=1,2,"%s"' % COPS)
self.send_at_cmd_pretty('AT+CFUN=1')
# LTE-M (Cat M1)
else:
self.send_at_cmd_pretty('AT+CFUN=0')
self.send_at_cmd_pretty('AT!="clearscanconfig"')
self.send_at_cmd_pretty('AT!="addscanfreq band=%s dl-earfcn=%s"' % (BAND, EARFCN))
self.send_at_cmd_pretty('AT+CGDCONT=1,"IP","%s"' % APN)
self.send_at_cmd_pretty('AT+CFUN=1')
self.send_at_cmd_pretty('AT+CSQ')
# For a range scan:
# AT!="addscanfreqrange band=20 dl-earfcn-min=3450 dl-earfcn-max=6352"
print('Attaching...')
seconds = 0
while not self.lte.isattached() and seconds < attach_timeout:
sleep(0.25)
seconds += 0.25
if self.lte.isattached():
print('Attached!')
else:
print('Failed to attach to LTE (timeout)!')
raise AttachTimeout
self.lte.connect()
print('Connecting...')
seconds = 0
while not self.lte.isconnected() and seconds < connect_timeout:
sleep(0.25)
seconds += 0.25
if self.lte.isconnected():
print('Connected!')
else:
print('Failed to connect to LTE (timeout)!')
raise ConnectTimeout
def disconnect(self):
if self.lte.isconnected():
self.lte.disconnect()
def dettach(self):
if self.lte.isattached():
self.lte.dettach()
class LteComms:
def __init__(self):
self.message_storage = 'AT+CPMS="SM", "SM", "SM"'
gc.collect()
try:
self.lte = LTE()
time.sleep(4)
except:
print("initialize LTE object?")
self.lte.reset()
time.sleep(4)
print("delay 4 secs")
def at(self, cmd):
print("modem command: {}".format(cmd))
r = self.lte.send_at_cmd(cmd).split('\r\n')
r = list(filter(None, r))
print("response={}".format(r))
return r
def attach_LTE(self):
gc.collect()
time.sleep(10.0)
if self.lte.isattached():
try:
print("LTE was already attached, disconnecting...")
if self.lte.isconnected():
print("disconnect")
self.lte.disconnect()
except:
print("Exception during disconnect")
try:
if self.lte.isattached():
print("detach")
self.lte.dettach()
except:
print("Exception during dettach")
try:
print("resetting modem...")
self.lte.reset()
except:
print("Exception during reset")
print("delay 5 secs")
time.sleep(5.0)
# enable network registration and location information, unsolicited result code
self.at('AT+CEREG=2')
# print("full functionality level")
self.at('AT+CFUN=1')
time.sleep(1.0)
# using Hologram SIM
self.at('AT+CGDCONT=1,"IP","hologram"')
print("attempt to attach cell modem to base station...")
# lte.attach() # do not use attach with custom init for Hologram SIM
self.at("ATI")
time.sleep(2.0)
i = 0
while self.lte.isattached() == False:
# get EPS Network Registration Status:
# +CEREG: <stat>[,[<tac>],[<ci>],[<AcT>]]
# <tac> values:
# 0 - not registered
# 1 - registered, home network
# 2 - not registered, but searching...
# 3 - registration denied
# 4 - unknown (out of E-UTRAN coverage)
# 5 - registered, roaming
r = self.at('AT+CEREG?')
try:
r0 = r[0] # +CREG: 2,<tac>
r0x = r0.split(',') # ['+CREG: 2',<tac>]
tac = int(r0x[1]) # 0..5
print("tac={}".format(tac))
except IndexError:
tac = 0
print("Index Error!!!")
# get signal strength
# +CSQ: <rssi>,<ber>
# <rssi>: 0..31, 99-unknown
r = self.at('AT+CSQ')
# extended error report
# r =self.at('AT+CEER')
# if lte.isattached():
# print("Modem attached (isattached() function worked)!!!")
# break
# if (tac==1) or (tac==5):
# print("Modem attached!!!")
# break
i = i + 5
print("not attached: {} secs".format(i))
# while self.lte.isattached():
# # self.receive_and_forward_to_chat()
# continue
# print("Modem not attached")
print("set to check messages on sim")
self.at(self.message_storage)
def connect_lte_data(self):
self.at('AT+CEREG?')
print("Attempt to connect")
if self.lte.isattached() == False:
print("Not attached, try again, will fail")
else:
print("Attached and continue")
self.lte.connect()
i = 0
while not self.lte.isconnected():
i = i + 1
print("not connected: {}".format(i))
time.sleep(1.0)
print("LTE connected for data!!!") # also send this to chat
# so just pymesh this to all nodes in leader_mesh_list
while self.lte.isconnected():
continue
def scrape_webpage(self, url):
s = socket.socket()
s = ssl.wrap_socket(s)
s.connect(socket.getaddrinfo(url, 443)[0][-1])
s.send(b"GET / HTTP/1.0\r\n\r\n")
print(s.recv(4096))
s.close()
def send_sms(self, number, msg):
# this will somehow have to be connected to the chat with a JM msg1
print("set mode to text")
self.at('AT+CMGF=1')
time.sleep(.5)
# msg = ('AT+CMGS="%s"\r%s\0x1a' % (number, msg))
# print(('ATTB+SQNSMSSEND="%s", "%s"' % (number, msg)))
print('sendin an sms', end=' ')
ans = self.lte.send_at_cmd(
('AT+SQNSMSSEND="%s", "%s"' % (number, msg))).split('\r\n')
print(ans)
# self.at(msg)
time.sleep(4)
print("sent!")
def receive_and_forward_to_chat(self):
# this will somehow have to be connected to the chat with a JM msg1
print("set mode to text")
self.at('AT+CMGF=1')
msg_list = []
msg_list = self.at('AT+CMGL="ALL"')
number_of_messages = 0
if len(msg_list) > 1:
print("This'll print if there a msg")
if len(msg_list) > 20:
print("More then 10 messages, loop")
i = 1
while len(msg_list) > 20:
print("This is the inner loop running %s times" % i)
msg_list = self.at('AT+CMGL="ALL"')
number_of_messages += len(msg_list)
self.write_msg_to_file_and_delete(msg_list)
time.sleep(15)
i += 1
print("This is to get the last group of messages")
# you don't scan for messages while it sleep, almost Need
# to run this in a thread in the background.
time.sleep(10)
msg_list = self.at('AT+CMGL="ALL"')
number_of_messages += len(msg_list)
self.write_msg_to_file_and_delete(msg_list)
else:
print("The list is less than 10, so straight to file")
number_of_messages += len(msg_list)
self.write_msg_to_file_and_delete(msg_list)
else:
print("This prints when no messages")
self.at('AT+CMGD=1,4')
# Cuz apparently you need to clean out the sim card, it only holds 10 msgs
# at('AT+CMGD=1,4')
time.sleep(5)
actual_messages = (number_of_messages / 2) - 1
print(actual_messages)
def msg_parse(self, msg_list):
parsed_msg_list = []
msg_list_string = "".join(msg_list)
split_msg_list = msg_list_string.split('+CMGL:')
for i in range(len(split_msg_list)):
temp_string = str(split_msg_list[i])
if temp_string[-2:] == 'OK':
parsed_msg_list.append(temp_string[:-2])
else:
parsed_msg_list.append(temp_string)
return parsed_msg_list
def disconnect_LTE(self):
self.lte.disconnect()
print("LTE Data disconnected")
# send to chat
def unattach_lte(self):
self.lte.detach(reset=True)
print("LTE modem deattached")
def signal_strength(self):
self.at('AT+CSQ')
def check_read_sms(self):
self.at('AT+CMGF=1')
msg_list = self.at('AT+CMGL="ALL"')
print(msg_list)
def write_msg_to_file_and_delete(self, msg_list):
parsed_msg_list = self.msg_parse(msg_list)
print("Writing to SMS log")
f = open('/sd/www/sms.txt', 'a+')
for i in range(len(parsed_msg_list)):
if parsed_msg_list[i] != '\r\n':
f.write(str(parsed_msg_list[i]))
f.write('\r\n')
f.close()
self.at('AT+CMGD=1,4')
from network import LTE
print('init')
lte = LTE(debug=True)
print('at')
lte.send_at_cmd('AT')
print('version')
lte.send_at_cmd('ATI1')
class SQNS:
"""
Synopsis::
sq = SQNS()
sq.info()
sq.firmware_info()
sq.at('showphy')
See also:
- https://git.cicer.de/autonome-zelle/fipy-nbiot-rtd/blob/master/main.py
"""
def __init__(self):
from network import LTE
self.lte = LTE()
self.at('RRC:setDbgPerm full')
def connect(self):
self.lte.init()
def attach(self):
self.lte.attach(band=8, apn="iot.1nce.net")
while not self.lte.isattached(): # do we have a timeout?
time.sleep(1)
try:
csq_at = self.lte.send_at_cmd("AT+CSQ")
csq_line_regex = ure.compile("\n")
csq_line = csq_line_regex.split(csq_at)
csq_string_regex = ure.compile(" ")
csq_string = csq_string_regex.split(csq_line[1])
csq_comma = csq_string[1]
csq_num_regex = ure.compile(",")
csq_num = csq_num_regex.split(csq_comma)
csq = csq_num[0]
print("[LTE ] ... still attaching ... (CSQ: " + csq + ")")
except:
csq = "-999.0"
print(
"[LTE ] ... no CSQ recevied, let us hope I am still attaching "
+ csq)
def at(self, command):
"""
:param command:
"""
self.raw('AT!="{}"'.format(command))
def raw(self, command):
"""
:param command:
"""
print('Sending command {}'.format(command))
print(self.lte.send_at_cmd(command))
def imei(self):
""" """
self.at('AT+CGSN=1')
def info(self):
""" """
# https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/8
self.at('AT')
self.at('ATI')
self.at('ATZ')
def firmware_info(self):
""" """
import sqnsupgrade
sqnsupgrade.info(verbose=True, debug=True)
def unbrick(self):
""" """
raise NotImplementedError(
'https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/21'
)
import socket
start = time.ticks_ms()
lte = LTE()
print("\nModem is activated, time needed (s): ",
time.ticks_diff(time.ticks_ms(), start) / 10000)
start = time.ticks_ms()
lte.attach(band=20, apn="company.iot.dk1.tdc")
while not lte.isattached():
time.sleep(0.5)
print(".", end="")
print("\nAttached to the Network!, time needed (s): ",
time.ticks_diff(time.ticks_ms(), start) / 10000)
start = time.ticks_ms()
lte.connect() # starting a data section and obtaining an ip address
while not lte.isconnected():
time.sleep(0.5)
print("-", end="")
print("Connected to the Network Operator!, time needed (s): ",
time.ticks_diff(time.ticks_ms(), start) / 1000)
lte.disconnect() # Dissconnect the module and send at commands
while lte.disconnect():
#time.sleep(0.5)
print("Disconnected!")
lte.send_at_cmd("AT+CSQ") # Check the Signal Strength
print("-", end="")
\
# Need to use global variables.\
# If in each function you delare a new reference, functionality is broken\
lte = LTE()\
\
# Returns a network.LTE object with an active Internet connection.\
def getLTE():\
\
# If already used, the lte device will have an active connection.\
# If not, need to set up a new connection.\
if lte.isconnected():\
return lte\
\
# Modem does not connect successfully without first being reset.\
print("Resetting LTE modem ... ", end='')\
lte.send_at_cmd('AT^RESET')\
print("OK")\
time.sleep(1)\
\
# While the configuration of the CGDCONT register survives resets,\
# the other configurations don't. So just set them all up every time.\
print("Configuring LTE ", end='')\
lte.send_at_cmd('AT+CGDCONT=1,"IP","vodafone.internet"')\
print(".", end='')\
lte.send_at_cmd('AT!="RRC::addscanfreq band=20 dl-earfcn=6300"')\
print(".", end='')\
lte.send_at_cmd('AT+CFUN=1')\
print(" OK")\
\
# If correctly configured for carrier network, attach() should succeed.\
if not lte.isattached():\
# [email protected] # # 2023-apr-23 # from network import LTE import time import socket lte = LTE() #some carriers have special requirements, check print(lte.send_at_cmd("AT+SQNCTM=?")) to see if your carrier is listed. #when using verizon, use #lte.init(carrier=verizon) #when usint AT&T use, #lte.init(carrier=at&t) print(lte.send_at_cmd("AT+SQNCTM=?")) #some carriers do not require an APN #also, check the band settings with your carrier lte = LTE() print("----AT+CGMI----") #lte.send_at_cmd('AT+CFUN=0') #lte.send_at_cmd('AT!="clearscanconfig"') #lte.send_at_cmd('AT!="addscanfreq band=28 dl-earfcn=9410"') #lte.send_at_cmd('AT+CGDCONT=1, "IP", "telstra.internet"') #lte.send_at_cmd('AT+CEMODE=0') #lte.send_at_cmd('AT+CEREG=2') #lte.send_at_cmd('AT+CFUN=1') lte.send_at_cmd('AT+CGMI') ###
from network import LTE
lte = LTE()
lte.send_at_cmd('AT+CGSN=1')
print (" ccid = " + str(ccid))
if ccid:
break
time.sleep(3)
print("Attempting to attach...", end="")
#vodafone uk:
lte.attach(band=20,apn="ep.inetd.gdsp")
#comms365:
#lte.attach(band=20, apn="nb.iot.com")
for j in range(10):
print(".", end ="")
time.sleep(1)
if lte.isattached():
print("\nAttached in attempt #"+str(j+1))
break
lte.send_at_cmd('AT+CEREG?').replace('\r\n','')
#NOTE: for Vodafone UK: AT+COPS=1,2,"23415"
lte.send_at_cmd('AT+COPS=1,2,"23415"').replace('\r\n','')
#NOTE: for Comms365 on vodafone
#lte.send_at_cmd('AT+COPS=1,2,"90128"').replace('\r\n','')
if not lte.isconnected():
lte.connect()
print("Attempting to connect..", end="")
for i in range(10):
print(".", end ="")
if lte.isconnected():
print("\nConnected in attempt #"+str(i+1))
break
#packet = b'$\x1a\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01'
packet = b'hello nbiot world'
class StartIoT:
def __init__(self, network=LTE_M):
self._network = network
self.lte = LTE()
try:
self.lte.deinit()
self.lte.reset()
except:
pass
sleep(5)
self.lte.init()
sleep(5)
self._assure_modem_fw()
def _assure_modem_fw(self):
response = self.lte.send_at_cmd('ATI1')
if response != None:
lines = response.split('\r\n')
fw_id = lines[1][0:3]
is_nb = fw_id == 'UE6'
if is_nb:
print('Modem is using NB-IoT firmware (%s/%s).' %
(lines[1], lines[2]))
else:
print('Modem in using LTE-M firmware (%s/%s).' %
(lines[1], lines[2]))
if not is_nb and self._network == NB_IOT:
print(
'You cannot connect using NB-IoT with wrong modem firmware! Please re-flash the modem with the correct firmware.'
)
raise WrongNetwork
if is_nb and self._network == LTE_M:
print(
'You cannot connect using LTE-M with wrong modem firmware! Please re-flash the modem with the correct firmware.'
)
raise WrongNetwork
else:
print('Failed to determine modem firmware. Rebooting device...')
reset() # Reboot the device
def _get_assigned_ip(self):
ip_address = None
try:
self.lte.pppsuspend()
response = self.send_at_cmd_pretty('AT+CGPADDR=1')
self.lte.pppresume()
lines = response.split('\r\n')
sections = lines[1].split('"')
ip_address = sections[1]
except:
print('Failed to retrieve assigned IP from LTE network.')
return ip_address
def send_at_cmd_pretty(self, cmd):
print('>', cmd)
response = self.lte.send_at_cmd(cmd)
if response != None:
lines = response.split('\r\n')
for line in lines:
if len(line.strip()) != 0:
print('>>', line)
else:
print('>> No response.')
return response
def connect(self):
# NB-IoT
if (self._network == NB_IOT):
self.send_at_cmd_pretty('AT+CFUN=0')
self.send_at_cmd_pretty('AT+CEMODE=0')
self.send_at_cmd_pretty('AT+CEMODE?')
self.send_at_cmd_pretty('AT!="clearscanconfig"')
self.send_at_cmd_pretty('AT!="addscanfreq band=%s dl-earfcn=%s"' %
(BAND, EARFCN))
self.send_at_cmd_pretty('AT+CGDCONT=1,"IP","%s"' % APN)
self.send_at_cmd_pretty('AT+COPS=1,2,"%s"' % COPS)
self.send_at_cmd_pretty('AT+CFUN=1')
# LTE-M (Cat M1)
else:
self.send_at_cmd_pretty('AT+CFUN=0')
self.send_at_cmd_pretty('AT!="clearscanconfig"')
self.send_at_cmd_pretty('AT!="addscanfreq band=%s dl-earfcn=%s"' %
(BAND, EARFCN))
self.send_at_cmd_pretty('AT+CGDCONT=1,"IP","%s"' % APN)
self.send_at_cmd_pretty('AT+CFUN=1')
self.send_at_cmd_pretty('AT+CSQ')
# For a range scan:
# AT!="addscanfreqrange band=20 dl-earfcn-min=3450 dl-earfcn-max=6352"
print('Attaching...')
seconds = 0
while not self.lte.isattached() and seconds < attach_timeout:
sleep(0.25)
seconds += 0.25
if self.lte.isattached():
print('Attached!')
else:
print('Failed to attach to LTE (timeout)!')
raise AttachTimeout
self.lte.connect()
print('Connecting...')
seconds = 0
while not self.lte.isconnected() and seconds < connect_timeout:
sleep(0.25)
seconds += 0.25
if self.lte.isconnected():
print('Connected!')
else:
print('Failed to connect to LTE (timeout)!')
raise ConnectTimeout
print('Retrieving assigned IP...')
ip_address = self._get_assigned_ip()
print("Device IP: {}".format(ip_address))
print(ip_address)
# Initialise the CoAP module
Coap.init(ip_address)
# Register the response handler for the requests that the module initiates as a CoAP Client
Coap.register_response_handler(self.response_callback)
# A CoAP server is needed if CoAP push is used (messages are pushed down from Managed IoT Cloud)
# self.setup_coap_server()
def setup_coap_server(self):
# Add a resource with a default value and a plain text content format
r = Coap.add_resource('',
media_type=Coap.MEDIATYPE_APP_JSON,
value='default_value')
# Configure the possible operations on the resource
r.callback(
Coap.REQUEST_GET | Coap.REQUEST_POST | Coap.REQUEST_PUT
| Coap.REQUEST_DELETE, True)
# Get the UDP socket created for the CoAP module
coap_server_socket = Coap.socket()
# Create a new poll object
p = uselect.poll()
# Register the CoAP module's socket to the poll
p.register(coap_server_socket,
uselect.POLLIN | uselect.POLLHUP | uselect.POLLERR)
# Start a new thread which will handle the sockets of "p" poll
_thread.start_new_thread(socket_thread, (p, coap_server_socket))
print('CoAP server running!')
# The callback that handles the responses generated from the requests sent to a CoAP Server
def response_callback(self, code, id_param, type_param, token, payload):
# The ID can be used to pair the requests with the responses
print('ID: {}'.format(id_param))
print('Code: {}'.format(code))
print('Type: {}'.format(type_param))
print('Token: {}'.format(token))
print('Payload: {}'.format(payload))
def disconnect(self):
if self.lte.isconnected():
self.lte.disconnect()
def dettach(self):
if self.lte.isattached():
self.lte.dettach()
def send(self, data):
if not self.lte.isconnected():
raise Exception('Not connected! Unable to send.')
id = Coap.send_request(IOTGW_IP,
Coap.REQUEST_POST,
uri_port=IOTGW_PORT,
uri_path=IOTGW_ENDPOINT,
payload=data,
include_options=True)
print('CoAP POST message ID: {}'.format(id))
def pull(self, uri_path='/'):
if not self.lte.isconnected():
raise Exception('Not connected! Unable to pull.')
id = Coap.send_request(IOTGW_IP,
Coap.REQUEST_GET,
uri_port=IOTGW_PORT,
uri_path=uri_path,
include_options=True)
Coap.read()
print('CoAP GET message ID: {}'.format(id))
class SequansLTE:
"""
Synopsis::
sq = SequansLTE()
sq.info()
sq.firmware_info()
sq.at('showphy')
See also:
- https://git.cicer.de/autonome-zelle/fipy-nbiot-rtd/blob/master/main.py
"""
def __init__(self, network_manager, settings):
self.network_manager = network_manager
self.settings = settings
from network import LTE
self.lte = LTE()
import machine
self.chrono = machine.Timer.Chrono()
self.chrono.start()
def start(self):
self.lte.init()
self.attach()
self.connect()
def stop(self):
self.lte.disconnect()
time.sleep(0.25)
self.lte.deinit()
time.sleep(0.25)
def attach(self):
log.info('Attaching to LTE')
self.lte.attach(band=self.settings.get('networking.lte.band'),
apn=self.settings.get('networking.lte.apn'))
self.chrono.reset()
while True:
log.info('Signal strength: {}'.format(self.get_signal_strength()))
if self.lte.isattached():
break
if self.chrono.read() > self.settings.get(
'networking.lte.attach_timeout'):
raise Exception('Attaching to LTE timed out')
time.sleep(0.25)
def connect(self):
log.info('Connecting to LTE')
self.lte.connect()
self.chrono.reset()
while True:
if self.lte.isconnected():
break
if self.chrono.read() > self.settings.get(
'networking.lte.connect_timeout'):
raise Exception('Connecting to LTE timed out')
time.sleep(0.25)
def imei(self):
"""
Return IMEI.
"""
return self.at('AT+CGSN=1')
def info(self):
"""
Get infos from Modem.
"""
log.info('Signal strength: {}'.format(self.get_signal_strength()))
self.at('RRC:setDbgPerm full')
self.at('RRC:showcaps')
self.at('showver')
# https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/8
#self.at('AT')
#self.at('ATI')
#self.at('ATZ')
def get_signal_strength(self):
csq_at = self.lte.send_at_cmd("AT+CSQ")
csq_line_regex = ure.compile("\n")
csq_line = csq_line_regex.split(csq_at)
csq_string_regex = ure.compile(" ")
csq_string = csq_string_regex.split(csq_line[1])
csq_comma = csq_string[1]
csq_num_regex = ure.compile(",")
csq_num = csq_num_regex.split(csq_comma)
csq = csq_num[0]
return csq
def at(self, command):
"""
:param command:
"""
return self.raw('AT!="{}"'.format(command))
def raw(self, command):
"""
:param command:
"""
log.info('Sending: {}'.format(command))
answer = self.lte.send_at_cmd(command)
log.info('Answer: {}'.format(answer))
return answer
def firmware_info(self):
""" """
import sqnsupgrade
sqnsupgrade.info(verbose=True, debug=True)
def unbrick(self):
""" """
raise NotImplementedError(
'https://forum.pycom.io/topic/4022/unable-to-update-gpy-modem-firmware/21'
)
class NanoGateway:
"""
Nano gateway class, set up by default for use with TTN, but can be configured
for any other network supporting the Semtech Packet Forwarder.
Only required configuration is wifi_ssid and wifi_password which are used for
connecting to the Internet.
"""
def __init__(self,
id,
frequency,
datarate,
server,
port,
ntp_server='pool.ntp.org',
ntp_period=3600):
self.id = id
self.server = server
self.port = port
self.frequency = frequency
self.datarate = datarate
# self.ssid = ssid
# self.password = password
self.ntp_server = ntp_server
self.ntp_period = ntp_period
self.server_ip = None
self.rxnb = 0
self.rxok = 0
self.rxfw = 0
self.dwnb = 0
self.txnb = 0
self.sf = self._dr_to_sf(self.datarate)
self.bw = self._dr_to_bw(self.datarate)
self.stat_alarm = None
self.pull_alarm = None
self.uplink_alarm = None
self.lte = None
self.sock = None
self.udp_stop = False
self.udp_lock = _thread.allocate_lock()
self.lora = None
self.lora_sock = None
self.rtc = machine.RTC()
def start(self):
"""
Starts the LoRaWAN nano gateway.
"""
pycom.heartbeat(False)
self._log('Starting LoRaWAN nano gateway with id: {}', self.id)
# # setup WiFi as a station and connect
# self.wlan = WLAN(mode=WLAN.STA)
# self._connect_to_wifi()
# setup LTE CATM1 connection
self.lte = LTE(carrier="verizon")
self._connect_to_LTE()
# get a time sync
self._log('Syncing time with {} ...', self.ntp_server)
self.rtc.ntp_sync(self.ntp_server, update_period=self.ntp_period)
while not self.rtc.synced():
utime.sleep_ms(50)
self._log("RTC NTP sync complete")
# get the server IP and create an UDP socket
self.server_ip = usocket.getaddrinfo(self.server, self.port)[0][-1]
self._log('Opening UDP socket to {} ({}) port {}...', self.server,
self.server_ip[0], self.server_ip[1])
self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM,
usocket.IPPROTO_UDP)
self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
self.sock.setblocking(False)
# push the first time immediatelly
self._push_data(self._make_stat_packet())
# create the alarms
self.stat_alarm = Timer.Alarm(
handler=lambda t: self._push_data(self._make_stat_packet()),
s=60,
periodic=True)
self.pull_alarm = Timer.Alarm(handler=lambda u: self._pull_data(),
s=25,
periodic=True)
# start the UDP receive thread
self.udp_stop = False
_thread.start_new_thread(self._udp_thread, ())
# initialize the LoRa radio in LORA mode
self._log('Setting up the LoRa radio at {} Mhz using {}',
self._freq_to_float(self.frequency), self.datarate)
self.lora = LoRa(mode=LoRa.LORA,
frequency=self.frequency,
bandwidth=self.bw,
sf=self.sf,
preamble=8,
coding_rate=LoRa.CODING_4_5,
tx_iq=True)
# create a raw LoRa socket
self.lora_sock = usocket.socket(usocket.AF_LORA, usocket.SOCK_RAW)
self.lora_sock.setblocking(False)
self.lora_tx_done = False
self.lora.callback(trigger=(LoRa.RX_PACKET_EVENT
| LoRa.TX_PACKET_EVENT),
handler=self._lora_cb)
self._log('LoRaWAN nano gateway online')
def stop(self):
"""
Stops the LoRaWAN nano gateway.
"""
self._log('Stopping...')
# send the LoRa radio to sleep
self.lora.callback(trigger=None, handler=None)
self.lora.power_mode(LoRa.SLEEP)
# stop the NTP sync
self.rtc.ntp_sync(None)
# cancel all the alarms
self.stat_alarm.cancel()
self.pull_alarm.cancel()
# signal the UDP thread to stop
self.udp_stop = True
while self.udp_stop:
utime.sleep_ms(50)
# disable LTE
self.lte.disconnect()
self.lte.dettach()
def _connect_to_wifi(self):
self.wlan.connect(self.ssid, auth=(None, self.password))
while not self.wlan.isconnected():
utime.sleep_ms(50)
self._log('WiFi connected to: {}', self.ssid)
def _connect_to_LTE(self):
print("reset modem")
try:
self.lte.reset()
except:
print("Exception during reset")
print("delay 5 secs")
utime.sleep(5.0)
if self.lte.isattached():
try:
print("LTE was already attached, disconnecting...")
if self.lte.isconnected():
print("disconnect")
self.lte.disconnect()
except:
print("Exception during disconnect")
try:
if self.lte.isattached():
print("detach")
self.lte.dettach()
except:
print("Exception during dettach")
try:
print("resetting modem...")
self.lte.reset()
except:
print("Exception during reset")
print("delay 5 secs")
utime.sleep(5.0)
# enable network registration and location information, unsolicited result code
self.at('AT+CEREG=2')
# print("full functionality level")
self.at('AT+CFUN=1')
utime.sleep(1.0)
# using Hologram SIM
self.at('AT+CGDCONT=1,"IP","hologram"')
print("attempt to attach cell modem to base station...")
# lte.attach() # do not use attach with custom init for Hologram SIM
self.at("ATI")
utime.sleep(2.0)
i = 0
while self.lte.isattached() == False:
# get EPS Network Registration Status:
# +CEREG: <stat>[,[<tac>],[<ci>],[<AcT>]]
# <tac> values:
# 0 - not registered
# 1 - registered, home network
# 2 - not registered, but searching...
# 3 - registration denied
# 4 - unknown (out of E-UTRAN coverage)
# 5 - registered, roaming
r = self.at('AT+CEREG?')
try:
r0 = r[0] # +CREG: 2,<tac>
r0x = r0.split(',') # ['+CREG: 2',<tac>]
tac = int(r0x[1]) # 0..5
print("tac={}".format(tac))
except IndexError:
tac = 0
print("Index Error!!!")
# get signal strength
# +CSQ: <rssi>,<ber>
# <rssi>: 0..31, 99-unknown
r = self.at('AT+CSQ')
# extended error report
# r = at('AT+CEER')
if self.lte.isattached():
print("Modem attached (isattached() function worked)!!!")
break
if (tac == 1) or (tac == 5):
print("Modem attached!!!")
break
i = i + 5
print("not attached: {} secs".format(i))
if (tac != 0):
self.blink(BLUE, tac)
else:
self.blink(RED, 5)
utime.sleep(2)
self.at('AT+CEREG?')
print("connect: start a data session and obtain an IP address")
self.lte.connect(cid=3)
i = 0
while not self.lte.isconnected():
i = i + 1
print("not connected: {}".format(i))
self.blink(YELLOW, 1)
utime.sleep(1.0)
print("connected!!!")
pycom.rgbled(GREEN)
def _dr_to_sf(self, dr):
sf = dr[2:4]
if sf[1] not in '0123456789':
sf = sf[:1]
return int(sf)
def _dr_to_bw(self, dr):
bw = dr[-5:]
if bw == 'BW125':
return LoRa.BW_125KHZ
elif bw == 'BW250':
return LoRa.BW_250KHZ
else:
return LoRa.BW_500KHZ
def _sf_bw_to_dr(self, sf, bw):
dr = 'SF' + str(sf)
if bw == LoRa.BW_125KHZ:
return dr + 'BW125'
elif bw == LoRa.BW_250KHZ:
return dr + 'BW250'
else:
return dr + 'BW500'
def _lora_cb(self, lora):
"""
LoRa radio events callback handler.
"""
events = lora.events()
if events & LoRa.RX_PACKET_EVENT:
self.rxnb += 1
self.rxok += 1
rx_data = self.lora_sock.recv(256)
stats = lora.stats()
packet = self._make_node_packet(rx_data, self.rtc.now(),
stats.rx_timestamp, stats.sfrx,
self.bw, stats.rssi, stats.snr)
self._push_data(packet)
self._log('Received packet: {}', packet)
self.rxfw += 1
if events & LoRa.TX_PACKET_EVENT:
self.txnb += 1
lora.init(mode=LoRa.LORA,
frequency=self.frequency,
bandwidth=self.bw,
sf=self.sf,
preamble=8,
coding_rate=LoRa.CODING_4_5,
tx_iq=True)
def _freq_to_float(self, frequency):
"""
MicroPython has some inprecision when doing large float division.
To counter this, this method first does integer division until we
reach the decimal breaking point. This doesn't completely elimate
the issue in all cases, but it does help for a number of commonly
used frequencies.
"""
divider = 6
while divider > 0 and frequency % 10 == 0:
frequency = frequency // 10
divider -= 1
if divider > 0:
frequency = frequency / (10**divider)
return frequency
def _make_stat_packet(self):
now = self.rtc.now()
STAT_PK["stat"]["time"] = "%d-%02d-%02d %02d:%02d:%02d GMT" % (
now[0], now[1], now[2], now[3], now[4], now[5])
STAT_PK["stat"]["rxnb"] = self.rxnb
STAT_PK["stat"]["rxok"] = self.rxok
STAT_PK["stat"]["rxfw"] = self.rxfw
STAT_PK["stat"]["dwnb"] = self.dwnb
STAT_PK["stat"]["txnb"] = self.txnb
return ujson.dumps(STAT_PK)
def _make_node_packet(self, rx_data, rx_time, tmst, sf, bw, rssi, snr):
RX_PK["rxpk"][0]["time"] = "%d-%02d-%02dT%02d:%02d:%02d.%dZ" % (
rx_time[0], rx_time[1], rx_time[2], rx_time[3], rx_time[4],
rx_time[5], rx_time[6])
RX_PK["rxpk"][0]["tmst"] = tmst
RX_PK["rxpk"][0]["freq"] = self._freq_to_float(self.frequency)
RX_PK["rxpk"][0]["datr"] = self._sf_bw_to_dr(sf, bw)
RX_PK["rxpk"][0]["rssi"] = rssi
RX_PK["rxpk"][0]["lsnr"] = snr
RX_PK["rxpk"][0]["data"] = ubinascii.b2a_base64(rx_data)[:-1]
RX_PK["rxpk"][0]["size"] = len(rx_data)
return ujson.dumps(RX_PK)
def _push_data(self, data):
token = uos.urandom(2)
packet = bytes([PROTOCOL_VERSION]) + token + bytes(
[PUSH_DATA]) + ubinascii.unhexlify(self.id) + data
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('Failed to push uplink packet to server: {}', ex)
def _pull_data(self):
token = uos.urandom(2)
packet = bytes([PROTOCOL_VERSION]) + token + bytes(
[PULL_DATA]) + ubinascii.unhexlify(self.id)
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('Failed to pull downlink packets from server: {}',
ex)
def _ack_pull_rsp(self, token, error):
TX_ACK_PK["txpk_ack"]["error"] = error
resp = ujson.dumps(TX_ACK_PK)
packet = bytes([PROTOCOL_VERSION]) + token + bytes(
[PULL_ACK]) + ubinascii.unhexlify(self.id) + resp
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('PULL RSP ACK exception: {}', ex)
def _send_down_link(self, data, tmst, datarate, frequency):
"""
Transmits a downlink message over LoRa.
"""
self.lora.init(mode=LoRa.LORA,
frequency=frequency,
bandwidth=self._dr_to_bw(datarate),
sf=self._dr_to_sf(datarate),
preamble=8,
coding_rate=LoRa.CODING_4_5,
tx_iq=True)
while utime.ticks_cpu() < tmst:
pass
self.lora_sock.send(data)
self._log(
'Sent downlink packet scheduled on {:.3f}, at {:.3f} Mhz using {}: {}',
tmst / 1000000, self._freq_to_float(frequency), datarate, data)
def _udp_thread(self):
"""
UDP thread, reads data from the server and handles it.
"""
while not self.udp_stop:
try:
data, src = self.sock.recvfrom(1024)
_token = data[1:3]
_type = data[3]
if _type == PUSH_ACK:
self._log("Push ack")
elif _type == PULL_ACK:
self._log("Pull ack")
elif _type == PULL_RESP:
self.dwnb += 1
ack_error = TX_ERR_NONE
tx_pk = ujson.loads(data[4:])
tmst = tx_pk["txpk"]["tmst"]
t_us = tmst - utime.ticks_cpu() - 15000
if t_us < 0:
t_us += 0xFFFFFFFF
if t_us < 20000000:
self.uplink_alarm = Timer.Alarm(
handler=lambda x: self._send_down_link(
ubinascii.a2b_base64(tx_pk["txpk"]["data"]),
tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"][
"datr"],
int(tx_pk["txpk"]["freq"] * 1000) * 1000),
us=t_us)
else:
ack_error = TX_ERR_TOO_LATE
self._log('Downlink timestamp error!, t_us: {}', t_us)
self._ack_pull_rsp(_token, ack_error)
self._log("Pull rsp")
except usocket.timeout:
pass
except OSError as ex:
if ex.errno != errno.EAGAIN:
self._log('UDP recv OSError Exception: {}', ex)
except Exception as ex:
self._log('UDP recv Exception: {}', ex)
# wait before trying to receive again
utime.sleep_ms(UDP_THREAD_CYCLE_MS)
# we are to close the socket
self.sock.close()
self.udp_stop = False
self._log('UDP thread stopped')
def _log(self, message, *args):
"""
Outputs a log message to stdout.
"""
print('[{:>10.3f}] {}'.format(utime.ticks_ms() / 1000,
str(message).format(*args)))
def at(self, cmd):
print("modem command: {}".format(cmd))
r = self.lte.send_at_cmd(cmd).split('\r\n')
r = list(filter(None, r))
print("response={}".format(r))
return r
def blink(self, rgb, n):
for i in range(n):
pycom.rgbled(rgb)
utime.sleep(0.25)
pycom.rgbled(BLACK)
utime.sleep(0.1)
def connect():
global lte
lte = LTE() # instantiate the LTE object
# Change this if you are using the M1 network (comment out the next 6 lines)
lte.send_at_cmd('AT+CFUN=0')
lte.send_at_cmd('AT+CEMODE=0')
lte.send_at_cmd('AT+CEMODE?')
lte.send_at_cmd('AT!="clearscanconfig"')
lte.send_at_cmd('AT!="addscanfreq band=20 dl-earfcn=6352"')
lte.send_at_cmd('AT+CFUN=1')
# End change this ....
lte.attach() # attach the cellular modem to a base station
while not lte.isattached():
time.sleep(0.25)
print("attatched")
lte.connect() # start a data session and obtain an IP address
while not lte.isconnected():
time.sleep(0.25)
print("connected")
https://forum.pycom.io/topic/5777/using-gpy-with-ipv6
https://pycomiot.atlassian.net/browse/PYCSD-1971
from network import LTE
lte = LTE()
lte.init()
lte.send_at_cmd('AT+CFUN=0')
lte.send_at_cmd('AT+CGDCONT=1,"IPV6","iot"')
lte.send_at_cmd('AT+CFUN?')
lte.send_at_cmd('AT+CFUN=1')
lte.send_at_cmd('AT+CFUN?')
lte.send_at_cmd('AT+CREG?')
# +SQNEDRX: 0,5,"1111","0000"
# <mode>[,<Requested_eDRX_value>,<Requested_ptw_value>]
attach()
# at('AT+COPS=?')
at('AT+CPIN?')
at('AT+CREG?') # registered? 2,5,"2E1D","01905667",9
at('AT+COPS?') # network 0,2,"20404",9
at('AT+CSQ')
at('AT+CGEREP=2,0')
at('AT+CMGF=1')
at('AT+CMGF?')
at('AT+CMGS="+<<<PHONENR>>>"\rHullo'+chr(26))
r = lte.send_at_cmd('AT+CMGS="+<<<PHONENR>>>",145\rHullo'+chr(26))
print(r)
r = lte.send_at_cmd('AT+CMGS="<<<PHONENR>>>"\rHullo'+chr(26))
print(r)
r = lte.send_at_cmd('AT+CMGS="<<<PHONENR>>>",129\rHullo'+chr(26))
print(r)
at('AT+CNMI?') # how newly arrived SMS messages should be handled
# connect()
lte.send_at_cmd('AT+CGPADDR')
'\r\n+CGPADDR: 1,"10.175.211.94"\r\n\r\nOK\r\n'
>>> lte.send_at_cmd('AT+CGCONTRDP=1')
'\r\n+CGCONTRDP: 1,5,"spe.inetd.vodafone.nbiot.mnc028.mcc901.gprs","10.175.211.94.255.255.255.255","","10.105.16.254","10.105.144.254","",""\r\n\r\nOK\r\n'
user="******",
password="******",
port=port,
ssl=True)
i2c = I2C(0, I2C.MASTER, baudrate=100000, pins=('G9', 'G10'))
scanner = i2c.scan()
print(scanner)
bme = bme280.BME280(i2c=i2c)
#pycom.heartbeat(True)
while lte.isconnected():
pycom.rgbled(0x007f00)
part = ".*?(-*\d+\.*\d*).*?"
try:
cellinfo = lte.send_at_cmd('AT+VZWRSRP')
m = re.search('.*?:{},{},{}'.format(part, part, part), cellinfo)
pci = int(m.group(1))
earfcn = int(m.group(2))
rsrp = float(m.group(3))
print("RSRP: " + str(rsrp))
print("PCI:" + str(pci))
print("EARFCN: " + str(earfcn))
except:
pass
pci = 0
earfcn = 0
rsrp = 0
print("Getting sensor vlaues...")
airpressure = bme.pressure[:-3]
time.sleep(2)
class StartIot():
def __init__(self):
self.lte = LTE()
self.initModem()
# METHOD FOR PRETTY PRINTING AT COMMANDS
def send_at_cmd_pretty(self, cmd):
response = self.lte.send_at_cmd(cmd)
if response != None:
lines=response.split('\r\n')
print("Response is:< ")
for line in lines:
if len(line.strip()) != 0:
print(line)
print(">")
else:
print("Response is None...")
return response
# SETUP AND START THE MODEM - ATTACH TO THE NETWORK
def initModem(self):
print ("Starting modem...")
self.send_at_cmd_pretty('AT+CFUN=0')
# Change this if you are using the NB1 network (uncomment the next 4 lines)
#self.send_at_cmd_pretty('AT+CEMODE=0')
#self.send_at_cmd_pretty('AT+CEMODE?')
#self.send_at_cmd_pretty('AT!="clearscanconfig"')
#self.send_at_cmd_pretty('AT!="addscanfreq band=20 dl-earfcn=6352"')
# End change this ....
self.send_at_cmd_pretty('AT+CGDCONT=1,"IP","mda.ee"')
self.send_at_cmd_pretty('AT+CFUN=1')
self.send_at_cmd_pretty('AT+CSQ')
print ("Waiting for attachement (To Radio Access Network)...")
while not self.lte.isattached():
time.sleep(0.25)
else:
print ("Attached (To Radio Access Network)...")
# CONNECT TO THE NETWORK
def connect(self):
if not self.lte.isattached():
raise Exception('NOT ATTACHED... call initModem() first')
print ("Waiting for connection (To IP network)...")
self.lte.connect()
# Wait until we get connected to network
while not self.lte.isconnected():
machine.idle()
print ("Connected (To IP network)!")
# OPEN SOCKET AND SEND DATA
def send(self, data):
if not self.lte.isconnected():
raise Exception('NOT CONNECTED')
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
IP_address = socket.getaddrinfo('172.16.15.14', 1234)[0][-1]
s.connect(IP_address)
s.send(data)
s.close()
def disconnect(self):
if self.lte.isconnected():
self.lte.disconnect()
def dettach(self):
if self.lte.isattached():
self.lte.dettach()
self.lte.send_at_cmd('AT+CFUN=0')
print("Modem offline")
class NetworkConnector:
def __init__(self):
self.logger = logging.get_logger(__name__)
self.lte = LTE()
def _attach(self):
"""
Attaches to the 1nce network
"""
self.lte.attach()
while not self.lte.isattached():
time.sleep(0.5)
print(".", end="")
self.logger.info("Sim attached to iot.1nce.net")
def connect(self):
"""
Connects to the 1nce network
"""
self._attach()
self.lte.connect()
while not self.lte.isconnected():
time.sleep(0.5)
self.logger.info("Sim connected to iot.1nce.net")
def disconnect(self):
self.lte.disconnect()
self.logger.info("Sim disconnected from iot.1nce.net")
def _send_at_command(self, command):
"""
Sends AT command over the modem
:rtype: Response string
"""
self.lte.pppsuspend()
resp = self.lte.send_at_cmd(command)
self.lte.pppresume()
return resp
def get_reception(self):
"""
Gets the current reception to the 1nce network
:return: Number Reception to the 1nce network
"""
return self._send_at_command("AT+CSQ")
def get_ip_address(self):
""""
Gets the Device it's Local IP address
:return IP Address
"""
resp = self._send_at_command("AT+CGPADDR=1")
self.logger.info(resp)
search = re.search(r"\"([1-2]?\d?\d\.[1-2]?\d?\d\.[1-2]?\d?\d\.[1-2]?\d?\d)\"", resp)
if search:
return search.group(1)
return None
for i in range(4):
ccid=lte.iccid()
print (" ccid = " + str(ccid))
if ccid:
break
time.sleep(1)
#Vodafone UK apn=nb.inetd.gdsp
print("Attempting to attach...", end="")
lte.attach(band=20,apn="ep.inetd.gdsp")
for j in range(10):
print(".", end ="")
time.sleep(1)
if lte.isattached():
print("\nAttached in attempt #"+str(j+1))
break
lte.send_at_cmd('AT+CEREG?').replace('\r\n','')
#NOTE: for Vodafone UK: AT+COPS=1,2,"23415"
lte.send_at_cmd('AT+COPS=1,2,"23415"').replace('\r\n','')
lte.connect()
print("Attempting to connect..", end="")
for i in range(10):
print(".", end ="")
if lte.isconnected():
print("\nConnected in attempt #"+str(i+1))
break
packet = b'$\x1a\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01'
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(20)
s.connect(("8.8.8.8", 53))
s.send(packet)