基于消息队列的C/S通信

最新推荐文章于 2023-08-05 10:42:17 发布
最新推荐文章于 2023-08-05 10:42:17 发布
阅读量665 收藏
点赞数
分类专栏： 嵌入式 vxworks 文章标签： 消息队列 通信 vxworks

程序示意图：



程序思路：

         分别写客户端和服务端的函数，在主任务中创建两个client和一个server，考虑到实际情况，应该server的优先级高并且先用taskSpawn函数创建server任务。然后等待客户端获得服务端的应答，则删除队列，程序结束。为了演示client请求，server应答的过程，本次实验采取client发送时发送一个value，在创建任务时给定，每次请求时value加一，服务端获得value之后将该值加一，并根据客户端的id，返回给相应的响应队列。Client函数中首先根据请求队列的大小发送数据，然后开始等待接收响应队列的返回结果。Server函数中等待请求队列不为空，获得请求并返回给对应的响应队列。


关键代码：

[cpp]  view plain copy
  1. main.h  
  2. #ifndef MAIN_H_INCLUDED  
  3. #define MAIN_H_INCLUDED  
  4. #include "vxWorks.h"  
  5. #include "semLib.h"  
  6. #include "taskLib.h"  
  7. #include "msgQLib.h"  
  8. #include "sysLib.h"  
  9. #include "stdio.h"  
  10. #define  CLIENT_TASK_PRI          99  
  11. #define  SERVER_TASK_PRI          98  
  12. #define  TASK_STACK_SIZE          5000  
  13. struct msg  
  14. {  
  15.     int id;  
  16.     int value;  
  17. };  
  18. LOCAL MSG_Q_ID requestQId;  
  19. LOCAL MSG_Q_ID response1QId;  
  20. LOCAL MSG_Q_ID response2QId;  
  21.   
  22. LOCAL BOOL notDone;  
  23. LOCAL int numMsg = 3;  
  24. LOCAL STATUS clientTask (int cid, int value);  
  25. LOCAL STATUS serverTask(void);  
  26. #endif // MAIN_H_INCLUDED  

[cpp]  view plain copy
  1. #include "main.h"  
  2. STATUS clientTask(int cid, int value)  
  3. {  
  4.     int i, j, k;  
  5.     struct msg request_msg, response_msg;  
  6.     printf ("clientTask started: cid = %d\n", cid);  
  7.     for(i=0; i<numMsg; i++)  
  8.     {  
  9.         request_msg.id = cid;  
  10.         request_msg.value = value+i;  
  11.        /* semTake(request_semMutex, WAIT_FOREVER);*/  
  12.         if (( msgQSend (requestQId, (char *) &request_msg, sizeof (request_msg),  
  13.                         WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)  
  14.         {  
  15.             perror ("Error in sending the message to request queue\n");  
  16.             return (ERROR);  
  17.         }  
  18.         else  
  19.         {  
  20.             printf ("clientTask: cid = %d, value = %d \n",  
  21.                     cid, value+i);  
  22.         }  
  23.         /*semGive(request_semMutex);*/  
  24.     }  
  25. /*接收数据从responseQ*/  
  26.     if(1 ==  cid)  
  27.     {  
  28.         for(j=0; j<numMsg; j++)  
  29.         {  
  30.            /* semTake(response1_semMutex, WAIT_FOREVER);*/  
  31.             if (( msgQReceive (response1QId, (char *) &response_msg,  
  32.                                sizeof (response_msg), WAIT_FOREVER)) == ERROR)  
  33.             {  
  34.                 perror ("Error in receiving the response1 message\n");  
  35.                 return (ERROR);  
  36.             }  
  37.             else  
  38.             {  
  39.                 printf ("clientTask: get msg of value %d from cid = %d\n",  
  40.                         response_msg.value, response_msg.id);  
  41.             }  
  42.         /*    semGive(response1_semMutex);*/  
  43.         }  
  44.   
  45.     }  
  46.     else if(2 == cid)  
  47.     {  
  48.         for(k=0; k<numMsg; k++)  
  49.         {  
  50.        /*     semTake(response2_semMutex, WAIT_FOREVER);*/  
  51.             if (( msgQReceive (response2QId, (char *) &response_msg,  
  52.                                sizeof (response_msg), WAIT_FOREVER)) == ERROR)  
  53.             {  
  54.                 perror ("Error in receiving the response2 message\n");  
  55.                 return (ERROR);  
  56.             }  
  57.             else  
  58.             {  
  59.                 printf ("clientTask: get msg of value %d from cid = %d\n",  
  60.                         response_msg.value, response_msg.id);  
  61.             }  
  62.          /*   semGive(response2_semMutex);*/  
  63.         }  
  64.   
  65.     }  
  66.     else  
  67.     {  
  68.         printf("clientTask: cid error!\n");  
  69.     }  
  70.     notDone = FALSE;  
  71.     return (OK);  
  72. }  
  73.   
  74. STATUS serverTask(void)  
  75. {  
  76.     int i;  
  77.     struct msg response_msg ;  
  78.     printf ("\nserverTask Started \n");  
  79.     for(i=0; i<numMsg*2; i++)  
  80.     {  
  81.     /*  semTake(request_semMutex, WAIT_FOREVER);*/  
  82.         if (( msgQReceive (requestQId, (char *) &response_msg,  
  83.                        sizeof (response_msg), WAIT_FOREVER)) == ERROR)  
  84.         {  
  85.             perror ("Error in receiving the message\n");  
  86.             return (ERROR);  
  87.         }  
  88.         else  
  89.         {  
  90.             printf ("serverTask: get msg of value %d from cid = %d\n",  
  91.                     response_msg.value, response_msg.id);  
  92.         }  
  93.         /*semGive(request_semMutex);*/  
  94.         /*将获得的value加一后，根据cid发给相应的应答序列*/  
  95.         response_msg.value += 1;  
  96.         if(response_msg.id==1)  
  97.         {  
  98.             /*semTake(response1_semMutex, WAIT_FOREVER);*/  
  99.             if (( msgQSend (response1QId, (char *) &response_msg, sizeof (response_msg),  
  100.                             WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)  
  101.             {  
  102.                 perror ("Error in sending the message to response1 queue\n");  
  103.                 return (ERROR);  
  104.             }  
  105.             else  
  106.             {  
  107.                 printf ("serverTask sending to response Q1: value = %d \n",  
  108.                         response_msg.value);  
  109.             }  
  110.             /*semGive(response1_semMutex);*/  
  111.         }  
  112.         else if(response_msg.id==2)  
  113.         {  
  114.             /*semTake(response2_semMutex, WAIT_FOREVER);*/  
  115.             if (( msgQSend (response2QId, (char *) &response_msg, sizeof (response_msg),  
  116.                             WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)  
  117.             {  
  118.                 perror ("Error in sending the message to response2 queue\n");  
  119.                 return (ERROR);  
  120.             }  
  121.             else  
  122.             {  
  123.                 printf ("serverTask sending to response Q2: value = %d \n",  
  124.                         response_msg.value);  
  125.             }  
  126.             /*semGive(response2_semMutex);*/  
  127.         }  
  128.         else  
  129.         {  
  130.             printf("error in response_msg, the id = %d\n", response_msg.id);  
  131.         }  
  132.     }      
  133.     return (OK);  
  134. }  
  135.   
  136. STATUS main()  
  137. {  
  138.     notDone = TRUE;  
  139.    /* request_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL); 
  140.     response1_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL); 
  141.     response2_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL);*/  
  142.     if ((requestQId = msgQCreate(numMsg*2, sizeof (struct msg), MSG_Q_FIFO)) == NULL)  
  143.     {  
  144.         perror ("Error in creating requestQ");  
  145.         return (ERROR);  
  146.     }  
  147.     if ((response1QId = msgQCreate(numMsg, sizeof (struct msg), MSG_Q_FIFO)) == NULL)  
  148.     {  
  149.         perror ("Error in creating response1Q");  
  150.         return (ERROR);  
  151.     }  
  152.     if ((response2QId = msgQCreate(numMsg, sizeof (struct msg), MSG_Q_FIFO)) == NULL)  
  153.     {  
  154.         perror ("Error in creating response2Q");  
  155.         return (ERROR);  
  156.     }  
  157.     if (taskSpawn (" tserverTask ", SERVER_TASK_PRI, 0, TASK_STACK_SIZE,  
  158.                    (FUNCPTR) serverTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)  
  159.     {  
  160.         perror ("serverTask: Error in spawning serverTask");  
  161.         return (ERROR);  
  162.     }  
  163.     if (taskSpawn (" tclientTask ", CLIENT_TASK_PRI, 0, TASK_STACK_SIZE,  
  164.                    (FUNCPTR) clientTask, 1, 10, 0, 0, 0, 0, 0, 0, 0, 0)  == ERROR)  
  165.     {  
  166.         perror ("clientTask: Error in spawning clientTask1");  
  167.         return (ERROR);  
  168.     }  
  169.     if (taskSpawn (" tclientTask ", CLIENT_TASK_PRI, 0, TASK_STACK_SIZE,  
  170.                    (FUNCPTR) clientTask, 2, 10, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)  
  171.     {  
  172.         perror ("clientTask: Error in spawning clientTask2");  
  173.         return (ERROR);  
  174.     }  
  175.       
  176.     while (notDone)  
  177.     {  
  178.         taskDelay (sysClkRateGet ());       
  179.     }  
  180.         if (msgQDelete(requestQId) == ERROR || msgQDelete(response1QId) == ERROR ||  
  181.            msgQDelete(response2QId) == ERROR)  
  182.         {  
  183.             perror ("Error in deleting msgQs");  
  184.             return (ERROR);  
  185.         }  
  186.     return (OK);  
  187. }  

实验结果：


    可以看出，首先进入了server任务，然后进入client任务，client发送给请求队列消息后，服务端立刻获得value值，因为server优先级高，所以打印发送信息也是在server阻塞后打印的，并且能够看出serverl立刻向相应的响应队列发送了消息，此时value的值比client发过来的值多一，符合程序的设计，后来也是如此。直到client1的请求都被响应了，client1从自己的响应队列中得到加一后的值，之后client2也同理。

下面是windview演示结果：

第一幅能看出t1即主任务创建了三个任务，然后切换到Server，但是server被阻塞，因为请求队列为空，又切换到client1，当client1有请求之后再切换到server给予响应，依次进行，client2也是如此。



下图是过了一段时间的截图，因为主程序一直在等待客户端接收到响应队列的消息，结束之后能从下图看出删除了请求队列和响应队列1，响应队列2，程序结束。


遇到问题：

1、  C语言的单行注释“//”不能使用，编译不能通过。

2、  刚开始使用二进制信号量控制队列只能有一个任务在发送或接受，造成死锁。发送之前将请求队列take，然后发送，由于server优先级高，此时还没有来得及释放信号量就切换到server任务，server接收请求队列获取不到信号量，造成一直等待的死锁局面。

3、  刚开始没有考虑实际情况，先创建了client1，client2，并且优先级设定为一致，而事实上应该先启动服务器在允许客户端请求，故更改顺序，先创建server任务。

4、用windview观察的时候要选择task state transition，刚开始使用默认的context switch观察不到想要的结果。之后观察成功，鼠标悬停就能看到相关的信息，非常方便。

竹立荷塘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言】消息队列
afleshfish的博客
08-16 4181
C-queue读取消息队列代码消息队列 写 代码 读取消息队列代码 #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <stdio.h> //int msgget(key_t key, int msgflg); //ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, //
c语言-消息队列
weixin_46158019的博客
10-17 857
一、消息队列的介绍消息队列的实现原理是将消息存储在一个队列中，生产者将消息放入队列的尾部，消费者从队列的头部取出消息进行处理。消息队列通常采用先进先出（FIFO）的方式进行消息的存储和处理。消息队列可以实现异步通信，提高系统的可靠性和可扩展性。具体实现上，消息队列通常由以下几个组件构成：消息队列：用于存储消息的队列。生产者：向消息队列中添加消息的组件。消费者：从消息队列中取出消息并进行处理...
C++ 实现一个消息队列
热门推荐
codeofcc的博客
10-29 1万+
消息队列在多线程的场景有时会用到，尤其是线程通信跨线程调用的时候，就可以使用消息队列进行通信。C++实现一个能用的消息队列还是比较简单的，只需要一个队列一个互斥变量和一个条件变量，这些在标准库中都有提供。基于曾经写过的项目，总结出来最简单的消息队列的实现将在下文中介绍。
linux打印调用栈 函数名_C语言编程： 函数调用中堆栈的个人理解
weixin_39881155的博客
11-21 229
接下来将通过下面几个问题解析函数调用中对堆栈理解：（1）函数调用过程中堆栈在内存中存放的结构如何？（2）汇编语言中call，ret，leave等具体操作时如何？（3）linux中任务的堆栈，数据存放是如何？1. 函数调用过程中堆栈在内存中存放的结构如何？计算机，嵌入式设备，智能设备等其实都是有软件和硬件两部分组成，具体实现也许复杂，但整体的结构也就如此。软件运行在硬件上，告诉硬件该干什么。操作系统...
项目-银行账户管理系统（linux C编程和 消息队列实现IPC编程）.rar
09-01
采用C/S架构进行设计 客户端：提供一个界面供用户选择，当用户选择具体的业务操作之后，客户端将用户的选择信息发送给服务器进行处理，客户端等待服务器的结果，并且显示给客户。 服务器：接收客户端发来的用户...
模拟ATM机使用C/S架构的小程序源码
07-17
恩，使用了C/S架构，多线程机制，消息队列通信，SQLite3数据库。别的到没什么。写的时间还蛮长的，当时还不成熟嘛！ 因为链接了libsqllite3.so，所以你得安装libsqite3这个库。 和大家分享下，记得回复下哦！
weaving-socket，已.net core为基础，设计基于TCP通信的交互框架 是编写物联网，消息队列，IM等完美的选择
最新发布
01-11
是编写物联网，消息队列，websocket应用，移动通信应用，IM等完美的选择。 可规范先后台交互处理，可支持，B/C,C/S,手机移动标准化的通信方式。支持 Json, Bytes, custom 多种方式，分别代表，内置json协议，内置二...
基于Qt的多线程流水线异步服务器稳定版
06-07
(上一个版本“一种可伸缩的全异步C/S架构服务器实现”是有问题的，现在已经完成更改)。 服务由以下几个模块组成. 1、 网络传输模块。负责管理用于监听、传输的套接字，并控制数据流在不同线程中流动。数据收发由一定...
基于MFC的Erlang计算器开发
07-04
基于MFC设计了一款软件，实现Erlang B公式的B、S、a，知二求一计算；并在此基础上，求得等待率C的值，画出中继线数目S一定时，B-a的曲线； 同时进行队列分析，分析M/M/S(N)系统输入不同的到达率λ，服务率u，中继线...
linux下用socket,子进程,消息队列编写的消息传送
07-29
这是在linux下用socket,子进程,消息队列编写的简单的客户端和服务器间通信的程序，客户端发送数据给服务器，服务器使用消息队列把消息存到文件中，用make运行Makefile编译程序
C语言/C++队列详细讲解教程及完整代码实现
qq_43884946的博客
06-30 2296
队列是一种常用的数据结构，具有先进先出的特点。在解决实际问题时，队列可以发挥重要作用。通过C语言的实现代码，我们可以更好地理解队列的概念和基本操作。希望本篇教程能对你理解队列有所帮助！
LinuxC 进程间通信 --- 消息队列
weixin_44977283的博客
08-05 343
消息队列的本质就是由内核创建的用于存放消息的链表，由于是存放消息的，所以我们就把这个链表称为消息队列。2、多进程网状交叉通信时，消息队列是上上之选。3、能实现大规模数据的通信。1、传送有格式的消息流。
c语言系统编程八：Linux进程间通信之消息队列
qq_33808440的博客
06-21 2532
消息队列是消息的链表，存放在内存中，由内核维护； System V提供的IPC通信机制需要一个key值，通过key值就可以在系统内获得一个唯一的消息队列标识符。key值可以人工指定，也可以通过ftok函数获得 功能 参数 返回值 功能 参数 返回值 删除消息队列 3.4 消息队列的信息格式的定义 消息队列的信息格式是需要人工定义的，格式放在一个结构体中； 信息结构体中的第一个long型的成员的作用是，只有对这类信息感兴趣的进程才能拿到这类信息 功能 向消息队
进程间通信机制详解（３）——消息队列
jwqq123的博客
03-29 484
消息队列 消息队列本质上是位于内核空间的链表，链表的每个节点都是一条消息。消息队列存放在内核中并由队列标识符标识。 消息数据格式 无论发送还是接收消息，消息的格式都必须按照规范来。 struct Msg{ long type; // 消息类型，值>0。 char mtext[1];// 消息正文， // ... }; 数字 1 表示类型为 1 的消息，数字2、...
C中消息队列
嵌入式
08-12 522
mymsg.h #ifndef __MYMSG_H__ #define __MYMSG_H__ #define N 32 struct mydata{ int a; int b; }; struct msgbuf{ long mtype; /* message type, must be > 0 */ char mtext[sizeof(struct mydata)]; /* message data */ }; #endif msg_snd.c #inc
Client-Server(C/S)结构
xikangsoon的博客
09-11 8249
服务器-客户机，即Client-Server(C/S)结构。C/S结构通常采取两层结构。服务器负责数据的管理，客户机负责完成与用户的交互任务。 客户机通过局域网与服务器相连，接受用户的请求，并通过网络向服务器提出请求，对数据库进行操作。服务器接受客户机的请求，将数据提交给客户机，客户机将数据进行计算并将结果呈现给用户。服务器还要提供完善安全保护及对数据完整性的处理等操作，并允许多个客户机同时访问...
任务2：消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。
weixin_45950398的博客
05-13 1630
任务2：编写消息队列通信程序task42s.c和task42c.c，利用消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。比如进程PID为1234的客户端发送的消息为”hello from Process 1234”，服务器收到该消息后发回消息为“receipt of hello from <您的姓名xxx>’s server to Process 1234”TOC](这里写自定义目录标题) 消息队
用消息队列编写一个客户端服务器通信的程序
陈龙的专栏
09-20 6584
实验原理：     本实验用消息队列设计一个简易的双人聊天程序（一个服务器，两个客户端）。消息队列重点在于消息类型的匹配，客户端和服务端的“通信协议”的设计。思想如下：   服务器端：接受客户端发来的任何消息，并根据器消息类型，转发给对应的客户端。同时，检测是否有退出标记，有
使用消息队列实现不同进程间的通信
06-01
它基于消息的异步传递，即一个进程把消息放入消息队列中，而另一个进程从队列中获取消息。 实现消息队列的主要步骤如下： 1. 创建消息队列。创建消息队列需要指定消息队列的键值和权限等信息。 2. 发送消息。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值