def sendSMS(NUMBER, SMSText):
TIMEOUT_CMD = 50
Helper.writeLog('Starting sendSMS\r\n')
res = Helper.sendCmd('AT+CMGF', '1', TIMEOUT_CMD) # select text format type
Helper.writeLog('Finished AT+CMGF\r\n')
res = Helper.sendCmd('AT+CNMI', '2,1', TIMEOUT_CMD) # alarm indicators
Helper.writeLog('Finished AT+CNMI\r\n')
res = Helper.sendCmd('AT+CMGS', NUMBER, TIMEOUT_CMD) # send the message without storing it
Helper.writeLog('Finished AT+CMGS\r\n')
if (res.find('>') == -1):
return -1
else:
res = MDM.send(SMSText, 0)
Helper.writeLog('Finished sending SMSText\r\n')
res = MDM.sendbyte(0x1a, 0)
Helper.writeLog('Finished CTRL+Z\r\n')
for i in range(6):
res=MDM.read()
if(res.find("OK")!=-1):
Helper.writeLog('Found and returning\r\n')
return 1
else:
MOD.sleep(300)
Helper.writeLog('REturning -1\r\n')
return -1
def send_CM(inSTR,connId,timeOut):
# This function sends a string while in Command Mode
# Arguments:
# inSTR: String to send
# connId: Connection #
# timeOut: Amount of time alotted to send
#
# Returns:
# 0: Pass
# 1: String argument empty
# -1: Exception
# -2: Timeout
if (len(inSTR)==0):
return 1
try:
res = MDM.send('AT#SSEND=' + str(connId) + '\r\n', 0)
#Start timeout counter
timerA = timers.timer(0)
timerA.start(timeOut)
prompt = '\r\n> '
#Start looking for '\r\n>'
while(1):
properties.CMD_BUFFER = properties.CMD_BUFFER + MDM.receive(1)
pos1 = properties.CMD_BUFFER.find(prompt) #look for prompt characters
if (pos1>=0):
properties.CMD_BUFFER = properties.CMD_BUFFER[0:pos1] + properties.CMD_BUFFER[pos1+len(prompt):len(properties.CMD_BUFFER)]
res = MDM.send(inSTR, 0)
res = MDM.sendbyte(0x1a, 0)
tempread = ''
res = ''
while(1):
tempread = MDM.read()
if (tempread != ''):
res = res + tempread
if (res.find('OK')>=0):
return (0) #Pass
if timerA.isexpired():
return (-2) #Expired, can't find OK response
if timerA.isexpired():
return (-2) #Expired, no prompt found
except:
printException("send_CM(" + inSTR + "," + connId + "," + timeOut + ")")
JANUS_SER.sendUART("Send CM Exception. \r\n")
#Would return with something else before this if it passes without exception
return (-1)
def sendAtCmd(theCommand, theTerminator, timeOut):
# This function sends an AT command to the MDM interface
# Input Parameter Definitions
# theCommand: The AT command to send to MDM interface
# theTerminator: string or character at the end of AT Command
# timeOut: number of seconds command could take to respond
try:
rtnList = [-1,-1] #[return status,return data]
# return status:
# -2: Timeout
# -1: Exception occurred
# 0: No errors occurred, no return data
# 1: No errors occurred, return data
#Clear input buffer
rtnList[1] = 'junk'
while(rtnList[1] != ''):
rtnList[1] = mySER.read()
print 'Sending AT Command: ' + theCommand + "\r\n"
rtnList[1] = mySER.send(theCommand,2)
rtnList[1] = mySER.sendbyte(0x0d,2)
while True:
#Wait for AT command response
rtnList = mdmResponse(theTerminator, timeOut)
if (rtnList[0] == -1) or (rtnList[0] == -2) : return rtnList
elif rtnList[0] == 1:
#what happens if res doesn't return data?
#Did AT command respond without error?
pos1 = rtnList[1].rfind('ERROR',0,len(rtnList[1]))
pos2 = rtnList[1].rfind(theTerminator,0,len(rtnList[1]))
if ((pos1 != -1) or (pos2 != -1)) :
rtnList = parseResponse(rtnList[1])
if rtnList[0] == -1: return rtnList
elif rtnList[0] == 1:
#what happens if res doesn't return data?
rtnList[0] = 1
break
except:
print sys.exc_info()
rtnList[0] = -1
print rtnList[1]
return rtnList
def exitDataMode():
rtnList = [-1,-1] #[return status,return data]
# return status:
# -1: Exception occurred
# 0: No errors occurred, no return data
# 1: No errors occurred, return data
try:
#Exit data mode
##Lookup the Escape Sequence Guard Time
## Future Use
# Delay to meet Escape Sequence Guard Time
## Remove Hard Coded Escape Sequence Guard Time
time.sleep(1)
#Start timeout counter
start = time.time()
##Lookup the Escape Sequence
## Future Use
#Sending +++
## Remove Hard Coded Escape Sequence
rtnList[1] = mySER.send('+', 10)
rtnList[1] = mySER.send('+', 10)
rtnList[1] = mySER.send('+', 10)
#Wait for response
rtnList[1] = ''
while rtnList[1].find("OK") <= -1:
rtnList += mySER.read()
if (time.time() - start) > 20:
rtnList[0] = -2
break
if ((rtnList[0] != -2) and len(rtnList[1] > 0)):
rtnList[0] = 0
except:
print sys.exc_info()
rtnList[0] = -1
print rtnList[1]
return rtnList
def sendAT(request, response, timeout = 2):
MDM.send(request + '\r', 2)
result = -2
data = ''
timer = MOD.secCounter() + timeout
while(MOD.secCounter() < timer):
rcv = MDM.read()
if(len(rcv) > 0):
data = data + rcv
if(data.find(response) != -1):
result = 0
break
if(data.find('ERROR') != -1):
result = -1
break
return (result, data)
def sendAT(request, response="OK", timeout=3):
MDM.send(request + "\r", 2)
result = -2
data = ""
timer = MOD.secCounter() + timeout
while MOD.secCounter() < timer:
rcv = MDM.read()
if len(rcv) > 0:
data = data + rcv
if data.find(response) != -1:
result = 0
break
if data.find("ERROR") != -1:
result = -1
break
return (result, data)
def receiveMDM(self):
data = ''
size = int(self.config.get('TCP_MAX_LENGTH'))
while(1):
rcv = MDM.read()
if(len(rcv) > 0):
self.buffer = self.buffer + rcv
if(len(self.buffer) > size):
break
else:
break
if(len(self.buffer) > 0):
data = self.getBuffer(size)
if(data.find('NO CARRIER') != -1):
raise Exception, '"NO CARRIER" on socket #1'
self.debug.send('Data received from socket #1 (data): ' + str(len(data)) + ' bytes')
return data
def receiveMDM(self):
data = ''
size = int(self.config.get('TCP_MAX_LENGTH'))
while(1):
rcv = MDM.read()
if(len(rcv) > 0):
self.buffer = self.buffer + rcv
if(len(self.buffer) > size):
break
else:
break
if(len(self.buffer) > 0):
data = self.getBuffer(size)
if(data.find('NO CARRIER') != -1):
raise Exception, '"NO CARRIER" on socket #1'
self.debug.send('Data received from socket #1 (data): ' + str(len(data)) + ' bytes')
return data
def sendSMS(NUMBER, SMSText):
TIMEOUT_CMD = 50
res = scmd.sendCmd('AT+CMGF', '1', TIMEOUT_CMD) # select text format type
res = scmd.sendCmd('AT+CNMI', '2,1', TIMEOUT_CMD) # alarm indicators
res = scmd.sendCmd('AT+CSMP', '17,167,0,0', TIMEOUT_CMD) # select message parameter
res = scmd.sendCmd('AT+CMGS', NUMBER, TIMEOUT_CMD) # send the message without storing it
if (res.find('>') == -1):
return -1
else:
res = MDM.send(SMSText, 0)
res = MDM.sendbyte(0x1a, 0)
for i in range(6):
res=MDM.read()
if(res.find("OK")!=-1):
return 1
else:
MOD.sleep(300)
return -1
def mdmResponse(theTerminator, timeOut):
# This function waits for AT Command response and handles errors and ignores unsolicited responses
# Input Parameter Definitions
# theTerminator: string or character at the end of a received string which indicates end of a response
# timeOut: number of seconds command could take to respond
try:
rtnList = [-1,-1] #[return status,return data]
# return status:
# -2: Timeout
# -1: Exception occurred
# 0: No errors occurred, no return data
# 1: No errors occurred, return data
print 'Waiting for AT Command Response' + "\r\n"
#Start timeout counter
start = time.time()
#Wait for response
rtnList[1] = ''
while ((rtnList[1].find(theTerminator)<=-1) and (rtnList[1].find("ERROR")<=-1)):
#MOD.watchdogReset()
rtnList[1] += mySER.read()
pass
if (time.time() - start) > timeOut:
rtnList[0] = -2
print "AT command timed out" + "\r\n"
return rtnList
rtnList[0] = 1
except:
print sys.exc_info()
rtnList[0] = -1
return rtnList
def sendAT(request, response, timeout=2, interface=1):
if (interface == 1):
MDM.send(request + '\r', 2)
else:
MDM2.send(request + '\r', 2)
result = -2
data = ''
timer = MOD.secCounter() + timeout
while (MOD.secCounter() < timer):
if (interface == 1):
rcv = MDM.read()
else:
rcv = MDM2.read()
if (len(rcv) > 0):
data = data + rcv
if (data.find(response) != -1):
result = 0
break
if (data.find('ERROR') != -1):
result = -1
break
return (result, data)
def enableAndReb(fileToExec, Number, MessageIndex):
#deleteSMS(MessageIndex)
SER.send('In Save file'+fileToExec+'\r\n')
SER.send('After renaming file'+fileToExec+'\r\n')
NUMBER = Number
SMSText = "I'm going to reboot, enabling the following file: "+fileToExec
SER.send("enableAndReb: trying to enable and reboot the module\r\n")
fileName = '"' + fileToExec + '"'
res=MDM.read()
res = Helper.sendCmd('AT#ESCRIPT',fileName,0)
res=MDM.receive(30)
if res.find('OK') != -1:
MOD.sleep(200)
text = "script qualified :" + fileName + '\r\n'
SER.send(text+"\r\n")
res= sendSMS(NUMBER,SMSText)
MOD.sleep(200)
res= MDM.send('AT#REBOOT\r',0)
MOD.sleep(200)
SER.send('rebooting\r\n')
return 1
else:
return -1
def enableAndReb(fileToExec, Number, MessageIndex):
#deleteSMS(MessageIndex)
SER.send('In Save file' + fileToExec + '\r\n')
SER.send('After renaming file' + fileToExec + '\r\n')
NUMBER = Number
SMSText = "I'm going to reboot, enabling the following file: " + fileToExec
SER.send("enableAndReb: trying to enable and reboot the module\r\n")
fileName = '"' + fileToExec + '"'
res = MDM.read()
res = Helper.sendCmd('AT#ESCRIPT', fileName, 0)
res = MDM.receive(30)
if res.find('OK') != -1:
MOD.sleep(200)
text = "script qualified :" + fileName + '\r\n'
SER.send(text + "\r\n")
res = sendSMS(NUMBER, SMSText)
MOD.sleep(200)
res = MDM.send('AT#REBOOT\r', 0)
MOD.sleep(200)
SER.send('rebooting\r\n')
return 1
else:
return -1
def GetData(FILE_NAME):
data = ' '
timer = MOD.secCounter()
timeout = MOD.secCounter() + TIMEOUT_DWNLD
datatmp = ''
while ((datatmp.find(HTML_UC_END) == -1) and (datatmp.find(HTML_LC_END) == -1) and (timer > 0) ):
data = data + datatmp
datatmp = MDM.receive(50)
timer = timeout - MOD.secCounter()
if ((datatmp.find(HTML_UC_END) != -1) or (datatmp.find(HTML_LC_END) != -1)):
data = data + datatmp
SER.send(data)
SER.send('\r')
else:
SER.send('No File found in data')
SER.send('\r')
data = -1
return data
uindx = data.find('\r\n')
SER.send(data[:uindx])
SER.send('\r')
lindx = data.find('<ftpuser>')
uindx = data.find('</ftpuser>')
ftpuser = data[lindx+9:uindx]
lindx = data.find('<ftppass>')
uindx = data.find('</ftppass>')
ftppass = data[lindx+9:uindx]
lindx = data.find('<md5>')
uindx = data.find('</md5>')
md5sent = data[lindx+5:uindx]
res = MDM.send('+++\r',0)
MOD.sleep(20)
res = MDM.receive(TIMEOUT_CONNECT)
SER.send('Connection Closed Response:')
SER.send(res)
SER.send('\r')
res = MDM.send('AT#SH\r',0)
res = MDM.receive(TIMEOUT_CONNECT)
res = ' '
while (res.find('OK')== -1):
res = MDM.send('AT#FTPOPEN="',0)
res = MDM.send(FTP_ADDR,0)
res = MDM.send('","',0)
res = MDM.send(ftpuser,0)
res = MDM.send('","',0)
res = MDM.send(ftppass,0)
res = MDM.send('",0\r',0)
SER.send('Opening FTP connection\r')
SER.send('User: '******' Password: '******'\r')
res = MDM.receive(10*TIMEOUT_CONNECT)
SER.send('FTP open result: ')
SER.send(res)
SER.send('\r')
if (res.find('Already connected') >= 0):
res = 'OK'
MDM.send('AT#FTPTYPE=0\r',0)
MDM.receive(TIMEOUT_MINIMUM)
MDM.send('AT#FTPGET="',0)
MDM.send(FILE_NAME,0)
MDM.send('"\r',0)
SER.send('Requesting File: ')
SER.send(FILE_NAME)
SER.send('\r')
timer = MOD.secCounter()
timeout = timer + 90 #secondi
#Retrieve and save data function?
ftpdata = ''
while((ftpdata.find('NO CARRIER') == -1) and (timer < timeout)):
ftpdata = ftpdata + MDM.read()
timer = MOD.secCounter()
if(len(ftpdata) == 0):
print "ERROR: data to save is empty \r"
SER.send('"ERROR: data to save is empty\r"')
return -1
startIndex = 0
endIndex = len(ftpdata)
if(ftpdata.find('CONNECT\r\n') != -1):
startIndex = ftpdata.find('CONNECT\r\n') + len ('CONNECT\r\n')
if(ftpdata.find('NO CARRIER') != -1):
endIndex = ftpdata.find('\r\nNO CARRIER')
ftpdata= ftpdata[startIndex: endIndex]
SER.send('Checking for MD5\r')
SER.send('MD5 sent:')
SER.send(md5sent)
SER.send('\r')
md5calc = md5.new(ftpdata).digest()
hexmd5 = md5ToHex(md5calc)
SER.send('MD5 calc:')
SER.send(hexmd5)
SER.send('\r')
if(hexmd5 != md5sent):
SER.send('MD5 does not match')
SER.send('\r')
data = -1
return data
return ftpdata
def transferFTP(transferType, fileName, mode, expectedFileSize):
SER.send('transferFTP\r\n')
TIMEOUT_CMD = 50
TIMEOUT_CMD_FTP = 100
FTP_PARAMETER = '"ftp.alwaysdata.com", "USERNAME", "PASSWORD",1'
fileName = '"' + fileName + '"'
numCheck = 3
res = Helper.iterateCmd('AT#FTPCLOSE', '', TIMEOUT_CMD, numCheck)
if (res == -1):
SER.send("ERROR: setting AT#FTPCLOSE \r\n")
return -1
res = Helper.iterateCmd('AT#FTPOPEN', FTP_PARAMETER, TIMEOUT_CMD_FTP,
numCheck)
if (res == -1):
textLog = "ERROR: setting AT#FTPOPEN = " + FTP_PARAMETER + "\r"
SER.send(textLog)
return -1
res = Helper.sendCmd('AT#FTPTYPE', '0', TIMEOUT_CMD)
if (transferType.find('GET') != -1):
SER.send('ftp get\r\n')
data = ''
res = Helper.sendCmd('AT#FTPGET', fileName, 0)
SER.send('data found\r\n')
SER.send(data)
dataList = []
timer = MOD.secCounter()
timeout = timer + 100 #secondi
temp = ''
if mode == 1:
SER.send('In Save file' + fileName + '\r\n')
fileSize = 0
while (((temp.find('NO CARRIER') == -1) or (MDM.getDCD() != 0))):
SER.send('temp is ' + temp + '\r\n')
temp = MDM.read()
if len(temp) != 0:
dataList.append(temp)
if mode == 1:
fileSize = fileSize + len(temp)
timer = MOD.secCounter()
if mode != 1:
SER.send('Length of data list: ' + str(len(dataList)) + '\r\n')
data = ''.join(dataList)
SER.send('Length of data: ' + str(len(data)) + '\r\n')
SER.send('fuori while\r\n')
if (len(data) == 0):
SER.send("ERROR: data to save is empty \r\n")
return -1
startIndex = 0
endIndex = len(data)
if (data.find('CONNECT\r\n') != -1):
startIndex = data.find('CONNECT\r\n') + len('CONNECT\r\n')
endIndex = len(data) - 12
data = data[startIndex:endIndex]
SER.send('Start Index: ' + str(startIndex) + '\r\n')
SER.send('End Index: ' + str(endIndex) + '\r\n')
SER.send('Length of data: ' + str(len(data)) + '\r\n')
SER.send('data fron ftp server:\r\n')
return data
else:
SER.send('Sending command AT#WSCRIPT\r\n')
SER.send('File size calculated = ' + str(fileSize) + '\r\n')
fileSize = fileSize - 25
if fileSize == int(expectedFileSize):
writeScript(fileName, dataList, 123, int(expectedFileSize))
return 1
return -1 #inutile
def transferFTP(transferType, fileName, mode, expectedFileSize):
SER.send('transferFTP\r\n')
TIMEOUT_CMD = 50
TIMEOUT_CMD_FTP =100
FTP_PARAMETER = '"ftp.alwaysdata.com", "USERNAME", "PASSWORD",1'
fileName = '"' + fileName + '"'
numCheck = 3
res = Helper.iterateCmd('AT#FTPCLOSE', '', TIMEOUT_CMD, numCheck)
if(res == -1):
SER.send("ERROR: setting AT#FTPCLOSE \r\n")
return -1
res = Helper.iterateCmd('AT#FTPOPEN', FTP_PARAMETER, TIMEOUT_CMD_FTP, numCheck)
if(res == -1):
textLog = "ERROR: setting AT#FTPOPEN = " + FTP_PARAMETER + "\r"
SER.send(textLog)
return -1
res = Helper.sendCmd('AT#FTPTYPE', '0', TIMEOUT_CMD)
if(transferType.find('GET') != -1):
SER.send('ftp get\r\n')
data = ''
res = Helper.sendCmd('AT#FTPGET',fileName,0)
SER.send('data found\r\n')
SER.send(data)
dataList = []
timer = MOD.secCounter()
timeout = timer + 100 #secondi
temp = ''
if mode == 1:
SER.send('In Save file'+fileName+'\r\n')
fileSize = 0
while(((temp.find('NO CARRIER') == -1) or (MDM.getDCD() != 0))):
SER.send('temp is '+temp+'\r\n')
temp = MDM.read()
if len(temp) != 0 :
dataList.append(temp)
if mode == 1:
fileSize = fileSize + len(temp)
timer = MOD.secCounter()
if mode != 1:
SER.send('Length of data list: '+str(len(dataList))+'\r\n')
data = ''.join(dataList)
SER.send('Length of data: '+str(len(data))+'\r\n')
SER.send('fuori while\r\n')
if(len(data) == 0):
SER.send("ERROR: data to save is empty \r\n")
return -1
startIndex = 0
endIndex = len(data)
if(data.find('CONNECT\r\n') != -1):
startIndex = data.find('CONNECT\r\n') + len ('CONNECT\r\n')
endIndex = len(data) - 12
data= data[startIndex: endIndex]
SER.send('Start Index: '+str(startIndex)+'\r\n')
SER.send('End Index: '+str(endIndex)+'\r\n')
SER.send('Length of data: '+str(len(data))+'\r\n')
SER.send('data fron ftp server:\r\n')
return data
else:
SER.send('Sending command AT#WSCRIPT\r\n')
SER.send('File size calculated = '+str(fileSize)+'\r\n')
fileSize = fileSize - 25
if fileSize == int(expectedFileSize) :
writeScript(fileName,dataList,123,int(expectedFileSize))
return 1
return -1 #inutile
def main():
try:
# Set Global Watchdog timeout in Seconds
MOD.watchdogEnable(300)
#######################################
## Initialization
#######################################
rtnList = [-1,-1] #[return status,return data]
# return status:
# -1: Exception occurred
# 0: No errors occurred, no return data
# 1: No errors occurred, return data
# 2: Error occurred
#Initialize the serial interface @ 115200, we must do this or nothing comes out the serial port
rtnList = mySER.init("115200",'8N1')
if (rtnList[0] == -1):
return
mySER.sendUART("Beginning the serial bridge program. \r\n\r\n")
# Set Global Watchdog timeout in Seconds
#MOD.watchdogEnable(300)
#Get configuration from demo.conf file, transpose into new local myApp class
myApp = conf.conf('/sys','demo.conf')
if myApp.CONF_STATUS != 0:
mySER.sendUART("Demo configuration error: " + str(myApp.CONF_STATUS))
return rtnList
mySER.sendUART("Configuration Loaded.\r\n")
rtnList = myIO.init()
if (rtnList[0] == -1) or (rtnList[0] == -2) or rtnList[1] == "ERROR": raise UserWarning
mySER.sendUART("\r\nInitializing Network Setup. \r\n")
#Set Network specific settings, wait for SIM card to be ready
rtnList = NETWORK.initNetwork(myApp.ENS)
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
#Initialize SOCKET communications
rtnList = SOCKET.init('1',myApp.APN)
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
mySER.sendUART("Network Setup Initialized. \r\n\r\n")
#Update Unit information
rtnList = ATC.getUnitInfo()
if (rtnList[0] == -1): raise UserWarning
# Loop forever, without this loop the script would run once and exit script mode. On reboot or power-on the script would run once more
while (1):
MOD.watchdogReset()
#######################################
## Registration
#######################################
RegCheck = 0 #Initialize check
DataCheck = 0 #Initialize Check
#What is the signal strength?
rtnList = ATC.sendAtCmd('AT+CSQ',ATC.properties.CMD_TERMINATOR,5)
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
mySER.sendUART("Signal Strength (AT+CSQ): " + rtnList[1] + "\r\n")
#Wait until module is registered to GSM Network
mySER.sendUART("Checking Modem Registration. \r\n")
rtnList = NETWORK.isRegistered(180) #Wait 180 seconds for module to obtain GSM registration
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
if (rtnList[0] == 0): #Registered successfully
RegCheck = 1
mySER.sendUART("Modem Registered. \r\n\r\n")
#Wait until module is ready for data
mySER.sendUART("Checking Data Availability. \r\n")
rtnList = NETWORK.isDataAttached(myApp.CGMM, 180) #Wait 180 seconds for module to obtain GSM registration
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
if (rtnList[0] == 0): #Registered successfully
DataCheck = 1
mySER.sendUART("Modem ready for data. \r\n\r\n")
#check for exit prompt, let's use command EXITSCR
rtnList = mySER.readUART()
if (rtnList[1].find('EXITSCR') != -1):
print '\r\nExit Command Found\r\n'
return
#######################################
## Socket Connection
#######################################
# Loop while we're registered/ready
while (RegCheck == 1 and DataCheck == 1):
#check for exit prompt, let's use command EXITSCR
rtnList = mySER.readUART()
if (rtnList[1].find('EXITSCR') != -1):
print '\r\nExit Command Found\r\n'
return
rtnList = NETWORK.isRegistered(10) #Fast reg check
if (rtnList[0] == -1) or (rtnList[0] == -2): #unavailable, drill down discretely and show the status
RegCheck = 0
rtnList = ATC.sendAtCmd('AT+CREG?',ATC.properties.CMD_TERMINATOR,5)
mySER.sendUART("Registration Unavailable, Status: " + rtnList[1] + "\r\n")
break #exit loop
rtnList = NETWORK.isDataAttached(myApp.CGMM, 10) #Fast data check
if (rtnList[0] == -1) or (rtnList[0] == -2): #unavailable, drill down discretely and show the status
DataCheck = 0
rtnList = ATC.sendAtCmd('AT+CGREG?',ATC.properties.CMD_TERMINATOR,5)
mySER.sendUART("Data Unavailable, Status: " + rtnList[1] + "\r\n")
break #exit loop
#Open socket in online mode
mySER.sendUART("Opening socket to server: " + myApp.IP + ":" + myApp.PORT + "\r\n")
rtnList = SOCKET.openSocket(myApp.IP,myApp.PORT,1,myApp.USERNAME,myApp.PASSWORD,myApp.PROTOCOL,0)
if (rtnList[0] == -1) or (rtnList[0] == -2): raise UserWarning
#Check for open connection, this catches both online and command mode operations
if (rtnList[1] == "OK" or rtnList[1] == "CONNECT"):
mySER.sendUART("Socket opened successfully.\r\n")
else:
mySER.sendUART("Connection failed to open, trying again. \r\n")
#Check for open socket
DCD = MDM.getDCD()
if (DCD == 1):
#Set DCD on USIF0
SER.setDCD(1)
#Forward CONNECT Message to Serial Port
mySER.sendUART('\r\nConnected to Server\r\n')
myIO.USER_LED('ON')
#######################################
## Data exchange loop
#######################################
##Loop while Socket connected. This loop operates on the notion that we are in online mode, so we are not using send_CM
while(1):
#Pet the watchdog
MOD.watchdogReset()
#Check for DCD active on MDM
DCD = MDM.getDCD()
if (DCD == 1):
#Outbound
#Get data from serial port, use function return
rtnList = mySER.readUART()
if (len(rtnList[1])!=0):
#Forward data to open socket if it's not empty and not the exit script command
#check for exit prompt, let's use command EXITSCR
if (rtnList[1].find('EXITSCR') != -1): #exit found
print '\r\nExit Command Found\r\n'
print 'Exiting data mode\r\n'
rtnList = SOCKET.exitDataMode()
print 'Closing the socket\r\n'
rtnList = SOCKET.closeSocket(1)
return
print rtnList[1] #Debug
res = MDM.send(rtnList[1],1)
#Inbound
#Get data from open socket connection, straight MDM read
res = MDM.read()
if (len(res)!=0):
#Forward socket data to serial port
print res #Debug
mySER.sendUART(res)
#When socket is closed exit loop via this path
#Will guarantee that '\r\nNO CARRIER\r\n' is sent every time
if (DCD == 0):
#Clear DCD on USIF0
SER.setDCD(0)
myIO.USER_LED('OFF')
#Get any remaining data from closed socket connection, straight MDM read
res = MDM.read()
if (len(res)!=0):
#Forward socket data to serial port
mySER.sendUART(res)
break #exit loop to registration checks
except UserWarning:
print 'Controlled Script exit'
except:
print sys.exc_info()
rtnList[0] = -1
return
