C++ libserial serial connection to Arduino - c++

Question

I'm trying to send data via serial connection (USB) from my PC (Ubuntu 14.04) to an Arduino Uno. The Arduino should display the received data for testing purposes. (I'm happy, if I receive anything...)
I use libserial to send the data but the Arduino receives nothing. With the help of the Arduino IDE I could send the data successfully to the Arduino. With normal console commands it is also possible to send the data.
Here is my Arduino 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);
// 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;
}
}
And this the c++ code (on the PC side):
//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;
}
Do you have any ideas why this doesn't work?
Thanks!

Answer 1

I found a solution, how to communicate with the Arduino via serial Port (USB). I don't use libserial.
I improved the Arduino code (display only, if there is a new line):
// 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;
}