嵌入式通信协议制作demo 服务端和客户端代码 同时支持大小端模式

最新推荐文章于 2023-07-24 09:46:41 发布
最新推荐文章于 2023-07-24 09:46:41 发布
阅读量214 收藏
点赞数
文章标签： c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44857505/article/details/126954778
版权

服务端

data_frame结构体是我们的通信协议

#include <stdint.h>
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "log.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include<errno.h>
#include <sys/types.h>
#include <signal.h>

#define    CMD_HEAD_FRAME                            0x6666bbbb
#define    CMD_TAIL_FRAME                            0x8888dddd

typedef uint64_t u64;
typedef uint32_t  u32;
typedef uint16_t u16;
typedef uint8_t  u8;

typedef struct {
        u32 head;
        u16 cmd;
        u32 len;
        u8 *data;
        u16 crc;
        u32 tail;
}data_frame;


// Switch the byte order of the data
u16 byte_order_switch16(u16 data)
{
        u16 temp = 0;
        temp = (data & 0xff) << 8;
        temp |= (data & 0xff00) >> 8;
        return temp;
}

u32 byte_order_switch32(u32 data)
{
        u32 temp = 0;
        temp = (data & 0xff) << 24;
        temp |= (data & 0xff00) << 8;
        temp |= (data & 0xff0000) >> 8;
        temp |= (data & 0xff000000) >> 24;
        return temp;
}

u64 byte_order_switch64(u64 data)
{
        u64 temp = 0;
        temp = (data & 0xff) << 56;
        temp |= (data & 0xff00) << 40;
        temp |= (data & 0xff0000) << 24;
        temp |= (data & 0xff000000) << 8;
        temp |= (data & 0xff00000000) >> 8;
        temp |= (data & 0xff0000000000) >> 24;
        temp |= (data & 0xff000000000000) >> 40;
        temp |= (data & 0xff00000000000000) >> 56;
        return temp;
}

u8 *data_frame_to_buf_big(data_frame *frame,int *data_len)
{
        u8 *buf = NULL;
        u8 *p = NULL;
        u16 crc = 0;
        u32 len = 0;
        u32 i = 0;

        if (frame == NULL) {
                return NULL;
        }

        len = frame->len + 16;
        buf = (u8 *)malloc(len);
        if (buf == NULL) {
                return NULL;
        }

        p = buf;
        *(u32 *)p = byte_order_switch32(frame->head);
        p += 4;
        *(u16 *)p = byte_order_switch16(frame->cmd);
        p += 2;
        *(u32 *)p = byte_order_switch32(frame->len);
        p += 4;
        memcpy(p, frame->data, frame->len);
        p += frame->len;
        *(u16 *)p = byte_order_switch16(frame->crc);
        p += 2;
        *(u32 *)p = byte_order_switch32(frame->tail);

        *data_len = len;

        return buf;
}

u8 *data_frame_to_buf_little(data_frame *frame,int *data_len)
{
        u8 *buf = NULL;
        u8 *p = NULL;
        u16 crc = 0;
        u32 len = 0;
        u32 i = 0;

        if (frame == NULL) {
                return NULL;
        }

        len = frame->len + 16;
        buf = (u8 *)malloc(len);
        if (buf == NULL) {
                return NULL;
        }

        p = buf;
        *(u32 *)p = frame->head;
        p += 4;
        *(u16 *)p = frame->cmd;
        p += 2;
        *(u32 *)p = frame->len;
        p += 4;
        memcpy(p, frame->data, frame->len);
        p += frame->len;
        *(u16 *)p = frame->crc;
        p += 2;
        *(u32 *)p = frame->tail;

        *data_len = len;

        return buf;
}

// 构造帧
data_frame *create_frame(u16 cmd, u8 *data, u32 len)
{
        data_frame *frame = NULL;
        u8 *buf = NULL;
        u16 crc = 0;
        u32 i = 0;

        if (data == NULL) {
                return NULL;
        }

        frame = (data_frame *)malloc(sizeof(data_frame));
        if (frame == NULL) {
                return NULL;
        }

        frame->head = CMD_HEAD_FRAME;
        frame->cmd = cmd;
        frame->len = len;
        frame->data = (u8 *)malloc(len);
        if (frame->data == NULL) {
                free(frame);
                return NULL;
        }
        memcpy(frame->data, data, len);
        frame->crc = crc;
        frame->tail = CMD_TAIL_FRAME;

        return frame;
}


void free_data_frame(data_frame *frame)
{
        if (frame == NULL) {
                return;
        }

        if (frame->data != NULL) {
                free(frame->data);
                frame->data = NULL;
        }

        free(frame);
        frame = NULL;
}

// create tcp socket server
int create_tcp_server(int port)
{
        int listenfd;
        struct sockaddr_in servaddr;

        listenfd = socket(AF_INET, SOCK_STREAM, 0);
        if (listenfd == -1) {
                log_error("create socket error: %s(errno: %d)", strerror(errno), errno);
                return -1;
        }

        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(port);

        int opt = 1;
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

        if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
                log_error("bind socket error: %s(errno: %d)", strerror(errno), errno);
                return -1;
        }
        // 复用地址和端口
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
        setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

       

        if (listen(listenfd, 10) == -1) {
                log_error("listen socket error: %s(errno: %d)", strerror(errno), errno);
                return -1;
        }

        log_info("======waiting for client's request======");
        return listenfd;
}


// 接受ctrl+c信号 退出 
void sigint_handler(int sig)
{
        log_info("catch signal %d", sig);
        exit(0);
}


int main(){
    // 注册ctrl+c信号
    signal(SIGINT, sigint_handler);


    static u8 data_send[100] = {0};
    static u8 *data_frame_buf = NULL;
    static u8 *data = "1234567890";
    log_info("data len = %d", strlen(data));
    u8 len = strlen(data) + 1;
    u32 total_len = 0;
    data_frame *frame = NULL;
    frame = create_frame(0x1234, data, len);
    data_frame_buf = data_frame_to_buf_little(frame, &total_len);

  
    for(int i = 0;i < total_len;i++){
        printf("%02x ",data_frame_buf[i]);
    }
      
    int listenfd = create_tcp_server(6666);
    if (listenfd == -1) {
        log_error("create tcp server error");
        return -1;
    }
    // 复用地址和端口
   

    // accept client
    int connfd;
    struct sockaddr_in cliaddr;
    socklen_t clilen = sizeof(cliaddr);
    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
    if (connfd == -1) {
        log_error("accept socket error: %s(errno: %d)", strerror(errno), errno);
        return -1;
    }
    log_info("accept client: %s:%d", inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);

    // send data
    while(1){

        int send_len = send(connfd, data_frame_buf, total_len, 0);
        if (send_len == -1) {
            log_error("send data error: %s(errno: %d)", strerror(errno), errno);
            return -1;
        }
        for(int i = 0; i < total_len; i++){
            printf("%02x ", data_frame_buf[i]);
        }
        fflush(stdout);
        sleep(5);
    }
    free_data_frame(data_frame_buf);
 
}

客户端

#include <stdint.h>
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "log.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include<errno.h>

#define    CMD_HEAD_FRAME                            0x6666bbbb
#define    CMD_TAIL_FRAME                            0x8888dddd

typedef uint64_t u64;
typedef uint32_t  u32;
typedef uint16_t u16;
typedef uint8_t  u8;

typedef struct {
        u32 head;
        u16 cmd;
        u32 len;
        u8 *data;
        u16 crc;
        u32 tail;
}data_frame;


// create tcp socket client
int create_tcp_client(char *ip, int port)
{
        int sockfd;
        struct sockaddr_in servaddr;

        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
                log_error("create socket error: %s(errno: %d)", strerror(errno), errno);
                return -1;
        }

        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(port);
        if (inet_pton(AF_INET, ip, &servaddr.sin_addr) <= 0) {
                log_error("inet_pton error for %s", ip);
                return -1;
        }

        if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
                log_error("connect error: %s(errno: %d)", strerror(errno), errno);
                return -1;
        }
        return sockfd;
}

// 根据data_frame结构体解析协议 接受的数据是大端的 按照大端的方式解析
int parse_data_frame_big(data_frame *frame, u8 *data, int len)
{
        int i = 0;
        u8 *p = data;
        u16 crc = 0;
        u32 head = 0;
        u32 tail = 0;
        u16 cmd = 0;
        u32 data_len = 0;
        u8 *data_buf = NULL;

        // if (len < 12) {
        //         log_error("data len error");
        //         return -1;
        // }
        // 0x6666bbbb 如果是大端的话 0x66在前面 0xbb在后面

        head = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
        if (head != CMD_HEAD_FRAME) {
                log_error("head error");
                return -1;
        }
        p += 4;

        cmd = (p[0] << 8) | p[1];
        p += 2;

        data_len = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
        p += 4;

        if (data_len > 0) {
                data_buf = (u8 *)malloc(data_len);
                if (data_buf == NULL) {
                        log_error("malloc error");
                        return -1;
                }
                memcpy(data_buf, p, data_len);
                p += data_len;
        }

        crc = (p[0] << 8) | p[1];
        p += 2;

        tail = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
        if (tail != CMD_TAIL_FRAME) {
                log_error("tail error");
                return -1;
        }

        frame->head = head;
        frame->cmd = cmd;
        frame->len = data_len;
        frame->data = data_buf;
        frame->crc = crc;
        frame->tail = tail;

        return 0;
}


// int parse_data_frame_small





// 根据data_frame解析协议
int parse_data_frame_little(data_frame *frame, u8 *data, u32 len)
{
        u32 i = 0;
        u32 head = 0;
        u32 tail = 0;
        u16 crc = 0;
        u32 data_len = 0;
        u8 *data_buf = NULL;

        // if (len < sizeof(data_frame)) {
        //         log_error("data len is too short");
        //         return -1;
        // }

        memcpy(&head, data, sizeof(u32));
        if (head != CMD_HEAD_FRAME) {
                log_error("head frame error");
                return -1;
        }

        memcpy(&frame->cmd, data + sizeof(u32), sizeof(u16));
        memcpy(&data_len, data + sizeof(u32) + sizeof(u16), sizeof(u32));
        if (data_len > 0) {
                data_buf = (u8 *)malloc(data_len);
                if (data_buf == NULL) {
                        log_error("malloc error");
                        return -1;
                }
                memcpy(data_buf, data + sizeof(u32) + sizeof(u16) + sizeof(u32), data_len);
                frame->data = data_buf;
        }
        memcpy(&crc, data + sizeof(u32) + sizeof(u16) + sizeof(u32) + data_len, sizeof(u16));
        memcpy(&tail, data + sizeof(u32) + sizeof(u16) + sizeof(u32) + data_len + sizeof(u16), sizeof(u32));
        if (tail != CMD_TAIL_FRAME) {
                log_error("tail frame error");
                return -1;
        }

        frame->head = head;
        frame->len = data_len;
        frame->crc = crc;
        frame->tail = tail;

        return 0;
}

int main(){
    // connect port 6666
    int sockfd = create_tcp_client("127.0.0.1", 6666);
    if (sockfd < 0) {
        log_error("create tcp client error");
        return -1;
    }
    log_info("create tcp client success");
    // receive data
    u8 recvline[4096];
    data_frame rev_frame;
    memset(&rev_frame, 0, sizeof(data_frame));
    while (1) {
        int n = recv(sockfd, recvline, 4096, 0);
        if (n < 0) {
            log_error("recv error: %s(errno: %d)", strerror(errno), errno);
            return -1;
        }
        recvline[n] = '\0';
        for (int i = 0; i < n; i++) {
            printf("%02x ", recvline[i]);
        }
        parse_data_frame_little(&rev_frame, recvline, n);
        log_info("cmd: %0x, len: %0x, crc: %0x ,head: %0x, tail: %0x", rev_frame.cmd, rev_frame.len, rev_frame.crc, rev_frame.head, rev_frame.tail);
        if (rev_frame.data != NULL) {
            log_info("data: %s", rev_frame.data);
        }

        printf("\r\n");
    }
}
db db
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
解决大小端与自定义协议不兼容问题
quanquanxiaobu的博客
05-26 380
通过高低位交换来解决大小端存储模式与自定义协议高低字节要求 不匹配的问题。搜集到四五种解决方案。
MQTT C# demo测试案例 包含服务端客户端
06-08
在这个MQTT C# demo测试案例中，我们将探讨如何使用C#来实现MQTT协议的服务器端（Broker）和客户端（Client）。 首先，我们需要了解MQTT协议的基本概念。MQTT基于发布/订阅模式，其中消息发布者将数据发送到特定...
linux C语言实现一个嵌入式测试框架，用来测试嵌入式设备的功能
最新发布
yll7702的博客
07-24 306
【代码】linux C语言实现一个嵌入式测试框架，用来测试嵌入式设备的功能。
分享一个嵌入式中Makefile的通用Demo
weixin_46582567的博客
10-05 577
国庆在家事情比较少，之前因为稍微学了点Makefile的基本语法，所以就想着自己写个Makefile，一来以后自己作参考，二来也是可以复习下之前的一些命令，三来就是分享啦~，哈哈。
2021-09-13嵌入式学习笔记--基于C++的环形缓冲区demo
jeason的博客
09-16 436
最近学习了韦东山老师的RTOS训练营相关的知识后想自己实现一下环形缓冲区，具体的实现如下： 注意： 缓冲区的大小要比实际的小一个！ 我也是查了半天才知道的！ 代码中对于未使用的空间写入了 -1 主要是方便查看，如果实际的应用中可以去掉 这一步 降低资源开销 // circleBuffer.h #ifndef _CIRCLE_BUFFER_H_ #define _CIRCLE_BUFFER_H_ #include <stdio.h> #include <cstdio> #in
嵌入式Linux（二）:Socket 通信
weixin_45259896的博客
08-28 567
嵌入式Linux实现TCP或UDP通信是使用Socket编程来实现。本文主要记录实现TCP UDP的细节。上面的TCP,UDP实现是参考韦东山老师的视频里的代码的。
STM32单片机作TCP服务器，实现PC多客户端连接Demo
10-12
STM32单片机作为TCP服务器的实现是一个高级嵌入式编程的应用，它涉及网络通信、并发处理和硬件资源管理等多个方面。在这个项目中，STM32F750开发板被用来创建一个能同时处理多个PC客户端连接的TCP服务器。下面我们将...
stm32-iap-ymodem-client-c#_c#iap升级demo_IAP_iap客户端_Ymodem_
10-03
4. 在STM32端编写IAP服务端代码，处理来自C#客户端的命令和数据。 5. 测试整个升级流程，确保在各种情况下都能成功更新固件。 通过以上步骤，我们可以构建一个完整的STM32 IAP升级系统，利用C#和Ymodem协议实现固件...
C#串口通讯和socket通讯demo
10-20
在"**CSharpPort**"压缩包中，可能有一个`SocketDemo`项目或类，它展示了如何使用`Socket`进行客户端和服务端的通信。 在`SocketDemo`中，你可能会看到以下关键步骤： 1. 创建Socket对象，指定其协议类型（TCP或UDP...
c_qq_demo:网上的C写的仿QQ聊天软件（linux服务端，windows客户端）
03-22
3. **多平台支持**：Linux服务端和Windows客户端的实现意味着代码必须具有跨平台兼容性。这通常通过使用像Posix API或mingw等工具集来实现。 4. **服务器架构**：服务端可能采用并发处理模型，比如多线程、多进程...
嵌入式输入法demo
09-12
在嵌入式arm上运行的一个双拼输入法demo,能在qt4.8上编译运行，不能联想
嵌入式/单片机开发示例程序
10-21
嵌入式/单片机开发示例程序，包括从最基础的led,键盘，到nand flash等相对深度的程序。
littlevgl在嵌入式linux开发demo
09-09
littlevgl在嵌入式linux设备中工程例子，可以查看博主文章说明开发https://blog.csdn.net/u012478275/article/details/120182113
嵌入测试工具--demo编写
hyb648115428的博客
10-08 462
嵌入测试工具--demo编写： http://e.vhall.com/home/vhallapi/embed 背景：此前的嵌入测试，存在缺少demo，直接测试嵌入地址，与客户使用场景不符，导致测试不全的情况。 价值：借助参考嵌入指南写的demo进行嵌入页的功能和兼容性测试。 操作说明： 以下嵌入测试demo，部署在测试环境，地址如下，后面的url为你想嵌入的任意地址 h...
Linux设备驱动程序学习（1）
临时工 Temporary's Space
01-14 1474
今天进入《Linux设备驱动程序（第3版）》第三章字符设备驱动程序的学习。这一章主要通过介绍字符设备scull（Simple Character Utility for Loading Localities，区域装载的简单字符工具）的驱动程序编写，来学习Linux设备驱动的基本知识。scull可以为真正的设备驱动程序提供样板。一、主设备号和此设备号主设备号表示设备对应的驱动程序；次设备号由内核使用
QT开发多功能嵌入式DEMO-MQTT
Lee1989
03-26 1135
环境 Qt5.11.1、MinGW32 下载mqtt官网源码准备 官方地址：https://codereview.qtproject.org/admin/repos/qt%2Fqtmqtt 步骤参考: https://blog.csdn.net/qq21497936/article/details/91463870?ops_request_misc=&request_id=&biz_id=102&utm_term=qtmqtt&utm_medium=distribute.
https 嵌入式客户端demo
書
04-24 1630
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEBUG 1 /**
嵌入式 Jetty 9.0+ 测试demo
z69183787的专栏
11-01 2207
pom： org.eclipse.jetty jetty-server 9.0.0.v20130308 org.eclipse.jetty jetty-webapp 9.0.0.v201303
【嵌入式】分享一个嵌入式中Makefile的通用Demo
Nonoas的博客
10-25 388
1.前言之前因为稍微学了点Makefile的基本语法，所以就想着自己写个Makefile，一来以后自己作参考，二来也是可以复习下之前的一些命令，三来就是分享啦~2.基本功能键入make:*自动生成elf、lst、hex、bin、o文件；*判断当前目录下是否有输出文件output、二进制文件obj的文件夹，若无，则新建，有则不执行；*将输出文件和目标文件自动移动值对应文件夹；键入make DEBUG...
智能嵌入式实训系统通信协议详解V4.2
"该文档是关于2019年智能嵌入式实训系统的通信协议V4.2，主要涉及如何使用nRF24L01芯片实现在单片机之间的数据传输，以及各种设备如Arduino、STM32和zigbee模块的通信。此协议详细描述了各种数据结构，包括平板电脑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值