我正在尝试编写一个非常简单的C ++应用程序来与Arduino进行通信。我想向Arduino发送一个它立即发回的角色。我从教程中获取的Arduino代码如下所示：
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);
}
我可以使用GNU屏幕轻松地与Arduino进行通信，因此我知道基本通信一切正常：
$ screen /dev/tty.usbmodem641 9600
我看到的（破碎的）C ++代码如下：
#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;
}
它编译得很好，但在运行时，Arduino上有一些指示灯闪烁，终端只挂在：
打开fstream
我哪里错了？
答案 0 :(得分：9)
有三点：
首先：您没有初始化Linux端的串行端口（TTY）。没有人知道它处于什么状态。
在您的计划中执行此操作，您必须使用tcgetattr(3)和tcsetattr(3)。您可以在此站点，Arduino站点或Google上使用这些关键字找到所需的参数。但只是为了快速测试我建议在你调用自己的命令之前发出这个命令：
stty -F /dev/tty.usbmodem641 sane raw pass8 -echo -hupcl clocal 9600
特别是丢失的clocal可能会阻止您打开TTY。
第二：当设备打开时，您应该稍等一会儿才发送任何内容。默认情况下，Arduino会在串行线路打开或关闭时重置。你必须考虑到这一点。
-hupcl部分将在大多数时间阻止此重置。但是至少需要一次复位，因为只有当TTY已经打开并且Arduino已经收到复位信号时才能设置-hupcl。因此-hupcl将“仅”阻止将来重置。
第三：您的代码中存在 NO 错误处理。请在TTY上的每个IO操作之后添加代码以检查错误，并且 - 最重要的部分 - 使用perror(3)或类似功能打印有用的错误消息。
答案 1 :(得分：2)
当您打开串口时，Arduino会重置。对于Arduino Uno，在复位和接地之间添加一个10μF电容可以防止这种情况发生。有关详细信息，请参阅this。请注意，每次需要重新编程芯片时都必须移除电容器。
您还必须正确配置串行端口，但首先需要解决硬件问题。
答案 2 :(得分：2)
我找到了一个很好的例子，Jeff Gray如何使用boost::asio创建一个简单的minicom类型客户端。原code listing can be found on the boost user group。这允许与原始帖子中提到的GNU Screen示例中的Arduino进行连接和通信。
代码示例（如下）需要与以下链接器标志链接
-lboost_system-mt -lboost_thread-mt
...但是经过一些调整后，一些对boost的依赖可以用新的C ++ 11标准功能取代。当我开始讨论时，我会发布修订版本。目前，这是一个可靠的基础。
/* 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;
}
答案 3 :(得分：0)
您应该检查您是否有权访问/dev/tty.usbmodem641。 Linux中通常的方法是使用adduser将用户添加到适当的组。
顺便说一句，我知道要访问串口，需要打开/dev/ttyS0（对于COM1），直到/dev/ttyS3。请参阅示例this example in C。