Inviare dati da arduino a programma JAVA/C++

Raga mi sto picchiando da un paio di giorni con questo problema. Ho un arduino 2009 e ho necessità di inviare dati tramite usb al pc e da qui leggerli con un programma in JAVA o C++ e gestirli... Ovviamente mandarli semplicemente e leggerli dall'ide di arduino o da putty (simil hyperterminal) è abbastanza banale :) Il discorso si complica notevolmente (almeno per me) quando si tratta di fare quanto sopra detto. Ho cercato nel forum e sul web ma quello che ho trovato o non compila o non funziona :( Possibile che non esistano librerie o metodi semplici x fare tutto ciò? L'usb ormai è usatissima....e java in particolare ha già di suo mille librerie comodissime...

io come libreria per il java uso http://www.rxtx.org/ che CREDO sia la stessa usata dall'ide di arduino

L' Arduino usa la USB per emulare una seriale; dovresti riuscire a ricevere dati dal arduino semplicemente leggendo dati dalla seriale. Ciao Uwe

sono riuscito (credo) a installare le RXTX, l’unico programma che ho provato fa un semplice test delle porte seriali/parallele e mi restituisce:

Started
Stable Library
=========================================
Native lib Version = RXTX-2.1-7
Java lib Version   = RXTX-2.1-7
Porta seriale: //./COM10
Porta parallela: //./COM10

che sembrerebbe giusto dato che anke l’ide di arduino si collega alla COM10, ma tutti quei // e . prima cosa sono?
Poi fatto questo non ho capito come faccio a ricevere uno stream…ho arduino che ogni 1 secondo mi invia i dati letti da due DS1624 nella forma:

Temp1:xx.yy-Temp2:xx.yy

dopo un botto di imprecazioni varie sono riuscito a tirare fuori qualcosa usando questa classe ceh ho scritto in poco tempo mettendo insieme le cose che funzionano...

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.InputStream;
import java.io.OutputStream;


public class serialPortHandler {
      static InputStream input;
    static OutputStream output;
    
    private int temp;
    private String serialReadedString="";
    private boolean stringSend=false;
    private SerialPort serialPort;
    private CommPortIdentifier portId;
    
    
    public boolean connect(String portName,String applicationName,int baudRate){
          try{
                portId = CommPortIdentifier.getPortIdentifier(portName);
      
                  serialPort = (SerialPort)portId.open(applicationName, 5000);
                  input = serialPort.getInputStream();
                  output = serialPort.getOutputStream();
                  serialPort.setSerialPortParams(
                              baudRate,
                          SerialPort.DATABITS_8,
                          SerialPort.STOPBITS_1,
                          SerialPort.PARITY_NONE);
                  
                  System.out.println("Connected to port:"+serialPort.getName()+
                                                " with baudrate of: "+serialPort.getBaudRate());
                  return true;
          }catch (Exception e) {
                  return false;
            }

    }    

    //Read byte from serial, when reach end string char return the received string
    public String readSerial()throws Exception{
                while(input.available()>0) {
                      //Read byte from serial
                      temp=input.read();
                      //If it is 13 (ASCII character CR) is the end of string, so generate it
                      if(temp == 13){
                            stringSend = true;
                            return serialReadedString;
                      }
                      //Read char and add to string (ignore ASCII 10, char LF)
                      else if(temp != 10){
                            if(stringSend == true){
                                  stringSend = false;
                                  serialReadedString="";
                            }
                            serialReadedString+=(char)temp;
                      }
                  }
                  return null;
    }
    
    public void disconnect() {
        if (serialPort != null) {
            // Close the port.
            serialPort.close();
        }
    }

}

io non la ho installata, basta includerla nel programma come libreria esterna. Ora non ricordo il comando da dare nel terminale, ma con eclipse è facile da fare via gui

A Dany88, Ciao Ho il tuo stesso problema... Sto provando a comunicare con ARDUINO UNO attraverso la USB ma senza risultati....non riesco ad inviare nulla ad arduino affinchè possa eseguire ciò che gli chiedo. In pratica io vorrei semplicemente rieseguire l'esempio riportato nel TUTORIAL "PhysicalPixel" ma senza l'ausilio di Programming, ovvero utilizzando Java. Mi potresti dare una mano. Grazie

io ero riuscito alla fine usando le TX RX di java... Bisogna un po studiarci però...

uh sapresti linkarmi le librerie rx/tx officiali di java? tnx!

http://rxtx.qbang.org/wiki/index.php/Download

Se usi eclipse è abbastanza semplice importarle :) altrimenti nn ti so aiutare...

ah ok, sono quelle che uso anch'io, pensavo fossero ufficiali nel senso già comprese nelle api :)

Sono riuscito a fare qualcosa....

const int ledPin = 13; // the pin that the LED is attached to
int incomingByte;      // a variable to read incoming serial data into

void setup() {
  // initialize serial communication:
  Serial.begin(9600);
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // see if there's incoming serial data:
   if (Serial.available() > 0) {
    // read the oldest byte in the serial buffer:
    incomingByte = Serial.read();
    // if it's a capital H (ASCII 72), turn on the LED:
    if (incomingByte == 'H') {
      digitalWrite(ledPin, HIGH);
      Serial.print(“ACCESO”);
    } 
    // if it's an L (ASCII 76) turn off the LED:
    if (incomingByte == 'L') {
      digitalWrite(ledPin, LOW);
      Serial.print(“SPENTO”);
    }
  }
}



package domotica.utils;

import java.io.*;
import java.util.*;
import gnu.io.*; 

public class TestIO {
      public static void main(String[] args)throws IOException {            
            InputStream stdln = System.in;
            String inputLine;
            System.out.println("Scrivi qualcosa qui sotto e premi invio");
            InputStreamReader in = new InputStreamReader(stdln);
            BufferedReader myReader = new BufferedReader(in);
            
            try{
                  inputLine = new String(myReader.readLine());
                  SerialComunicationIOTest.messageString = inputLine;//perchè messageString è static
                  SerialComunicationIOTest.exec();
                  
                  SerialComunicationIOTest s = new SerialComunicationIOTest();
                  s.run();
                        
            }catch(IOException e){throw e;}
                  System.out.println("Hai Scritto " +inputLine);
      }
}



*****************************************************************************************
package domotica.utils;

//derived from SUN's examples in the javax.comm package
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;

public class SerialComunicationIOTest implements Runnable, SerialPortEventListener {
      static CommPortIdentifier portId;
      static CommPortIdentifier saveportId;
      static Enumeration portList;
      static InputStream inputStream;
      static SerialPort serialPort;
      Thread readThread;

      //static String messageString = "Hello, world!";
      static String messageString = null;
      
      static OutputStream outputStream;
      static boolean outputBufferEmptyFlag = false;
      
public static void exec() {
            boolean portFound = false;
            String defaultPort;
            // determine the name of the serial port on several operating systems
            String osname = System.getProperty("os.name","").toLowerCase();
            if (osname.startsWith("windows") ) {
            // windows
                  defaultPort = "COM27";
            } else if (osname.startsWith("linux")) {
            // linux
                  defaultPort = "/dev/ttyUSB0";
            } else if (osname.startsWith("mac") ) {
          // mac
                  defaultPort = "????";
            } else {
                  System.out.println("Sorry, your operating system is not supported");
                  return;
            }
//non so perchè non va
//            if (args.length > 0) {
//                  defaultPort = args[0];
//            }

            System.out.println("Set default port to "+defaultPort);

            // parse ports and if the default port is found, initialized the reader
            portList = CommPortIdentifier.getPortIdentifiers();
            while (portList.hasMoreElements()) {
                  portId = (CommPortIdentifier) portList.nextElement();
                  if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                        if (portId.getName().equals(defaultPort)) {
                              System.out.println("Found port: "+defaultPort);
                              portFound = true;
                              //init  threadreader
                              SerialComunicationIOTest reader = new SerialComunicationIOTest();
                        }
                  }
            }
            if (!portFound) {
                  System.out.println("port " + defaultPort + " not found.");
            }
      }
      
      public void initwritetoport() {
      // initwritetoport() assumes that the port has already been opened and
      //    initialized by "public SerialComunication()"
            try {
                  // get the outputstream
                  outputStream = serialPort.getOutputStream();
            } catch (IOException e) {}
  }

      public void writetoport() {
            System.out.println("Writing \""+messageString+"\" to "+serialPort.getName());
            try {
                  // write string to serial port
                  outputStream.write(messageString.getBytes());
            } catch (IOException e) {}
      }
      
      public void initreadtoport() {
            try {
                  // get the inputstream
                  inputStream = serialPort.getInputStream();
            } catch (IOException e) {}      
      }
      
      public void readtoport() {
            try {      
                  inputStream = serialPort.getInputStream();
                  int available = inputStream.available();
                  byte chunk[] = new byte[available];
                  inputStream.read(chunk, 0, available);
                  System.out.print("mo1");
                  System.out.println(new String(chunk));
                  System.out.println("mo2");                        
            } catch (Exception e) {
                  System.err.println(e.toString());
            }
      }
      
      public SerialComunicationIOTest() {
      // initalize serial port
            try {
                  serialPort = (SerialPort) portId.open("SimpleReadApp", 2000);
            } catch (PortInUseException e) {}
            
            try {
                  inputStream = serialPort.getInputStream();
            } catch (IOException e) {}

            try {
                  outputStream = serialPort.getOutputStream();
            } catch (IOException e) {}            
            
            try {
                  serialPort.addEventListener(this);
            } catch (TooManyListenersException e) {}

            // activate the DATA_AVAILABLE notifier
            serialPort.notifyOnDataAvailable(true);

            try {
          // set port parameters
            serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8,
                                                                   SerialPort.STOPBITS_1,
                                                                   SerialPort.PARITY_NONE);
            } catch (UnsupportedCommOperationException e) {}

            // start the read thread
            readThread = new Thread(this);
            readThread.start();
      }

      public void run() {
      // first thing in the thread, we initialize the write operation
            initwritetoport();
            initreadtoport();
            try {
                  while (true) {
                        // write string to port, the serialEvent will read it
                        writetoport();
                        //Thread.sleep(2000);
                        readtoport();
                        Thread.sleep(2000);
                  }
            } catch (InterruptedException e) {}
      }

      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:
                  // we get here if data has been received
                  try {                        
                        int available = inputStream.available();
                        byte chunk[] = new byte[available];
                        inputStream.read(chunk, 0, available);
                        // Displayed results are codepage dependent
                        System.out.print(new String(chunk));
                  } catch (Exception e) {
                        System.err.println(e.toString());
                  }                        
            }
      }
}

Ho allegato lo sketch e le due classi java. In linea di massima funziona, certo ci sono diversi problemini da risolvere... prima di tutto si dovrebbe fermare e attendere un nuovo comando altrimenti esegue solo il loop ed in più c'è da riguardare qualcosina. Mi dareste una mano. grazie mille

prima di tutto si dovrebbe fermare e attendere un nuovo comando

intendi che la serial.read() dovrebbe essere loccante(ovvero blocca il codice finchè non legge qualcosa)?
secondo me è una brutta pratica, meglio imparare a usare tutto non loccante, in molte applicazioni ritorna utile.
cmq in caso basta fare:

while(Serial.avaiable()<1)
    ; //non fa nulla
//se è uscito dal ciclo vuol dire che è arrivato qualcosa via seriale

si ma stavo pensando... Se uno vuole realizzare un progetto che sfrutta l'usb deve comprare il FT232RL, che vedo molto difficile saldare correttamente :( :( Perchè di fatto arduino non ha un modulo USB con enumeratore e tutto...

dani non capisco il problema. arduino già possiede un chip FTDI (tranne la uno che usa una soluzione diversa ma alla fine dei conti è la stessa cosa ma open-source invece che proprietaria)

Se vuoi usare l'atmega da solo allora serve un chip FTDI. Non è assolutamente difficile da saldare, vendono la schedina già assemblata intorno ai 10? e a dir la verità non c'è niente da saldare perchè possiede dei pin, basta collegare GND/RX/TX con GND/TX/RX sull'atmega e il gioco è fatto (anche VCC se si vuole usare la corrente dall'USB)

ma forse ho capito male l'affermazione :)

si si ho visto dopo che ci sn le mini board già pronte :) Cmq oggi ho ordinato della pasta saldante lead free (spero non dia problemi senza piombo, stavo pensando di prenderne anche una Sn63% e Pb 37%) perchè volevo iniziare a far pratica con componenti smd. Volevo anche costruire un riscaldatore a IR per saldare...

le paste al piombo son cancerogene e per quel che so non le possono più vendere (almeno in Italia), vai tranquillo con le paste normali, il riscaldatore IR mi interessa assai, se semplifica le saldature smd