projects/smsdaemon/ModemTransceiver.cpp

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

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

#include <time.h>


#include "SerialPort.h"

#include "GsmModem.h"

#include "util.h"
#include "common.h"

#include "SmsPdu.h"

using namespace std;


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


string GsmModem::GetResponse()
{

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

        buf.push_back(0);

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

        return str;
}


string GsmModem::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 )
        {
                Common::instance()->logMessage( string("GsmModem::Command time out --") + command);
                        Common::instance()->logMessage( string("Modem responded: ") + Util::str_trim(response) );
                        _timeout = true;
            break;
        }
        }

        Util::Sleep(5);


        return response;
}

vector<SMS> GsmModem::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);
                retval.push_back( SMS::FromPduString(sms_entry) );;

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

        return retval;
}


void GsmModem::SendSmsPdu(std::string pdu, int len) //pdu inclussive leading "00"
{
        Common::instance()->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 GsmModem::SendSms(string to, string message, bool allowMultipart)
{
        Common::instance()->logMessage( string("SMS send to ") + to);

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

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

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

                SendSmsPdu(pdu.pdu, pdu.len);
        }

}

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

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

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


void GsmModem::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

        //Set RealTimeClock ??
        
        //Enter pin code ??
}


void DebugGsmModem::SendSms(std::string to, std::string message, bool allowMultipart) 
{
        _to=to; 
        _message = message; 
        _multipart = allowMultipart;

        if (_print)
        {
                cout << "DebugGsmModem::SendSms --------------" << endl;
                cout << "To:        " << to << endl;;
                cout << "Message:   " << message << endl;
                cout << "Multipart: " << allowMultipart << endl;

        }
}
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			#include "SerialPort.h"
12
13			#include "GsmModem.h"
14
15			#include "util.h"
16			#include "common.h"
17
18	torben	63	#include "SmsPdu.h"
19	torben	26
20			using namespace std;
21
22
23
24			GsmModem::GsmModem(SerialPort& serialport)
25			: m_port(serialport)
26			{
27			}
28
29
30
31			string GsmModem::GetResponse()
32			{
33
34			SerialPort::DataBuffer buf;
35			m_port.Read(buf);
36
37			buf.push_back(0);
38
39			std::string str((char*) &buf[0]);
40
41			return str;
42			}
43
44	torben	34
45	torben	26	string GsmModem::Command(string command, string term)
46			{
47			time_t start,now;
48			start = time(0);
49	torben	57	_timeout = false;
50	torben	26
51	torben	34	if (term != "> ")
52			command.append("\r"); //Dont append CarriageReturn if sending SMS
53
54	torben	26	m_port.Write(command);
55
56	torben	34	Util::Sleep(1);
57	torben	26	string response = GetResponse();
58
59			unsigned int tlen = term.length();
60			while ( 1 )
61			{
62			if (response.length() >= tlen)
63			{
64			if (response.substr(response.length()-tlen,tlen) == term)
65			break;
66			}
67
68			response += GetResponse();
69	torben	34	Util::Sleep(1);
70	torben	26
71			now = time(0);
72			if ( (now-start) > 10 )
73			{
74			Common::instance()->logMessage( string("GsmModem::Command time out --") + command);
75	torben	72	Common::instance()->logMessage( string("Modem responded: ") + Util::str_trim(response) );
76	torben	57	_timeout = true;
77	torben	26	break;
78			}
79			}
80
81			Util::Sleep(5);
82
83
84			return response;
85			}
86
87			vector<SMS> GsmModem::ReadSms(bool readAll)
88			{
89	torben	63
90	torben	75	Command( "AT+CMGF=0" ); //Set SMS format to PDU
91	torben	63
92	torben	26	const string search = "+CMGL: ";
93			std::string cmd = "AT+CMGL";
94			if (readAll)
95	torben	75	cmd.append("=4");
96	torben	26
97			string result = Command(cmd);
98
99			vector<SMS> retval;
100			if (result.find(search) == string::npos)
101			return retval;
102
103			result = result.substr(2, result.length() - 8); //remove trailing "\r\nOK\r\n" and initial "\r\n"
104
105
106			while ( 1 )
107			{
108			unsigned int endpos = result.find(search,5);
109
110
111			string sms_entry = result.substr(0,endpos);
112	torben	75	retval.push_back( SMS::FromPduString(sms_entry) );;
113	torben	26
114			if (endpos == string::npos)
115			break;
116
117			result = result.substr(endpos, result.length() - endpos);
118			}
119
120			return retval;
121			}
122
123	torben	59
124			void GsmModem::SendSmsPdu(std::string pdu, int len) //pdu inclussive leading "00"
125			{
126			Common::instance()->logMessage( string("SMS pdu send") );
127
128			Command("AT+CMGF=0");
129			Util::Sleep(2);
130
131			string line1 = "AT+CMGS=";
132			line1.append( Util::str_formatint(len) );
133			line1.append("\r");
134
135
136			Command(line1,"> ");
137
138			pdu.append("\032"); // \032 == Ctrl+Z
139			Command( pdu );
140			Util::Sleep( 50 );
141			Common::instance()->smsCounter.outgoing++;
142			}
143
144	torben	63	void GsmModem::SendSms(string to, string message, bool allowMultipart)
145	torben	26	{
146			Common::instance()->logMessage( string("SMS send to ") + to);
147
148	torben	63	if (to.at(0) == '+')
149			to.erase(0,0);
150	torben	26
151	torben	63	vector<PduInfo> pdu_vec = SmsPdu::CreateSmsPdu(to, message, allowMultipart);
152	torben	26
153	torben	63	for (unsigned i=0; i<pdu_vec.size(); ++i)
154			{
155			PduInfo& pdu = pdu_vec[i];
156	torben	26
157	torben	63	SendSmsPdu(pdu.pdu, pdu.len);
158	torben	50	}
159	torben	26
160			}
161
162			void GsmModem::DeleteSms(std::string smsIndex)
163			{
164			string cmd = "AT+CMGD=";
165			cmd.append(smsIndex);
166			Command(cmd);
167			}
168
169			int GsmModem::DeleteAllSms()
170			{
171			vector<SMS> sms = ReadSms(true);
172
173			for (unsigned int i= 0; i<sms.size(); ++i)
174			{
175			DeleteSms( sms[i].sms_index);
176			}
177			return sms.size();
178			}
179
180
181
182			void GsmModem::Init()
183			{
184	torben	58	Command( "AT" );
185	torben	57	if (_timeout)
186			throw std::runtime_error("Modem did not respond!");
187
188	torben	58	Command( "ATZ" ); //Reset any previous setup
189
190	torben	33	Command( "AT\\Q3" ); //Hardware flow control
191	torben	26
192			Command( "ATE0" ); //Disable echo
193
194			Command ("AT^SM20=0,0" ); //No SM20 compability
195
196	torben	83	//Command("AT+CGATT=1"); //GPRS Attach
197
198			//Command("AT+CGSMS=2"); //SMS over GPRS preferred
199
200	torben	26	//Set RealTimeClock ??
201
202			//Enter pin code ??
203			}
204	torben	59
205
206	torben	67
207
208			void DebugGsmModem::SendSms(std::string to, std::string message, bool allowMultipart)
209			{
210			_to=to;
211			_message = message;
212			_multipart = allowMultipart;
213
214			if (_print)
215			{
216			cout << "DebugGsmModem::SendSms --------------" << endl;
217			cout << "To: " << to << endl;;
218			cout << "Message: " << message << endl;
219			cout << "Multipart: " << allowMultipart << endl;
220
221			}
222			}