def __init__(self, settings):
self.timer = MOD.secCounter()
self.settings = settings
self.settingsByKey = settingsByKey = self.settings.byKey
SER.set_speed('300')
#self.charmParsed = settingsByKey['charm']
self.name = settingsByKey['name']
self.i = settingsByKey['id']
self.serverAddr = settingsByKey['serverAddr']
self.maxLate = settingsByKey['maxlate']
self.desc = settingsByKey['desc']
self.charm = settingsByKey['charm']
self.mainLoop = None
print self.timer
# Komendy odpowiedzialne za komunikacje internetową
SER.setDSR(0)
SER.setCTS(0)
SER.setDCD(0)
self.time = 0
self.SMS = SMS(self)
self.ipAddr = ""
self.getTime()
atstart = settingsByKey["atstart"]
if len(atstart): sendATlist(atstart)
self.maxSMSinMEM = settingsByKey["sms_limit"]
MDM.send(self.m_init, 10)
MDM.receive(20)
def net(self):
""" Funkcja Wprowadza komendy AT odpowiedzialne
za komunikacje internetnetową"""
b = ""
i = 0
a1, a2 = self.m_net
list = map(\
(lambda x,y,s=(self.settingsByKey): x + s[y][0] +'"\r'),\
('AT#USERID="','AT#PASSW="'),\
('gsmuser',"gsmpass")\
)
for a in a1, list, a2:
for c in a:
MDM.send(str(c), 10)
i = 0
while i < 20:
b = MDM.receive(10)
if not b:
i = i + 1
MOD.sleep(5)
continue
print "Network Initializer: ", c
isError(b)
break
# self.ipAddr=b[:b.find("\r")]
else:
print "ERROR to receive command responce."
def sendAndCheck(command="AT\r",
commit="OK",
s=10,
retryR=3,
retryS=1,
timeout=5):
"""
Funkcja wysyła komendy AT oraz sprawdza ich
wartość zwrotną. Wrazie nietrzymania wartości
zwrotnej funkcja ponawia próbe jej odebrania.
Wrazie przekroczenie limitu prób odebrania
wartości zwrotnej ("retryR" razy). Funkcja
ponawia próbe wywołania komendy AT (retryS razy)
"""
i = 0
c = e = None
while i < retryS:
MDM.receive(1)
# if a[:-1]!="\r": a+="\r"
e = MDM.send(command, s)
for a in range(0, retryR):
c = MDM.receive(10)
if c.find(commit) > -1: return 1
MOD.sleep(timeout)
i = i + 1
return 0
def sendATData(self, atcom, atres, trys=1, timeout=1, csd=1):
mdm_timeout = int(self.config.get('TIMEOUT_MDM'))
s = MDM.receive(mdm_timeout)
result = -2
while (1):
if (csd):
self.tryCSD()
if (self.config.get('DEBUG_AT') == '1'):
self.debug.send('DATA AT OUT: ' + atcom)
s = ''
MDM.send(atcom, mdm_timeout)
timer = MOD.secCounter() + timeout
while (1):
s = s + MDM.receive(mdm_timeout)
if (s.find(atres) != -1):
result = 0
break
if (s.find('ERROR') != -1):
result = -1
break
if (MOD.secCounter() > timer):
break
if (self.config.get('DEBUG_AT') == '1'):
self.debug.send('DATA AT IN: ' + s[2:])
trys = trys - 1
if ((trys <= 0) or (result == 0)):
break
MOD.sleep(15)
return (result, s)
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 sendAT(cmd):
MDM.send(cmd + '\r', 0)
res = MDM.receive(30)
if (res.find('OK') == -1):
print 'cmd: %s failed: %s' % (cmd, res)
return 0
return 1
def gprsIsOn():
MDM.send('AT#GPRS?\r', 0)
res = MDM.receive(10)
print 'GPRS on: ' + res
if (res.find('1') == -1):
return 0
else:
return 1
def sendSMS(self, number, smstext):
# Send command for sending message
a = MDM.send('AT+CMGS="' + number + '"\r', 2)
# clear receive buffer
res = MDM.receive(10)
a = MDM.send(smstext, 2) # Send body of message
# this terminates the message and sends it
a = MDM.sendbyte(0x1A, 2) # terminating the message require ctrl-z
return ()
def sendEscapeSequence():
# Module doesn't care if it isn't in data mode
# Must sleep AT LEAST 1 sec before and after escape sequence
MOD.sleep(12)
MDM.send("+++", 5)
MOD.sleep(12)
timeout = MOD.secCounter() + 5
return _target(["OK"], timeout) != 0
def __init__(self, module):
self.allowedNumbers = ["+48796752703", "+48601593746"]
MDM.send('ATE0\r', 2)
self.prepare()
self.messageFlag = 0
self.messages = {}
self.messagePos = ""
module.add_operation("SMSCHECK", lambda module,SMS = self: \
SMS.smsCheck(module) \
)
def initModem():
if (not sendAT('AT')):
return 0
if (not sendAT('AT+IPR=9600')):
return 0
if (not sendAT('AT+CMEE=2')):
return 0
res = MDM.send('AT+CPIN=1234\r', 0) # insert your pin
res = MDM.receive(3)
# ignore error, maybe pin is already set
return 1
def sendCmd(cmd, value, waitfor):
if (value != ""):
cmd = cmd + '='
else:
cmd = cmd + '\r'
res = MDM.send(cmd, 0)
if (value != ""):
res = MDM.send(value, 0)
res = MDM.send('\r', 0)
if (waitfor > 0):
res = MDM.receive(waitfor)
return res
def serverCommunication(self,\
counter = MOD.secCounter,
read = MDM.read,
sleep = MOD.sleep
):
""" Funkcja przekazuje komunikacje do funkcji
parseConfiguration odpowiedzialnej za
interpretacje konfiguracji."""
x = ""
loD = 0
timeout = counter() + 60
p = config(self.module)
while timeout > counter():
x = read()
if x == "":
sleep(10)
continue
loD = len(x)
e = p.parse(x, loD)
if e == 0: return
timeout = counter() + 60
del p
MDM.send("+++", 10)
MDM.receive(50)
MDM.send("AT#SH=1", 10)
MDM.receive(10)
def getMessage(self, msgid):
msg = self.messages.get(msgid)
if msg: return msg
MDM.receive(10)
MDM.send('AT+CMGR=' + str(msgid) + '\r', 2)
SMScontent = ""
t = 0
while not SMScontent:
SMScontent = MDM.receive(15)
if t >= 5:
print "[SMS] Cannot get message number", msgid, "\r"
return ""
t = t + 1
self.messages[msgid] = SMScontent
return SMScontent
def receiveReponse():
timeout = MOD.secCounter() + 10
str = ""
length = ""
newlinepos = 0
while (MOD.secCounter() < timeout):
newlinepos = str.find("\n\r")
if ((newlinepos != -1) and not length):
newlinepos = newlinepos + 2
pos = str.find("Content-Length:") + 15
while (str[pos] != '\n'):
length = "%s%s" % (length, str[pos])
pos = pos + 1
length = int(length) + newlinepos
else:
MOD.sleep(5)
str = str + MDM.receive(1)
if (length and len(str) >= length):
return str[newlinepos:(newlinepos + length)]
return 0
def __init__(self, api=None, maxPS=512):
self.api = api
if api is MDM:
self.isMDM = 1
self.isSER = 0
self.name = "MDM"
self.send = lambda b: MDM.send(b, 1)
self.alive = self.MDM_connection_alive
else:
self.isSER = 1
self.isMDM = 0
self.name = "SER"
self.limit = 256
self.alive = lambda: 1
self.send = lambda b: SER.send(b)
self.maxPS = maxPS
self.baudSec = 0
self.baud = None
self.isMDM = 0
self.baudId = "-1"
self.b = ""
self.ex = 0
self.p = 0
self.c = 0
self.name = ""
self.limit = 1024
self.l = 0
self.reset = 0
self.nextInterface = None
def parseConfigLine(self):
# - Znak "#" powoduje do wprowadznie konfiguracji nastepujacej po nim
# - Za wyjątkiem sytuacji w której pd znaku "#" występuje znak "?",
# w tej sytuacji moduł wysyła na interfejs konfiguracje w formacie:
# <Id>%<Nazwa modułu>%<Opis>%<Harmonogram>
argsLine = [""]
charm = []
argsIn = 0
isnEnd = 1
a = ""
c_now = ""
forward = self.forward
m = self.module
c_now = forward()[1]
if c_now == "?":
MDM.send(self.module.getDeviceInfoLine(), 1)
return
else:
print "Parsing properties."
while (c_now and c_now != ';'):
a = argsLine[argsIn]
if c_now == '/' and a:
charm.append(argsLine[argsIn])
argsLine[argsIn] = ""
elif c_now == "%":
print "Argument: ", a
argsIn = argsIn + 1
argsLine.append("")
else:
argsLine[argsIn] = a + c_now
c_now = forward()[1]
if argsIn:
m.i[0] = argsLine[0]
m.name[0] = argsLine[1]
m.desc[0] = argsLine[2]
if len(charm) and m.mainLoop:
m.mainLoop.parseCharmSequence(charm)
print \
"id: ", m.i[0],'\r\n',\
"name: ", m.name[0],'\r\n',\
"desc: ", m.desc[0],'\r\n',\
"charm: ", charm,'\r\n',\
"parsing charm...",'\r\n'
print "OK"
return 1
def connectToServer(self, module):
"""Funkcja rozpoczyna komunikacje z serwerem"""
i = 0
module.getCSGN()
MDM.send("AT#SH=1\r", 1)
MDM.receive(0)
print module.serverAddr
ip, port = module.serverAddr[0:2]
command = "AT#SD=1,0," + port + "," + ip + "\r"
if sendAndCheck(command, "CONNECT", 5, 5, 5):
print "--SOCKET OPENED--"
MDM.send(str("$" + module.CSGN), 1)
self.serverCommunication()
else:
print "Cannot connect to socket"
print "--SOCKET FAILURE--"
MDM.send("AT#SH=1", 1)
MDM.receive(0)
def wait_for_response(timeout=5.0):
data = ''
time_max = time.time() + timeout
while not contains_any(data, 'OK\r', 'ERROR\r') and time.time() < time_max:
byte = MDM.readbyte()
if byte != -1:
data += chr(byte)
return 'OK\r' in data
def read_registers(start_reg, n):
SER2.send('reading: %02x %d\r\n' % (start_reg, n))
MDM.send(
'AT#I2CRD=%d,%d,%02x,%02x,%d\r' %
(GPIO_SDA, GPIO_SCL, CODEC_ADDR, start_reg, n), 0)
data = ''
time_max = time.time() + 10.0
while not contains_any(data, 'OK\r', 'ERROR\r') and time.time() < time_max:
byte = MDM.readbyte()
if byte != -1:
data += chr(byte)
data = data.lstrip()
if data.startswith('#I2CRD: '):
return data[8:data.index('\r')]
return None
def isMessage(self):
res = MDM.receive(5)
a = res.find('+CMTI: "SM",')
if (a != -1):
firstdigit_pos = a + 12
self.messagePos = res[firstdigit_pos:-2]
print "Message id is", self.messagePos
self.messageFlag = 1
return 1
else:
self.messageFlag = 0
return 0
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 _target(targets, timeout):
res = ""
while (MOD.secCounter() < timeout):
res = res + MDM.receive(1)
index = 0
for target in targets:
if (res.rfind(target) != -1):
return [index, res]
index = index + 1
return 0
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 write_registers(start_reg, *data):
SER2.send('writing: %02x %r\r\n' % (start_reg, data))
MDM.send(
'AT#I2CWR=%d,%d,%02x,%02x,%d\r' %
(GPIO_SDA, GPIO_SCL, CODEC_ADDR, start_reg, len(data)), 0)
MDM.send(''.join(hex(x)[2:].zfill(2) for x in data), 0)
MDM.sendbyte(0x1a, 0)
return wait_for_response()
def _command(command, timeout=5):
# Clear input buffer before reading
MDM.receive(1)
MDM.send(command, 5)
MDM.send(CRLF, 5)
#SER.send("%s \n" % (command))
return MOD.secCounter() + timeout
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 check4SMS():
Helper.sendCmd('AT+CMGF','1', 50)
data= ''
data = Helper.sendCmd('AT+CMGL','"ALL"',20)
smslist=''
#listen to what the telit says with a timeout of 20
smslist = smslist + data
while data != '':
data = MDM.receive(20)
smslist = smslist + data
smsarray = []
lines = smslist.split('+CMGL:')
if len(lines) > 1:
for i in range(1,len(lines)):
smsarray.append(parseSMS(lines[i]))
return smsarray
def makeRequest(path, content):
MDM.receive(1)
message = ("POST %s HTTP/1.1\n"
"Host: %s\n"
"Content-Type: application/json\n"
"Content-Length: %s\n"
"\n"
"%s") % (path, CONNECTED_HOST, len(content), content)
MDM.send(message, 5)
MDM.send(CRLF, 5)
response = receiveReponse()
return response
def main():
if config_codec():
SER2.send('Codec configured\r\n')
else:
SER2.send('Cannot configure the codec\r\n')
data = ''
while True:
byte = MDM.readbyte()
if byte == -1:
time.sleep(0.1)
continue
data += chr(byte)
if not '\r' in data:
time.sleep(0.1)
continue
line, data = data.split('\r', 2)
if 'RING' in line:
SER2.send('ring!!!\r\n')
accept_call()
else:
SER2.send(line + '\r\n')
