网站导航
> 文章列表 > 嵌入式Linux应用程序开发-TCP-IP网络通信应用程序

嵌入式Linux应用程序开发-TCP-IP网络通信应用程序

网友: 文章列表 2024-03-21 21:11:50

嵌入式Linux应用程序开发-TCP-IP网络通信应用程序

作为全世界最优秀的开源操作系统，Linux内部已经集成了强大的网络协议栈，并向应用层提供丰富的系统调用，开发者可以基于通用的系统调用接口，使用Linux内核提供的网络功能。
如果要分析Linux内部的网络通信机制以及实现原理，相信不是一时半刻或片文只字能描述清楚，一般的应用开发者可以通过网上搜索资料去了解一下，但在初学阶段，不建议去深入研究。
因此，本章节只是站在应用开发的角度，描述如何开发嵌入式QT的网络应用程序。
        TCP/IP协议模型（Transmission Control Protocol/Internet Protocol），包含了一系列构成互联网基础的网络协议，是Internet的核心协议。
它是一种面向连接的、可靠的、基于字节流的传输协议。关于TCP/IP协议的具体实现原理，本文不进行描述（关于TCP/IP的实现原理描述，其复杂度已经可以用一本书来具体阐述了）。
本文着重描述在嵌入式QT环境下，如何使用TCP/IP进行数据通信。
对于TCP/IP的客户端（TCP-Client）角色，在进行数据通信之前，一般会经历以下过程：
（1）调用socket套接字函数，创建套接字的文件描述符。
（2）配置连接参数（需要连接的服务器IP，端口，连接协议，等等）。
（3）基于套接字的文件描述符，调用connect函数，连接指定的服务器。
（4）处理connect过程中可能出现的情况。（如连接成功，连接出错，找不到服务器等）
（5）connect成功后，调用数据发送接口，进行数据发送。
（6）调用数据接收接口，并处理接收到的网络数据。（Linux C语言开发，可以阻塞接收或使用select/poll机制接收。QT开发，可以使用信号槽机制进行接收。）
        使用嵌入式QT进行TCP/IP的网络通信应用程序开发，对于TCP客户端，只需要关注QT提供的QTcpSocket类，这个类继承于QAbstractSocket类，在QAbstractSocket类里面提供了一系列的网络操作接口函数，
如：连接服务器connectToHost()、断开与服务器的连接disconnectFromHost()，等等。提供各种信号（connected()、disconnected()、stateChanged()）与槽函数，方便应用开发者调用。具体可以参阅 QtNetwork/qabstractsocket.h 文件的内容。

目标：使用QT提供的TCP/IP网络通信类，实现一个简单的TCP客户端（TCP-Client）
功能：
（1）开发板界面显示开发板的网络IP地址。
（2）可手动输入需要连接的服务器IP和端口。
（3）界面显示TCP客户端的连接状态。（连接成功，断开连接，连接出错）
（4）界面显示TCP客户端的收发数据，并提供清屏按钮。
（5）提供手动发送按钮和自动发送按钮。

创建一个tcp_client.h文件，编写一个TCP_Client类继承于QTcpSocket，TCP_Client类提供了一些客户端经常用的操作函数，如连接服务器，获取本机IP，处理连接状态，等等。类的具体实现如下图所示：

  1. #define TCP_CONNECTED        "CONNECTED"
  2. #define TCP_DISCONNECTED     "DISCONNECTED"
  3. #define TCP_CONNECT_ERROR    "CONNECT_ERROR"
  5. class TCP_Client : public QTcpSocket
  6. {
  7.     Q_OBJECT
  9. public:
  10.     TCP_Client(QObject* parent=0);
  11.     ~TCP_Client();
  13.     QString get_local_ipaddr(void);   //获取本机的IP地址
  14.     void connect_server(QString server_ip, int server_port);   //连接服务器函数
  15.     void disconnect_server(void);  //断开与服务器的连接
  17.     void tcp_client_send_data(QByteArray arr_data);    //客户端向服务器发送数据
  18.     void tcp_client_send_data(QString str_data);    //客户端向服务器发送数据
  20. public slots:
  21.     void slot_tcp_client_connected(void);  //客户端连接成功的槽函数
  22.     void slot_tcp_client_disconnected(void);  //客户端断开连接的槽函数
  23.     void slot_tcp_client_connect_error(QAbstractSocket::SocketError);   //客户端连接出错的槽函数
  24.     void slot_tcp_client_recv_data();   //客户端从服务器接收数据
  26. signals:
  27.     void signal_tcp_client_recv_data(QByteArray arr_data);  //发送此信号，通知widget类处理接收到的服务端数据
  28.     void signal_tcp_client_connect_state(QString state);   //发送此信号，通知widget类关于TCP-Client的连接状态
  30. private:
  32.     QTcpSocket *m_tcp_socket;  //QTcpSocket对象，用来进行网络操作
  33. };

复制代码

创建一个tcp_client.cpp文件，这个文件内包含了TCP_Client类里面的所有函数实现。有关tcp_client.cpp的具体内容，请参阅源码。

Qt应用程序启动时，跟C语言一样，都是以main函数作为入口。（当然了，真正的程序启动入口并不是main函数，这里忽略了main函数之前的一系列复杂过程，应用程序呈现给开发者的，一般都是以main函数作为入口）。
以下是Qt应用程序的main函数入口。

  1. int main(int argc, char *argv[])
  2. {
  3.     QApplication a(argc, argv);
  4.     Widget w;
  5.     w.show();
  7.     return a.exec();
  8. }

复制代码

这个main函数比较简单，里面定义了一个QApplication和Widget对象，通过Widget::show()函数显示窗体，然后执行QApplication::exec()函数把整个应用程序加入Qt的事件队列，不断循环。

在Qt的界面应用程序中，对于Widget类型的窗体，其ui都是通过QWidget类进行构建，在widget.cpp文件中，针对本工程，Widget类的构造函数如下图所示：

  1. Widget::Widget(QWidget *parent) :
  2.     QWidget(parent),
  3.     ui(new Ui::Widget)
  4. {
  5.     ui->setupUi(this);
  7.     ui->pushButton_connect->setCheckable(false);
  8.     ui->pushButton_auto_send_data->setCheckable(false);
  10.     ui->pushButton_send_data->setEnabled(false);         //手动发送数据按钮不可用
  11.     ui->pushButton_auto_send_data->setEnabled(false);    //自动发送数据按钮不可用
  13.     ui->lineEdit_server_ip->setEnabled(true);  //服务器IP可以被输入
  14.     ui->lineEdit_server_port->setEnabled(true); //服务器端口可以被输入
  16.     tcp_client = new TCP_Client();  //创建一个TCP_Client类对象
  18.     ui->label_local_ip_display->setText(tcp_client->get_local_ipaddr());   //显示本机的IP地址
  20.     //连接信号槽，用来处理TCP客户端的连接状态
  21.     connect(tcp_client,SIGNAL(signal_tcp_client_connect_state(QString)),this,SLOT(slot_tcp_client_connect_state(QString)));
  23.     //连接信号槽，用来处理TCP客户端接收到的数据
  24.     connect(tcp_client,SIGNAL(signal_tcp_client_recv_data(QByteArray)),this,SLOT(slot_tcp_client_recv_data(QByteArray)));
  26.     auto_send_timer = new QTimer();     //构建一个TCP自动发送数据的定时器
  27.     connect( auto_send_timer, SIGNAL(timeout()), this, SLOT(slot_auto_send_timer_handler()));  //关联定时器超时槽函数
  28. }

在Widget类的构造函数里面，先对ui里面的某些控件进行配置，比如：在连接按钮点击之前，手动和自动发送数据的按钮不可用，服务器IP和端口可被编辑。
然后创建一个TCP_Client类对象，TCP-Client的一系列操作，如连接服务器，收发数据等等，都是基于这个类对象进行。
程序开始运行的时候，在界面上显示本机的IP地址，并连接tcp-client对象提供的信号槽。最后，构建一个定时器对象用于数据的自动发送，定时器对象在构建时，并没有启动计时。

先在windows7上运行服务器端的程序，设置好监听的IP和端口。imx6ul板卡上的客户端应用程序启动后，设置好需要连接的服务器参数，点击 [CONNECT] 按钮，程序就会调用该按钮的槽函数void Widget::on_pushButton_connect_clicked()，函数的实现内容如下图所示：

  1. //点击此按钮，连接服务器
  2. void Widget::on_pushButton_connect_clicked()
  3. {
  4.     QString server_ip;
  5.     int server_port;
  6.     bool ok;
  8.     if(ui->pushButton_connect->isCheckable())      //客户端处于连接状态
  9.     {
  10.         tcp_client->disconnect_server();
  11.     }
  12.     else     //客户端处于断开状态
  13.     {
  14.         //检查服务器IP和服务器端口是否参数有效
  15.         if(ui->lineEdit_server_ip->text().isEmpty() || ui->lineEdit_server_port->text().isEmpty())
  16.         {
  17.             ui->label_connect_status->setText(QString("params error!"));
  18.             QMessageBox::information(this,"Server Params","Server Params Error!");
  19.             return;
  20.         }
  21.         else
  22.         {
  23.             server_ip = ui->lineEdit_server_ip->text();
  24.             server_port = ui->lineEdit_server_port->text().toInt(&ok,10);
  26.             tcp_client->connect_server(server_ip,server_port);   //根据指定的ip和端口，连接服务器
  27.         }
  28.     }
  29. }

点击按钮后，分两种情况，需要判断当前的客户端网络状态是连接还是断开。如果客户端处于连接状态，则点击按钮后，断开客户端与服务器的连接。
如果客户端处于断开状态，则点击按钮后，先检查输入的参数是否有效，如果参数有效，则启动客户端与服务器的连接。客户端与服务器的连接函数connect_server()，如下图所示：

  1. //连接服务器函数
  2. void TCP_Client::connect_server(QString server_ip,int server_port)
  3. {
  4.     if(m_tcp_socket)
  5.     {
  6.         m_tcp_socket->connectToHost(server_ip,server_port,QTcpSocket::ReadWrite); //尝试连接服务器
  8.         //建立信号槽，接收连接成功的信号
  9.         connect(m_tcp_socket,SIGNAL(connected()),this,SLOT(slot_tcp_client_connected()));
  10.         //建立信号槽，接收连接失败的信号
  11.         connect(m_tcp_socket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(slot_tcp_client_connect_error(QAbstractSocket::SocketError)));
  13.     }
  14. }
  16. //断开与服务器的连接
  17. void TCP_Client::disconnect_server(void)
  18. {
  19.     if(m_tcp_socket)
  20.         m_tcp_socket->disconnectFromHost();   //断开与服务器的连接
  21. }

客户端与服务器连接过程中，由于在TCP-Client类里面绑定了连接状态的信号槽，因此，连接状态改变后，系统会发送相应的信号，然后调用对应的槽函数进行处理。
因为需要把连接状态显示在界面上，因此，需要在Widget类中，编写一个处理连接状态的槽函数，这个槽函数处理了CONNECTED，DISCONNECTED和CONNECT_ERROR这三种状态。如下图所示：

  1. //客户端连接状态的信号槽
  2. void Widget::slot_tcp_client_connect_state(QString state)
  3. {
  4.     if(state == TCP_CONNECTED)    //TCP客户端处于连接状态
  5.     {
  6.         ui->pushButton_connect->setCheckable(true);
  7.         ui->pushButton_connect->setText(trUtf8("DISCONNECT"));
  9.         //连接成功后，服务器的IP和端口不可以再被编辑
  10.         ui->lineEdit_server_ip->setEnabled(false);
  11.         ui->lineEdit_server_port->setEnabled(false);
  13.         //连接成功后，客户端的发送数据按钮和自动发送按钮可被使用
  14.         ui->pushButton_send_data->setEnabled(true);
  15.         ui->pushButton_auto_send_data->setEnabled(true);
  17.         ui->label_connect_status->setText("connect success");
  18.     }
  19.     else if(state == TCP_DISCONNECTED)   //TCP客户端处于断开状态
  20.     {
  21.         ui->pushButton_connect->setCheckable(false);
  22.         ui->pushButton_connect->setText(trUtf8("CONNECT"));
  24.         //连接断开后，服务器的IP和端口可以再被编辑
  25.         ui->lineEdit_server_ip->setEnabled(true);
  26.         ui->lineEdit_server_port->setEnabled(true);
  28.         //连接断开后，客户端的发送数据按钮和自动发送按钮不可被使用
  29.         ui->pushButton_send_data->setEnabled(false);
  30.         ui->pushButton_auto_send_data->setEnabled(false);
  32.         //自动发送定时器要关闭
  33.         ui->pushButton_auto_send_data->setCheckable(false);
  34.         ui->pushButton_auto_send_data->setText(trUtf8("START_AUTO_SEND"));
  36.         auto_send_timer->stop();
  38.         ui->label_connect_status->setText("disconnect success");
  40.     }
  41.     else if(state == TCP_CONNECT_ERROR)   //TCP客户端连接出错
  42.     {
  43.         ui->pushButton_connect->setCheckable(false);
  44.         ui->pushButton_connect->setText(trUtf8("CONNECT"));
  46.         ui->lineEdit_server_ip->setEnabled(true);
  47.         ui->lineEdit_server_port->setEnabled(true);
  49.         ui->pushButton_send_data->setEnabled(false);
  50.         ui->pushButton_auto_send_data->setEnabled(false);
  52.         ui->label_connect_status->setText("connect error");
  53.     }
  54. }

每点击一次手动发送按钮 [tcp_send_data]，客户端将会发送一包数据到服务端。点击自动发送按钮 [START_AUTO_SEND] 按钮，客户端将启动定时器，并以1秒的间隔向服务端发送数据。
手动发送函数和自动发送函数，如下图所示：

  1. //手动发送数据按钮
  2. void Widget::on_pushButton_send_data_clicked()
  3. {
  4.     tcp_client->tcp_client_send_data(QString("helloworld"));
  6.     display_tcp_client_tx_data(QString("helloworld"));
  7. }
  9. //自动发送数据按钮
  10. void Widget::on_pushButton_auto_send_data_clicked()
  11. {
  12.     if(ui->pushButton_auto_send_data->isCheckable())
  13.     {
  14.         ui->pushButton_auto_send_data->setCheckable(false);
  15.         ui->pushButton_auto_send_data->setText(trUtf8("START_AUTO_SEND"));
  17.         auto_send_timer->stop();   //关停定时器
  18.     }
  19.     else
  20.     {
  21.         ui->pushButton_auto_send_data->setCheckable(true);
  22.         ui->pushButton_auto_send_data->setText(trUtf8("STOP_AUTO_SEND"));
  24.         auto_send_timer->start(1000);   //启动定时器，以1秒的频率自动发送数据
  25.     }
  26. }

客户端的发送数据函数tcp_client_send_data(QString)，是直接调用了QIODevice::write()进行发送的。我们用面向对象多态的思维，编写两个发送函数，可以分别以QByteArry或QString类型的参数进行数据发送，如下图所示：

  1. //客户端向服务器发送数据，以QByteArray发送
  2. void TCP_Client::tcp_client_send_data(QByteArray arr_data)
  3. {
  4.     if(m_tcp_socket)
  5.         m_tcp_socket->write(arr_data);
  6. }
  8. //客户端向服务器发送数据，以QString格式发送
  9. void TCP_Client::tcp_client_send_data(QString str_data)
  10. {
  11.     if(m_tcp_socket)
  12.         m_tcp_socket->write(str_data.toLatin1().data(),str_data.length());
  13. }

客户端的接收数据函数，是通过信号槽机制来实现的，当Widget类对象接收到TCP-Client类发送的信号signal_tcp_client_recv_data(QByteArray)，就调用槽函数处理接收到的数据，如下图所示：

  2. //处理TCP客户端接收到的数据
  3. void Widget::slot_tcp_client_recv_data(QByteArray data_recv)
  4. {
  5.     QString str_display;
  7.     str_display.prepend(data_recv);
  9.     display_tcp_client_rx_data(str_display);   //显示TCP客户端接收到的数据
  10. }

在TCP-Client类对象中，客户端是通过槽函数slot_tcp_client_recv_data()进行网络数据接收的，这个槽函数绑定了QIODevice::readyRead()信号，
一旦底层的IO有网络数据接收，则会调用该槽函数处理，然后这个槽函数会把数据从底层驱动的缓冲区中把数据全部读出，再发送signal_tcp_client_recv_data(QByteArray)，通知Widget类进行处理。
在这里，可能大家会有一个疑惑，为什么不在这个槽函数直接处理数据呢？那是因为考虑到了软件的封装性。TCP-Client类只负责接收数据，然后再把接收到的数据通过信号槽传递出去，至于数据怎样处理，则应该在其他的数据handle类里面进行。
比如，这个客户端只进行数据显示，则可以在Widget类里面处理数据，只需要把Widget类里面的数据处理槽函数与TCP-Client类里面的信号绑定就行了。TCP-Client类里面的槽函数slot_tcp_client_recv_data()如下图所示：

  1. //客户端从服务器接收数据
  2. void TCP_Client::slot_tcp_client_recv_data()
  3. {
  4.     //qDebug() << ">>> void TCP_Client::slot_tcp_client_recv_data() >>>";
  5.     QByteArray arr_data_recv;
  7.     arr_data_recv.resize(m_tcp_socket->bytesAvailable());
  9.     arr_data_recv = m_tcp_socket->readAll();
  11.     emit signal_tcp_client_recv_data(arr_data_recv);
  12. }

至此，整个TCP-Client连接服务器以及数据收发过程已经描述完成。这个工程只是简单地描述了TCP-Client建立通信和数据收发的简单过程。在真正的TCP-Client网络应用程序中，还需要处理很多突发的网络情况。
如：连接过程中的错误处理，心跳包机制，服务端强行断开连接后客户端的处理，数据粘包与断包，数据接收队列，等等。开发者应在工程开发中不断积累经验，才能开发出稳定可靠的网络应用程序。

题外知识：
      很多初学者可能会对服务器和客户端没有什么概念，不知道怎样理解服务端/客户端这两个角色，个人觉得，要记住关键的一点：客户端是请求服务的，服务器是提供服务的。
举一个简单而通俗的例子：汽车去加油站加油。
把汽车比喻为TCP-Client客户端，把加油站的加油机比喻为TCP-Server服务器。当汽车（TCP-Client）需要向加油机（TCP-Server）请求加油服务时，
则需要先知道加油站在哪（服务器的IP地址），在哪台加油机（服务器端口）上加油，当指定好加油站和具体的加油机后，就可以向加油机请求连接（向汽车插上加油枪）了。
But，总会有特殊情况的时候，比如，当该加油机没有油而导致加不了油（连接不上）了，那么，加油机（服务器）就会通知请求加油的汽车（客户端）进行处理，（这里就涉及到连接不上的情况了）。
当汽车加完油之后，就像是服务端已经提供完服务，那么，汽车（客户端）就可以主动端开与加油机（服务端）的连接了。

网络标签：

相关问题