STM32MP157驱动开发——按键驱动（休眠与唤醒）

news2024/11/18 17:24:34

文章目录

  • “休眠-唤醒”机制：
  • APP执行过程
  • 内核函数
    • 休眠函数
    • 唤醒函数
  • 休眠与唤醒方式的按键驱动程序(stm32mp157)
    • 驱动程序框架
    • button_test.c
    • gpio_key_drv.c
    • Makefile
    • 修改设备树文件
    • 编译测试

“休眠-唤醒”机制：

当应用程序必须等待某个事件发生，比如必须等待按键被按下时，可以使用“休眠-唤醒”机制：

  • ① APP 调用 read 等函数试图读取数据，比如读取按键；
  • ② APP 进入内核态，也就是调用驱动中的对应函数，发现有数据则复制到用户空间并马上返回；
  • ③ 如果 APP 在内核态，也就是在驱动程序中发现没有数据，则 APP 休眠；
  • ④ 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒 APP；
  • ⑤ APP 继续运行它的内核态代码，也就是驱动程序中的函数，复制数据到用户空间并马上返回。

APP执行过程

在这里插入图片描述

  • 驱动中没有数据时，APP1 在内核态执行到 drv_read 时会休眠。
  • 所谓休眠就是把自己的状态改为非 RUNNING，这样内核的调度器就不会让它运行。
  • 当按下按键，驱动程序中的中断服务程序被调用，它会记录数据，并唤醒 APP1。所以唤醒就是把程序的状态改为 RUNNING，这样内核的调度器有合适的时间就会让它运行。
  • 当 APP1 再次运行时，就会继续执行 drv_read 中剩下的代码，把数据复制回用户空间，返回用户空间。
  • 在 APP的read到内核态的drv_read函数中（进程上下文），也就是在 APP1 的执行过程中，它是可以休眠的
  • 在中断处理函数中（属于中断上下文），不能休眠，也就是不能调用会导致休眠的函数。

内核调度器负责维护该链表，链表里面保存的是线程，如果线程的状态为RUNNING，则会找到合适的时间就会让它运行，如果是非RUNNING，内核的调度器就不会让它运行。

内核函数

参考内核源码： include\linux\wait.h

休眠函数

函数说明
wait_event_interruptible(wq, condition)休眠，直到 condition 为真；休眠期间是可被打断的，可以被信号打断
wait_event(wq, condition)休眠，直到 condition 为真；退出的唯一条件是 condition 为真，信号也不好使
wait_event_interruptible_timeout(wq,condition, timeout)休眠，直到 condition 为真或超时；休眠期间是可被打断的，可以被信号打断
wait_event_timeout(wq, condition,timeout)休眠，直到 condition 为真；退出的唯一条件是 condition 为真，信号也不好使

比较重要的参数就是：

  • ① wq：waitqueue，等待队列
    • 休眠时除了把程序状态改为非 RUNNING 之外，还要把进程/进程放入wq 中，以后中断服务程序要从 wq 中把它取出来唤醒。
    • 没有 wq 的话，茫茫人海中，中断服务程序去哪里找到你？
  • ② condition
    • 这可以是一个变量，也可以是任何表达式。表示“一直等待，直到condition 为真”

唤醒函数

函数说明
wake_up_interruptible(x)唤醒 x 队列中状态为“TASK_INTERRUPTIBLE”的线程，只唤醒其中的一个线程
wake_up_interruptible_nr(x, nr)唤醒 x 队列中状态为“TASK_INTERRUPTIBLE”的线程，只唤醒其中的 nr 个线程
wake_up_interruptible_all(x)唤醒 x 队列中状态为“TASK_INTERRUPTIBLE”的线程，唤醒其中的所有线程
wake_up(x)唤 醒 x 队 列 中 状 态 为 “ TASK_INTERRUPTIBLE ” 或“TASK_UNINTERRUPTIBLE”的线程，只唤醒其中的一个线程
wake_up_nr(x, nr)唤 醒 x 队 列 中 状 态 为 “ TASK_INTERRUPTIBLE ” 或“TASK_UNINTERRUPTIBLE”的线程，只唤醒其中 nr 个线程
wake_up_all(x)唤 醒 x 队 列 中 状 态 为 “ TASK_INTERRUPTIBLE ” 或“TASK_UNINTERRUPTIBLE”的线程，唤醒其中的所有线程

休眠与唤醒方式的按键驱动程序(stm32mp157)

驱动程序框架

在这里插入图片描述

要休眠的线程，放在 wq 队列里，中断处理函数从 wq 队列里把它取出来唤醒。

代码编写内容

  • ① 初始化 wq 队列
  • ② 在驱动的 read 函数中，调用 wait_event_interruptible：
    • 它本身会判断 event 是否为 FALSE，如果为 FASLE 表示无数据，则休眠。当从 wait_event_interruptible 返回后，把数据复制回用户空间。
  • ③ 在中断服务程序里：
    • 设置 event 为 TRUE，并调用 wake_up_interruptible 唤醒线程。

button_test.c

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

/*
 * ./button_test /dev/100ask_button0
 *
 */
int main(int argc, char **argv)
{
	int fd;
	int val;
	
	/* 1. 判断参数 */
	if (argc != 2) 
	{
		printf("Usage: %s <dev>\n", argv[0]);
		return -1;
	}

	/* 2. 打开文件 */
	fd = open(argv[1], O_RDWR);
	if (fd == -1)
	{
		printf("can not open file %s\n", argv[1]);
		return -1;
	}

	while (1)
	{
		/* 3. 读文件 */
		read(fd, &val, 4);
		printf("get button : 0x%x\n", val);
	}
	
	close(fd);
	
	return 0;
}

gpio_key_drv.c

使用环形缓冲区来保存按键值，相比于全局变量，可以避免被覆盖的问题

#include <linux/module.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>


struct gpio_key{
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
} ;

static struct gpio_key *gpio_keys_first;

/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;

/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;//r，w是指针，指向读写的位置

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
	return (r == w);//一开始rw都是0，表示空
}

static int is_key_buf_full(void)
{
	return (r == NEXT_POS(w));//下一个写的位置等于r表示满，容量为128字节的buffer存储到127表示满了
}

static void put_key(int key)
{
	if (!is_key_buf_full())
	{
		g_keys[w] = key;//把数据放入w位置
		w = NEXT_POS(w);//移动w
	}
}

static int get_key(void)
{
	int key = 0;
	if (!is_key_buf_empty())
	{
		key = g_keys[r];//从r位置读数据
		r = NEXT_POS(r);//移动r
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);//该队列使用宏来初始化

/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
	struct gpio_key *gpio_key = dev_id;
	int val;
	int key;
	
	val = gpiod_get_value(gpio_key->gpiod);
	

	printk("key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
	int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;
	enum of_gpio_flags flag;
		
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	count = of_gpio_count(node);
	if (!count)
	{
		printk("%s %s line %d, there isn't any gpio available\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}

	gpio_keys_first = kzalloc(sizeof(struct gpio_key) * count, GFP_KERNEL);
	for (i = 0; i < count; i++)
	{
		gpio_keys_first[i].gpio = of_get_gpio_flags(node, i, &flag);
		if (gpio_keys_first[i].gpio < 0)
		{
			printk("%s %s line %d, of_get_gpio_flags fail\n", __FILE__, __FUNCTION__, __LINE__);
			return -1;
		}
		gpio_keys_first[i].gpiod = gpio_to_desc(gpio_keys_first[i].gpio);
		gpio_keys_first[i].flag = flag & OF_GPIO_ACTIVE_LOW;
		gpio_keys_first[i].irq  = gpio_to_irq(gpio_keys_first[i].gpio);
	}

	for (i = 0; i < count; i++)
	{
		err = request_irq(gpio_keys_first[i].irq, gpio_key_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpio_keys_first[i]);
	}

	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_gpio_key", &gpio_key_drv);  /* /dev/gpio_key */

	gpio_key_class = class_create(THIS_MODULE, "100ask_gpio_key_class");
	if (IS_ERR(gpio_key_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_gpio_key");
		return PTR_ERR(gpio_key_class);
	}

	device_create(gpio_key_class, NULL, MKDEV(major, 0), NULL, "100ask_gpio_key"); /* /dev/100ask_gpio_key */
        
    return 0;
    
}

static int gpio_key_remove(struct platform_device *pdev)
{
	//int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;

	device_destroy(gpio_key_class, MKDEV(major, 0));
	class_destroy(gpio_key_class);
	unregister_chrdev(major, "100ask_gpio_key");

	count = of_gpio_count(node);
	for (i = 0; i < count; i++)
	{
		free_irq(gpio_keys_first[i].irq, &gpio_keys_first[i]);
	}
	kfree(gpio_keys_first);
    return 0;
}


static const struct of_device_id my_keys[] = {
    { .compatible = "first_key,gpio_key" },
    { },
};

/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
    .probe      = gpio_key_probe,
    .remove     = gpio_key_remove,
    .driver     = {
        .name   = "my_gpio_key",
        .of_match_table = my_keys,
    },
};

/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
    int err;
    
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    err = platform_driver_register(&gpio_keys_driver); 
	
	return err;
}

/* 3. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 *     卸载platform_driver
 */
static void __exit gpio_key_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

    platform_driver_unregister(&gpio_keys_driver);
}


/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(gpio_key_init);
module_exit(gpio_key_exit);

MODULE_LICENSE("GPL");

Makefile

# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR =   /home/book/100ask_stm32mp157_pro-sdk/Linux-5.4

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o button_test button_test.c
clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order  button_test

# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o



obj-m += gpio_key_drv.o

修改设备树文件

在这里插入图片描述
对于一个引脚要用作中断时，

  • a) 要通过 PinCtrl 把它设置为 GPIO 功能；【ST 公司对于 STM32MP157 系列芯片，GPIO 为默认模式 不需要再进行配置Pinctrl 信息】
  • b) 表明自身：是哪一个 GPIO 模块里的哪一个引脚【修改设备树】

打开内核的设备树文件：arch/arm/boot/dts/stm32mp157c-100ask-512d-lcd-v1.dts

gpio_keys_first {
	compatible = "first_key,gpio_key";
	gpios = <&gpiog 3 GPIO_ACTIVE_LOW
			&gpiog 2 GPIO_ACTIVE_LOW>;
};

与此同时，需要把用到引脚的节点禁用

注意，如果其他设备树文件也用到该节点，需要设置属性为disabled状态，在arch/arm/boot/dts目录下执行如下指令查找哪些设备树用到该节点

grep "&gpiog" * -nr

如果用到该节点，需要添加属性去屏蔽：

status = "disabled";

在这里插入图片描述

编译测试

首先要设置 ARCH、CROSS_COMPILE、PATH 这三个环境变量后，进入 ubuntu 上板子内核源码的目录，在Linux内核源码根目录下，执行如下命令即可编译 dtb 文件：

make dtbs V=1

编译好的文件在路径由DTC指定，移植设备树到开发板的共享文件夹中，先保存源文件，然后覆盖源文件，重启后会挂载新的设备树，进入该目录查看是否有新添加的设备节点

cd /sys/firmware/devicetree/base

编译驱动程序，在Makefile文件目录下执行make指令，此时，目录下有编译好的内核模块gpio_key_drv.ko和可执行文件button_test文件移植到开发板上

确定一下烧录系统：cat /proc/mounts，查看boot分区挂载的位置，将其重新挂载在boot分区：mount /dev/mmcblk2p2 /boot，然后将共享文件夹里面的设备树文件拷贝到boot目录下，这样的话设备树文件就在boot目录下

cp /mnt/stm32mp157c-100ask-512d-lcd-v1.dtb /boot

重启后挂载，运行

insmod -f gpio_key_drv.ko // 强制安装驱动程序
ls /dev/my_gpio_key
./button_test /dev/my_gpio_key & //后台运行，此时prink函数打印的内容看不到

然后按下按键

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/788611.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

docker - 学习笔记

docker - 学习笔记

一、简介 1.1 相关地址 Docker是基于Go语言开发的官网&#xff1a;https://www.docker.com/官方文档&#xff1a;https://docs.docker.com/仓库地址&#xff1a;https://hub.docker.com/ 1.2 虚拟化技术和容器化技术对比 1.2.1 虚拟化技术的缺点 资源占用十分多冗余步骤多启…
阅读更多...
vue 中断请求

vue 中断请求

1 背景&#xff1a;针对一些请求时间较长&#xff0c;组件销毁后即中断请求&#xff1b; 2 方法&#xff1a; data(){return {//用于取消请求abortController:new AbortController(), } }, created(){//请求接口this.groundAcquisition(); }, beforeDestroy(){//中断请求this.…
阅读更多...
网安高级笔记1

网安高级笔记1

html实体编码 HTML实体编码&#xff0c;格式 以&符号开头&#xff0c;以;分号结尾的 HTML 中的预留字符必须被替换为字符实体 在 HTML 中不能使用小于号&#xff08;<&#xff09;和大于号&#xff08;>&#xff09;&#xff0c;这是因为浏览器会误认为它们是…
阅读更多...
Python内置函数系统学习（2）——数据转换与计算（详细语法参考 + 参数说明 + 具体示例），详解max()函数实例 | 编程实现当前内存使用情况的监控

Python内置函数系统学习（2）——数据转换与计算（详细语法参考 + 参数说明 + 具体示例），详解max()函数实例 | 编程实现当前内存使用情况的监控

才识是岁月的冠冕&#xff0c;正如思念是我们共同的时光。 【Neo4j Python】基于知识图谱的电影问答系统&#xff08;含问题记录与解决&#xff09;附&#xff1a;源代码&#xff08;含Bug解决&#xff09;【Neo4j 知识图谱】图形化数据库基本操作: 创建节点与关系、添加属性…
阅读更多...
了解Unity编辑器之组件篇Scripts（六）

了解Unity编辑器之组件篇Scripts（六）

Scripts&#xff1a;有Unity提供的一些脚本插件&#xff08;自己新建的脚本也会出现在里面&#xff09; 一、TMPro&#xff1a;有一些与文字显示和排版相关的脚本 1.TextContainer&#xff08;文本容器&#xff09;&#xff1a;TextContainer 是一个内容框&#xff0c;用于定…
阅读更多...
5分钟掌握接口自动化测试，4个知识点简单易学！

5分钟掌握接口自动化测试，4个知识点简单易学！

一. 什么是接口测试 接口测试是一种软件测试方法&#xff0c;用于验证不同软件组件之间的通信接口是否按预期工作。在接口测试中&#xff0c;测试人员会发送请求并检查接收到的响应&#xff0c;以确保接口在不同场景下都能正常工作。 就工具而言&#xff0c;常见的测试工具有…
阅读更多...
代码随想录-108-背包问题

代码随想录-108-背包问题

目录 前言思路3. 算法实现4. 算法坑点 前言 我在刷卡哥的“代码随想录”&#xff0c;自己的总结笔记均会放在“算法刷题-代码随想录”该专栏下。 代码随想录此题链接 思路 前提&#xff0c;当前的物品有i1个&#xff0c;编号为0~i&#xff0c;重量weight和价值value数组如下…
阅读更多...
FreeRTOS（软件定时器）

FreeRTOS（软件定时器）

一、什么是定时器 简单可以理解为闹钟&#xff0c;到达指定一段时间后&#xff0c;就会响铃。 STM32 芯片自带硬件定时器&#xff0c;精度较高&#xff0c;达到定时时间后会触发中断&#xff0c;也可以生成 PWM 、输入 捕获、输出比较&#xff0c;等等&#xff0c;功能强大&am…
阅读更多...
springMVC--中文乱码处理(新思路--化繁为简)

springMVC--中文乱码处理(新思路--化繁为简)

文章目录 springMVC--中文乱码处理(新思路--化繁为简)编码过滤器自定义中文乱码过滤器举例应用实例1. 创建过滤器springmvc\src\com\web\filter\MyCharacterFilter.java实现思路 2. 配置web.xml完成测试 Spring MVC--过滤器处理中文修改web.xml完成测试 springMVC–中文乱码处理…
阅读更多...
Go语言导入本地文件包

Go语言导入本地文件包

Go语言导入本地文件包 ​ 在Go程序中&#xff0c;每一个包通过称为**导入路径&#xff08;import path&#xff09;**的唯一字符串来标识。它们出现在import声明中&#xff0c; 一个导入路径标注一个目录&#xff0c;目录中包含构成包的一个或多个Go源文件。 举例&#xff1a;…
阅读更多...
数据库应用：Redis主从复制、哨兵、cluster集群

数据库应用：Redis主从复制、哨兵、cluster集群

目录 一、理论 1.Redis高可用 2.Redis主从复制 3.部署Redis主从复制 4.Redis哨兵模式 5.部署Redis哨兵模式 6.Redis集群模式 7.部署Redis集群 二、实验 1.部署Redis主从复制 2.部署Redis哨兵模式 3.部署Redis集群 三、问题 1.开启Redis群集失败 四、总结 一、理…
阅读更多...
HTML5+CSS3+JS小实例：翻滚吧乔巴自定义滑块控件

HTML5+CSS3+JS小实例：翻滚吧乔巴自定义滑块控件

实例：翻滚吧乔巴自定义滑块控件 技术栈：HTML+CSS+JS 效果： 源码： 【html】 <!DOCTYPE html> <html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"><meta name="viewport" cont…
阅读更多...
Docker 安装 Nacos

Docker 安装 Nacos

简介 Nacos 是一个轻量级的服务发现、配置管理和服务管理平台&#xff0c;它支持多种语言&#xff08;Java、Go、Node.js 等&#xff09;和多种协议&#xff08;HTTP、gRPC、DNS 等&#xff09;&#xff0c;能够帮助开发者构建微服务体系结构&#xff0c;简化了应用程序在不同…
阅读更多...
入门前端监控

入门前端监控

背景 前端监控是指通过一系列手段对Web页面或应用程序进行实时监控和数据采集&#xff0c;以了解页面或应用程序的性能状况、用户行为等等&#xff0c;并及时发现和解决潜在的问题。一个完整的前端监控平台可以包括&#xff1a;数据收集与上报、数据整理与存储、数据展示这里仅…
阅读更多...
去重排序2——set

去重排序2——set

题目描述 输入 个正整数 ​ &#xff0c;按照从大到小的顺序输出不重复的数。 输入格式 第一行一个整数 n 。 第二行 个用空格隔开的正整数 ​ 。 输出格式 每行一个正整数&#xff0c;为从大到小排序后的不重复的数。 样例 #1 样例输入 #1 8 1 3 4 2 2 2 3 1样例输出 #1 4 3…
阅读更多...
Linux Mint 21.2 “Victoria “现已可供下载

Linux Mint 21.2 “Victoria “现已可供下载

导读Linux Mint 21.2 “Victoria “发行版今天出现在该项目全球稳定镜像上&#xff0c;这意味着开发者将很快发布官方公告&#xff0c;通知想要下载最新Linux Mint版本的用户。 Linux Mint 21.2从2023年6月21日开始进行公开测试&#xff0c;这给了开发者足够的时间来修复剩余的…
阅读更多...
redis（11）：springboot中使用redis

redis（11）：springboot中使用redis

1 创建springboot项目 2 创建pom文件 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http:/…
阅读更多...
同样是测试点工，他凭啥薪资比我高？

同样是测试点工，他凭啥薪资比我高？

如果别人在功能测试方面薪资比你高那是因为做得比你好&#xff0c;别人功能测试做的比你好可能有以下几个原因&#xff1a; 测试策略和方法&#xff1a;别人可能采用了更有效的测试策略和方法&#xff0c;能够更全面地覆盖功能的各个方面。他们可能有更深入的测试计划和设计&a…
阅读更多...
【云驻共创】CodeArts Repo ---高效代码协同开发之旅

【云驻共创】CodeArts Repo ---高效代码协同开发之旅

目录 一、代码托管发展史 1.1 第一代 1.2 第二代 1.3 第三代 二、CodeArts Repo 介绍 二、CodeArts Repo 功能架构 2.1 研发协同 2.2 代码管理功能 2.3 代码存储特性 三、CodeArts Repo 技术能力 三、华为云代码托管技术发展历程 四、CodeAr…
阅读更多...
《重构的时机和方法》一本值得程序员都认真读的书

《重构的时机和方法》一本值得程序员都认真读的书

写在前面 《重构的时机和方法》是一本关于软件开发中重构技术的书籍。它以独特的风格和内容优势&#xff0c;为读者提供了全面而易于理解的指导&#xff0c;帮助他们在实际项目中应用重构技术&#xff0c;提高代码质量和开发效率。这本书由两个不同风格的部分组成&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023