projects/smsdaemon/ModemTransceiver.cpp

/* using http://sourceforge.net/projects/libserial/
 */

#include <iostream>
#include <string>
#include <stdexcept>

#include <time.h>


#include "serialport/SerialPort.h"

#include "ModemTransceiver.h"

#include "Util.h"
#include "Common.h"
#include "Logger.h"
#include "ConfigFile.h"

#include "SmsPdu.h"
#include "SmsHelper.h"
#include "Exceptions.h"

using namespace std;


ModemTransceiver::ModemTransceiver(SerialPort& serialport)
: m_port(serialport)
{
}


string ModemTransceiver::GetResponse()
{

        SerialPort::DataBuffer buf;
        m_port.Read(buf);

        buf.push_back(0);

        std::string str((char*) &buf[0]);

        return str;
}


string ModemTransceiver::Command(string command, string term)
{
        time_t  start,now;
        start = time(0);
        _timeout = false;

        if (term != "> ")
                command.append("\r"); //Dont append CarriageReturn if sending SMS

        m_port.Write(command);

        Util::Sleep(1);
        string response = GetResponse();

        unsigned int tlen = term.length();
        while ( 1 )
        {
                if (response.length() >= tlen)
                {
                        if (response.substr(response.length()-tlen,tlen) == term)
                                break;
                }

                response += GetResponse();
                Util::Sleep(1);

        now = time(0);
        if ( (now-start) > 10 )
        {
                Logger::logMessage( string("ModemTransceiver::Command time out --") + command);
                        Logger::logMessage( string("Modem responded: ") + Util::str_trim(response) );
                        _timeout = true;
            break;
        }
        }

        Util::Sleep(5);


        return response;
}

vector<SMS> ModemTransceiver::ReadSms(bool readAll)
{

        Command( "AT+CMGF=0" ); //Set SMS format to PDU

        const string search = "+CMGL: ";
        std::string cmd = "AT+CMGL";
        if (readAll)
                cmd.append("=4");

        string result = Command(cmd);
                
        vector<SMS> retval;
        if (result.find(search) == string::npos)
                return retval;

        result = result.substr(2, result.length() - 8); //remove trailing "\r\nOK\r\n" and initial "\r\n"


        while ( 1 )
        {
                unsigned int endpos = result.find(search,5);

                
                string sms_entry = result.substr(0,endpos);

                try 
                {
                        SMS sms = SmsHelper::FromPduString(sms_entry);
        
                        retval.push_back( sms );
                }
                catch (smsnotfoundexception& e) //do nothing
                {
                }

                if (endpos == string::npos)
                        break;
        
                result = result.substr(endpos, result.length() - endpos);
        }

        return retval;
}


void ModemTransceiver::SendSmsPdu(std::string pdu, int len) //pdu inclussive leading "00"
{
        Logger::logMessage( string("SMS pdu send") );

        Command("AT+CMGF=0");
        Util::Sleep(2);

        string line1 = "AT+CMGS=";
        line1.append( Util::str_formatint(len) );
        line1.append("\r");


        Command(line1,"> ");

        pdu.append("\032"); // \032 == Ctrl+Z
        Command( pdu );
        Util::Sleep( 50 );
        Common::instance()->smsCounter.outgoing++;
}

void ModemTransceiver::SendSms(string to, string message, bool allowMultipart)
{
        Logger::logMessage( string("SMS send to ") + to);

        if (to.at(0) == '+')
                to.erase(0,0);

        vector<PduInfo> pdu_vec = SmsPdu::CreateSmsPdu(to, Util::str_latin2gsm(message), allowMultipart);

        for (unsigned i=0; i<pdu_vec.size(); ++i)
        {
                PduInfo& pdu = pdu_vec[i];

                SendSmsPdu(pdu.pdu, pdu.len);
        }
        Logger::logMessage( "All PDU's send");

}

void ModemTransceiver::DeleteSms(std::string smsIndex)
{
        string cmd = "AT+CMGD=";
        cmd.append(smsIndex);
        Command(cmd);
}

int  ModemTransceiver::DeleteAllSms()
{
        vector<SMS> sms = ReadSms(true);

        for (unsigned int i= 0; i<sms.size(); ++i)
        {
                DeleteSms( sms[i].GetIndex() );
        }
        return sms.size();
}


void ModemTransceiver::WaitForSimcard()
{
        int start = time(0);
        string result;


        while (result != "^SSIM READY")
        {
                result += GetResponse();
                result = Util::str_trim(result);

                if ( (time(0) - start) > 10)
                        throw std::runtime_error("Sim card timed out:");
                Util::Sleep(100);
        }

}

void ModemTransceiver::HandlePincode()
{
        string pin = Common::instance()->GetConfigfile()->GetValue("gsmmodem","pin");

        string result = Command("AT+CPIN?");
        result = Util::str_trim(result);
        result.erase(result.length() -2, 2); //remove trailing ok
        result = Util::str_trim(result);
        if (result != "+CPIN: READY")
        {
                if (result == "+CPIN: SIM PIN")
                {
                        Command("AT^SSET=1");
                        result = Command( string("AT+CPIN=")+pin  );
                        if ( result.substr(result.length()-4, 4) != "OK\r\n")
                                throw std::runtime_error(string("Illegal pincode: ") + result);
                        
                        WaitForSimcard();
                }
                else
                {
                        throw std::runtime_error(string("AT+CPIN? returned unhandled code: ") + result);
                }

        }
}

void ModemTransceiver::Init()
{
        Command( "AT" );
        if (_timeout)
                throw std::runtime_error("Modem did not respond!");

        Command( "ATZ" ); //Reset any previous setup

        Command( "AT\\Q3" ); //Hardware flow control

        Command( "ATE0" ); //Disable echo

        Command ("AT^SM20=0,0" ); //No SM20 compability

        //Command("AT+CGATT=1"); //GPRS Attach

        //Command("AT+CGSMS=2"); //SMS over GPRS preferred

        HandlePincode();
}
1	torben	26	/* using http://sourceforge.net/projects/libserial/
2			*/
3
4			#include <iostream>
5			#include <string>
6			#include <stdexcept>
7
8			#include <time.h>
9
10
11	torben	132	#include "serialport/SerialPort.h"
12	torben	26
13	torben	149	#include "ModemTransceiver.h"
14	torben	26
15	torben	158	#include "Util.h"
16			#include "Common.h"
17	torben	157	#include "Logger.h"
18	torben	171	#include "ConfigFile.h"
19	torben	26
20	torben	63	#include "SmsPdu.h"
21	torben	142	#include "SmsHelper.h"
22	torben	178	#include "Exceptions.h"
23	torben	26
24			using namespace std;
25
26
27
28	torben	149	ModemTransceiver::ModemTransceiver(SerialPort& serialport)
29	torben	26	: m_port(serialport)
30			{
31			}
32
33
34
35	torben	149	string ModemTransceiver::GetResponse()
36	torben	26	{
37
38			SerialPort::DataBuffer buf;
39			m_port.Read(buf);
40
41			buf.push_back(0);
42
43			std::string str((char*) &buf[0]);
44
45			return str;
46			}
47
48	torben	34
49	torben	149	string ModemTransceiver::Command(string command, string term)
50	torben	26	{
51			time_t start,now;
52			start = time(0);
53	torben	57	_timeout = false;
54	torben	26
55	torben	34	if (term != "> ")
56			command.append("\r"); //Dont append CarriageReturn if sending SMS
57
58	torben	26	m_port.Write(command);
59
60	torben	34	Util::Sleep(1);
61	torben	26	string response = GetResponse();
62
63			unsigned int tlen = term.length();
64			while ( 1 )
65			{
66			if (response.length() >= tlen)
67			{
68			if (response.substr(response.length()-tlen,tlen) == term)
69			break;
70			}
71
72			response += GetResponse();
73	torben	34	Util::Sleep(1);
74	torben	26
75			now = time(0);
76			if ( (now-start) > 10 )
77			{
78	torben	157	Logger::logMessage( string("ModemTransceiver::Command time out --") + command);
79			Logger::logMessage( string("Modem responded: ") + Util::str_trim(response) );
80	torben	57	_timeout = true;
81	torben	26	break;
82			}
83			}
84
85			Util::Sleep(5);
86
87
88			return response;
89			}
90
91	torben	149	vector<SMS> ModemTransceiver::ReadSms(bool readAll)
92	torben	26	{
93	torben	63
94	torben	75	Command( "AT+CMGF=0" ); //Set SMS format to PDU
95	torben	63
96	torben	26	const string search = "+CMGL: ";
97			std::string cmd = "AT+CMGL";
98			if (readAll)
99	torben	75	cmd.append("=4");
100	torben	26
101			string result = Command(cmd);
102
103			vector<SMS> retval;
104			if (result.find(search) == string::npos)
105			return retval;
106
107			result = result.substr(2, result.length() - 8); //remove trailing "\r\nOK\r\n" and initial "\r\n"
108
109
110			while ( 1 )
111			{
112			unsigned int endpos = result.find(search,5);
113
114
115			string sms_entry = result.substr(0,endpos);
116
117	torben	178	try
118			{
119			SMS sms = SmsHelper::FromPduString(sms_entry);
120
121			retval.push_back( sms );
122			}
123			catch (smsnotfoundexception& e) //do nothing
124			{
125			}
126
127	torben	26	if (endpos == string::npos)
128			break;
129
130			result = result.substr(endpos, result.length() - endpos);
131			}
132
133			return retval;
134			}
135
136	torben	59
137	torben	149	void ModemTransceiver::SendSmsPdu(std::string pdu, int len) //pdu inclussive leading "00"
138	torben	59	{
139	torben	157	Logger::logMessage( string("SMS pdu send") );
140	torben	59
141			Command("AT+CMGF=0");
142			Util::Sleep(2);
143
144			string line1 = "AT+CMGS=";
145			line1.append( Util::str_formatint(len) );
146			line1.append("\r");
147
148
149			Command(line1,"> ");
150
151			pdu.append("\032"); // \032 == Ctrl+Z
152			Command( pdu );
153			Util::Sleep( 50 );
154			Common::instance()->smsCounter.outgoing++;
155			}
156
157	torben	149	void ModemTransceiver::SendSms(string to, string message, bool allowMultipart)
158	torben	26	{
159	torben	157	Logger::logMessage( string("SMS send to ") + to);
160	torben	26
161	torben	63	if (to.at(0) == '+')
162			to.erase(0,0);
163	torben	26
164	torben	135	vector<PduInfo> pdu_vec = SmsPdu::CreateSmsPdu(to, Util::str_latin2gsm(message), allowMultipart);
165	torben	26
166	torben	63	for (unsigned i=0; i<pdu_vec.size(); ++i)
167			{
168			PduInfo& pdu = pdu_vec[i];
169	torben	26
170	torben	63	SendSmsPdu(pdu.pdu, pdu.len);
171	torben	50	}
172	torben	157	Logger::logMessage( "All PDU's send");
173	torben	26
174			}
175
176	torben	149	void ModemTransceiver::DeleteSms(std::string smsIndex)
177	torben	26	{
178			string cmd = "AT+CMGD=";
179			cmd.append(smsIndex);
180			Command(cmd);
181			}
182
183	torben	149	int ModemTransceiver::DeleteAllSms()
184	torben	26	{
185			vector<SMS> sms = ReadSms(true);
186
187			for (unsigned int i= 0; i<sms.size(); ++i)
188			{
189	torben	142	DeleteSms( sms[i].GetIndex() );
190	torben	26	}
191			return sms.size();
192			}
193
194
195
196	torben	149	void ModemTransceiver::WaitForSimcard()
197	torben	105	{
198			int start = time(0);
199			string result;
200
201
202			while (result != "^SSIM READY")
203			{
204			result += GetResponse();
205			result = Util::str_trim(result);
206
207			if ( (time(0) - start) > 10)
208			throw std::runtime_error("Sim card timed out:");
209			Util::Sleep(100);
210			}
211
212			}
213
214	torben	149	void ModemTransceiver::HandlePincode()
215	torben	105	{
216	torben	171	string pin = Common::instance()->GetConfigfile()->GetValue("gsmmodem","pin");
217
218	torben	105	string result = Command("AT+CPIN?");
219			result = Util::str_trim(result);
220			result.erase(result.length() -2, 2); //remove trailing ok
221			result = Util::str_trim(result);
222			if (result != "+CPIN: READY")
223			{
224			if (result == "+CPIN: SIM PIN")
225			{
226			Command("AT^SSET=1");
227	torben	171	result = Command( string("AT+CPIN=")+pin );
228	torben	105	if ( result.substr(result.length()-4, 4) != "OK\r\n")
229			throw std::runtime_error(string("Illegal pincode: ") + result);
230
231			WaitForSimcard();
232			}
233			else
234			{
235			throw std::runtime_error(string("AT+CPIN? returned unhandled code: ") + result);
236			}
237
238			}
239			}
240
241	torben	149	void ModemTransceiver::Init()
242	torben	26	{
243	torben	58	Command( "AT" );
244	torben	57	if (_timeout)
245			throw std::runtime_error("Modem did not respond!");
246
247	torben	58	Command( "ATZ" ); //Reset any previous setup
248
249	torben	33	Command( "AT\\Q3" ); //Hardware flow control
250	torben	26
251			Command( "ATE0" ); //Disable echo
252
253			Command ("AT^SM20=0,0" ); //No SM20 compability
254
255	torben	83	//Command("AT+CGATT=1"); //GPRS Attach
256
257			//Command("AT+CGSMS=2"); //SMS over GPRS preferred
258
259	torben	105	HandlePincode();
260	torben	26	}