CSerialDriver.java
上传用户:shunchung
上传日期:2013-04-07
资源大小:438k
文件大小:7k
源码类别:

手机短信编程

开发平台:

Java

  1. // jSMSEngine API.
  2. // An open-source API package for sending and receiving SMS via a GSM device.
  3. // Copyright (C) 2002-2006, Thanasis Delenikas, Athens/GREECE
  4. // Web Site: http://www.jsmsengine.org
  5. //
  6. // jSMSEngine is a package which can be used in order to add SMS processing
  7. // capabilities in an application. jSMSEngine is written in Java. It allows you
  8. // to communicate with a compatible mobile phone or GSM Modem, and
  9. // send / receive SMS messages.
  10. //
  11. // jSMSEngine is distributed under the LGPL license.
  12. //
  13. // This library is free software; you can redistribute it and/or
  14. // modify it under the terms of the GNU Lesser General Public
  15. // License as published by the Free Software Foundation; either
  16. // version 2.1 of the License, or (at your option) any later version.
  17. // This library is distributed in the hope that it will be useful,
  18. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20. // Lesser General Public License for more details.
  21. // You should have received a copy of the GNU Lesser General Public
  22. // License along with this library; if not, write to the Free Software
  23. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24. //
  25. package org.jsmsengine;
  26. import java.io.*;
  27. import java.util.*;
  28. import java.util.logging.*;
  29. import gnu.io.*;
  30. /**
  31. This class handles the operation the serial port.
  32. <br><br>
  33. This class contains all the necessary (low-level) functions that handle COMM API
  34. and are responsible for the serial communication with the GSM device.
  35. <br><br>
  36. Comments left to be added in next release.
  37. */
  38. class CSerialDriver  implements SerialPortEventListener
  39. {
  40. /**
  41. Timeout period for the phone to respond to jSMSEngine.
  42. */
  43. private static final int RECV_TIMEOUT = 30 * 1000;
  44. /**
  45. Input/Output buffer size for serial communication.
  46. */
  47. private static final int BUFFER_SIZE = 16000;
  48. private String port;
  49. private int baud;
  50. private CommPortIdentifier portId;
  51. private SerialPort serialPort;
  52. private InputStream inStream;
  53. private OutputStream outStream;
  54. private Logger log;
  55. public CSerialDriver(String port, int baud, Logger log)
  56. {
  57. this.port = port;
  58. this.baud = baud;
  59. this.log = log;
  60. }
  61. public void setPort(String port) { this.port = port; }
  62. public String getPort() { return port; }
  63. public int getBaud() { return baud; }
  64. public void open() throws Exception
  65. {
  66. Enumeration portList;
  67. log.log(Level.INFO, "Connecting...");
  68. portId = CommPortIdentifier.getPortIdentifier(getPort());
  69. serialPort = (SerialPort) portId.open("jSMSEngine", 1971);
  70. inStream = serialPort.getInputStream();
  71. outStream = serialPort.getOutputStream();
  72. serialPort.notifyOnDataAvailable(true);
  73. serialPort.notifyOnOutputEmpty(true);
  74. serialPort.notifyOnBreakInterrupt(true);
  75. serialPort.notifyOnFramingError(true);
  76. serialPort.notifyOnOverrunError(true);
  77. serialPort.notifyOnParityError(true);
  78. //serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
  79. serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN);
  80. serialPort.addEventListener(this);
  81. serialPort.setSerialPortParams(getBaud(), SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
  82. serialPort.setInputBufferSize(BUFFER_SIZE);
  83. serialPort.setOutputBufferSize(BUFFER_SIZE);
  84. serialPort.enableReceiveTimeout(RECV_TIMEOUT);
  85. }
  86. public void close()
  87. {
  88. log.log(Level.INFO, "Disconnecting...");
  89. try { serialPort.close(); } catch (Exception e) {}
  90. }
  91. public void serialEvent(SerialPortEvent event)
  92. {
  93. switch(event.getEventType())
  94. {
  95. case SerialPortEvent.BI:
  96. break;
  97. case SerialPortEvent.OE:
  98. log.log(Level.SEVERE, "COMM-ERROR: Overrun Error!");
  99. break;
  100. case SerialPortEvent.FE:
  101. log.log(Level.SEVERE, "COMM-ERROR: Framing Error!");
  102. break;
  103. case SerialPortEvent.PE:
  104. log.log(Level.SEVERE, "COMM-ERROR: Parity Error!");
  105. break;
  106. case SerialPortEvent.CD:
  107. break;
  108. case SerialPortEvent.CTS:
  109. break;
  110. case SerialPortEvent.DSR:
  111. break;
  112. case SerialPortEvent.RI:
  113. break;
  114. case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
  115. break;
  116. case SerialPortEvent.DATA_AVAILABLE:
  117. break;
  118. }
  119. }
  120. public void clearBuffer() throws Exception
  121. {
  122. while (dataAvailable()) inStream.read();
  123. }
  124. public void send(String s) throws Exception
  125. {
  126. log.log(Level.INFO, "TE: " + formatLog(new StringBuffer(s)));
  127. for (int i = 0; i < s.length(); i ++)
  128. {
  129. outStream.write((byte) s.charAt(i));
  130. }
  131. outStream.flush();
  132. }
  133. public void send(char c) throws Exception
  134. {
  135. outStream.write((byte) c);
  136. outStream.flush();
  137. }
  138. public void skipBytes(int numOfBytes) throws Exception
  139. {
  140. int count, c;
  141. count = 0;
  142. while (count < numOfBytes)
  143. {
  144. c = inStream.read();
  145. if (c != -1) count ++;
  146. }
  147. }
  148. public boolean dataAvailable() throws Exception
  149. {
  150. return (inStream.available() > 0 ? true : false);
  151. }
  152. public String getResponse() throws Exception
  153. {
  154. final int RETRIES = 3;
  155. final int WAIT_TO_RETRY = 1000;
  156. StringBuffer buffer;
  157. int c, retry;
  158. retry = 0;
  159. buffer = new StringBuffer(BUFFER_SIZE);
  160. while (retry < RETRIES)
  161. {
  162. try
  163. {
  164. while (true)
  165. {
  166. c = inStream.read();
  167. if (c == -1)
  168. {
  169. buffer.delete(0, buffer.length());
  170. break;
  171. }
  172. buffer.append((char) c);
  173. if  ((buffer.toString().indexOf("rnOKr") > -1) || (buffer.toString().indexOf("rnERRORr") > -1)) break;
  174. }
  175. retry = RETRIES;
  176. }
  177. catch (Exception e)
  178. {
  179. if (retry < RETRIES)
  180. {
  181. Thread.sleep(WAIT_TO_RETRY);
  182. retry ++;
  183. }
  184. else throw e;
  185. }
  186. }
  187. log.log(Level.INFO, "ME: " + formatLog(buffer));
  188. if (dataAvailable()) skipBytes(1);
  189. while ((buffer.length() > 1) && ((buffer.charAt(0) == 'r') || (buffer.charAt(0) == 'n'))) buffer.delete(0, 1);
  190. return buffer.toString();
  191. }
  192. private String formatLog(StringBuffer s)
  193. {
  194. String response;
  195. int i;
  196. response = "";
  197. for (i = 0; i < s.length(); i ++)
  198. {
  199. switch (s.charAt(i))
  200. {
  201. case 13 :
  202. response += "<cr>";
  203. break;
  204. case 10 :
  205. response += "<lf>";
  206. break;
  207. case 9 :
  208. response += "<tab>";
  209. break;
  210. default:
  211. response += "<" + (int) s.charAt(i) + ">";
  212. break;
  213. }
  214. }
  215. response += "  Text:[";
  216. for (i = 0; i < s.length(); i ++)
  217. {
  218. switch (s.charAt(i))
  219. {
  220. case 13 :
  221. response += "<cr>";
  222. break;
  223. case 10 :
  224. response += "<lf>";
  225. break;
  226. case 9 :
  227. response += "<tab>";
  228. break;
  229. default:
  230. response += s.charAt(i);
  231. break;
  232. }
  233. }
  234. response += "]";
  235. return response;
  236. }
  237. }