projects/smsdaemon/ModemTransceiver.cpp

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

#include <iostream>

#include <string>
#include <cstring>
#include <stdexcept>

#include <sys/time.h>
#include <time.h>


#include "SerialPort.h"

#include "GsmModem.h"

#include "util.h"
#include "common.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);
                        _timeout = true;
            break;
        }
        }

        Util::Sleep(5);

//      cout  << response.length() << ":" << response << endl;
//      DumpString(response);

        return response;
}

vector<SMS> GsmModem::ReadSms(bool readAll)
{
        const string search = "+CMGL: ";
        std::string cmd = "AT+CMGL";
        if (readAll)
                cmd.append("=ALL");

        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::FromRawString(sms_entry) );;

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

        return retval;
}

void GsmModem::SendSms(string to, string message)
{
        Common::instance()->logMessage( string("SMS send to ") + to);

        Command("AT+CMGF=1");///Allways telling the format makes the application more stable
        Util::Sleep(2);

        string line1 = "AT+CMGS=";
        line1.append(to);
        line1.append("\r");

        Command(line1,"> ");

        if (message.length() > 160)
        {
                message = message.substr(0,160);
                Common::instance()->logMessage( "Trunkating message! ");
        }

        message.append("\032"); // \032 == Ctrl+Z

        Command( message ); //In textmode limit to 160 bytes


        Util::Sleep(50); //Give the modem some time to send the sms and be ready again
        Common::instance()->smsCounter.outgoing++;
}

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+CMGF=1" ); //Set SMS format to text

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

        //Set RealTimeClock ??
        
        //Enter pin code ??
}
1	/* using http://sourceforge.net/projects/libserial/
2	*/
3
4	#include <iostream>
5
6	#include <string>
7	#include <cstring>
8	#include <stdexcept>
9
10	#include <sys/time.h>
11	#include <time.h>
12
13
14	#include "SerialPort.h"
15
16	#include "GsmModem.h"
17
18	#include "util.h"
19	#include "common.h"
20
21
22	using namespace std;
23
24
25
26	GsmModem::GsmModem(SerialPort& serialport)
27	: m_port(serialport)
28	{
29	}
30
31
32
33	string GsmModem::GetResponse()
34	{
35
36	SerialPort::DataBuffer buf;
37	m_port.Read(buf);
38
39	buf.push_back(0);
40
41	std::string str((char*) &buf[0]);
42
43	return str;
44	}
45
46
47	string GsmModem::Command(string command, string term)
48	{
49	time_t start,now;
50	start = time(0);
51	_timeout = false;
52
53	if (term != "> ")
54	command.append("\r"); //Dont append CarriageReturn if sending SMS
55
56	m_port.Write(command);
57
58	Util::Sleep(1);
59	string response = GetResponse();
60
61	unsigned int tlen = term.length();
62	while ( 1 )
63	{
64	if (response.length() >= tlen)
65	{
66	if (response.substr(response.length()-tlen,tlen) == term)
67	break;
68	}
69
70	response += GetResponse();
71	Util::Sleep(1);
72
73	now = time(0);
74	if ( (now-start) > 10 )
75	{
76	Common::instance()->logMessage( string("GsmModem::Command time out --") + command);
77	_timeout = true;
78	break;
79	}
80	}
81
82	Util::Sleep(5);
83
84	// cout << response.length() << ":" << response << endl;
85	// DumpString(response);
86
87	return response;
88	}
89
90	vector<SMS> GsmModem::ReadSms(bool readAll)
91	{
92	const string search = "+CMGL: ";
93	std::string cmd = "AT+CMGL";
94	if (readAll)
95	cmd.append("=ALL");
96
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	retval.push_back( SMS::FromRawString(sms_entry) );;
113
114	if (endpos == string::npos)
115	break;
116
117	result = result.substr(endpos, result.length() - endpos);
118	}
119
120	return retval;
121	}
122
123	void GsmModem::SendSms(string to, string message)
124	{
125	Common::instance()->logMessage( string("SMS send to ") + to);
126
127	Command("AT+CMGF=1");///Allways telling the format makes the application more stable
128	Util::Sleep(2);
129
130	string line1 = "AT+CMGS=";
131	line1.append(to);
132	line1.append("\r");
133
134	Command(line1,"> ");
135
136	if (message.length() > 160)
137	{
138	message = message.substr(0,160);
139	Common::instance()->logMessage( "Trunkating message! ");
140	}
141
142	message.append("\032"); // \032 == Ctrl+Z
143
144	Command( message ); //In textmode limit to 160 bytes
145
146
147	Util::Sleep(50); //Give the modem some time to send the sms and be ready again
148	Common::instance()->smsCounter.outgoing++;
149	}
150
151	void GsmModem::DeleteSms(std::string smsIndex)
152	{
153	string cmd = "AT+CMGD=";
154	cmd.append(smsIndex);
155	Command(cmd);
156	}
157
158	int GsmModem::DeleteAllSms()
159	{
160	vector<SMS> sms = ReadSms(true);
161
162	for (unsigned int i= 0; i<sms.size(); ++i)
163	{
164	DeleteSms( sms[i].sms_index);
165	}
166	return sms.size();
167	}
168
169
170
171	void GsmModem::Init()
172	{
173	Command( "AT" );
174	if (_timeout)
175	throw std::runtime_error("Modem did not respond!");
176
177	Command( "ATZ" ); //Reset any previous setup
178
179	Command( "AT\\Q3" ); //Hardware flow control
180
181	Command( "ATE0" ); //Disable echo
182
183	Command( "AT+CMGF=1" ); //Set SMS format to text
184
185	Command ("AT^SM20=0,0" ); //No SM20 compability
186
187	//Set RealTimeClock ??
188
189	//Enter pin code ??
190	}