Newsgroup: it.comp.java
Titolo: non si ferma!!! modem- java comm

sto dialogando con un modem attraverso la porta seriale usando le java
comm ,fin qui niente di anomalo quando provo la scansione delle porte
tutto ok quando provo a scrivere o meglio inviargli un comando mi
risponde come dovrebbe; il problema risiede nel fatto che dopo avermi
risposto dovrebbe bloccarsi la mia applicazione perchè io voglio
inviarli un comando ricevere la risposta e basta invece il mio
programma rimane in ascolto senza bloccarsi è il serialEvent che rompe
o qualche thread sono alla frutta le ho provate tutte quindi vi prego
di postarmi eventuali modifiche al mio codice e non filosofiche
risposte(ne ho ricevute già di belle) vi riporto il codice se volete
dargli un occhiata e apportargli qualche modifica(vi ringrazio per la
pazienza accordatami)non fatevi spaventare dalla lunghezza;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.Serializable;
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 SimpleWrite1 implements Runnable,
SerialPortEventListener {
   static String DEFAULT_PORT = "COM4";
//leggo e scrivo sulla porta  COM4 nel mio caso
   InputStream  in;
   OutputStream out;
   private String message = "AT\r";
//il comando di prova che invio al modem è AT in risposta ho OK
private Object readerThread;
   public void writeToCommPort(String message)  {
     this.message = message;
     Thread readerThread;
       }
 /**
  * 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 SimpleWrite1(CommPortIdentifier portId) throws
PortInUseException {
      try {//apro la porta seriale
         SerialPort serialPort = (SerialPort)
portId.open("SimpleReadWrite",
                                                          2000);
//Port mit
         in  = serialPort.getInputStream();
         out = serialPort.getOutputStream();
         serialPort.addEventListener(this);
         serialPort.notifyOnDataAvailable(true);
         serialPort.setSerialPortParams(9600,
              SerialPort.DATABITS_8,
                                        SerialPort.STOPBITS_1,
                                        SerialPort.PARITY_NONE);
         Thread readerThread = new Thread(this);
         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);
         }
   }
 /**
  * This method loops forever, reading data from the
  * command line and writing it directly to the serial port.
  * No buffering is performed.
  */
    public void run() {
      try {
           out.write(message.getBytes());
      }
          catch (IOException e) {
         // Terminate thread
         }
   }
 /**
  * Process serial port events.  This method is required
  * when implementing SerialPortEventListener
  *
  * @param event SerialPortEvent object to process
  */
    public void serialEvent(SerialPortEvent event) {
      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 {String l;
               while (in.available() >0 && (in.read())!=0) {
                  int numBytes = in.read(readBuffer);
                  //in.close();
               }
               System.out.write(readBuffer);
            }
                catch (IOException e) {
                 // Terminate handling this event on read error
               }
            break;
         default:
            System.out.print("Unknown SerialPortEvent type = " +
                              event.getEventType());
            break;
      }
   }
}

                }
L'unico punto in cui potrebbe esserci qualche problema, IMHO, è nel ciclo
che ho riportato.
-- 
Ciao,
 Fabrizio
=== 
http://www.negusweb.it
 ===

Negus ha scritto:

per bloccarsi intendo che dovrei dichiarare o racchiudere del codice
con syncronized usare wait o altri metodi per tentare di bloccare i
thread che rimangono attivi dopo aver effettuata la lettura visto il
codice saresti in grado di darmi un'idea sui possibili cambiamenti da
apportare grazie alla prossima!

                while (in.available() >0 && (in.read())!=0) {
Per la lettura dei dati ho visto che nell'esempio sul sito ufficiale si
controlla solo il metodo available().
Perchè usi anche la condizione in.read()!=0 ?
