How to transfer data to a serial port?

Question

I know that in J2ME CommConnection is the connection to use when working with serial port. I know there are the openInputStream and openOutputStream methods , but in fact I don't know how to transfer data from my MIDLet to the COM port ( the USB port into which the phone's cable is inserted , the phone is Alcatel OT-806D ). For example I want to send the text "Hello world". How to achieve that ?

Here are codes :

J2ME :

import java.io.IOException;
import java.io.OutputStream;
import javax.microedition.io.CommConnection;
import javax.microedition.io.Connector;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.*;

public class SerialPortMidlet extends MIDlet implements CommandListener, Runnable {
    private Command upload = new Command("upload", Command.SCREEN, 0);
    private Command exit = new Command("exit", Command.SCREEN, 1);
    private Form f = new Form("test serial port");
    private Thread uploadThread;
    private CommConnection com;
    private OutputStream os;
    public SerialPortMidlet()
    {
        f.addCommand(upload);
        f.addCommand(exit);
        f.setCommandListener(this);
        uploadThread = new Thread(this);
    }
    public void startApp() {
        Display.getDisplay(this).setCurrent(f);
    }
    public void pauseApp() {
    }
    public void destroyApp(boolean unconditional) {
        notifyDestroyed();
    }
    public void commandAction(Command c, Displayable d) {
        if (c == upload)
        {
            uploadThread.start();
            f.removeCommand(upload);
        }
        else if (c == exit)
        {
            if (uploadThread.isAlive())
            {
                uploadThread.interrupt();
                try {
                    uploadThread.join();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
            destroyApp(true);
        }
    }
    public void run() {
        try
        {
            String s = new String("andrana mandefa lavaka");
            com = (CommConnection) Connector.open("comm:COM4");
            os = com.openOutputStream();
            os.write(s.getBytes());
            os.close();
        } 
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

J2SE : ( Eclipse )

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class TwoWaySerialComm 
{
    public TwoWaySerialComm()
    {
        super();
    }
    void connect ( String portName ) throws Exception
    {
        CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
        if ( portIdentifier.isCurrentlyOwned() )
        {
            System.out.println("Error: Port is currently in use");
        }
        else
        {
            CommPort commPort = portIdentifier.open(this.getClass().getName(),2000);

            if ( commPort instanceof SerialPort )
            {
                SerialPort serialPort = (SerialPort) commPort;
                serialPort.setSerialPortParams(57600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);

                InputStream in = serialPort.getInputStream();
                OutputStream out = serialPort.getOutputStream();

                (new Thread(new SerialWriter(out))).start();

                serialPort.addEventListener(new SerialReader(in));
                serialPort.notifyOnDataAvailable(true);

            }
            else
            {
                System.out.println("Error: Only serial ports are handled by this example.");
            }
        }     
    }
    public static class SerialReader implements SerialPortEventListener 
    {
        private InputStream in;
        private byte[] buffer = new byte[1024];

        public SerialReader ( InputStream in )
        {
            this.in = in;
        }

        public void serialEvent(SerialPortEvent arg0) {
            int data;

            try
            {
                int len = 0;
                while ( ( data = in.read()) > -1 )
                {
                    if ( data == '\n' ) {
                        break;
                    }
                    buffer[len++] = (byte) data;
                }
                System.out.print(new String(buffer,0,len));
            }
            catch ( IOException e )
            {
                e.printStackTrace();
                System.exit(-1);
            }             
        }

    }
    public static class SerialWriter implements Runnable 
    {
        OutputStream out;

        public SerialWriter ( OutputStream out )
        {
            this.out = out;
        }

        public void run ()
        {
            try
            {                
                int c = 0;
                while ( ( c = System.in.read()) > -1 )
                {
                    this.out.write(c);
                }                
            }
            catch ( IOException e )
            {
                e.printStackTrace();
                System.exit(-1);
            }            
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try
        {
            (new TwoWaySerialComm()).connect("COM1");
        }
        catch ( Exception e )
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

I run the J2SE program , I inserted the mobile phone cable into the computer ( in the USB slot ) , I clicked the upload command in the J2ME app , but there is nothing in the output screen of the eclipse !

So what's the problem ?

I run this J2SE code to detect the port on which the phone's cable is :

import gnu.io.*;
public class SerialPortLister {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        listPorts();
    }
    private static void listPorts()
    {
        @SuppressWarnings("unchecked")
        java.util.Enumeration<CommPortIdentifier> portEnum = CommPortIdentifier.getPortIdentifiers();
        while ( portEnum.hasMoreElements() ) 
        {
            CommPortIdentifier portIdentifier = portEnum.nextElement();
            System.out.println(portIdentifier.getName()  +  " - " +  getPortTypeName(portIdentifier.getPortType()) );
        }        
    }
    private static String getPortTypeName ( int portType )
    {
        switch ( portType )
        {
            case CommPortIdentifier.PORT_I2C:
                return "I2C";
            case CommPortIdentifier.PORT_PARALLEL:
                return "Parallel";
            case CommPortIdentifier.PORT_RAW:
                return "Raw";
            case CommPortIdentifier.PORT_RS485:
                return "RS485";
            case CommPortIdentifier.PORT_SERIAL:
                return "Serial";
            default:
                return "unknown type";
        }
    }
}

And it shows COM4 because when I detach the cable then only COM1 and LPT1 are displayed.

So what's the problem ?

Answer 1

Your phone seems to be well detected by the computer as connected on the virtual COM port 4. However, this is not clear to me that you should use the COM port protocol on the phone side to communicate with the computer. It is perfectly possible that there is simply a buffer on the phone, that once filled will be delivered on the usb port.

I don't know your phone but I have already programmed a microcontroller. There I was never using the COM port protocol and managed to communicate with a computer with virtual com port driver.

To understand better my point, you can probably refer to documentation of the microcontroller present on your phone.