嵌入式学习DAY27 --- System V 共享内存 ，POSIX 信号量 ，POSIX 消息队列_posix 共享内存 嵌入式平台

最新推荐文章于 2024-07-17 18:03:32 发布
最新推荐文章于 2024-07-17 18:03:32 发布
阅读量995 收藏 15
点赞数 13
分类专栏： 程序员 文章标签： 物联网 嵌入式硬件 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85015014/article/details/138882748
版权

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
img
img

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

函数功能：获得共享内存
函数参数：key：共享内存的键值，多个进程可以通过它访问同一个共享内存。其中有个特殊值 IPC_PRIVATE，用于创建当前进程的私有共享内存。
size：共享内存的大小
shmflg：同open()函数的权限位，也可以使用八进制表示法
函数返回值：
成功：共享内存段标识符
失败：-1
*/
int shmget(key_t key, size_t size, int shmflg);


##### (3)shmat函数：

#include <sys/types.h>
#include <sys/shm.h>
函数参数：
shmid：要映射的共享内存区标识符。
shmaddr：将共享内存映射到指定地址若为NULL，则表示系统自动分配地址，并把该段共享 内存映射到调用进程的地址空间)
shmflg：SHM_RDONLY:共享内存只读
默认0：共享内存可读可写
函数返回值：成功：被映射的段地址
出错：-1
void *shmat(int shmid, const void *shmaddr, int shmflg);


##### (4)shmdt函数：

#include <sys/types.h>
#include <sys/shm.h>

	函数原型：int shmdt(const void \*shmaddr);
	函数参数：shmaddr：被映射的共享内存段地址
	函数返回值：
		成功：0
		失败：-1


#### 4.如何查看共享内存：


ipcs -m


#### 5.如何删除共享内存:


ipcrm -m [shmid]


#### 6.代码演示



> 
> 1.read\_p ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

typedef struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[50]; /* message data */
}Msg_Buf;

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘a’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
//msgget
int msgqid = -1;
msgqid = msgget(key, IPC_CREAT | 0664);
if(msgqid < 0)
{
puts(“msgget error.”);
return -1;
}
while(1)
{
puts(“recv message from queue:”);
//msgsnd
Msg_Buf msg;
memset(msg.mtext, 0, 50);
msg.mtype = getpid();
int ret = msgrcv(msgqid, &msg, 50, 0, 0);
if(ret > 0)
{
puts(msg.mtext);
}
else
{
break;
}

	if(strncmp(msg.mtext,"quit",4) == 0)
	{
		break;
	}
}
msgctl(msgqid,IPC_RMID,NULL);
return 0;

}



> 
> 2.write\_p ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

typedef struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[50]; /* message data */
}Msg_Buf;

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘a’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
//msgget
int msgqid = -1;
msgqid = msgget(key, IPC_CREAT | 0664);
if(msgqid < 0)
{
puts(“msgget error.”);
return -1;
}
while(1)
{
puts(“input some message send to queue:”);
//msgsnd
Msg_Buf msg;
char *p = fgets(msg.mtext, 50, stdin);
if(NULL == p)
{
puts(“get msg.text error.”);
continue;
}
msg.mtype = getpid();
int ret = msgsnd(msgqid, &msg, 50, 0);
if(ret < 0)
{
puts(“msgsnd error.”);
continue;
}

	if(strncmp(msg.mtext,"quit",4) == 0)
	{
		break;
	}
}
return 0;

}




---


### 二、POSIX 信号量


#### 1.需求：


7个进程实现一个餐厅的流水线  
 买菜—>洗菜—>切菜---->炒菜---->装盘—>吃—>洗盘


7个进程之间有顺序关系  
 如何保证7个进程对菜操作权限和顺序


#### 2.信号量概述：


（1）在多任务操作系统中，多个进程/线程会同时运行。多个任务可能为了完成同一个事情而相互协作，这样就形成了任务之间的同步关系。同样，不同任务之间为了争夺有限的系统资源(硬件或软件资源)会进入竞争状态，这样就是任务之间的互斥关系。


（2）任务之间的互斥与同步关系存在的根源在于临界资源。临界资源是指在同一个时刻只允许有限个(通常只有一个)任务可以访问(读）或者修改(写)的资源。通常包括硬件资源(处理器、内存、存储器以及其他外围设备等)和软件资源(共享代码段、共享结构体和变量)。访问临界资源的代码称为临界区。


（3）信号量是用来解决进程/线程之间的同步与互斥问题的一种通信机制，包括一个称为信号量的变量和在该信号量下等待资源的进程等待队列，以及对信号量进行的两个原子操作（PV操作）。其中，信号量对应于某一种资源，取一个非负的整数值。信号量值指的是当前可用的该资源的数量，若它等于0则意味着目前没有可用的资源。


#### 3.PV原子操作的具体定义：


##### (1)P操作：


如果有可用的资源(信号量的值大于0)，则占用一个资源(信号量值减1，进入临界区代码)；如果没 有可用的资源(信号量值等于0)，则被阻塞，直到系统将资源分配给该任务（进入等待队列，一直 等到有资源的时候被唤醒）。


##### (2)V操作：


如果该信号量的等待队列中有任务在等待资源，则唤醒一个阻塞任务，如果没有任务等待它，则 释放一个资源(信号量值加1)


##### 注意：


最简单的信号量只有0和1两种值，这两种信号量被称为二值信号量。在本节中，主要讨论二值信号量。二值信号量的应用比较容易扩展到使用多值信号量的情况。


#### 4.信号量编程：


##### 步骤：


Linux下，使用有名信号量通常分为以下几个步骤：  
 (1)创建信号量或获得系统已经存在的有名信号量，此时需要调用sem\_open()函数，不同的进程通过使用同一个信号量键值来获得同一个信号量。并初始化信号量的值。


(2)获取信号量的值，此时使用sem\_getvalue()。


(3)信号量减一，使用sem\_wait()。


(4)信号量加一，使用sem\_post()。


(5)关闭信号量，使用sem\_close()。


##### （1）sem\_open:

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

	sem_t \*sem\_open(const char \*pathname, int oflag);
	/\*

*函数名：sem_open
*函数功能：打开一个信号量，如果信号量不存在，则创建信号量
*函数参数：
* const char *pathname:信号量的名字（标识）
* int oflag：同文件IO的创建时的权限
* O_CREAT | O_RDWR
* mode_t mode:同文件权限
* unsigned in value：信号量的初始值
*函数返回值：sem_t *:成功返回信号量操作对象的指针
*/
sem_t *sem_open(const char *pathname, int oflag, mode_t mode, unsigned int value);


##### （2）sem\_getvalue:

#include <semaphore.h>
/*
*函数名:sem_getvalue
*函数功能：获取当前信号量的值
*函数参数：
* sem_t *sem:信号量的操作指针
* int *sval:存储信号量值得内存首地址
*函数返回值：int:成功返回0，失败返回-1
*/
int sem_getvalue(sem_t *sem, int *sval);


##### （3）sem\_wait:

#include <semaphore.h>
/*
*函数名:sem_wait
*函数功能：信号量值减一
*函数参数：sem_t *sem:信号量的操作指针
*函数返回值：int:成功返回0，失败返回-1
*/
int sem_wait(sem_t *sem);


##### （4）sem\_post:

#include <semaphore.h>
/*
*函数名:sem_post
*函数功能：信号量值加一
*函数参数：sem_t *sem:信号量的操作指针
*函数返回值：int:成功返回0，失败返回-1
*/
int sem_post(sem_t *sem);


##### （5）sem\_close:

#include <semaphore.h>
/*
*函数名:sem_close
*函数功能：关闭一个有名信号量
*函数参数：sem_t *sem:信号量的操作指针
*函数返回值：int:成功返回0，失败返回-1
*/
int sem_close(sem_t *sem);


##### 注意：


进程中使用的信号量，称之为有名信号量  
 编译时链接库 -lpthread


#### 5.代码演示：


代码中以4个进程来代替前面需求中说的7个进程，进行简单的演示：



> 
> 1.p1.c ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘c’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
char buf[30];
//shmget
int shmid = shmget(key,sizeof(buf),IPC_CREAT | 0664);
if(shmid < 0)
{
puts(“shmget error.”);
return 0;
}
//shmat
char *shmaddr = NULL;
shmaddr = (char *)shmat(shmid, NULL, 0);

sem_t \*mysem = NULL;
mysem = sem\_open("mysem", O_CREAT | O_RDWR, 0664, 6);
if(NULL == mysem)
{
	puts("sem\_open error.");
	shmdt(shmaddr);
	return -1;
}

while(1)
{
	int sem_v = 0;
	sem\_getvalue(mysem, &sem_v);
	printf("sem\_v:%d\n",sem_v);
	if(sem_v == 6)
	{
		sem\_wait(mysem);
		puts(shmaddr);
		sprintf(buf,"buy v");
		memset(shmaddr,0,sizeof(buf));
		memcpy(shmaddr,buf,strlen(buf));
	}
	sleep(3);
}
//shmdt
shmdt(shmaddr);
sem\_close(mysem);
return 0;

}



> 
> 2.p2.c ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘c’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
char buf[30];
//shmget
int shmid = shmget(key,sizeof(buf),IPC_CREAT | 0664);
if(shmid < 0)
{
puts(“shmget error.”);
return 0;
}
//shmat
char *shmaddr = NULL;
shmaddr = (char *)shmat(shmid, NULL, 0);

sem_t \*mysem = NULL;
mysem = sem\_open("mysem", O_CREAT | O_RDWR, 0664, 6);
if(NULL == mysem)
{
	puts("sem\_open error.");
	shmdt(shmaddr);
	return -1;
}

while(1)
{
	int sem_v = 0;
	sem\_getvalue(mysem, &sem_v);
	printf("sem\_v:%d\n",sem_v);
	if(sem_v == 5)
	{
		sem\_wait(mysem);
		puts(shmaddr);
		sprintf(buf,"brush v");
		memset(shmaddr,0,sizeof(buf));
		memcpy(shmaddr,buf,strlen(buf));
	}
	sleep(3);
}
//shmdt
shmdt(shmaddr);
sem\_close(mysem);
return 0;

}



> 
> 3.p3.c ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘c’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
char buf[30];
//shmget
int shmid = shmget(key,sizeof(buf),IPC_CREAT | 0664);
if(shmid < 0)
{
puts(“shmget error.”);
return 0;
}
//shmat
char *shmaddr = NULL;
shmaddr = (char *)shmat(shmid, NULL, 0);

sem_t \*mysem = NULL;
mysem = sem\_open("mysem", O_CREAT | O_RDWR, 0664, 6);
if(NULL == mysem)
{
	puts("sem\_open error.");
	shmdt(shmaddr);
	return -1;
}

while(1)
{
	int sem_v = 0;
	sem\_getvalue(mysem, &sem_v);
	printf("sem\_v:%d\n",sem_v);
	if(sem_v == 4)
	{
		sem\_wait(mysem);
		puts(shmaddr);
		sprintf(buf,"cut v");
		memset(shmaddr,0,sizeof(buf));
		memcpy(shmaddr,buf,strlen(buf));
	}
	sleep(3);
}
//shmdt
shmdt(shmaddr);
sem\_close(mysem);
return 0;

}



> 
> 4.p4.c ---------------------------------------------------------------------------------------如下：
> 
> 
>

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>

int main()
{
//ftok
key_t key = -1;
key = ftok(“.”,‘c’);
if(key < 0)
{
puts(“ftok error.”);
return -1;
}
char buf[30];
//shmget
int shmid = shmget(key,sizeof(buf),IPC_CREAT | 0664);
if(shmid < 0)
{
puts(“shmget error.”);
return 0;
}
//shmat
char *shmaddr = NULL;
shmaddr = (char *)shmat(shmid, NULL, 0);

sem_t \*mysem = NULL;
mysem = sem\_open("mysem", O_CREAT | O_RDWR, 0664, 6);
if(NULL == mysem)
{
	puts("sem\_open error.");
	shmdt(shmaddr);
	return -1;
}

while(1)
{
	int sem_v = 0;
	sem\_getvalue(mysem, &sem_v);
	printf("sem\_v:%d\n",sem_v);
	if(sem_v == 3)
	{
		sem\_wait(mysem);
		puts(shmaddr);
		sprintf(buf,"do v");
		memset(shmaddr,0,sizeof(buf));
		memcpy(shmaddr,buf,strlen(buf));
		sem\_post(mysem);
		sem\_post(mysem);
		sem\_post(mysem);
		sem\_post(mysem);
	}
	sleep(3);
}
//shmdt
shmdt(shmaddr);

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
img
img

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

nt sem_v = 0;
sem_getvalue(mysem, &sem_v);
printf(“sem_v:%d\n”,sem_v);
if(sem_v == 3)
{
sem_wait(mysem);
puts(shmaddr);
sprintf(buf,“do v”);
memset(shmaddr,0,sizeof(buf));
memcpy(shmaddr,buf,strlen(buf));
sem_post(mysem);
sem_post(mysem);
sem_post(mysem);
sem_post(mysem);
}
sleep(3);
}
//shmdt
shmdt(shmaddr);

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
[外链图片转存中…(img-0Ba9Rymf-1715716610756)]
[外链图片转存中…(img-Zy9qL7hQ-1715716610756)]

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_85015014
关注
  • 13
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Posix与System V共享内存区
weixin_50866517的博客
09-29 844
要使用 POSIX 共享内存对象需要完成下列任务：使用shm_open()函数打开一个与指定的名字对应的对象。shm_open()函数与 open()系统调用类似，它会创建一个新共享对象或打开一个既有对象。作为函数结果，shm_open()会返回一个引用该对象的文件描述符。将上一步中获得的文件描述符传入mmap()调用并在其flags参数中指定MAP_SHARED。这将共享内存对象映射进进程的虚拟地址空间。与mmap()一样，一旦映射了对象之后就能够关闭该文件描述符而不会影响到这个映射。
Linux-C 进程通信之system-V IPC
Genven_Liang的博客
08-24 2128
Linux-C 进程通信之system-V IPC 一、简述 记--简单的system-VIPC 例子。其中包括消息队列、共享内存、信号量。 多进程间使用IPC对象进行通信。有一个key值唯一标识这个IPC对象。 使用命令：ipcs -a 来查看所有IPC对象 或者使用:ipcs -q 查看消息队列...
嵌入式学习DAY27 --- System V 共享内存 ，POSIX 信号量 ，POSIX 消息队列_posix 共享内存 嵌入式平台(1)
2401_84248681的博客
05-04 703
一、System V 共享内存二、POSIX 信号量三、POSIX 消息队列（1）在多任务操作系统中，多个进程/线程会同时运行。多个任务可能为了完成同一个事情而相互协作，这样就形成了任务之间的同步关系。同样，不同任务之间为了争夺有限的系统资源(硬件或软件资源)会进入竞争状态，这样就是任务之间的互斥关系。（2）任务之间的互斥与同步关系存在的根源在于临界资源。临界资源是指在同一个时刻只允许有限个(通常只有一个)任务可以访问(读）或者修改(写)的资源。
进程间通信（IPC）-管道、消息队列、共享内存、信号、信号量、套接字
Unique-You的博客
05-02 6975
多进程：首先，先来讲一下fork之后，发生了什么事情。由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是...
Linux进程间通信(IPC)教程 Linux共享内存介绍：介绍POSIX共享内存的基本概念、用途和编程实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-28 1199
POSIX共享内存概述 共享内存是最高效的IPC机制，因为它不涉及进程之间的任何数据传输。 这种高效率带来的问题是，我们必须用其他辅助手段来同步进程对共享内存的访问，否则会产生竞态条件。 因此，共享内存通常和其他进程间通信方式一起使用。 Linux下有三种共享内存的IPC技术：System V共享内存、共享文件映射(mmap)、POSIX共享内存。本文只介绍POSIX共享内存。 POSIX共享内存和POSIX消息队列，有名信号量一样都是具有随内核持续性的特点。 POSIX共享内存流程 ..
SystemV 和Posix两种方式实现共享内存
modi000的博客
05-30 472
正如实现信号量的方式有SystemV 和Posix两种形式， 实现共享内存也有SystemV 和Posix两种形式，参考该文和该文和该文 一、Posix形式：（常用） i 用到如下函数： shm_open mmap ftruncate shm_unlink 二、System V 形式： 参考该文。 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sy.
Linux 进程间通信：管道、共享内存、消息队列、信号量
凌桓丶的博客
04-13 2648
进程间通信 管道 共享内存 消息队列 信号量 进程间通信 https://blog.csdn.net/qq_35423154/article/details/105294963 在之前的一篇博客中讲过， # <h1 id="2"> 管道</h1> # <h1 id="3"> 共享内存</h1> # <h1 id="4"&gt...
SystemV信号量与POSIX信号量简介
FinixLei的专栏 (https://github.com/FinixLei)
01-14 461
转载自：http://linuxperf.com/?p=25 对原文做了一些删减和结构上的优化。 SystemV 信号量 SystemV 信号量是内核对象，由内核统一管理； 它的存续不依赖于进程，即使进程退出也仍然存在。 semget(2): 向内核提出申请，内核根据需要创建新的信号量或关联已存在的信号量，每组信号量都有唯一的ID标识，可以被多个进程共享。 semop(2) 或 semtimedop(2): PV操作。 semctl(2): 删除信号量。（进程即使不存在，信号量也存在于内核中，除非调用此函
System V 与 POSIX 简介与对比
qq295109601的博客
07-31 3729
当我们在 Linux 系统中进行进程间通信时，例如信号量，消息队列，共享内存等方式，会发现有System V以及POSIX两种类型。今天我们就来简单介绍下它们。 POSIX： POSIX(Portable Operating System Interface for Computing Systems)是由IEEE 和ISO/IEC 开发的一簇标准。该标准是基于现有的UNIX 实践和经验，描述了操作系统的调用服务接口，用于保证编制的应用程序可以在源代码一级上在多种操作系统上移植运行。它是在1980 年
ipc.rar_共享内存 封装_进程信号量
09-23
在IT领域，进程间通信（IPC，Inter-Process Communication）是多进程系统中不可或缺的一部分，它...通过学习和理解这些代码，开发者可以更好地掌握共享内存和信号量在实际项目中的应用，提高程序的并发性能和稳定性。
x86_64-8.1.0-release-posix-seh-rt_v6-rev0.zip
07-03
"posix-seh"表示这个Mingw-w64版本使用了Windows的结构化异常处理（Structured Exception Handling, SEH），而不是传统的Unix/Linux信号处理机制。SEH在Windows上提供了更高效且兼容性更好的异常处理机制。 **RT_v6...
嵌入式Linux高级编程--04posix_进程间通信.ppt
09-17
目前Linux使用的进程间通信方式包括管道、消息队列、共享内存、信号量和信号等。 管道通信是进程间通信的一种方式，管道是单向的、先进先出的、无结构的、固定大小的字节流。写进程在管道的尾端写入数据，读进程在...
商业编程-源码-共享内存封装类.zip
06-23
通常使用POSIX信号量或系统V信号量。 - **关键区**：代码段，其中包含对共享内存的访问。在关键区内，进程必须获取并释放信号量，确保独占访问。 3. **共享内存封装类的设计** - **类结构**：通常包括初始化、...
Posix-program-Linux.zip_linux posix_linux program_linux 应用_linux
09-24
5. **线程通信**：使用共享内存、消息队列、管道、信号等方式实现线程间的通信。 6. **线程安全**：理解线程不安全函数，如动态内存分配、I/O操作等，并使用线程安全的库函数。 7. **线程调度**：了解Linux的调度...
ESP32——物联网小项目汇总
Irving.Gao的博客
07-06 1134
商品级ESP32智能手表 [文章链接] 用ESP32，做了个siri？！开源了！ [文章链接]
AIoTedge智能物联网边缘计算平台：引领未来智能边缘技术
云腾五洲官方博客
07-17 332
AIoTedge智能物联网边缘计算平台，以其创新的技术架构和强大的功能，为各行各业的智能化升级提供了强有力的支持。AIoTedge智能物联网边缘计算平台，以其创新的边云协同架构，为智能设备和系统提供了强大的数据处理和智能决策能力，开启了智能物联网的新篇章。这种架构不仅优化了数据处理速度，还提高了系统的可靠性和灵活性，为企业提供了一个高效、可靠的智能边缘解决方案。即使在断网的情况下，一旦网络恢复，设备状态将自动与云端同步，确保了设备管理的连续性和一致性。用户可以通过拖拽的方式，轻松实现AI推理和数据上报。
唯众物联网综合实训台 物联网实验室建设方案
whwzzc的博客
07-15 902
具共同构成的物联应用开发平台。实训装置综合运用传感器技术、RFID技术、接口控制技术、无线传感网技术、Android应用开发等，配合实训台上的433M无线通信设备、ZigBee节点、射频设备、控制设备、网关以及物联网融合云平台，构建集基础性、验证性、设计性、综合性和创新性开发五位一体综合实训装置，实现智能家居门禁安防监控、智能家居环境监测、家居设备智能控制、农业环境智能检测、农业设备智能控制等功能。App可以实现动作列表的编辑，可以将执行器的动作按顺序打包为动作列表，并为其配备触发源信号，从而实现联动。
【5G Sub-6GHz模块】专为IoT/eMBB应用而设计的RG520NNA、RG520FEB、RG530FNA、RG500LEU 5G模组
最新发布
Mandy_mjd的博客
07-17 668
专为IoT/eMBB应用而设计的RG520NNA、RG520FEB、RG530FNA、RG500LEU 5G模组
进程间通信，共享内存，posix信号量,消息队列
05-23
进程间通信（Inter-Process Communication, IPC）是指不同进程之间进行数据交换和协调的机制。常见的IPC方式有管道、命名管道、共享内存、消息队列、信号量等。 共享内存是一种IPC方式，它允许多个进程访问同一块物理内存，从而实现进程间数据共享。共享内存通常需要配合信号量来实现进程间同步。 Posix信号量是一种进程间同步机制，它通过对共享资源的访问进行控制，保证多个进程之间的协调和同步。它包括二进制信号量和计数信号量两种类型。 消息队列是一种通信机制，它允许进程之间通过发送消息实现通信。多个进程可以通过一个公共的消息队列来传递消息，从而实现进程间通信和同步。 以上这些IPC方式都可以用于进程间通信和协调，但在不同情况下，选择不同的IPC方式可以更好地满足需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值