Sending command and waiting for reply to a USB device - c++

Question

I have a device (rotary measuring table) connected over USB to /dev/ttyACM0, and need to write a simple cpp controller to send the commands to the device and listen for response.
I have no experience with this kind of stuff. I understand I can open the USB device using fstream and send the command using write(). That works.
Question is how can I send the command and start listening for response?
The code below just hangs. I am guessing because it is synchronous and therefore the response is missed.
#include <iostream>
#include <fstream>
#include <string>
int main()
{
std::fstream f;
char command[256] = "?ASTAT\n\r";
char response[256];
std::string str;
f.open("/dev/ttyACM0");
if (f.is_open())
{
std::cout << "Port opened" << std::endl;
}
f.write(command, 256);
while(1)
{
while (f >> str)
{
std::cout << str;
}
}
return 0;
}
I have looked into asynchronious libusb-1.0 but have a problem finding my way around http://libusb.sourceforge.net/api-1.0/group__libusb__asyncio.html and figuring out where to start from.
EDIT:
I managed to get the device to respond as follows:
std::string response_value = "";
char response = 0;
std::cout << "response: ";
while(1)
{
f << command;
f.read(&response, 1);
if ((int)response == 13)
{
break;
}
std::cout << (response) << " ";
response_value += response;
}
After talking to the producer and trying out different commands and outputting the message, I figured out that the device should send variable length response which always ends with 0x0D or integer 13.
Currently if I send multiple commands after each other, nothing happens.
From other sources I understand I need to set the baud rate, however, fstream has no file descriptor, and `tcgetattr(2)1 reauires file descriptor to initialize the termios structure. Is there a way to retrieve it?

Answer 1

To answer the question the best I can. It is possible to read/write to usb device as a file because the os has drivers which are handling the communication (please correct me if I understood it wrong).
fstream is capable of reading and writing, however it is not possible to adjust the baud rate (frequency at which the device is communication) because the adjustment mus be done on terminal level and is therefore os dependent. For Linux, we must use fctl.h, termios.h and unistd.h. It allows us to set the rate, as well as a timeout in case there is no response from the device.
Therefore, implementing the reading and writing only using cpp functions is quite a bit more complex.
I am posting here my solution which works for me, but any comments on it are welcome.
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <string>
#include <iostream>
bool init_terminal_interface(struct termios& tty, const int file_descriptor)
{
memset(&tty, 0, sizeof tty); // Init the structure;
if (tcgetattr(file_descriptor, &tty) != 0)
{
std::cout << "Error" << errno << " from tcgetattr: " << strerror(errno) << std::endl;
return false;
}
/* Set Baud Rate */
cfsetospeed (&tty, (speed_t)B9600);
cfsetispeed (&tty, (speed_t)B9600);
/* Setting other Port Stuff */
tty.c_cflag &= ~PARENB; // Make 8n1
tty.c_cflag &= ~CSTOPB;
tty.c_cflag &= ~CSIZE;
tty.c_cflag &= ~ICANON;
tty.c_cflag |= CS8;
tty.c_cflag &= ~CRTSCTS; // no flow control
tty.c_cc[VMIN] = 0; //
tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout
tty.c_cflag |= CREAD | CLOCAL; // turn on READ & ignore ctrl lines
/* Flush Port, then applies attributes */
tcflush(file_descriptor, TCIFLUSH);
if (tcsetattr(file_descriptor, TCSANOW, &tty) != 0) {
std::cout << "Error " << " from tcsetattr: " << strerror(errno) << std::endl;
return false;
}
return true;
}
void send_command(std::string command, const int file_descriptor)
{
write(file_descriptor, command.c_str(), command.size());
std::cout << "Command sent: " << command << std::endl;
}
std::string check_response(int file_descriptor)
{
std::string response_value = "";
char response = 0;
ssize_t n_read = 0;
do {
// In blocking mode, read() will return 0 after timeout.
n_read = read( file_descriptor, &response, 1 );
if (n_read > 0)
{
response_value += response;
}
} while( response != '\r' && (int)response != 13 && n_read != 0);
// In case of timeout it will return an empty string.
return response_value;
}
int open_serial(const std::string serial_path)
{
int file_descriptor = open(serial_path.c_str(), O_RDWR);
if (file_descriptor == -1)
{
std::cout << "Unable to access the turntable device." << std::endl;
return -1;
}
std::cout << "File opened: " << file_descriptor << std::endl;
struct termios tty;
init_terminal_interface(tty, file_descriptor);
return file_descriptor;
}
int main()
{
int file_descriptor = open_serial("/dev/ttyACM0");
if (file_descriptor == -1)
{
return 1;
}
// Good command.
std::string command = "?baudrate\r\n";
send_command(command, file_descriptor);
std::string response_value = check_response(file_descriptor);
std::cout << "Full response: " << response_value << std::endl;
// Wrong command.
command = "?asasdtat\r\n";
send_command(command, file_descriptor);
response_value = check_response(file_descriptor);
std::cout << "Full response: " << response_value << std::endl;
// Good command.
command = "init1\r\n";
send_command(command, file_descriptor);
response_value = check_response(file_descriptor);
std::cout << "Full response: " << response_value << std::endl;
// Good command.
command = "ref1=4\r\n";
send_command(command, file_descriptor);
response_value = check_response(file_descriptor);
std::cout << "Full response: " << response_value << std::endl;
return 0;
}