Comunicación bidireccional en C++ a través de la conexión en serie

Question

Estoy tratando de escribir una aplicación C++ realmente simple para comunicarme con un Arduino. Me gustaría enviar al Arduino un personaje que devuelve inmediatamente. El código de Arduino que tomé de un tutorial se ve así:

void setup() 
{ 
    Serial.begin(9600); 
} 

void loop() 
{ 
    //Have the Arduino wait to receive input 
    while (Serial.available()==0); 

    //Read the input 
    char val = Serial.read(); 

    //Echo 
    Serial.println(val); 
} 

me puedo comunicar con el Arduino fácilmente utilizando la pantalla de GNU, así que sé que todo está funcionando bien con la comunicación básica:

pantalla /dev/tty.usbmodem641 $ 9600

El código (roto) C++ que tengo se ve así:

#include <fstream> 
#include <iostream> 
int main() 
{ 
    std::cout << "Opening fstream" << std::endl; 
    std::fstream file("/dev/tty.usbmodem641"); 
    std::cout << "Sending integer" << std::endl; 
    file << 5 << std::endl; // endl does flush, which may be important 
    std::cout << "Data Sent" << std::endl; 
    std::cout << "Awaiting response" << std::endl; 
    std::string response; 
    file >> response; 
    std::cout << "Response: " << response << std::endl; 

    return 0; 
} 

Se compila bien, pero cuando se ejecuta, algunas luces de flash en el Arduino y el terminal simplemente se cuelga en:

fstream Apertura

Dónde estoy haciendo mal?

Answer 1

Debe verificar si tiene acceso al /dev/tty.usbmodem641. La forma habitual en Linux es agregar el usuario al grupo adecuado con adduser.

Por cierto, sé que para acceder al puerto serie, es necesario abrir /dev/ttyS0 (para COM1), hasta /dev/ttyS3. Ver por ejemplo this example in C.

Answer 2

Cuando abre el puerto serie, el Arduino se reinicia. Para un Arduino Uno, la adición de un condensador de 10   μF entre el reinicio y la conexión a tierra previene eso. Ver this para más detalles. Tenga en cuenta que debe quitar el condensador cada vez que necesite reprogramar el chip.

También debe configurar el puerto serie correctamente, pero primero debe resolver el problema del hardware.

Answer 3

hay tres puntos:

Primero: no inicializa el puerto serie (TTY) en el lado de Linux. Nadie sabe en qué estado está.

Haciendo esto en su programa debe usar tcgetattr(3) y tcsetattr(3). Puede encontrar los parámetros necesarios utilizando estas palabras clave en este sitio, en el sitio Arduino o en Google. Pero sólo para las pruebas rápida propongo a emitir este comando antes de llamar a su propio comando:

stty -F /dev/tty.usbmodem641 sane raw pass8 -echo -hupcl clocal 9600 

Especialmente la falta del clocal pueden impedir la apertura de la TTY.

Segundo: Cuando el dispositivo está abierto, debe esperar un poco antes de enviar cualquier cosa. Por defecto, Arduino se reinicia cuando se abre o cierra la línea serie. Tienes que tener esto en cuenta.

La pieza -hupcl evitará este reinicio la mayor parte del tiempo.Pero siempre es necesario un reinicio, ya que -hupcl solo se puede configurar cuando el TTY ya está abierto y en ese momento el Arduino ya recibió la señal de reinicio. Por lo tanto, -hupcl "solo" evitará restablecimientos futuros.

Tercero: Hay NO tratamiento de errores en el código. Agregue código después de cada operación IO en el TTY que comprueba si hay errores y, la parte más importante, imprime mensajes de error útiles usando perror(3) o funciones similares.

Answer 4

Encontré un buen ejemplo por Jeff Gray de cómo hacer un cliente tipo minicom simple usando boost::asio. El original code listing can be found on the boost user group. Esto permite la conexión y comunicación con Arduino como en el ejemplo de la pantalla GNU mencionado en la publicación original.

El ejemplo de código (abajo) debe estar vinculada con las siguientes banderas de engarce

-lboost_system-mt -lboost_thread-mt

... pero con un poco de ajuste, algunos de la dependencia del impulso puede ser reemplazado con nuevas características estándar de C++ 11. Publicaré versiones revisadas cuando lo encuentre. Por ahora, esto compila y es una base sólida.

/* minicom.cpp 
     A simple demonstration minicom client with Boost asio 

     Parameters: 
       baud rate 
       serial port (eg /dev/ttyS0 or COM1) 

     To end the application, send Ctrl-C on standard input 
*/ 

#include <deque> 
#include <iostream> 
#include <boost/bind.hpp> 
#include <boost/asio.hpp> 
#include <boost/asio/serial_port.hpp> 
#include <boost/thread.hpp> 
#include <boost/lexical_cast.hpp> 
#include <boost/date_time/posix_time/posix_time_types.hpp> 

#ifdef POSIX 
#include <termios.h> 
#endif 

using namespace std; 

class minicom_client 
{ 
public: 
     minicom_client(boost::asio::io_service& io_service, unsigned int baud, const string& device) 
       : active_(true), 
        io_service_(io_service), 
        serialPort(io_service, device) 
     { 
       if (!serialPort.is_open()) 
       { 
         cerr << "Failed to open serial port\n"; 
         return; 
       } 
       boost::asio::serial_port_base::baud_rate baud_option(baud); 
       serialPort.set_option(baud_option); // set the baud rate after the port has been opened 
       read_start(); 
     } 

     void write(const char msg) // pass the write data to the do_write function via the io service in the other thread 
     { 
       io_service_.post(boost::bind(&minicom_client::do_write, this, msg)); 
     } 

     void close() // call the do_close function via the io service in the other thread 
     { 
       io_service_.post(boost::bind(&minicom_client::do_close, this, boost::system::error_code())); 
     } 

     bool active() // return true if the socket is still active 
     { 
       return active_; 
     } 

private: 

     static const int max_read_length = 512; // maximum amount of data to read in one operation 

     void read_start(void) 
     { // Start an asynchronous read and call read_complete when it completes or fails 
       serialPort.async_read_some(boost::asio::buffer(read_msg_, max_read_length), 
         boost::bind(&minicom_client::read_complete, 
           this, 
           boost::asio::placeholders::error, 
           boost::asio::placeholders::bytes_transferred)); 
     } 

     void read_complete(const boost::system::error_code& error, size_t bytes_transferred) 
     { // the asynchronous read operation has now completed or failed and returned an error 
       if (!error) 
       { // read completed, so process the data 
         cout.write(read_msg_, bytes_transferred); // echo to standard output 
         read_start(); // start waiting for another asynchronous read again 
       } 
       else 
         do_close(error); 
     } 

     void do_write(const char msg) 
     { // callback to handle write call from outside this class 
       bool write_in_progress = !write_msgs_.empty(); // is there anything currently being written? 
       write_msgs_.push_back(msg); // store in write buffer 
       if (!write_in_progress) // if nothing is currently being written, then start 
         write_start(); 
     } 

     void write_start(void) 
     { // Start an asynchronous write and call write_complete when it completes or fails 
       boost::asio::async_write(serialPort, 
         boost::asio::buffer(&write_msgs_.front(), 1), 
         boost::bind(&minicom_client::write_complete, 
           this, 
           boost::asio::placeholders::error)); 
     } 

     void write_complete(const boost::system::error_code& error) 
     { // the asynchronous read operation has now completed or failed and returned an error 
       if (!error) 
       { // write completed, so send next write data 
         write_msgs_.pop_front(); // remove the completed data 
         if (!write_msgs_.empty()) // if there is anthing left to be written 
           write_start(); // then start sending the next item in the buffer 
       } 
       else 
         do_close(error); 
     } 

     void do_close(const boost::system::error_code& error) 
     { // something has gone wrong, so close the socket & make this object inactive 
       if (error == boost::asio::error::operation_aborted) // if this call is the result of a timer cancel() 
         return; // ignore it because the connection cancelled the timer 
       if (error) 
         cerr << "Error: " << error.message() << endl; // show the error message 
       else 
         cout << "Error: Connection did not succeed.\n"; 
       cout << "Press Enter to exit\n"; 
       serialPort.close(); 
       active_ = false; 
     } 

private: 
     bool active_; // remains true while this object is still operating 
     boost::asio::io_service& io_service_; // the main IO service that runs this connection 
     boost::asio::serial_port serialPort; // the serial port this instance is connected to 
     char read_msg_[max_read_length]; // data read from the socket 
     deque<char> write_msgs_; // buffered write data 
}; 

int main(int argc, char* argv[]) 
{ 
// on Unix POSIX based systems, turn off line buffering of input, so cin.get() returns after every keypress 
// On other systems, you'll need to look for an equivalent 
#ifdef POSIX 
     termios stored_settings; 
     tcgetattr(0, &stored_settings); 
     termios new_settings = stored_settings; 
     new_settings.c_lflag &= (~ICANON); 
     new_settings.c_lflag &= (~ISIG); // don't automatically handle control-C 
     tcsetattr(0, TCSANOW, &new_settings); 
#endif 
     try 
     { 
       if (argc != 3) 
       { 
         cerr << "Usage: minicom <baud> <device>\n"; 
         return 1; 
       } 
       boost::asio::io_service io_service; 
       // define an instance of the main class of this program 
       minicom_client c(io_service, boost::lexical_cast<unsigned int>(argv[1]), argv[2]); 
       // run the IO service as a separate thread, so the main thread can block on standard input 
       boost::thread t(boost::bind(&boost::asio::io_service::run, &io_service)); 
       while (c.active()) // check the internal state of the connection to make sure it's still running 
       { 
         char ch; 
         cin.get(ch); // blocking wait for standard input 
         if (ch == 3) // ctrl-C to end program 
           break; 
         c.write(ch); 
       } 
       c.close(); // close the minicom client connection 
       t.join(); // wait for the IO service thread to close 
     } 
     catch (exception& e) 
     { 
       cerr << "Exception: " << e.what() << "\n"; 
     } 
#ifdef POSIX // restore default buffering of standard input 
     tcsetattr(0, TCSANOW, &stored_settings); 
#endif 
     return 0; 
}