驱动 D2

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量37 收藏
点赞数 1
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CCCHQHQ/article/details/131561899
版权

通过ioctl函数选择不同硬件的控制，LED 蜂鸣器 马达 风扇

head.h

#ifndef __HEAD_H__
#define __HEAD_H__ 
typedef struct{
    unsigned int MODER;
    unsigned int OTYPER;
    unsigned int OSPEEDR;
    unsigned int PUPDR;
    unsigned int IDR;
    unsigned int ODR;
}gpio_t;
#define PHY_LED1_ADDR   0X50006000
#define PHY_LED2_ADDR   0X50007000
#define PHY_LED3_ADDR   0X50006000
#define PHY_BEE_ADDR    0X50003000
#define PHY_FENG_ADDR   0X50006000
#define PHY_MOTOR_ADDR   0X50007000
#define PHY_RCC_ADDR    0X50000A28


#define LED_ON _IOW('l',1,int)  //开
#define LED_OFF _IOW('l',0,int)//关
#endif

test.c

#include<stdlib.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<unistd.h>
#include<string.h>
#include <sys/ioctl.h>
#include"head.h"

int main(int argc, char const *argv[])
{
    int a,b;
    char buf[128]={0};
    int fd1=open("/dev/led0",O_RDWR);
    if(fd1<0)
    {
        printf("打开设备文件led失败\n");
        exit(-1);
    }
    int fd2=open("/dev/bee",O_RDWR);
    if(fd2<0)
    {
        printf("打开设备文件bee失败\n");
        exit(-1);
    }
    int fd3=open("/dev/feng",O_RDWR);
    if(fd3<0)
    {
        printf("打开设备文件feng失败\n");
        exit(-1);
    }
    int fd4=open("/dev/motor",O_RDWR);
    if(fd4<0)
    {
        printf("打开设备文件motor失败\n");
        exit(-1);
    }
    while(1)
    {
        //从终端读取
        printf("请选择要实现的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d",&a);
        printf("请输入要控制的\n");
        printf("1(LED1) 2(LED2) 3(LED3) 4(BEE) 5(FENG) 6(MOTOR)>");
        scanf("%d",&b);
        if(a==1)//开
        {
            if(b==1)
            ioctl(fd1,LED_ON,b);
            else if(b==2)
            ioctl(fd1,LED_ON,b);
            else if(b==3)
            ioctl(fd1,LED_ON,b);
            else if(b==4)
            ioctl(fd2,LED_ON,b);
            else if(b==5)
            ioctl(fd3,LED_ON,b);
            else if(b==6)
            ioctl(fd4,LED_ON,b);
        }
        else if(a==0)//关
        {
            if(b==1)
            ioctl(fd1,LED_OFF,b);
            else if(b==2)
            ioctl(fd1,LED_OFF,b);
            else if(b==3)
            ioctl(fd1,LED_OFF,b);
            else if(b==4)
            ioctl(fd2,LED_OFF,b);
            else if(b==5)
            ioctl(fd3,LED_OFF,b);
            else if(b==6)
            ioctl(fd4,LED_OFF,b);
        }
        
    }
    
    close(fd1);
    close(fd2);
    close(fd3);
    close(fd4);

    return 0;
}

led.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case LED_ON: // 开灯
        switch (arg)
        {
        case 1: // LED1
            vir_led1->ODR |= (0x1 << 10);
            break;
        case 2: // LED2
            vir_led2->ODR |= (0x1 << 10);
            break;
        case 3: // LED3
            vir_led3->ODR |= (0x1 << 8);
            break;
        }
        break;
    case LED_OFF: // 关灯
        switch (arg)
        {
        case 1:
            vir_led1->ODR &= (~(0X1 << 10));
            break;
        case 2:
            vir_led2->ODR &= (~(0X1 << 10));
            break;
        case 3:
            vir_led3->ODR &= (~(0X1 << 8));
            break;
        }

        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    if (vir_led1 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    if (vir_led2 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led3 = vir_led1;
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // led1
    vir_led1->MODER &= (~(3 << 20));
    vir_led1->MODER |= (1 << 20);
    vir_led1->ODR &= (~(1 << 10));
    // led2
    vir_led2->MODER &= (~(3 << 20));
    vir_led2->MODER |= (1 << 20);
    vir_led2->ODR &= (~(1 << 10));
    // led3
    vir_led3->MODER &= (~(3 << 16));
    vir_led1->MODER |= (1 << 16);
    vir_led1->ODR &= (~(1 << 8));
    printk("寄存器初始化成功\n");

    return 0;
}

static int __init mycdev_init(void)
{
    int i;
    // 字符设备驱动注册
    major = register_chrdev(0, "led", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "led");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 为三盏灯创建三个设备文件
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "led%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    // 取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_rcc);
    // 销毁设备节点信息
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "led");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

bee.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_bee;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case LED_ON: // 开
        vir_bee->ODR |= (0x1 << 6);
        break;
    case LED_OFF: // 关
        vir_bee->ODR &= (~(0X1 << 6));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_bee = ioremap(PHY_BEE_ADDR, sizeof(gpio_t));
    if (vir_bee == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (1 << 1);
    // feng
    vir_bee->MODER &= (~(3 << 12));
    vir_bee->MODER |= (1 << 12);
    vir_bee->ODR &= (~(1 << 6));
    printk("寄存器初始化成功\n");

    return 0;
}

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "bee", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "bee");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 创建设备文件
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "bee");
    if (IS_ERR(dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_bee);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "bee");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

feng.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_feng;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case LED_ON: // 开
        vir_feng->ODR |= (0x1 << 9);
        break;
    case LED_OFF: // 关
        vir_feng->ODR &= (~(0X1 << 9));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_feng = ioremap(PHY_FENG_ADDR, sizeof(gpio_t));
    if (vir_feng == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // feng
    vir_feng->MODER &= (~(3 << 18));
    vir_feng->MODER |= (1 << 18);
    vir_feng->ODR &= (~(1 << 9));
    printk("寄存器初始化成功\n");

    return 0;
}

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "feng", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "feng");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 创建设备文件
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "feng");
    if (IS_ERR(dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_feng);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "feng");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

motor.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_motor;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case LED_ON: // 开
        vir_motor->ODR |= (0x1 << 6);
        break;
    case LED_OFF: // 关
        vir_motor->ODR &= (~(0X1 << 6));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_motor = ioremap(PHY_FENG_ADDR, sizeof(gpio_t));
    if (vir_motor == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // feng
    vir_motor->MODER &= (~(3 << 12));
    vir_motor->MODER |= (1 << 12);
    vir_motor->ODR &= (~(0x1 << 6));
    printk("寄存器初始化成功\n");

    return 0;
}

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "motor", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "motor");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 创建设备文件
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "motor");
    if (IS_ERR(dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_motor);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "motor");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

THEREDCOM
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
全志V3S嵌入式驱动开发（lcd屏幕驱动）
嵌入式-老费，一个分享专业嵌入式知识的blog
06-06 2485
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 对于一些设备，人们是希望从屏幕上面获取结果信息的，这样也显得更直观一些。另外，也有一些设备，它本身是需要客户和它不停交互，去一起完成某个功能的，这个时候，我们就要引入电容屏或者电阻屏了。那么，对于v3s来说，如果需要完成lcd屏幕的驱动和显示，需要完成哪些工作呢，这部分今天大家可以一起讨论下。 1、重新编译uboot 重新编译uboot代码，这部分是最容易被忽
android 红外驱动,Android内核驱动-红外驱动IR
weixin_39940182的博客
05-27 1003
1、概述：对多种红外遥控器的信号进行分析，其发出的红外指令中，引导码各不相同，而且后面的控制指令也有较大差别，甚至指令码的位数也不相同，原因是这些红外设计没有遵守相同的红外标准。但是其基本思想是相同的，即采用不同周期和不同占空比的脉冲分别表示逻辑0及1，只要根据期占空比及脉冲周期进行解析即可得到具体的按键码值。2、协议种类：市面上基本上有如下几大类协议：NEC with simple repeat...
如何在ubuntu中安装D2XX驱动
weixin_35748962的博客
02-15 257
D2XX驱动是FTDI公司提供的用于其USB芯片的驱动程序，可用于在Ubuntu中连接和控制FTDI设备。要在Ubuntu中安装D2XX驱动，请按照以下步骤操作： 下载D2XX驱动程序： 首先，从FTDI公司的网站上下载D2XX驱动程序的Linux版本，下载链接为 https://www.ftdichip.com/Drivers/D2XX.htm。下载完毕后，将下载的压缩包解压到您选择的目录中。...
Linux如何安装FTDI D2XX驱动
pq的博客
09-22 4486
1. VCP驱动和D2XX驱动的区别 VCP是VirtualCOMPort的简称，VCP驱动是通用的虚拟串口驱动，一般系统是内嵌此驱动。D2XX驱动是FTDI为其USB桥接芯片设计的驱动程序，可以提供更多的USB虚拟设备支持（即FTDI独有的MPSSE功能），例如USB转SPI，USB转I2C等。 2. 使用VCP驱动 2.1 打开终端，输入dmesg | grep FTDI（当前插入的FT4232H的平台，4路串口） 2.2 安装minicom 在终端中输入 ： sudo apt-ge...
FTDI FTD2XX 驱动学习笔记（一）
一名FPGA芯片设计爱好者的技术博客
12-24 6529
文章目录一、 简介二、常用的D2XX 函数参考文献 注：转载请注明出处 作者：雪天鱼，， 记录下学习过程，个人水平有限，可能理解有误，后续若发现错误之处，会及时更新。 Version Date 1.0 2021.12.24 FTDI 为其驱动程序提供 DLL 和虚拟 COM 端口 (VCP) 应用程序接口，现主要学习 FTD2XX 驱动。 一、 简介 FTDI的 D2XX 驱动下载链接:D2XX 可以选择直接使用 CDM 驱动安装程序进行安装，CDM驱动包含了D2XX 和 VCP两种驱动
camera驱动概述
marshal_zsx的博客
04-17 1785
camera驱动概述1 概述    camera模块是经常进行调试修改的模块，所以熟悉camera的工作流程以及工作原理将会大大的提供工作效率，但对于整个android系统camera是个十分复杂的模块，下面只是对camera的驱动加载进行分析。2 名词释义2.1 四个供电 a) VCAMD 就是DVDD数字供电，DVDD电压用CAMERA_POWER_VCAM_D表示； b) VCAM_I
Z7M D2 触摸板驱动
xiaoguaihu12的博客
04-15 783
Z7M-SL7D2 按该型号到官网查找
【WIFI】mtk7621驱动
smartvxworks的博客
04-22 1520
mtk7621驱动 无线驱动在完成驱动注册的同时，需要进行 cfg80211接口注册（提供命令支持）。 1.驱动 mtk wifi驱动基于pci进行扩展，第一个文件：/os/linux/pci_main_dev.c 文件用于创建和注册基于pci接口的网络设备，PCI设备上有三种地址空间：PCI的I/O空间、PCI的存储空间和PCI的配置空间。CPU可以访问PCI设备上的所有地址空间，其中I/O空间和存储空间提供给设备驱动程序使用，而配置空间则由Linux内核中的PCI初始化代码使用。内核在启动..
windows驱动开发-电源管理
苏洛坷的博客
05-01 1656
IRP_MJ_POWER
pci驱动开发详解
热门推荐
一技旁身
05-11 1万+
一、在了解pic启动开发前，作为开发人员需了解以下内核结构体： struct pci_device_id { __u32 vendor, device;/* Vendor and device ID or PCI_ANY_ID*/ __u32 subvendor, subdevice;/* Subsystem ID's or PCI_ANY_ID */ __u32 clas...
大银 D2T驱动器 操作手册
12-19
大银 D2T驱动器操作手册 大银 D2T驱动器操作手册是为使用大银 D2T驱动器的用户提供的操作手册，旨在指导用户正确地使用驱动器，确保驱动器的安全和高效运行。 驱动器概述 大银 D2T驱动器是一款高性能的驱动器，...
华为d2驱动
03-18
华为D2驱动是针对华为D2手机开发的一套设备驱动程序，主要用于确保计算机与华为D2手机之间的通信正常。在日常使用中，安装正确的驱动程序至关重要，因为它们是连接硬件设备（如手机）与操作系统（如Windows）的桥梁...
上银D2驱动器，中文手册
04-13
上银D2驱动器中文版手册，详解。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
上银D2或D2T伺服驱动器
11-11
"上银D2或D2T伺服驱动器" 上银D2或D2T伺服驱动器是一种自动换刀系统解决方案，可以满足不同刀把数与减速齿比互相搭配的应用需求。该驱动器采用高自由度且多样性的运动程序描述语言（Process description language，...
D2伺服驱动器LCD速查表
04-07
D2伺服驱动器 LCD速查表 D2伺服驱动器 D2伺服驱动器
【Linux】进程间通信——匿名管道
最新发布
2201_76024104的博客
07-08 713
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 314
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux存储管理I
m0_54563444的博客
07-03 906
主要知识点: 基本分区、逻辑卷LVM、EXT3/4/XFS文件系统、RAID。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 733
主要介绍Cmake的安装方法，及自己安装的过程

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值