Newsgroup: it.comp.java
Titolo: java commapi e linux

Sono alle prese con un programma che mi permetta sotto Linux di comunicare 
con un modem. Il programma l'ho sviluppato sotto Windows utilizzando le 
commapi. Ora ho la necessità di farlo funzionare anche sotto linux. Premetto 
che su Windows il programma funziona.
Ho seguito tutte le istruzioni presenti sul sito 
http://www.rxtx.org/
 ed in 
particolare quelle contenute in 
http://wass.homelinux.net/howtos/Comm_How-To.shtml
. Purtroppo il mio 
programma sotto Mandrake Linux 10.1 non funziona. Ho installato tutte le 
ultime versioni di JDK e delle Java Commapi per Linux. L'errore visualizzato 
dalla console di Eclipse è il seguente:
#
# An unexpected error has been detected by HotSpot Virtual Machine:
# SIGSEGV (0xb) at pc=0x40008483, pid=5201, tid=1075164800
# Java VM: Java HotSpot(TM) Client VM (1.5.0_02-b09 mixed mode, sharing)
# Problematic frame:
# C [ld-linux.so.2+0x8483]
# An error report file with more information is saved as hs_err_pid5201.log
# If you would like to submit a bug report, please visit:
# 
http://java.sun.com/webapps/bugreport/crash.jsp
Mi potreste dire il perché? 

 Mi potreste dire il perché? 
Dovresti dare piu' informazioni, per esempio dove esattamente crasha la
VM. Il file di log (Nel caso da te riportato "hs_err_pid5201.log") cosa
dice ?
-- 
Giambo - Occhio al filtro antispam _e_ alla whitelist !

 wrote in message 
news:42a4b55d$0$1162$5402...@news.sunrise.ch...


scusa Roby se mi intrometto non so da quello che dici come risolvere il
tuo problema ma tu esordisci dicendo che su windows ti funziona e anche
al sottoscritto funziona usando il codice che riporterò di seguito ma
devo far bloccare il thread di lettura brutalmente mettendelo a null
sapresti suggerirmi un metodo migliore senza "suicidare" il thread di
lettura ,grazie  spero tu possa aiutarmi questi thread mi creano
difficoltà non indifferenti poi posta il tuo errore forse posso
esserti d'aiuto ciao
import java.io.InputStream;
   import java.io.OutputStream;
   import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;
   import java.util.TooManyListenersException;
   import javax.comm.*;
/**
 * Simple program to read characters from the command-line, send
 * them to the specified serial port, and echo any characters
returned.
 * Modeled after the SimpleRead and SimpleWrite sample programs
included
 * with the Java Communications API distribution.
 */
    public class SimpleReadWrite1 implements Runnable,
SerialPortEventListener
	{
      static String DEFAULT_PORT = "COM4";
      InputStream  in;
      OutputStream out;
      private String message = "ATI6\r";
     boolean t = true;
      Thread readerThread;
      SerialPort serialPort;
	protected static Object srw;
      public void writeToCommPort(String message)  {
        this.message = message;
      }
    /**
     * Main method.
     */
       public static void main(String[] args) {
         String portname = DEFAULT_PORT;
         if (args.length > 1) {
            System.err.println("Usage: java SimpleReadWrite
[port_name]");
            System.exit(1);
         }
         else if (args.length == 1) {
            portname = args[0];
         }
         try {
            CommPortIdentifier portId =
CommPortIdentifier.getPortIdentifier(portname);
            if (portId.getPortType() ==
CommPortIdentifier.PORT_SERIAL) {
               SimpleReadWrite1 srw = new SimpleReadWrite1(portId);
            }
            else {
               System.err.println(portname + " is not a serial port");
               System.exit(1);
            }
         }
             catch (NoSuchPortException e) { //Port nicht vorhanden
               System.err.println("No such port: " + portname);
               System.exit(1);
            }
             catch (PortInUseException e) { //Port ist
gesperrt/inGebrauch
               System.err.println("Port in use: " + portname);
               System.exit(1);}
             }
    /**
     * Constructor.
     */
       public SimpleReadWrite1(CommPortIdentifier portId) throws
PortInUseException {
         try {
            SerialPort serialPort = (SerialPort)
portId.open("SimpleReadWrite",
                                                             2000);
//Port mit
            in  = serialPort.getInputStream();
            out = serialPort.getOutputStream();
           serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
            serialPort.setSerialPortParams(9600,
//Schnittstelleneinstellungen initialisieren
                                           SerialPort.DATABITS_8,
                                           SerialPort.STOPBITS_1,
                                           SerialPort.PARITY_NONE);
            Thread readerThread = new Thread(this);
            //readerThread.setDaemon(true);
            readerThread.start();
         } //Exception-Handling
             catch (IOException e) {
               System.err.println("Problem opening streams");
               System.exit(1);
            }
             catch (TooManyListenersException e) {
               System.err.println("Too Many Listeners");
               System.exit(1);
            }
             catch (UnsupportedCommOperationException e) {
               System.err.println("Problem setting port parameters");
               System.exit(1);
            }
      }
    /**
	 * @param b
	 */
	/**
     * This method loops forever, reading data from the
     * command line and writing it directly to the serial port.
     * No buffering is performed.
	 * @throws InterruptedException
     */
       public void run() {
         try {
            while(true){
			synchronized(this){
               out.write(message.getBytes());
          wait();
            } }
         }
             catch (IOException e) {
            // Terminate thread
            } catch (InterruptedException e) {
				// TODO Blocco catch generato automaticamente
				e.printStackTrace();
			}byte[] readBuffer = new byte[1];
            try {
                while (in.available() > 0) {
                   int numBytes = in.read(readBuffer);
                }
               System.out.print(new String(readBuffer));
            //   readerThread.interrupt();
       //  readerThread=null;
             }
                 catch (IOException e) {
                  // Terminate handling this event on read error
                }}
      /* public boolean stopThread() throws IOException{out.close();
       in.close();return t=false;}*/
    /**
     * Process serial port events.  This method is required
     * when implementing SerialPortEventListener
     *
     * @param event SerialPortEvent object to process
     */
     public void serialEvent(SerialPortEvent event) {
       	String a;
         switch (event.getEventType()) {
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
               break;
            case SerialPortEvent.DATA_AVAILABLE:
                // If there is data available on serial port,
                // read it in in chunks <=20 bytes
                //
               byte[] readBuffer = new byte[1];
               try {
                  while (in.available() > 0) {
                     int numBytes = in.read(readBuffer);
                  }
                 System.out.print(a=new String(readBuffer));
                 new Timer(true).schedule(new TimerTask() {
                    public void run() {
                     //System.out.println("Preparing to interrupt");
                    try{  readerThread.interrupt();
                      readerThread = null;}
                    catch(NullPointerException npe){System.exit(0);}//
to release it
                    }
                  }, 2000); // run() after 2000 milliseconds
                 // t=stopThread();
               }
                   catch (IOException e) {
                    // Terminate handling this event on read error
                  }
               break;
            default:
               System.out.print("Unknown SerialPortEvent type = " +
                                 event.getEventType());
               break;
         }
 
      }
         }

 wrote in message 
news:1118091875.6...@g14g2000cwa.googlegroups.com...


proverò ma come fai a farlo senza l'uso dei thread quando lanci il
comando non dovresti stare in "parallelo" in ascolto della risposta?
domanda banale? il tuo codice è del tipo lancio il comando e poi in un
secondo momento leggo la risposta che immagazini su un buffer? ti
chiedo delucidazioni perchè per me è particolarmente importante,
grazie e ciao

 wrote in message 
news:1118127687.8...@g49g2000cwa.googlegroups.com...


 che su windows funziona tutto.
Il problema sembra essere "esterno" a Java, legato cioe' ai metodi
nativi per leggere/scrivere sulla porta seriale.
Di piu' non so' dirti.
