Come trasferire i dati su una porta seriale?

Question

So che in J2ME CommConnection è la connessione da utilizzare quando si lavora con serial port. So che ci sono i metodi openInputStream e openOutputStream, ma in realtà non so come trasferire i dati dal mio MIDLet alla porta COM (la porta USB in cui è inserito il cavo del telefono, il telefono è Alcatel OT-806D). Ad esempio voglio inviare il testo "Hello world". Come raggiungerlo?

Ecco i codici:

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(); 
     } 
    } 
} 

ho eseguito il programma di J2SE, ho inserito il cavo del telefono cellulare in il computer (nello slot USB), ho fatto clic sul comando upload in J2M E app, ma non c'è nulla nella schermata di output dell'eclissi!

Quindi qual è il problema?

ho eseguito questo codice di J2SE per rilevare la porta su cui il cavo del telefono è:

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"; 
     } 
    } 
} 

e si vede COM4 perché quando stacco il cavo allora solo COM1 e LPT1 vengono visualizzati.

Quindi qual è il problema?

Answer 1

Il telefono sembra essere correttamente rilevato dal computer come collegato sulla porta COM virtuale 4. Tuttavia, non è chiaro per me che è necessario utilizzare il protocollo della porta COM sul lato del telefono per comunicare con il computer. È perfettamente possibile che ci sia semplicemente un buffer sul telefono, che una volta riempito verrà consegnato sulla porta USB.

Non conosco il telefono ma ho già programmato un microcontrollore. Non ho mai utilizzato il protocollo della porta COM e sono riuscito a comunicare con un computer con il driver della porta virtuale.

Per capire meglio il mio punto, è possibile fare riferimento alla documentazione del microcontrollore presente sul telefono.