Connexion série libserial C++ à Arduino

Question

J'essaie d'envoyer des données via une connexion série (USB) de mon PC (Ubuntu 14.04) vers un Arduino Uno. L'Arduino doit afficher les données reçues à des fins de test. (Je suis heureux, si je reçois quelque chose ...)

J'utilise libserial pour envoyer les données mais l'Arduino ne reçoit rien. Avec l'aide de l'IDE Arduino, je pourrais envoyer les données avec succès à l'Arduino. Avec les commandes normales de la console, il est également possible d'envoyer les données.

Voici mon code Arduino:

#include <LiquidCrystal.h> 
#include <SoftwareSerial.h> 

// initialize the library with the numbers of the interface pins 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 

String inputString = "";   // a string to hold incoming data 
boolean stringComplete = false; // whether the string is complete 

void setup() { 
    // set up the LCD's number of columns and rows: 
    lcd.begin(16, 2); 
    // Print a message to the LCD. 
    lcd.print("connecting..."); 

    inputString.reserve(200); 

    Serial.begin(9600); 
    while (!Serial) { 
    ; // wait for serial port to connect. Needed for native USB port only 
    } 

    lcd.setCursor(0, 0); 
    lcd.print("successful connected"); 

} 

void loop() { 
    lcd.setCursor(0, 1); 

    // print the string when a newline arrives: 

    lcd.setCursor(0, 1); 
    lcd.print("    "); 

    lcd.setCursor(0, 1); 
    lcd.print(inputString); 

    delay(500); 
} 

void serialEvent() { 

    if (Serial.available()) { 
    // get the new byte: 
    char inChar = (char)Serial.read(); 
    // add it to the inputString: 
    inputString += inChar; 
    } 
} 

Et ce C++ code (côté PC):

//Libserial: sudo apt-get install libserial-dev 
#include <SerialStream.h> 
#include <iostream> 
#include <unistd.h> 

using namespace LibSerial; 
using namespace std; 

int main(int argc, char** argv) 
{ 
    SerialStream my_serial_stream; 
    // 
    // Open the serial port for communication. 
    // 
    my_serial_stream.Open("/dev/ttyACM0"); 

    my_serial_stream.SetBaudRate(SerialStreamBuf::BAUD_9600); 

    //my_serial_stream.SetVTime(1); 
    //my_serial_stream.SetVMin(0); 

    my_serial_stream.SetCharSize(SerialStreamBuf::CHAR_SIZE_8); 
    my_serial_stream.SetParity(SerialStreamBuf::PARITY_NONE); 
    my_serial_stream.SetFlowControl(SerialStreamBuf::FLOW_CONTROL_NONE); 
    my_serial_stream.SetNumOfStopBits(1); 

    int i = 0; 

    while(i<=5) { 

     usleep(1500000); 

     if (!my_serial_stream.good()) { 

      my_serial_stream << i << "\n" << endl; 
      cout << i << endl; 


     } 
     else { 

      cout << "serial is not good" << endl; 
     } 

     i++; 
    } 

    my_serial_stream.Close(); 

    cout << "ready" << endl; 


    return 0; 
} 

Avez-vous des idées pourquoi cela ne fonctionne pas?

Merci!

Answer 1

J'ai trouvé une solution, comment communiquer avec l'Arduino via le port série (USB). Je n'utilise pas libserial.

I amélioré le code Arduino (affichage uniquement, s'il y a une nouvelle ligne):

// include the library code: 
#include <LiquidCrystal.h> 
#include <SoftwareSerial.h> 

// initialize the library with the numbers of the interface pins 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 

String inputString = "";   // a string to hold incoming data 
boolean stringComplete = false; // whether the string is complete 

void setup() { 
    // set up the LCD's number of columns and rows: 
    lcd.begin(16, 2); 
    // Print a message to the LCD. 
    lcd.print("connecting..."); 

    inputString.reserve(200); 

    Serial.begin(9600); 
    while (!Serial) { 
    ; // wait for serial port to connect. Needed for native USB port only 
    } 

    lcd.setCursor(0, 0); 
    lcd.print("successful connected"); 

} 

void loop() { 
    lcd.setCursor(0, 1); 

    if (stringComplete) { 
    // print the string when a newline arrives: 

    lcd.setCursor(0, 1); 
    lcd.print("    "); 

    lcd.setCursor(0, 1); 
    lcd.print(inputString); 

    inputString = ""; 
    stringComplete = false; 

    } 
} 

void serialEvent() { 

    if (Serial.available()) { 
    while (Serial.available()) { 
    // get the new byte: 
    char inChar = (char)Serial.read(); 
    // add it to the inputString: 
    inputString += inChar; 
    // if the incoming character is a newline, set a flag 
    // so the main loop can do something about it: 
    if (inChar == '\n') { 
     stringComplete = true; 
    } 
    } 
    } 
} 

C++ Code:

//to compile use: g++ serial_success.cpp -o serial -std=c++11 

//you might not need every inclusion 
#include <iostream> 
#include <unistd.h> 
#include <string> 

#include <stdio.h> // standard input/output functions 
#include <string.h> // string function definitions 
#include <unistd.h> // UNIX standard function definitions 
#include <fcntl.h> // File control definitions 
#include <errno.h> // Error number definitions 
#include <termios.h> // POSIX terminal control definitionss 
#include <time.h> // time calls 

using namespace std; 

#define BAUDRATE B9600 


int main(int argc, char** argv) 
{ 

    int fileDescriptor = open("/dev/ttyACM0", O_RDWR | O_NOCTTY); 

    struct termios newtio; 
    bzero(&newtio, sizeof(newtio)); 
    newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD; 

    // set to 8N1 
    newtio.c_cflag &= ~PARENB; 
    newtio.c_cflag &= ~CSTOPB; 
    newtio.c_cflag &= ~CSIZE; 
    newtio.c_cflag |= CS8; 

    newtio.c_iflag = IGNPAR; 

    // output mode to 
    //newtio.c_oflag = 0; 
    newtio.c_oflag |= OPOST; 

    /* set input mode (non-canonical, no echo,...) */ 
    newtio.c_lflag = 0; 

    newtio.c_cc[VTIME] = 10; /* inter-character timer 1 sec */ 
    newtio.c_cc[VMIN] = 0; /* blocking read disabled */ 

    tcflush(fileDescriptor, TCIFLUSH); 
    if (tcsetattr(fileDescriptor, TCSANOW, &newtio)) { 
     perror("could not set the serial settings!"); 
     return -99; 
    } 

    int i = 0; 
    string test = ">123,456,7890;"; 

    while(i < 10) { 

     usleep(100000); 

     string res = test + std::to_string(i) + "\n"; 
     long wrote = write(fileDescriptor, res.c_str(), sizeof(char)*res.size()); 

     cout << res << endl; 


     i++; 
    } 


    cout << "ready" << endl; 

    return 0; 
}