15.平台总线专题4

最新推荐文章于 2024-09-06 23:27:54 发布
最新推荐文章于 2024-09-06 23:27:54 发布
阅读量149 收藏
点赞数
分类专栏： 驱动开发初级 文章标签： linux 驱动程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_Xian/article/details/120860537
版权

文章目录

平台总线的probe代码实现

1.在probe方法中注册设备号并设计一个全局的设备对象
在这里插入图片描述在这里插入图片描述在这里插入图片描述

2.初始化硬件
在这里插入图片描述在这里插入图片描述

3.释放资源
在这里插入图片描述

平台总线完成led设备的控制

实现fops

nt val;
	int ret;

	ret = copy_from_user(&val, buf, count);
	if(ret > 0)
	{
		printk("copy_from_user error\n");
		return -EFAULT;
	}

	if(val){ //亮
		writel(readl(samsung_led->reg_base + 4) | (0x3<<4) , samsung_led->reg_base+4);
	}else{
		writel(readl(samsung_led->reg_base + 4) & ~(0x3<<4) , samsung_led->reg_base+4);
	}

	return count;

}


int led_pdrv_open(struct inode *inode, struct file *filp)
{
	printk("-----%s------------\n", __FUNCTION__);
	return 0;

}
int led_pdrv_close(struct inode *inode, struct file *filp)
{
	printk("-----%s------------\n", __FUNCTION__);
	return 0;
}





const struct file_operations led_fops = {
	.open = led_pdrv_open,
	.release = led_pdrv_close,
	.write = led_pdrv_write,

};

完整代码

plat_led_pdev.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>


#define GPIO_REG_BASE 0x11400000

#define GPF3_CON GPIO_REG_BASE + 0x01E0
#define GPF3_SIZE  24

#define GPX1_CON  GPIO_REG_BASE + 0x0C20
#define GPX1_SIZE  24



// 一个设备可能有多个资源: 
struct resource led_res[] = {
	[0] = {
		.start = GPF3_CON,
		.end = GPF3_CON + GPF3_SIZE - 1, 
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = GPX1_CON,
		.end = GPX1_CON + GPX1_SIZE - 1, 
		.flags = IORESOURCE_MEM,
	},

	//有些设备也有中断资源 ，用于说明中断资源的使用，本驱动中是没有太多意义
	[2] = {
		.start =  67,
		.end = 67, 
		.flags = IORESOURCE_IRQ,
	},		

};



struct platform_device led_pdev = {
	.name = "exynos4412_led", // 用于做匹配  /sys/bus/platform/devices/exynos4412_led
	.id = -1,
	.num_resources = ARRAY_SIZE(led_res),
	.resource = led_res,
};



static int __init plat_led_dev_init(void)
{

	//注册一个platform_devices
	return platform_device_register(&led_pdev);
}

static void __exit plat_led_dev_exit(void)
{
	platform_device_unregister(&led_pdev);
}


module_init(plat_led_dev_init);
module_exit(plat_led_dev_exit);
MODULE_LICENSE("GPL");

plat_led_pdrv.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>

#include <asm/io.h>
#include <asm/uaccess.h>


//设计一个全局的设备对象
struct led_dev{
	int dev_major;
	struct class *cls;
	struct device *dev;
	struct resource *res; //获取到的内存资源
	void *reg_base; //表示物理地址映射之后的虚拟地址
};
struct led_dev *samsung_led;


ssize_t led_pdrv_write (struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
{
	int val;
	int ret;

	ret = copy_from_user(&val, buf, count);
	if(ret > 0)
	{
		printk("copy_from_user error\n");
		return -EFAULT;
	}

	if(val){ //亮
		writel(readl(samsung_led->reg_base + 4) | (0x3<<4) , samsung_led->reg_base+4);
	}else{
		writel(readl(samsung_led->reg_base + 4) & ~(0x3<<4) , samsung_led->reg_base+4);
	}

	return count;

}


int led_pdrv_open(struct inode *inode, struct file *filp)
{
	printk("-----%s------------\n", __FUNCTION__);
	return 0;

}
int led_pdrv_close(struct inode *inode, struct file *filp)
{
	printk("-----%s------------\n", __FUNCTION__);
	return 0;
}





const struct file_operations led_fops = {
	.open = led_pdrv_open,
	.release = led_pdrv_close,
	.write = led_pdrv_write,

};

//申请资源，总线匹配成功后会自动调用probe方法
int led_pdrv_probe(struct platform_device *pdev)
{
	printk("-----%s------------\n", __FUNCTION__);
	int ret;

	samsung_led = kzalloc(sizeof(struct led_dev), GFP_KERNEL);
	if(samsung_led == NULL)
	{
		printk("kzalloc errorn\n");
		return -ENOMEM;
	}

	/*
		a，注册设备号，并且注册fops--为用户提供一个设备标示，同时提供文件操作io接口
		b， 创建设备节点
		c， 初始化硬件
					ioremap(地址);  //地址从pdev需要获取
					readl/writle();
		d，实现各种io接口： xxx_open, xxx_read, ..

	*/

	samsung_led->dev_major = register_chrdev(0, "led_drv", &led_fops);

	samsung_led->cls = class_create(THIS_MODULE, "led_new_cls");

	samsung_led->dev = device_create(samsung_led->cls, NULL, MKDEV(samsung_led->dev_major, 0),
							NULL, "led0");
	
	//获取资源
	// 参数1: 从哪个pdev中获取资源
	// 参数2:  资源类型
	// 参数3: 表示获取同种资源的第几个
	
	samsung_led->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	
	int irqno = platform_get_irq(pdev, 0);
	// 等同于platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	printk("--------irqno = %d\n", irqno);

	samsung_led->reg_base = ioremap(samsung_led->res->start,  resource_size(samsung_led->res));

	
	//对寄存器进行配置--输出功能
	writel((readl(samsung_led->reg_base) & ~(0xff<<16))| (0x11<<16) , samsung_led->reg_base);

	return 0;
}
//释放资源
int led_pdrv_remove(struct platform_device *pdev)
{
	printk("-----%s------------\n", __FUNCTION__);

	iounmap(samsung_led->reg_base);
	device_destroy(samsung_led->cls, MKDEV(samsung_led->dev_major, 0));
	class_destroy(samsung_led->cls);

	unregister_chrdev(samsung_led->dev_major, "led_drv");
	
		
	kfree(samsung_led);
	
	return 0;
}
	

const struct platform_device_id led_id_table[] = {
		{"exynos4412_led", 0x4444},
		{"s5pv210_led", 0x2222},
		{"s3c2410_led", 0x3333},
		{"s3c6410_led", 0x3333},
};	

struct platform_driver led_pdrv = {
	.probe = led_pdrv_probe,
	.remove = led_pdrv_remove,
	.driver = {
			.name = "samsung_led_drv",
				//可以用于做匹配
				// /sys/bus/platform/drivers/samsung_led_drv
	},
	.id_table = led_id_table,
};


static int __init plat_led_pdrv_init(void)
{
	printk("-----%s------------\n", __FUNCTION__);
	//注册一个pdrv
	
	return platform_driver_register(&led_pdrv);
}


static void __exit plat_led_pdrv_exit(void)
{
	printk("-----%s------------\n", __FUNCTION__);
	platform_driver_unregister(&led_pdrv);

}



module_init(plat_led_pdrv_init);
module_exit(plat_led_pdrv_exit);
MODULE_LICENSE("GPL");

led_test.c

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




int main(int argc, char *argv[])
{
	int fd;
	int on =0;
	
	fd = open("/dev/led0", O_RDWR);
	if(fd < 0)
	{
		perror("open");
		exit(1);
	}

	while(1)
	{
		on = 1;
		write(fd, &on, 4);
		sleep(1);

		on = 0;
		write(fd, &on, 4);
		sleep(1);
	}


	close(1);

	return 0;
}

Makefile

ROOTFS_DIR = /opt/4412/rootfs
MODULE_NAME = plat_led_pdev
MODULE_NAME2 = plat_led_pdrv
APP_NAME = led_test

CROSS_COMPILE = /home/george/Linux_4412/toolchain/gcc-4.6.4/bin/arm-none-linux-gnueabi-
CC = $(CROSS_COMPILE)gcc

ifeq ($(KERNELRELEASE), )
KERNEL_DIR = /home/george/Linux_4412/kernel/linux-3.14
CUR_DIR = $(shell pwd)
all :
	$(CC) $(MODULE_NAME).c -o $(MODULE_NAME)
	make -C $(KERNEL_DIR) M=$(CUR_DIR) modules
clean :
	make -C $(KERNEL_DIR) M=$(CUR_DIR) clean

install:
	cp -raf *.ko $(APP_NAME)  $(ROOTFS_DIR)/drv_module
	
else

obj-m += $(MODULE_NAME).o
obj-m += $(MODULE_NAME2).o
#obj-m += $(MODULE_NAME3).o

endif

需求

利用互联网的思想，通过编写客户端和服务端，开发板上运行服务端，可以直接控制led灯，并且等待客户端端的连接，客户端通过
socket连接到服务端，通过发送指令来远程控制服务端的led灯
server.c

#include "net.h"

//定义在net.h中，统一管理fd
struct fds *myfd;

void cli_data_handle (void *arg);

int main (void)
{
	myfd = malloc(sizeof(struct fds));
	if (myfd == NULL)
		return -1;

	//打开设备led0
	myfd->openfd = open("/dev/led0", O_RDWR);
	if(myfd->openfd < 0)
	{
		perror("open");
		exit(1);
	}
	
	myfd->socketfd = -1;
	struct sockaddr_in sin;

	/* 1. 创建socket fd */
	if ((myfd->socketfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
		perror ("socket");
		exit (1);
	}

	/* 允许绑定地址快速重用 */
	int b_reuse = 1;
	setsockopt (myfd->socketfd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));


	/* 绑定 */
	/*填充struct sockaddr_in结构体变量 */
	bzero (&sin, sizeof (sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons (SERV_PORT);	//网络字节序的端口号

	/* 让服务器程序能绑定在任意的IP上 */
	sin.sin_addr.s_addr = htonl (INADDR_ANY);
	/*2.2 绑定 */
	if (bind (myfd->socketfd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
		perror ("bind");
		exit (1);
	}

	/* 调用listen()把主动套接字变成被动套接字 */
	if (listen (myfd->socketfd, BACKLOG) < 0) {
		perror ("listen");
		exit (1);
	}
	printf ("Server starting....OK!\n");

	myfd->acceptfd = -1;
	/* 阻塞等待客户端连接请求 */

/*  用多线程处理已经建立号连接的客户端数据 */
	pthread_t tid;

	struct sockaddr_in cin;
	socklen_t addrlen = sizeof (cin);

	while (1) {
		if ((myfd->acceptfd = accept (myfd->socketfd, (struct sockaddr *) &cin, &addrlen)) < 0) {
			perror ("accept");
			exit (1);
		}

		char ipv4_addr[16];
		if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
			perror ("inet_ntop");
			exit (1);
		}

		printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, htons (cin.sin_port));

		pthread_create (&tid, NULL, (void *) cli_data_handle, (void *) &myfd->acceptfd);
	}

	close (myfd->socketfd);
	close(myfd->openfd);
	return 0;
}

void cli_data_handle (void *arg)
{
	printf ("handler thread: acceptfd =%d\n", myfd->acceptfd);

	//..和acceptfd进行数据读写
	int ret = -1;
	int command;
	while (1) {
		bzero (&command, sizeof(int));
		do {
			ret = read (myfd->acceptfd, &command, sizeof(int));
		} while (ret < 0 && EINTR == errno);
		if (ret < 0) {

			perror ("read");
			exit (1);
		}
		if (!ret) {				//对方已经关闭
			break;
		}
		printf ("Receive data: %d\n", command);
		//控制灯,非零亮，零灭
		write(myfd->openfd, &command, 4);
		
		if (command < 0) {	//用户输入了小于0的数退出
			printf ("Client(fd=%d) is exiting!\n", myfd->acceptfd);
			break;
		}
	}
	close (myfd->acceptfd);

}

client.c


/*./client serv_ip serv_port */
#include "net.h"

//定义在net.h中，统一管理fd
struct fds *myfd;

void usage (char *s)
{
	printf ("\n%s serv_ip serv_port", s);
	printf ("\n\t serv_ip: server ip address");
	printf ("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
	myfd = malloc(sizeof(struct fds));
	if (myfd == NULL)
		return -1;
	
	myfd->socketfd = -1;

	int port = -1;
	struct sockaddr_in sin;

	if (argc != 3) {
		usage (argv[0]);
		exit (1);
	}
	/* 1. 创建socket fd */
	if ((myfd->socketfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
		perror ("socket");
		exit (1);
	}

	port = atoi (argv[2]);
	if (port < 5000) {
		usage (argv[0]);
		exit (1);
	}
	/*2.连接服务器 */

	/*2.1 填充struct sockaddr_in结构体变量 */
	bzero (&sin, sizeof (sin));

	sin.sin_family = AF_INET;
	sin.sin_port = htons (port);	//网络字节序的端口号

	if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
		perror ("inet_pton");
		exit (1);
	}

	if (connect (myfd->socketfd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
		perror ("connect");
		exit (1);
	}

	printf ("Client starting...OK!\n");
	/*3. 读写数据 */
	int command;
	int ret = -1;
	while (1) {
		bzero (&command, sizeof(int));
		printf("input command:");
		scanf("%d", &command);
		printf("command = %d\n", command);
		if (command == EOF) {
			continue;
		}
		
		do {
			ret = write (myfd->socketfd, &command, sizeof(int));
		} while (ret < 0 && EINTR == errno);

		if (command < 0) {	//用户输入了小于0的数退出
			printf ("Client is exiting!\n");
			break;
		}
	}

	/*4.关闭套接字 */
	close (myfd->socketfd);
}

net.h

#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>			/* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>			/* superset of previous */
#include <pthread.h>
#include <sys/stat.h>
#include <fcntl.h>


#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.18.100"
#define BACKLOG 5
//统一管理fd
struct fds
{
	int socketfd;
	int acceptfd;
	int openfd;
};

#endif

Makefile

ROOTFS_DIR = /opt/4412/rootfs
MODULE_NAME = plat_led_pdev
MODULE_NAME2 = plat_led_pdrv
APP_NAME = plat_led_server

CROSS_COMPILE = arm-none-linux-gnueabi-
CC = $(CROSS_COMPILE)gcc

ifeq ($(KERNELRELEASE), )
KERNEL_DIR = /home/linux/linux-3.14.10
CUR_DIR = $(shell pwd)
all :
	$(CC) $(APP_NAME).c -lpthread -o $(APP_NAME)
	make -C $(KERNEL_DIR) M=$(CUR_DIR) modules
	
clean :
	make -C $(KERNEL_DIR) M=$(CUR_DIR) clean

install:
	cp -raf *.ko $(APP_NAME)  $(ROOTFS_DIR)/drv_module
	
else

obj-m += $(MODULE_NAME).o
obj-m += $(MODULE_NAME2).o

endif
CSDN_Xian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【重识云原生】第四章云网络4.9.5.1节下一代智能网卡——DPU综述
junbaozi的专栏
07-20 1138
随着数据中心的高速发展，通信能力和计算能力成为数据中心基础设施的相辅相成的两个重要发展方向。若数据中心仅关注计算能力的提升，通信基础设施的提升跟不上，那么数据中心的整体系统性能依然受限，无法发挥出真正的潜力。DPU的提出背景就是应对这些数据量和复杂性的指数级增长。未来，需要将计算移至接近数据的位置，这是目前业界所公认的以数据为中心的体系结构下的创新。综上，DPU对数据中心来说，是通过更明细的分工来实现效率的提升、实现总体系统的成本最优化。...
can总线一帧多少字节多少位_【解惑】CAN报文到底有多少位？
weixin_39755890的博客
12-18 2356
原标题：【解惑】CAN报文到底有多少位？CAN-bus总线是应用最广泛的现场总线之一。而很多非常熟练的CAN工程师，面对一条CAN报文到底有多少位的问题时，却不能非常准确地回答。今天我们就从最基本的帧格式来解惑一条CAN报文的到底有多少位。CAN报文帧分为几种呢？CAN-bus通信帧共分为数据帧、远程帧、错误帧、过载帧和帧间隔。而数据帧和远程帧又有标准帧和扩展帧两种。其帧类型以及用途如表1所示：表...
probe()函数是什么时候被调用，设备和驱动是怎么联系起来的
黄仁军的专栏
07-17 7301
probe()函数是什么时候被调用，设备和驱动是怎么联系起来的？？   platform_add_devices(ldd6410_devices, ARRAY_SIZE(ldd6410_devices));  //这是bsp中添加所有的设备--》 platform_device_
14.平台总线专题3
CSDN_Xian的博客
10-20 155
文章目录平台总线作用和设计思想介绍平台总线中的三元素平台总线led驱动之资源的定义平台总线中driver实现的逻辑过程 平台总线作用和设计思想介绍 平台总线模型： 为什么会有平台总线： 用于平台升级：三星：　2410, 2440, 6410, s5pc100 s5pv210 4412 硬件平台升级的时候，部分的模块的控制方式，基本上是类似的 但是模块的地址是不一样 gpio控制逻辑： 1， 配置gpio的输入输出功能： gpxxconf 2， 给gpio的数据寄存器设置高低电平： g
13.平台总线专题2
CSDN_Xian的博客
10-18 119
文章目录device的构建和注册driver的构建和注册 device的构建和注册 device对象：设备对象，描述设备信息，包括地址，中断号，甚至其他自定义的数据 struct device { struct kobject kobj;　　//所有对象的父类 const char *init_name; // 在总线中会有一个名字，用于做匹配，在/sys/bus/mybus/devices/名字 struct bus_type *bus; //指向该device对象依附于总线的对象 void *pla
12.平台总线专题1
CSDN_Xian的博客
10-15 131
文章目录设备驱动模型的由来sysfs文件系统的介绍创建bus的代码编程 设备驱动模型的由来 字符设备驱动模型 字符设备驱动模型中不太变化的有1,2,3,5,6；需要变化的有4.为了优化代码，可以把1,2,3,5,6和4分离出来，把动作部分（申请、映射、创建等动作）变成设备驱动对象，把静态部分（地址、中断）变成设备对象，这两部分通过总线对象串联起来。 sysfs文件系统的介绍 sys目录 创建bus的代码编程 构建自己的总线 ...
专题资料（2021-2022年）大庆市科技企业技术需求项目汇总表.doc
10-08
15. 小口径管内涂层现场补口技术：开发适用于不同尺寸管道的内涂层修补技术，确保符合行业标准。 16. 压力平衡退火容器和单晶等径生长自动控制程序：涉及精密制造和自动化控制，提高材料处理的精度和效率。 【医药...
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2732
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
红队专题-REVERSE汇编/二进制PWN/逆向/反编译
aming小老弟
10-10 1197
ROP（Return-Oriented Programming）链是一种计算机安全领域中的攻击技术，用于绕过内存执行保护措施，实现利用漏洞进行代码注入和控制流劫持。由一系列已存在于程序内存中的代码片段（称为gadget）组成的，这些片段通常是程序的合法指令序列。通过将这些gadget按照特定的顺序串联起来，攻击者可以构造出一条可执行的ROP链，用于实现特定的攻击目的。ROP链的基本原理依赖于已存在的代码片段，而不是插入自定义的恶意代码。这样可以避免执行数据区域中的恶意代码，
【运维监控】prometheus+node exporter+grafana 监控linux机器运行情况（2）
alanchanchn的专栏
09-03 1922
本示例是通过prometheus的node exporter收集主机的信息，然后在grafana的dashborad进行展示。本示例使用到的组件均是最新的，下文中会有具体版本说明，linux环境是centos。本示例分为四个部分，即prometheus、grafana、node exporter的部署和三者集成的监控linux。本文旨在说明三者如何使用，不涉及各自组件的介绍，如果需要使用到本文的，肯定都有了解。
＜Linux＞ 基础IO
prodigy623的博客
09-06 473
详解Linux基础IO：文件系统调用接口与C库文件函数的关系、重定向、数据缓冲区、文件系统、动静态库
Linux实用操作
c1tenj2的博客
09-06 548
环境变量是操作系统（Windows、Linux、Mac）在运行的时候，记录的一些关键性信息，用以辅助系统运行。env命令即可查看当前系统中记录的环境变量环境变量是一种KeyValue型结构，即名称和值，如下图：HOME：/home，用户的HOME路径USER：root，当前的操作用户PWD：当前工作路径......我们知道使用的一系列命令其实本质上就是一个个的可执行程序。比如，cd命令的本体就是：/usr/bin/cd 这个程序文件。
【Linux】08.Linux 下的第一个小程序——进度条
caryon的博客
09-02 601
对换行与回车的直观解释，认识缓冲区，编写小程序
Linux 技巧汇编
最新发布
极客七
09-06 249
Linux相关经验总结, 技巧汇编,笔记,命令,# 10个重要的Linux ps命令实战 ## 显示所有当前进程 ## 根据用户过滤进程 ## 通过cpu和内存使用来过滤进程 ## 通过进程名和PID过滤 ## 根据线程来过滤进程 ## 树形显示进程 ## 显示安全信息 ## 格式化输出root用户（真实的或有效的UID）创建的进程 ## 使用PS实时监控进程状态 Python 云服务器应用 | Https应用 | 宝塔面板设置服务器进程定时重启 CentOS/RedHat 搭建Dotnet服务器 云镜
【Linux修行路】线程安全和死锁
m0_68662723的博客
09-06 775
今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，您的支持就是我前进的动力！
Linux统计，高级命令
Valder__的博客
09-05 220
常用gzip-->.gz文件、bzip-->.bz2文件、xz-->.xz文件。内部命令直接由shell处理，外部命令通常为可执行文件，存储在系统文件路径中（/bin等）查找命令的路径，用于确定某个命令的可执行文件在系统中的具体位置。为另一个命令的标准输入（也可以理解为有一个AND的作用）识别别名：若某个命令是别名，which会显示别名的信息。永久生效的别名，要将命令写入用户的~/.bashrc。-w：统计字数（单词数），单词以空格或换行符分隔。-L：显示最长一行的长度（字符数）-f：指定归档文件的名称。
[Linux] 项目自动化构建工具-make/Makefile
水墨不写bug
09-03 890
[Linux] 项目自动化构建工具-make/Makefile
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 427
Linux 内核编程 /proc 例子代码
米联客2022 版axi4 总线专题篇
08-27
米联客2022版AXI4总线专题篇是一本关于AXI4总线架构的专题教材。AXI4总线是一种高性能、高带宽的总线协议，通常用于多核处理器和外设的连接。本专题篇主要介绍了AXI4总线的基本原理、信号传输、相关协议和应用实例。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值