def main():
print('Initializing modem...')
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE)
modem.connect(PIN)
modem.waitForNetworkCoverage(10)
print('Sending USSD string: {0}'.format(USSD_STRING))
response = modem.sendUssd(USSD_STRING) # response type: gsmmodem.modem.Ussd
print('USSD reply received: {0}'.format(response.message))
if response.sessionActive:
print('Closing USSD session.')
# At this point, you could also reply to the USSD message by using response.reply()
response.cancel()
else:
print('USSD session was ended by network.')
modem.close()
def getUnreadText(key):
if key.strip() == '9703BB8D5A':
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting mode"
modem.connect()
except:
return "Error connecting"
try:
messages = modem.listStoredSms(status=Sms.STATUS_RECEIVED_UNREAD)
except Exception as e:
return str(e)
modem.close()
retString = ""
print "Got %d messages" % len(messages)
for message in messages:
retString = retString + "%s : %s" % (message.number, message.text)
return retString
else:
return "Incorrect key"
class Modem(threading.Thread):
def __init__(self, smsq, device, *a,**kw):
self.modem = GsmModem(device,9600,dsrdtr=True,rtscts=True)
self.smsq = smsq
return super(Modem,self).__init__(*a,**kw)
def run(self):
while True:
try:
self.modem.connect()
except (TimeoutException,IOError) as e:
self.modem.close()
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.debug(traceback.format_tb(exc_traceback))
time.sleep(10)
continue
try:
while True:
phone,text = self.smsq.get()
logging.debug(u'modem to {} text: {}'.format(phone,text))
sms = self.modem.sendSms(phone,text)
self.smsq.task_done()
time.sleep(10)
except Exception as e:
self.modem.close()
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.error(type(e))
logging.error(e.message)
logging.debug(traceback.format_tb(exc_traceback))
def getAllText(key):
if key.strip() == '9703BB8D5A':
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting modem"
modem.connect()
except Exception as e:
return str(e)
try:
messages = modem.listStoredSms()
except Exception as e:
return str(e)
modem.close()
retString = ""
print "Got %d messages" % len(messages)
for message in messages:
retString = retString + "%s : %s" % (message.number,
message.text) + "\n"
return retString
else:
return "Incorrect key"
def text(number, message, key):
if key.strip() == '9703BB8D5A':
print "Creating modem instance"
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting modem"
modem.connect()
except PinRequiredError:
print "Pin required"
try:
print "Waiting for Network coverage info"
modem.waitForNetworkCoverage(5)
except TimeoutException:
print "Signal strength not strong enough"
return "No signal"
else:
try:
print "Sending %s to %s" % (message, number)
sms = modem.sendSms(number, message)
except TimeoutException:
print "Failed to send message"
return 'Error encountered'
print "Closing modem"
modem.close()
return True
else:
return 'Key is not correct'
def getAllText(key):
if key.strip() == '9703BB8D5A':
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting modem"
modem.connect()
except Exception as e:
return str(e)
try:
messages = modem.listStoredSms()
except Exception as e:
return str(e)
modem.close()
retString = ""
print "Got %d messages" % len(messages)
for message in messages:
retString = retString + "%s : %s" % (message.number, message.text) + "\n"
return retString
else:
return "Incorrect key"
def initModem(port='/dev/ttyUSB0', baud=460800):
global modem
modem = GsmModem(port, baud)
# Uncomment the following line to see what the modem is doing:
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
print('Connecting to GSM modem on {0}...'.format(port))
try:
modem.connect()
except PinRequiredError:
sys.stderr.write(
'Error: SIM card PIN required. Please specify a PIN. \n')
sys.exit(1)
except IncorrectPinError:
sys.stderr.write('Error: Incorrect SIM card PIN entered.\n')
sys.exit(1)
print('Checking for network coverage...')
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print(
'Network signal strength is not sufficient, please adjust modem position/antenna and try again.'
)
modem.close()
sys.exit(1)
def send_sms(phone_num, context):
modem = GsmModem(port=PORT)
modem.connect(PIN)
for i in range(len(phone_num)):
modem.sendSms(phone_num[i], context)
# modem.smsTextMode = False
modem.close()
class Modem(threading.Thread):
def __init__(self, smsq, device, *a, **kw):
self.modem = GsmModem(device, 9600, dsrdtr=True, rtscts=True)
self.smsq = smsq
return super(Modem, self).__init__(*a, **kw)
def run(self):
while True:
try:
self.modem.connect()
except (TimeoutException, IOError) as e:
self.modem.close()
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.debug(traceback.format_tb(exc_traceback))
time.sleep(10)
continue
try:
while True:
phone, text = self.smsq.get()
logging.debug(u'modem to {} text: {}'.format(phone, text))
sms = self.modem.sendSms(phone, text)
self.smsq.task_done()
time.sleep(10)
except Exception as e:
self.modem.close()
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.error(type(e))
logging.error(e.message)
logging.debug(traceback.format_tb(exc_traceback))
def run(self):
# initialize modem
modem = GsmModem(self._modem_device,
self._modem_baud,
smsReceivedCallbackFunc=self._handleSms)
modem.connect(self._modem_pin)
# try to sycn clock with GSM network time
self.set_clock_from_network(modem)
# handle SMS
self._pon_requested = False
modem.smsTextMode = False
modem.processStoredSms()
# wait for completion
try:
modem.rxThread.join(1)
finally:
modem.close()
# handle asynchronous sms request
if self._pon_requested:
self._pon_requested = False
self.setup_connection()
def getUnreadText(key):
if key.strip() == '9703BB8D5A':
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting mode"
modem.connect()
except:
return "Error connecting"
try:
messages = modem.listStoredSms(status=Sms.STATUS_RECEIVED_UNREAD)
except Exception as e:
return str(e)
modem.close()
retString = ""
print "Got %d messages" % len(messages)
for message in messages:
retString = retString + "%s : %s" % (message.number, message.text)
return retString
else:
return "Incorrect key"
def main():
# sendsms("+972549766158", "Hello")
print('Initializing modem...')
# Uncomment the following line to see what the modem is doing:
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
# modem = GsmModem(PORT)
# modem.connect()
# modem.smsc = "+972586279099"
# modem.sendSms("+972549766158", "before")
# modem.close()
numOfSeats = 4
message = "זוהי הודעה מגבאי בית הכנסת : נשמח אם תוכל להחזיר הודעה עם מספר המושבים הפנויים שמוקצים לך ולמשפחתך בשבת הקרובה." + "\nמקסימום: " + str(
numOfSeats)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
# modem.smsc = "+972586279099" #golan telecom
modem.smsc = "+972521100059" #cellcom
# modem.sendSms("+972549766158", "שלום מדבר אמיתי מלכה תוכל להגיב לי בבקשה?")
modem.sendSms("+972587766185", message)
# modem.smsc = "+972586279099"
print('Waiting for SMS message...')
try:
modem.rxThread.join(
2**31
) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
def main():
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
try:
modem.rxThread.join(2**31)
finally:
modem.close()
def main():
global modem
global phonebook
config.read('config.ini')
# Create the phonebook
tmpPhonebook = config.items('phonebook')
for row in tmpPhonebook:
phonebook[row[0]] = row[1]
# Initialize the modem
print('Initializing modem...')
modem = GsmModem(config.get('modem', 'port'),
config.getint('modem', 'baudrate'),
smsReceivedCallbackFunc=on_gsm_handleSms)
modem.smsTextMode = True
# Connect to the modem
try:
modem.connect(config.get('modem', 'pin'))
except PinRequiredError:
print('Pin required')
sys.exit(1)
except IncorrectPinError:
print('Wrong pin')
sys.exit(1)
# Print information about modem and network
print(u'Connected to modem: {0} {1}'.format(modem.manufacturer,
modem.model))
print(u'Connected to network: {0}'.format(modem.networkName))
print(u'Signal strenght: {0}'.format(str(modem.signalStrength)))
print('Ready!')
print('===')
# Make sure to empty incoming sms bucket
modem.processStoredSms()
# Initialize MQTT
client.on_connect = on_mqtt_connect
client.on_message = on_mqtt_message
client.username_pw_set(config.get('mqtt', 'user'),
config.get('mqtt', 'pass'))
client.connect(config.get('mqtt', 'server'), config.getint('mqtt', 'port'),
60)
client.loop_start()
# Keep running forever
try:
modem.rxThread.join(
2**31
) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
def main():
print('Initializing modem...')
logging.basicConfig(filename='/var/log/gsm.log', format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, incomingCallCallbackFunc=handleIncomingCall)
modem.connect()
print('Waiting for incoming calls...')
try:
modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
def main():
global modem
print('Initializing modem...')
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, incomingCallCallbackFunc=handleIncomingCall, smsReceivedCallbackFunc=handleSms, gpsStatusReportCallbackFunc=handleIncomingGPS)
modem.connect()
print('Waiting for incoming calls or SMS messages')
try:
modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
def main():
print('Initializing modem...')
# Uncomment the following line to see what the modem is doing:
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
print('Waiting for SMS message...')
try:
modem.rxThread.join(2**10)
finally:
modem.close()
def main():
print('Initializing modem...')
# Uncomment the following line to see what the modem is doing:
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
print('Waiting for SMS message...')
try:
modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close();
def main():
print('Initializing modem...')
# Uncomment the following line to see what the modem is doing:
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
print('Waiting for SMS message...')
try:
modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close();
def main():
print('Initializing modem...')
modem = GsmModem(PORT,
BAUDRATE,
smsReceivedCallbackFunc=sms_catcher,
incomingCallCallbackFunc=call_catcher)
modem.smsTextMode = False
modem.connect()
print('Waiting for SMS or Call...')
try:
modem.rxThread.join()
finally:
modem.close()
def main():
print('Initializing modem...')
modem = GsmModem(PORT, BAUDRATE)
modem.connect(PIN)
modem.waitForNetworkCoverage(10)
print('Sending SMS to: {0}'.format(SMS_DESTINATION))
response = modem.sendSms(SMS_DESTINATION, SMS_TEXT, True)
if type(response) == SentSms:
print('SMS Delivered.')
else:
print('SMS Could not be sent')
modem.close()
def main():
print('Initializing modem...')
modem = GsmModem(PORT, SPEED)
modem.smsTextMode = False
modem.connect(PIN)
try:
number_request = '+79372219943'
#number_request = '+79179812832'
#number_request = '+79272294597'
message = "/00000 INS OUTS"
modem.sendSms(number_request, message)
#modem.status()
finally:
modem.close()
def runModem():
print('Initializing modem...')
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
modem.deleteMultipleStoredSms()
#modem.sendSms('+44740000000','asdsdefed',False)
print('Waiting for SMS message...')
try:
modem.rxThread.join(
2**31
) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
def main():
print('Initializing modem...')
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE)
modem.connect(PIN)
modem.waitForNetworkCoverage(10)
print('Sending USSD string: {0}'.format(USSD_STRING))
response = modem.sendUssd(USSD_STRING) # response type: gsmmodem.modem.Ussd
print('USSD reply received: {0}'.format(response.message))
if response.sessionActive:
print('Closing USSD session.')
# At this point, you could also reply to the USSD message by using response.reply()
response.cancel()
else:
print('USSD session was ended by network.')
modem.close()
def main():
if NUMBER == None or NUMBER == "00000":
print(
"Error: Please change the NUMBER variable's value before running this example."
)
sys.exit(1)
print("Initializing modem...")
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE)
modem.connect(PIN)
print("Waiting for network coverage...")
modem.waitForNetworkCoverage(30)
print("Dialing number: {0}".format(NUMBER))
call = modem.dial(NUMBER)
print("Waiting for call to be answered/rejected")
wasAnswered = False
while call.active:
if call.answered:
wasAnswered = True
print("Call has been answered; waiting a while...")
# Wait for a bit - some older modems struggle to send DTMF tone immediately after answering a call
time.sleep(3.0)
print("Playing DTMF tones...")
try:
if (
call.active
): # Call could have been ended by remote party while we waited in the time.sleep() call
call.sendDtmfTone("9515999955951")
except InterruptedException as e:
# Call was ended during playback
print("DTMF playback interrupted: {0} ({1} Error {2})".format(
e, e.cause.type, e.cause.code))
except CommandError as e:
print("DTMF playback failed: {0}".format(e))
finally:
if call.active: # Call is still active
print("Hanging up call...")
call.hangup()
else: # Call is no longer active (remote party ended it)
print("Call has been ended by remote party")
else:
# Wait a bit and check again
time.sleep(0.5)
if not wasAnswered:
print("Call was not answered by remote party")
print("Done.")
modem.close()
def main():
print 'Initializing modem...'
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
global modem
modem = GsmModem(PORT,
BAUDRATE,
incomingCallCallbackFunc=handleIncomingCall)
while True:
modem.connect(PIN)
print 'Waiting for incoming calls...'
try:
modem.rxThread.join(
10
) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
print "Reopening modem..."
class phoneConnection:
def __init__(self, handleSMSCallBack):
self.port = '/dev/ttyUSB2'
ports = list(serial.tools.list_ports.comports())
for p in ports:
if 'ZTE NMEA Device' in p.description:
self.port = p.device
self.baudRate = 115200
self.pin = None # SIM card PIN (if any)
self.modem = GsmModem(self.port, self.baudRate, smsReceivedCallbackFunc=handleSMSCallBack\
,incomingCallCallbackFunc=handleCall)
self.modem.smsTextMode = False
self.modem.connect(self.pin)
self.signalStrength = self.modem.waitForNetworkCoverage(10)
self.response = None
self.modem.ownNumber
def sendUSSD(self, ussdString):
if (self.response and self.response.sessionActive):
self.response.reply(ussdString)
else:
self.response = self.modem.sendUssd(ussdString)
ucs2Message = binascii.unhexlify(self.response.message)
utf16Message = ucs2Message.decode('utf-16-be')
return utf16Message
def sessionActiveClose(self):
if self.response.sessionActive:
response.cancel()
def getIrancellAccountBalance(self):
try:
message = self.sendUSSD('*141*1#')
balance = int(message.split()[1])
self.sessionActiveClose()
except:
balance = -1
return balance
def accountCharging(self):
pass
#'*780*2*1*0936XXX9014*10000*1*#')
def __del__(self):
if (self.modem):
self.modem.close()
def main():
logging.basicConfig(format="%(levelname)s: %(message)s",
level=logging.INFO)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
try:
if modem.ownNumber:
print("Modem phone number:", modem.ownNumber)
print("IMSI:", modem.imsi)
print("IMEI:", modem.imei)
modem.processStoredSms()
while True:
print("--- Network: {0} / Signal: {1} ---".format(
modem.networkName, modem.signalStrength))
modem.rxThread.join(60 * 60)
finally:
modem.close()
def autodetect_modem(pin=None, check_fn=None, modem_options={'baudrate': 9600}):
""" Autodetect a suitable cellular modem connected to the system.
:param pin: Security PIN to unlock the SIM.
:param check_cn: Callable that should take a single ``modem`` argument
and return True if the modem instance is suitable.
:param modem_options: Structure to pass as keyword arguments to
``GsmModem`` initialisation.
:type modem_options: dict-like
:returns: Connected modem instance
:rtype: :class:`gsmmodem.modem.GsmModem`
This method will iterate through all potential serial ports on the system
and attempt to ``connect()`` to each of them in turn. The first serial
port that connects successfully, and passes the ``check_fn(modem)`` call
(if ``check_fn`` is specified), will be returned.
All other unsuccessful connections will be closed during the process.
This method will return ``None`` if no modems could be detected.
"""
ports = enumerate_serial()
if not ports:
log.error('No modem ports detected on system.')
return
modem = None
for port in ports:
modem = GsmModem(port, **modem_options)
try:
log.debug('Attempting to connect to modem at %s' % port)
modem.connect(pin=pin)
if not check_fn or check_fn and check_fn(modem):
log.debug('Successfully detected modem at %s' % port)
return modem
except SerialException:
log.warn('Serial communication problem for port %s' % port)
except TimeoutException:
log.warn('Timeout detected on port %s' % port)
log.debug('Closing modem at %s' % port)
modem.close()
def run(self):
logging.info("Modem thread running")
global modem
rxListenLength = 10
init_count = 0
while self.running and init_count > -1:
try:
init_count = init_count + 1
modem = GsmModem(PORT,
BAUDRATE,
incomingCallCallbackFunc=handleIncomingCall)
logging.info("Initializing modem, try {0}.".format(init_count))
modem.connect(PIN)
init_count = -1
except TimeoutException as e:
logging.critical("Failed to initialize the GSM module: {0}", e)
modem.close()
logging.info('Waiting for incoming calls...')
while self.running:
try:
#waitForNetworkCoverage()
self.signalStrength = modem.signalStrength
self.networkName = modem.networkName
serving_cell = self.CGED_REGEX.match(
modem.write("AT+CGED=3")[0])
if serving_cell:
mcc = serving_cell.group(1)
mnc = serving_cell.group(2)
lac = serving_cell.group(3)
ci = serving_cell.group(4)
self.cellInfo = "{0}/{1}/{2}/{3}".format(mcc, mnc, lac, ci)
# Comms are handled elsewhere so we could eventually just sleep, waiting
#time.sleep(rxListenLength)
modem.rxThread.join(rxListenLength)
except (InterruptedException, PinRequiredError, IncorrectPinError,
TimeoutException):
logging.error("rxThread died: {0}".format(sys.exc_info()[0]))
modem.close()
logging.info("Modem closed.")
def main():
if NUMBER == None or NUMBER == '00000':
print('Error: Please change the NUMBER variable\'s value before running this example.')
sys.exit(1)
print('Initializing modem...')
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE)
modem.connect(PIN)
print('Waiting for network coverage...')
modem.waitForNetworkCoverage(30)
print('Dialing number: {0}'.format(NUMBER))
call = modem.dial(NUMBER)
print('Waiting for call to be answered/rejected')
wasAnswered = False
while call.active:
if call.answered:
wasAnswered = True
print('Call has been answered; waiting a while...')
# Wait for a bit - some older modems struggle to send DTMF tone immediately after answering a call
time.sleep(3.0)
print('Playing DTMF tones...')
try:
if call.active: # Call could have been ended by remote party while we waited in the time.sleep() call
call.sendDtmfTone('9515999955951')
except InterruptedException as e:
# Call was ended during playback
print('DTMF playback interrupted: {0} ({1} Error {2})'.format(e, e.cause.type, e.cause.code))
except CommandError as e:
print('DTMF playback failed: {0}'.format(e))
finally:
if call.active: # Call is still active
print('Hanging up call...')
call.hangup()
else: # Call is no longer active (remote party ended it)
print('Call has been ended by remote party')
else:
# Wait a bit and check again
time.sleep(0.5)
if not wasAnswered:
print('Call was not answered by remote party')
print('Done.')
modem.close()
def main():
print('[%s] Initializing modem...' % datetime.datetime.now())
# Uncomment the following line to see what the modem is doing:
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect(PIN)
print('[%s] Initialized modem!' % datetime.datetime.now())
print('[%s] Sending Message...' % datetime.datetime.now())
cellnum = raw_input("Please Enter your phone number:")
text = raw_input("Please Enter your text message:")
print('Type:', type(text))
modem.sendSms(cellnum, unicode(text, 'gbk'))
print('[%s] Waiting for SMS message...' % datetime.datetime.now())
try:
modem.rxThread.join(2 ** 31)
# Specify a (huge) timeout so that it essentially blocks indefinitely,
# but still receives CTRL+C interrupt signal
finally:
modem.close()
def gmsmodem(port=3, baud=115200, pin=None):
while port < 9:
try:
print('Connecting to GSM modem on com %s...' % (port + 1))
modem = GsmModem(port, baud)
try:
print('Checking for pin...')
modem.connect(pin)
try:
print('Checking for network coverage...')
modem.waitForNetworkCoverage(5)
return modem
except Exception, e:
modem.close()
print e
except Exception, e:
print e
except Exception, e:
print e
port += 1
def gmsmodem(port=3,baud=115200,pin=None):
while port<9:
try:
print('Connecting to GSM modem on com %s...'%(port+1))
modem = GsmModem(port,baud)
try:
print('Checking for pin...')
modem.connect(pin)
try:
print('Checking for network coverage...')
modem.waitForNetworkCoverage(5)
return modem
except Exception, e:
modem.close()
print e
except Exception, e:
print e
except Exception, e:
print e
port+=1
def list_sms(args):
modem = GsmModem(args.port, args.baud, AT_CNMI=args.CNMI)
if args.debug:
# enable dump on serial port
logging.basicConfig(format='%(levelname)s: %(message)s',
level=logging.DEBUG)
print('Connecting to GSM modem on {0}...'.format(args.port))
try:
modem.connect(args.pin, waitingForModemToStartInSeconds=args.wait)
except PinRequiredError:
sys.stderr.write(
'Error: SIM card PIN required. Please specify a PIN with the -p argument.\n'
)
sys.exit(1)
except IncorrectPinError:
sys.stderr.write('Error: Incorrect SIM card PIN entered.\n')
sys.exit(1)
#print('Checking for network coverage...')
messages = modem.listStoredSms()
"""
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
modem.close()
sys.exit(1)
else:
try:
pass #sms = modem.sendSms(args.destination, text, waitForDeliveryReport=args.deliver)
except TimeoutException:
print('Failed to send message: the send operation timed out')
modem.close()
sys.exit(1)
else:
modem.close()
"""
for x in messages:
print(x.text)
modem.close()
def run(self):
logging.info("Modem thread running")
global modem
rxListenLength = 10
init_count = 0
while self.running and init_count > -1:
try:
init_count = init_count + 1
modem = GsmModem(PORT, BAUDRATE, incomingCallCallbackFunc=handleIncomingCall)
logging.info("Initializing modem, try {0}.".format(init_count))
modem.connect(PIN)
init_count = -1
except TimeoutException as e:
logging.critical("Failed to initialize the GSM module: {0}", e)
modem.close()
logging.info('Waiting for incoming calls...')
while self.running:
try:
#waitForNetworkCoverage()
self.signalStrength = modem.signalStrength
self.networkName = modem.networkName
serving_cell=self.CGED_REGEX.match(modem.write("AT+CGED=3")[0])
if serving_cell:
mcc=serving_cell.group(1)
mnc=serving_cell.group(2)
lac=serving_cell.group(3)
ci=serving_cell.group(4)
self.cellInfo="{0}/{1}/{2}/{3}".format(mcc, mnc, lac, ci)
# Comms are handled elsewhere so we could eventually just sleep, waiting
#time.sleep(rxListenLength)
modem.rxThread.join(rxListenLength)
except (InterruptedException, PinRequiredError, IncorrectPinError, TimeoutException):
logging.error("rxThread died: {0}".format(sys.exc_info()[0]))
modem.close()
logging.info("Modem closed.")
def listen_for_sms():
global modem
global correct_format
# print('Initializing modem...')
# Uncomment the following line to see what the modem is doing:
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = False
modem.connect()
first_text = BOX + ' Restart: Waiting for credentials | cmcibm,<BROKER>,<PORT>,<USERNAME>,<PASSWORD>'
#load_dest()
sentmsg = modem.sendSms(DESTINATION, first_text)
print('Waiting for SMS message')
try:
modem.rxThread.join(TIMEOUT)
finally:
print('Closing modem')
to_print = load_mqtt()
if correct_format == 1:
#print("the format is correct and equal to")
# to_print = load_mqtt()
print(change_required)
print(correct_format)
print(to_print[0])
print(to_print[1])
print(to_print[2])
print(to_print[3])
else:
#print("the format is NOT correct and equal to")
print(change_required)
print(correct_format)
print('')
print('')
print('')
print('')
modem.close()
def initModem(port='/dev/ttyUSB1', baud=460800):
global modem
modem = GsmModem(port, baud)
# Uncomment the following line to see what the modem is doing:
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
print('Connecting to GSM modem on {0}...'.format(port))
try:
modem.connect()
except PinRequiredError:
sys.stderr.write('Error: SIM card PIN required. Please specify a PIN. \n')
sys.exit(1)
except IncorrectPinError:
sys.stderr.write('Error: Incorrect SIM card PIN entered.\n')
sys.exit(1)
print('Checking for network coverage...')
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
modem.close()
sys.exit(1)
class Read_SMS():
def __init__(self, PORT='ttyUSB0', SPEED=9600, PIN=None):
self.modem = GsmModem(PORT, SPEED)
self.modem.smsTextMode = False
self.modem.connect(PIN)
print('Initializing modem...')
def read_sms(self):
sms_message_db = SmsMessage()
for sms in self.modem.listStoredSms(memory='sm', delete=True):
print(sms.number, sms.time, sms.text)
sms_message_db.date = datetime.now().date()
sms_message_db.time = datetime.now().time()
sms_message_db.number = sms.number
sms_message_db.text_sms = sms.text
sms_message_db.ps = filter_ps(sms.number)
sms_message_db.save()
#print(sms_message_db.get())
def modem_close(self):
self.modem.close()
print("модем отключен")
def send_sms(args):
modem = GsmModem(args.port, args.baud, AT_CNMI=args.CNMI)
if args.debug:
# enable dump on serial port
logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG)
print("Connecting to GSM modem on {0}...".format(args.port))
try:
modem.connect(args.pin, waitingForModemToStartInSeconds=args.wait)
except PinRequiredError:
sys.stderr.write(
"Error: SIM card PIN required. Please specify a PIN with the -p argument.\n"
)
sys.exit(1)
except IncorrectPinError:
sys.stderr.write("Error: Incorrect SIM card PIN entered.\n")
sys.exit(1)
print("Checking for network coverage...")
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print(
"Network signal strength is not sufficient, please adjust modem position/antenna and try again."
)
modem.close()
sys.exit(1)
else:
if args.message is None:
print("\nPlease type your message and press enter to send it:")
text = raw_input("> ")
else:
text = args.message
if args.deliver:
print("\nSending SMS and waiting for delivery report...")
else:
print("\nSending SMS message...")
try:
sms = modem.sendSms(
args.destination, text, waitForDeliveryReport=args.deliver
)
except TimeoutException:
print("Failed to send message: the send operation timed out")
modem.close()
sys.exit(1)
else:
modem.close()
if sms.report:
print(
"Message sent{0}".format(
" and delivered OK."
if sms.status == SentSms.DELIVERED
else ", but delivery failed."
)
)
else:
print("Message sent.")
def main():
args = parseArgsPy26() if sys.version_info[0] == 2 and sys.version_info[1] < 7 else parseArgs()
if args.port == None:
sys.stderr.write('Error: No port specified. Please specify the port to which the GSM modem is connected using the -i argument.\n')
sys.exit(1)
modem = GsmModem(args.port, args.baud, AT_CNMI=args.CNMI)
if args.debug:
# enable dump on serial port
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
print('Connecting to GSM modem on {0}...'.format(args.port))
try:
modem.connect(args.pin, waitingForModemToStartInSeconds=args.wait)
except PinRequiredError:
sys.stderr.write('Error: SIM card PIN required. Please specify a PIN with the -p argument.\n')
sys.exit(1)
except IncorrectPinError:
sys.stderr.write('Error: Incorrect SIM card PIN entered.\n')
sys.exit(1)
print('Checking for network coverage...')
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
modem.close()
sys.exit(1)
else:
if args.message is None:
print('\nPlease type your message and press enter to send it:')
text = raw_input('> ')
else:
text = args.message
if args.deliver:
print ('\nSending SMS and waiting for delivery report...')
else:
print('\nSending SMS message...')
try:
sms = modem.sendSms(args.destination, text, waitForDeliveryReport=args.deliver)
except TimeoutException:
print('Failed to send message: the send operation timed out')
modem.close()
sys.exit(1)
else:
modem.close()
if sms.report:
print('Message sent{0}'.format(' and delivered OK.' if sms.status == SentSms.DELIVERED else ', but delivery failed.'))
else:
print('Message sent.')
def main():
port = '/dev/ttyUSB0'
baud = 460800
deliver = False
destination = "0711661919"
message = "Testing_message \n new line \t tab \n n \n e \n l"
modem = GsmModem(port, baud)
# Uncomment the following line to see what the modem is doing:
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
print('Connecting to GSM modem on {0}...'.format(port))
try:
modem.connect()
except PinRequiredError:
sys.stderr.write('Error: SIM card PIN required. Please specify a PIN. \n')
sys.exit(1)
except IncorrectPinError:
sys.stderr.write('Error: Incorrect SIM card PIN entered.\n')
sys.exit(1)
print('Checking for network coverage...')
try:
modem.waitForNetworkCoverage(5)
except TimeoutException:
print('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
modem.close()
sys.exit(1)
else:
print('\nPlease type your message and press enter to send it:')
text = message
if deliver:
print ('\nSending SMS and waiting for delivery report...')
else:
print('\nSending SMS message...')
try:
sms = modem.sendSms(destination, text, waitForDeliveryReport=deliver)
except TimeoutException:
print('Failed to send message: the send operation timed out')
modem.close()
sys.exit(1)
else:
modem.close()
if sms.report:
print('Message sent{0}'.format(
' and delivered OK.' if sms.status == SentSms.DELIVERED else ', but delivery failed.'))
else:
print('Message sent.')
def start(self):
""" Samotne jadro daemona: setupneme GmailAPI, setupneme GSM modem a zacneme provadet nekonecnou smycku """
self.running = True
# (0) SETUP VIRTUAL SERIAL PORT FOR MODEM
if "virtualPortInitCommand" in myconfig['modem']:
try:
virtualSerialPortInstance = virtualSerialPort(myconfig['modem']['virtualPortInitCommand'])
virtualSerialPortInstance.start()
except:
pass
else:
virtualSerialPortInstance = None
# (1) SETUP GMAIL ACCESS
logging.info('Initializing GMAIL access...')
try:
gmailService = gmailUtils.get_service(self.cwd)
except RuntimeError as e:
print(str(e))
logging.critical(str(e))
if (virtualSerialPortInstance is not None):
virtualSerialPortInstance.stop()
#sys.exit(1)
self.stop()
######################################################################################################################################################
# (2) SETUP GSM MODEM + bind a "smsReceived" callback + poll gmail inbox
logging.info('Initializing GSM modem on {0} port @ {1} speed...'.format(myconfig['modem']['port'], myconfig['modem']['baudrate']))
modem = GsmModem(myconfig['modem']['port'], myconfig['modem']['baudrate'], smsReceivedCallbackFunc=self.incomingSmsHandler)
modem.smsTextMode = False
while self.running:
# start of gsm init loop
try:
modem.connect(myconfig['modem']['pin'])
except serial.SerialException:
logging.error('Error: Cannot connect to modem on serial port %s @ %s. Trying again in %d sec...' % (myconfig['modem']['port'], myconfig['modem']['baudrate'], myconfig['modem']['errorRetryWaitTime']))
time.sleep(myconfig['modem']['errorRetryWaitTime'])
except TimeoutException:
logging.error('Error: Serial device %s @ %s timeout. Trying again in %d sec...' % (myconfig['modem']['port'], myconfig['modem']['baudrate'], myconfig['modem']['errorRetryWaitTime']))
time.sleep(myconfig['modem']['errorRetryWaitTime'])
except PinRequiredError:
# Fatal error
logging.critical('Error: SIM card PIN required. Please provide PIN in the config file.')
self.stop()
return 1
except IncorrectPinError:
# Fatal error
logging.critical('Error: Incorrect SIM card PIN entered!')
self.stop()
return 1
else:
logging.info('Modem connected.')
try:
logging.info('Checking for network coverage...')
modem.waitForNetworkCoverage(8) # of seconds
except TimeoutException:
logging.warning('We can now start gmail inbox polling infinite loop.')
print('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
modem.close()
else:
logging.info('GSM modem is ready.')
logging.info('We are now handling all incoming SMS messages.')
try:
if (myconfig['incomingSmsHandlerSetup']['processStoredSms'] == "all"):
modem.processStoredSms(unreadOnly=False)
elif (myconfig['incomingSmsHandlerSetup']['processStoredSms'] == "unread"):
modem.processStoredSms(unreadOnly=True)
except Exception as e:
logging.critical("Nastal problem pri zpracovani drivejsich neprectenych SMS:")
raise
sys.exit(0)
else:
logging.info('We can now start gmail inbox polling infinite loop.')
try:
while self.running:
# start of main gmail loop
logging.debug('Checking incoming emails...')
newMessagesCount = self.incomingGmailHandler(gmailService, modem)
time.sleep(myconfig['general']['gmailQueueWaitingPeriod'] if newMessagesCount > 0 else myconfig['general']['gmailPollingInterval'])
# end of main gmail loop
except KeyboardInterrupt:
#sys.exit(0)
self.stop()
return 0
except Exception as e:
print("Nastala vyjimka v hlavni smycce daemona, viz log.")
logging.exception("Nastal problem v hlavni smycce:")
raise
finally:
print("Bye gmail loop.")
finally:
print("Bye stored sms handling try-cache.")
finally:
print("Bye.")
modem.close()
if (virtualSerialPortInstance is not None):
virtualSerialPortInstance.stop()
finally:
print("end of gsm init loop")
# end of gsm init loop
# normally we won't reach this place, but when a non-fatal error happens
# (like 'No modem found', 'No GSM signal', etc.), we can continue the loop to
# try it again in the new iteration of the main loop
# TODO - move kill socat here. Move socat init to try finally
######################################################################################################################################################
return 0 # just for make sure, the program should never end up on this line
def run(self):
# Initialize the GPIO interface
#exportpins()
#writepins('1')
logging.info("Modem thread running.")
global modem
global ppp_requested
global sms_queue
global beat
global modem_failure
rxListenLength = 5
init_count = 0
while self.running:
beat += 1
while self.running and not ppp_requested and init_count > -1:
if (init_count > 10):
# Let's exit after 10 fails
self.running = False
modem_failure = True
return(1)
try:
init_count = init_count + 1
modem = GsmModem(PORT, BAUDRATE, incomingCallCallbackFunc=handleIncomingCall, smsReceivedCallbackFunc=handleSms)
logging.info("Initializing modem, try {0}.".format(init_count))
modem.connect(PIN)
modem.write('AT+CFUN=1')
init_count = -1
except (OSError, TimeoutException,CommandError):
# OSError means pppd is likely running
logging.error("Failed to initialize the GSM module.")
try:
modem.close()
except AttributeError:
True
time.sleep(5)
#self.modemPowerCycle()
logging.info('Waiting for incoming calls...')
while self.running and not ppp_requested and init_count < 0:
try:
#waitForNetworkCoverage()
self.signalStrength = modem.signalStrength
self.networkName = modem.networkName
data['signalStrength'] = self.signalStrength
data['networkName'] = self.networkName
#modem.write("AT+CFUN=1")
serving_cell=self.CGED_REGEX.match(modem.write("AT+CGED=3")[0])
if serving_cell:
mcc=serving_cell.group(1)
mnc=serving_cell.group(2)
lac=serving_cell.group(3)
ci=serving_cell.group(4)
self.cellInfo="{0}/{1}/{2}/{3}".format(mcc, mnc, lac, ci)
data['cellInfo'] = self.cellInfo
# Comms are handled elsewhere so we could eventually just sleep, waiting
#time.sleep(rxListenLength)
if (self.signalStrength > 5):
sent_position = 0
if sms_enabled:
while (len(sms_queue) > 0):
text=sms_queue.pop()
if (text == 'position') and sent_position:
logging.info('Not resending position in the same interval')
elif (text == 'position'):
send_position_via_sms(default_destination)
sent_position = 1
else:
try:
modem.sendSms(default_destination, text, waitForDeliveryReport=False)
except (CommandError, TimeoutException):
sms_queue.append(text)
else:
logging.info('Waiting for better network coverage')
modem.rxThread.join(rxListenLength)
if self.do_shutdown:
logging.warn('Disabling radio RX/TX.')
modem.write('AT+CFUN=0')
self.running = False
modem.close()
except (CommandError, InterruptedException, PinRequiredError, IncorrectPinError, TimeoutException):
logging.error("rxThread died: {0}".format(sys.exc_info()[0]))
modem.close()
time.sleep(5)
init_count = 0
# If PPP was requested, now it's the time
if self.running and ppp_requested and self.signalStrength > 5 and init_count < 0:
try:
self.signalStrength = 101
logging.info('Launching PPP session.')
if sms_enabled:
while (len(sms_queue) > 0):
logging.info('==== Sending PPP activation SMS =====')
text=sms_queue.pop()
try:
modem.sendSms(default_destination, text, waitForDeliveryReport=False)
time.sleep(1)
except (CommandError, TimeoutException):
sms_queue.append(text)
#waitForNetworkCoverage()
modem.close()
logging.info("Modem interface closed.")
rc = subprocess.check_output(['/usr/bin/timeout','250','/usr/bin/pon'], stderr=subprocess.STDOUT)
logging.info('PPP ended: %s' % s)
except subprocess.CalledProcessError as e:
logging.info('PPP ended: %s' % e)
sms_queue.append('PPP connection terminated')
ppp_requested = False
init_count = 0
class dispgsm:
_user=None
metrics={}
def __init__(self, user):
dispgsm._user=user
self.logger = logging.getLogger(user.user_code+'.dispgsm')
self.logger.info('Initializing GSM device %s',user.user_code)
self._config = ConfigParser.ConfigParser()
self._config.read('./config.cfg')
self._msisdn = ast.literal_eval(self._config.get('GSM_CREDENTIALS',user.user_code))['msisdn']
self._pin = ast.literal_eval(self._config.get('GSM_CREDENTIALS',user.user_code))['pin']
self._port = ast.literal_eval(self._config.get('GSM_CREDENTIALS',user.user_code))['port']
self._baudrate = ast.literal_eval(self._config.get('GSM_CREDENTIALS',user.user_code))['baudrate']
self._modem = GsmModem(self._port, int(self._baudrate), incomingCallCallbackFunc=dispgsm.handleIncomingCall, smsReceivedCallbackFunc=dispgsm.handleSms, smsStatusReportCallback=dispgsm.handleSmsDeliveryReport)
#self._modem.smsTextMode = False
def connect(self):
self.logger.info('Connecting GSM modem...')
#self._modem.connect()
self._modem.connect(self._pin)
self.logger.info('Waiting for network coverage...')
try:
self._modem.waitForNetworkCoverage(30)
except TimeoutException:
self.logger.error('Network signal strength is not sufficient, please adjust modem position/antenna and try again.')
self.disconnect()
self.metrics['handled_sms']=[]
self.metrics['handled_call']=[]
self.metrics['send_sms']=[]
self.metrics['dial_call']=[]
self.logger.info('GSM Device ready to use.')
def disconnect(self):
self.logger.info('Disconnecting modem...')
self._modem.close()
self.logger.info('Disconnected')
def send_sms(self, destination, text, waitForDeliveryReport=True, deliveryTimeout=15):
if text==None:
text = str(random.randint(1000000000, 9999999999))
self.logger.info('Sending SMS with text:%s',text)
m ={}
m['sms_text'] = text
m['sms_delivery_timeout'] = deliveryTimeout
m['sms_sent_time'] = str(datetime.datetime.now())
try:
sms = self._modem.sendSms(destination, text, waitForDeliveryReport, deliveryTimeout)
self.logger.info('Message sent with delivery report status:%s reference:%s',sms.status,sms.reference)
if sms.status==0:
m['sms_status'] = 'ENROUTE'
elif sms.status==1:
m['sms_status'] = 'DELIVERED'
elif sms.status==2:
m['sms_status'] = 'FAILED'
else:
m['sms_status'] = 'ERROR'
except TimeoutException:
self.logger.warning('Fail to deliver message: the send operation timed out')
m['sms_end'] = str(datetime.datetime.now())
self.metrics['send_sms'].append(m)
def dial(self, destination, dtmf):
if dtmf==None:
dtmf = str(random.randint(1000000000, 9999999999))
self.logger.info('Calling number %s and sending DTMF:%s',destination,dtmf)
m = {}
m['dial_dtmf'] = dtmf
m['dial_start'] = str(datetime.datetime.now())
call = self._modem.dial(destination)
wasAnswered = False
while call.active:
if call.answered:
wasAnswered = True
self.logger.info('Call has been answered; waiting a while...')
m['dial_answered'] = str(datetime.datetime.now())
# Wait for a bit - some older modems struggle to send DTMF tone immediately after answering a call
time.sleep(3.0)
self.logger.info('Playing DTMF tones: %s',dtmf)
try:
if call.active: # Call could have been ended by remote party while we waited in the time.sleep() call
call.sendDtmfTone(dtmf)
self.logger.info('DTMF tones sent')
time.sleep(10)
except InterruptedException as e:
# Call was ended during playback
self.logger.info('DTMF playback interrupted: {0} ({1} Error {2})'.format(e, e.cause.type, e.cause.code))
except CommandError as e:
self.logger.error('DTMF playback failed: {0}'.format(e))
finally:
if call.active: # Call is still active
self.logger.info('Hanging up call...')
m['dial_hangup'] = str(datetime.datetime.now())
call.hangup()
else: # Call is no longer active (remote party ended it)
self.logger.info('Call has been ended by remote party')
else:
# Wait a bit and check again
time.sleep(0.5)
if not wasAnswered:
self.logger.info('Call was not answered by remote party')
self.logger.info('Call finished')
m['dial_end'] = str(datetime.datetime.now())
self.metrics['dial_call'].append(m)
def handleIncomingCall(call):
logger = logging.getLogger('device.'+dispsip._user.user_code+'.dispgsm')
if call.ringCount == 1:
logger.info('Incoming call from:', call.number)
elif call.ringCount >= 2:
logger.info('Answering call and playing some DTMF tones...')
call.answer()
# Wait for a bit - some older modems struggle to send DTMF tone immediately after answering a call
time.sleep(20.0)
try:
call.sendDtmfTone('9515999955951')
except InterruptedException as e:
# Call was ended during playback
logger.info('DTMF playback interrupted: {0} ({1} Error {2})'.format(e, e.cause.type, e.cause.code))
finally:
if call.answered:
logger.info('Hanging up call.')
call.hangup()
else:
logger.info(' Call from {0} is still ringing...'.format(call.number))
def handleSms(sms):
logger = logging.getLogger('device.'+dispsip._user.user_code+'.dispgsm')
logger.info(u'== SMS message received ==\nFrom: {0}\nTime: {1}\nMessage:\n{2}\n'.format(sms.number, sms.time, sms.text))
#sms.reply(u'SMS received: "{0}{1}"'.format(sms.text[:20], '...' if len(sms.text) > 20 else ''))
def handleSmsDeliveryReport(sms):
logger = logging.getLogger('device.'+dispsip._user.user_code+'.dispgsm')
logger.info('Delivery report received status:%s reference:%s timeSent:%s timefinalized:%s deliveryStatus:%s',sms.status,sms.reference,sms.timeSent,sms.timeFinalized,sms.deliveryStatus)
# logging.info("Use dev %s", device)
logging.info("Initializing modem...")
modem = GsmModem(device, BAUDRATE, smsReceivedCallbackFunc=handleSms)
modem.smsTextMode = True
modem.connect()
logging.info("Waiting for network coverage...")
modem.waitForNetworkCoverage(30)
with open( 'data/' + unit + '.csv', 'rU' ) as csvfile:
thisList = csv.reader(csvfile, delimiter=',', quotechar='"')
head = next(thisList)
totalrows = 0
for row in thisList:
totalrows += 1
phone = '0' + str(row[0])
logging.info("%s Send to %s", totalrows, phone)
try:
modem.sendSms(phone,message, deliveryTimeout=30)
except CommandError as e:
logging.info('SMS send failed: {0}'.format(e))
except TimeoutException as e:
logging.info('SMS timeout failed: {0}'.format(e))
time.sleep(10.0)
logging.info("Blasting done")
modem.close()
def text(number, message, key):
if key.strip() == '9703BB8D5A':
print "Creating modem instance"
modem = GsmModem('/dev/ttyUSB0', 9600)
try:
print "Connecting modem"
modem.connect()
except PinRequiredError:
print "Pin required"
try:
print "Waiting for Network coverage info"
modem.waitForNetworkCoverage(5)
except TimeoutException:
print "Signal strength not strong enough"
return "No signal"
else:
try:
print "Sending %s to %s" % (message, number)
sms = modem.sendSms(number, message)
except TimeoutException:
print "Failed to send message"
return 'Error encountered'
print "Closing modem"
modem.close()
return True
else:
return 'Key is not correct'
def send_sms_at(data, action_config):
"""Send SMS via local modem with AT commands
Meact configuration:
action_config = {
"recipient": ["your-number", "your-number2'],
"port": "/dev/ttyUSB1",
"speed": 19200,
"enabled": 1
}
"""
if not action_config.get('enabled'):
sys.exit(1)
LOG.info('Sending SMS via AT')
modem = GsmModem(action_config['port'], action_config['speed'])
while True:
try:
modem.connect()
modem.waitForNetworkCoverage()
except TimeoutException:
pass
else:
break
for rcpt in action_config['recipient']:
try:
sms = modem.sendSms(rcpt, data['message'])
except TimeoutException:
LOG.warning('Got exception in send_sms_at')
sys.exit(2)
modem.close()
sys.exit(0)
def main():
print('Initializing modem...')
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
modem = GsmModem(PORT, BAUDRATE, incomingCallCallbackFunc=handleIncomingCall)
modem.connect(PIN)
print('Waiting for incoming calls...')
try:
modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
finally:
modem.close()
