STM32f407 网络接收 fpga 的 bin 文件并更新到 fpga series7(2)
简介
实验 2：在单片机搭建好 tcp 服务器后，编写传送文件的上位机。
整体实现
- 利用qt的tcpsocket简单封装
- 每次发送512字节，这样小的tcp包就不会自动分包。保证每一个512tcp包都有帧头。
- 每次发送完，等待服务器返回一个包，用来判断是否正确写入fpga
代码
tcpclient.h
#ifndef TCPCLIENT_H
#define TCPCLIENT_H
#include <QObject>
#include <QString>
#include <QTcpSocket>
#include <QHostAddress>
class TcpClient : public QObject {
Q_OBJECT
public:
explicit TcpClient(QObject *parent = nullptr);
Q_INVOKABLE bool connect_server(QString ip, int port);
Q_INVOKABLE void close_client();
Q_INVOKABLE bool send_buffer(char *buf, size_t len);
Q_INVOKABLE bool recv_buffer(char *pdata, uint32_t len);
private:
QTcpSocket *socket_;
};
#endif // TCPCLIENT_H
tcpclient.c
#include "tcpclient.h"
#include <QAbstractSocket>
TcpClient::TcpClient(QObject *parent) {
socket_ = new QTcpSocket(this);
}
/// @brief 连接服务器
/// @param ip
/// @param port
/// @return 成功返回true，超时返回false
bool TcpClient::connect_server(QString ip, int port) {
socket_->connectToHost(QHostAddress(ip), port);
if (socket_->waitForConnected(3000)) {
return true;
} else {
return false;
}
}
void TcpClient::close_client() { socket_->close(); }
/// @brief 发送buffer
/// @param buf
/// @param len
/// @return 成功返回true，超时返回false
bool TcpClient::send_buffer(char *buf, size_t len) {
socket_->write(buf, len);
if (socket_->waitForBytesWritten(3000)) {
return true;
} else {
return false;
}
socket_->flush();
}
/// @brief 接收buffer
/// @param pdata
/// @param len
/// @return 成功返回true，超时返回false
bool TcpClient::recv_buffer(char *pdata, uint32_t len) {
if(!socket_->waitForReadyRead(10000)){
return false;
}
socket_->read(pdata, len);
return true;
}
main.c
// 文件: main.cpp
// 时间: 2024-08-21
// 来自: ccj
// 描述: 把fpga程序发送给STM32服务器
// 1. 自定义帧结构 512字节，其中24字节帧头。剩下都是数据
// 2. 发送一个512字节的帧，要接收一个24字节的帧，里面有判断是否写入fpga成功。
// 3. 整体流程
// 3.1 发送24字节的开始命令帧
// 3.2 发送512字节的数据帧
// 3.1 发送24字节的结束命令帧
#include <stdint.h>
#include <time.h>
#include <thread>
#include <QFile>
#include <QString>
#include <QFileInfo>
#include "tcpclient.h"
#define qdebug() qDebug() << "[" << __FILE__ << ":" << __LINE__ << "]"
// 帧信息
#define kbuffer_len 512
#define kheader_size 24
#define kdata_len (kbuffer_len - kheader_size)
#define kmagic 0xaa5555aa
#define kmagic1 0x55aaaa55
// 发送帧头type字段定义
#define ksend_type_start 0xa
#define ksend_type_write 0xb
#define ksend_type_end 0xc
// 接收帧头offset定义
#define krecv_offset_success 0
#define krecv_offset_failed 1
/// @brief 帧头
struct tcp_package_header {
uint32_t magic;
uint32_t type;
uint32_t data_offset;
uint32_t data_len;
uint32_t order;
uint32_t magic1;
};
// 发送和接收缓冲区
char send_buffer[kbuffer_len];
char recv_buffer[kheader_size];
struct tcp_package_header *send_header = (struct tcp_package_header *)send_buffer;
struct tcp_package_header *recv_header = (struct tcp_package_header *)recv_buffer;
char *pdata = send_buffer + kheader_size;
// 接收校验
// 发送一个tcp包，就接收一个tcp包做校验
#define recv_verify() \
do { \
ret = client.recv_buffer(recv_buffer, kheader_size); \
if (!ret) { \
qdebug() << "recv buffer failed."; \
return 1; \
} \
switch (recv_header->data_offset) { \
case krecv_offset_success: break; \
case krecv_offset_failed: qdebug() << "write to fpga failed."; return 1; \
default: break; \
} \
} while (0)
int main(int argc, char *argv[]) {
// 0 读取命令行参数
if (argc != 4) {
qdebug() << "Usage: tcpclient {ip} {port} {file_full_path}";
return 1;
}
QString server_ip = QString::fromLocal8Bit(argv[1]);
int server_port = std::stoi(argv[2]);
QString file_full_path = QString::fromLocal8Bit(argv[3]);
// QString server_ip = "192.168.11.33";
// int server_port = 7;
// QString file_full_path = "qf_pciefmc_top.bin";
// 1 判断参数是否有效
// 1.1 判断是否可以连接服务器
TcpClient client;
bool ret = client.connect_server(server_ip, server_port);
if (!ret) {
qdebug() << "connect server failed.";
return 1;
}
// 1.2 判断文件是否存在
QFile file(file_full_path);
if (!file.open(QIODevice::ReadOnly)) {
qdebug() << "Cannot open file for reading:" << file.errorString();
return 1;
}
clock_t start, end;
start = clock();
// 2 发送文件到服务器
// 2.1 发送开始帧
std::memset(send_header, 0, sizeof(struct tcp_package_header));
send_header->magic = kmagic;
send_header->data_offset = kheader_size;
send_header->magic1 = kmagic1;
send_header->type = ksend_type_start;
ret = client.send_buffer(send_buffer, kheader_size);
if (!ret) {
qdebug() << "send buffer failed.";
return 1;
}
recv_verify();
// 2.2 循环文件发送每一个帧
QFileInfo fileinfo(file_full_path);
uint64_t total_file_size = fileinfo.size();
uint64_t total_read_size = 0;
uint64_t read_buf_size = 0;
int order = 1;
while (total_read_size < total_file_size) {
// 2.2.1 读取一个帧
read_buf_size = file.read(pdata, kdata_len);
if (read_buf_size == -1) {
qdebug() << "read file error." << file.errorString();
return 1;
}
// 2.2.2 发送帧
send_header->type = ksend_type_write;
send_header->data_len = read_buf_size;
send_header->order = order;
ret = client.send_buffer(send_buffer, kbuffer_len);
if (!ret) {
qdebug() << "send buffer failed.";
return 1;
}
recv_verify();
// 2.2.3 继续循环
total_read_size += read_buf_size;
order++;
// 打印发送进度
if (order % 5 == 0)
qdebug() << "total: " << total_file_size << ", send: " << total_read_size
<< ", process: " << (double)total_read_size / total_file_size * 100 << "%";
}
// 2.3 发送结束帧
send_header->type = ksend_type_end;
ret = client.send_buffer(send_buffer, kheader_size);
if (!ret) {
qdebug() << "send buffer failed.";
return 1;
}
recv_verify();
end = clock();
double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
qdebug() << "update success. cost time: " << cpu_time_used << "s.";
}
