From Flames To Fork, Comes Freedom

* A command string should start with "AT" or "at", except for the commands "A/" and "+++". At or aT are invalid.
* Several commands can be given in one command string.
* The commands can be given in upper or lower case.
* A command string should contain less than 40 characters.
* When an error is made during the typing of the command, it can be corrected using the backspace key.
* Commands and command strings must be terminated with an <ENTER>, except +++ and A/
* A telephone number can exist of following characters: 1 2 3 4 5 6 7 8 9 * = , ; # + > . All other characters are ignored (space, underscore ). They help formatting the dialstring.
* Commands that use a numerical parameter, can be used without a numerical value. In this case the command will be issued with the value zero.
* If the command string contains two consecutive commands without parameter, as discussed above, the modem will respond with an error.
* After the command ATZ has been issued, a pause of two seconds should be respected before entering the next commands.

AT+CMGF: Message Format:

Command Possible response(s)
+CMGF=[<mode>]
+CMGF?
+CMGF: <mode>
+CMGF=?
+CMGF: (list of supported <mode>s)

<mode>: 0: PDU mode;1: text mode;

AT+CSCA: Service Center Address:

Command Possible response(s)
+CSCA=<sca>[,<tosca>]
+CSCA?
+CSCA: <sca>,<tosca>
+CSCA=?

<sca> = service center address;

AT+CMGL: List Messages:

Command Possible response(s)
+CMGL[=<stat>]
+CMGL: message...
+CMGL=?
+CMGL: (list of supported <stat>s)

<stat>: status of messages to be read.

defined values:
0: received unread
1: received read;
2: stored unsent;
3: stored sent;
4: all;

AT+CMGR: Read Message:

Command Possible response(s)
+CMGR=<index>
+CMGR: message... +CMGR=?

AT+CMGS: Send Message:

Command Possible response(s)
+CMGS=<da>[,<toda>]
+CMGS: <mr> +CMGS=?

<da> = Destination Address;

AT+CMGD: Delete Message:

Command Possible response(s)
+CMGD=<index>
+CMGD=?

CMS Errors:

300: ME Failure;
302: Operation not allowed;
303: Operation not supported;
304: Invalid PDU mode parameter;
305: Invalid text mode parameter;
320: memory failure;
321: invalid memory index;
322: memory full;
330: SCA unknown;
500: Unknown error

AT+CNMI: New Message indication to TE


Command Possible response(s) +CNMI=[<mode>[,<mt>[,<bm>[,<ds>[,<bfr>]]]]]
+CNMI?
+CNMI: <mode>,<mt>,<bm>,<ds>,<bfr>
+CNMI=?+CSCB: (list of supported <mode>s,<mt>s,<bm>s,<ds>s,<bfr>s)


<mode>: 0: buffer in TA;

1: discard indication and reject new SMs when TE-TA link is reserved; otherwise forward directly;

2: buffer new Sms when TE-TA link is reserved and flush them to TE after reservation; otherwise forward directly to the TE;

3: forward directly to TE;<mt>: 0: no SMS-DELIVER are routed to TE;

1: +CMTI: <mem>,<index> routed to TE;

2: for all SMS_DELIVERs except class 2: +CMT: .... routed to TE; class 2 is indicated as in <mt>=1;

3: Class 3: as in <mt>=2;

other classes: As in <mt>=1;

<bm>: same as <mt>, but for CBMs;
<ds>: 0: No SMS-STATUS-REPORT are routed to TE;

1: SMS-STATUS-REPORTs are routed to TE, using +CDS: ...

<bfr>: 0: TA buffer is flushed to TE (if <mode>=1..3);

1: TA buffer is cleared (if <mode>=1..3);

---> Only when <mt> is different from 0, you will get a message that a new SMS has been received.

Code: Select all

    public void run() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {}
    }

Code: Select all

    public void run() {
        while ( readThread != null ) {
          try {
             Thread.sleep(10000);
          } catch (InterruptedException e) {}
        }
    }

Code: Select all

    public void stop() {
        readThread = null;
    }

at+cmgf=1
OK

at+cnmi=?
+CNMI: (0-2),(0-3),(0,2,3),(0-2),(0,1)

OK

at+cnmi=1,2,0,0,0
OK

+CMT: "+60193384826",,"06/09/26,16:11:29+32"
test

sureshquest wrote:In java the timer is simple, just create a thread and loop tht forever and put a sleep inside periodically.

Code: Select all

/*
* @(#)SimpleRead.java   1.12 98/06/25 SMI
*
* Copyright (c) 1998 Sun Microsystems, Inc. All Rights Reserved.
*/

import java.io.*;
import java.util.*;
import javax.comm.*;

public class SimpleRead implements Runnable, SerialPortEventListener {
    static CommPortIdentifier portId;
    static Enumeration portList;
      static SerialPort serialPort;
    static OutputStream outputStream;
   InputStream inputStream;
    Thread readThread;
   
//AT Commands to be sent ---------------------------------------
    static String destinationAddress = "0178869378";

   //Reset modem
   static String reset ="ATZ\r";
   
   //Check connection between modem and COM port
   static String atcheck = "AT\r";
   
   //Set message format to be text
   static String cmgf = "AT+CMGF=1\r";
   
   //Set how the modem will response when a SMS is received
   static String cnmi ="AT+CNMI=1,2,0,0,0\r";
   
   
//Main ()----------------------------------------------------------------------
    public static void main(String[] args) {
        portList = CommPortIdentifier.getPortIdentifiers();

        while (portList.hasMoreElements()) {
            portId = (CommPortIdentifier) portList.nextElement();
            if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
               if (portId.getName().equals("COM1")) {
                  
//Fixed Setup---------------------------------------------------------------
                   // System.out.println("COM1");
                  try
                   {
                        serialPort = (SerialPort)portId.open("SimpleWriteApp", 2000);
                   }
                   catch (PortInUseException e)
                   {
                        System.out.println("PortInUseException");
                   }
                   try
                   {
                        outputStream = serialPort.getOutputStream();
                   }
                   catch (IOException e){}
                   try
                   {
                         serialPort.setSerialPortParams(9600,
                         SerialPort.DATABITS_8,
                         SerialPort.STOPBITS_1,
                         SerialPort.PARITY_NONE);
                    }
                    catch (UnsupportedCommOperationException e){} 
//Initial setup of AT Command----------------------------------------------
                    try
                    {
                      outputStream.write(reset.getBytes());
                    }
                    catch(IOException e){}
                    try
                    {
                       Thread.sleep(1000);
                    }
                    catch(InterruptedException e){}
                    try
                    {
                         outputStream.write(cmgf.getBytes());
                    }
                    catch(IOException e){}
                    try
                    {
                       Thread.sleep(1000);
                    }
                    catch(InterruptedException e){}
                   try
                    {
                         outputStream.write(cnmi.getBytes());
                    }
                    catch(IOException e){};
                    try
                    {
                       Thread.sleep(1000);
                    }
                    catch(InterruptedException e){}

//Read SMS--------------------------------------------------------------------
                    SimpleRead reader = new SimpleRead();
                }
            }
        }
    }
     public SimpleRead() {
        try
        {
            serialPort = (SerialPort) portId.open("", 2000);
        }
        catch (PortInUseException e){System.out.println("Port already in used");
        }
        try
        {
            inputStream = serialPort.getInputStream();
        }
        catch (IOException e){System.out.println("InputStream");   
        }
       try
       {
            serialPort.addEventListener(this);
       }
       catch (TooManyListenersException e){System.out.println("TooManyListenersException");}
       
       serialPort.notifyOnDataAvailable(true);
        try
        {
                serialPort.setSerialPortParams(9600,
                SerialPort.DATABITS_8,
                SerialPort.STOPBITS_1,
                SerialPort.PARITY_NONE);
        }
        catch (UnsupportedCommOperationException e){System.out.println("UnsupportedCommOperationException");}
        readThread = new Thread(this);
        readThread.start();
    }

    public void run()
    {
       System.out.println("Ready to Read");
       try
       {
            Thread.sleep(20000);
        }
       catch (InterruptedException e) {}
    }

    public void serialEvent(SerialPortEvent event)
    {
        switch(event.getEventType()) {
        case SerialPortEvent.BI:
           System.err.println("Break Interrupt");
        case SerialPortEvent.OE:
           System.err.println("OE");
        case SerialPortEvent.FE:
           System.err.println("FE");
        case SerialPortEvent.PE:
           System.err.println("PE");
        case SerialPortEvent.CD:
           System.err.println("CD");
        case SerialPortEvent.CTS:
           System.err.println("Clear To Send");
        case SerialPortEvent.DSR:
           System.err.println("Data Set Ready");
        case SerialPortEvent.RI:
           System.err.println("Ring Indicator");
        case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            break;
        case SerialPortEvent.DATA_AVAILABLE:
            byte[] readBuffer = new byte[20];
            try
            {
                while (inputStream.available() > 0)
                {
                    int numBytes = inputStream.read(readBuffer);
                }
                System.out.print(new String(readBuffer)+"\n");
                //System.out.print("Reading");
            }
            catch (IOException e){System.out.println("IOException");}
            break;
        }
    }
}