9.5I2C适配器驱动

最新推荐文章于 2024-07-24 09:48:42 发布
最新推荐文章于 2024-07-24 09:48:42 发布
阅读量37 收藏
点赞数 1
分类专栏： linux驱动开发 文章标签： linux 驱动开发 arm开发 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lf282481431/article/details/134864723
版权

此章节利用GPIO模拟I2C时序实现一个I2C适配器驱动，有关I2C时序相关内容可以参考博文深入浅出理解I2C协议

硬件连接

这里利用GPIO A11和GPIO A12引脚来模拟I2C总线的SCL和SDA，用于驱动外设AP3216C，有关AP3216C的驱动已经在9.4在内核空间使用I2C总线章节中实现，可以直接使用，因此本章节只实现一个利用GPIO模拟I2C控制器的驱动。
在这里插入图片描述在这里插入图片描述

编写设备树

按如下步骤在设备树中添加GPIO I2C适配器的描述

  1. 在顶层设备树的根节点中添加如下节点
i2c_gpio@sfi2c0 {
   compatible = "alientek,gpio-i2c";
   sda-gpio = <&gpioa 12 GPIO_ACTIVE_HIGH>;
   scl-gpio = <&gpioa 11 GPIO_ACTIVE_HIGH>;
   delay-us = <5>;
   #address-cells = <1>;
   #size-cells = <0>;

   ap3216c@1e {
   	compatible = "alientek,ap3216c";
   	labe = "ap3216c_0";
   	reg = <0x1e>;
   };
};
  1. 在顶层设备树中引用i2c5节点，将状态修改为disable，因为GPIO模拟的IIC适配器使用了I2C5控制器的引脚
&i2c5 {
	pinctrl-names = "default", "sleep";
	pinctrl-0 = <&i2c5_pins_a>;
	pinctrl-1 = <&i2c5_pins_sleep_a>;
	status = "disable";

	ap3216c@1e {
		compatible = "alientek,ap3216c";
		labe = "ap3216c_0";
		reg = <0x1e>;
	};
};

编写驱动代码

内核空间I2C驱动主要包括以下部分：

  1. 实现master_xfer函数和functionality函数，master_xfer函数用于传输i2c_msg，functionality函数用于返回I2C控制器所支持的功能
static const struct i2c_algorithm adapter_algorithm = {
	.master_xfer = adapter_master_xfer,
	.functionality = adapter_func,
};
  1. 分配并初始化i2c_adapter
	i2c_bit->adapter.owner = THIS_MODULE;
	i2c_bit->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_DDC | I2C_CLASS_SPD;
	i2c_bit->adapter.nr = -1;
	i2c_bit->adapter.algo = &adapter_algorithm;
	i2c_bit->adapter.dev.of_node = pdev->dev.of_node;
	i2c_bit->adapter.dev.parent = &pdev->dev;
	snprintf(i2c_bit->adapter.name, sizeof(i2c_bit->adapter.name), "gpio-i2c-bus");
  1. 注册i2c_adapter
i2c_add_adapter(&i2c_bit->adapter);

完整的GPIO模拟I2C适配器的代码如下：

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c-algo-bit.h>
#include <linux/i2c.h>

#ifndef I2C_BIT_OUTPUT_OD
#define SDA_INPUT(i2c_bit)		gpiod_direction_input((i2c_bit)->sda)
#define SDA_OUTPUT(i2c_bit)		gpiod_direction_output((i2c_bit)->sda, 1)
#else
#define SDA_INPUT(i2c_bit) 
#define SDA_OUTPUT(i2c_bit)
#endif

#define SDA_H(i2c_bit)			gpiod_set_value((i2c_bit)->sda, 1)
#define SDA_L(i2c_bit)			gpiod_set_value((i2c_bit)->sda, 0)

#define SCL_H(i2c_bit)			gpiod_set_value((i2c_bit)->scl, 1)
#define SCL_L(i2c_bit)			gpiod_set_value((i2c_bit)->scl, 0)

#define SET_SDA(i2c_bit, val)	((val)==0 ? SDA_L(i2c_bit) : SDA_H(i2c_bit))
#define GET_SDA(i2c_bit)		gpiod_get_value((i2c_bit)->sda)

#define DELAY(i2c_bit)			udelay((i2c_bit)->delay_us)
#define DELAY2(i2c_bit)			udelay((i2c_bit)->delay_us >> 1)

typedef struct gpio_adapter {
	struct i2c_adapter adapter;
	struct gpio_desc *scl;
	struct gpio_desc *sda;
	uint32_t delay_us;
}gpio_adapter_t;

static void _i2c_start(gpio_adapter_t *i2c_bit)
{
	SDA_OUTPUT(i2c_bit);
	
	SDA_L(i2c_bit);
	DELAY(i2c_bit);
	SCL_L(i2c_bit);
	DELAY2(i2c_bit);
}

static void _i2c_restart(gpio_adapter_t *i2c_bit)
{
	SDA_OUTPUT(i2c_bit);
	
	SDA_H(i2c_bit);
	DELAY2(i2c_bit);
	SCL_H(i2c_bit);
	DELAY(i2c_bit);
	
	SDA_L(i2c_bit);
	DELAY(i2c_bit);
	SCL_L(i2c_bit);
	DELAY2(i2c_bit);
}

static void _i2c_stop(gpio_adapter_t *i2c_bit)
{
	SDA_OUTPUT(i2c_bit);
	
	SDA_L(i2c_bit);
	SCL_L(i2c_bit);
	DELAY2(i2c_bit);
	
	SCL_H(i2c_bit);
	DELAY(i2c_bit);
	SDA_H(i2c_bit);
	DELAY(i2c_bit);
}

static int _i2c_waitack(gpio_adapter_t *i2c_bit, int ignore_nack)
{
	int ack;
	
	SDA_INPUT(i2c_bit);
	
	SDA_H(i2c_bit);
	DELAY2(i2c_bit);
	SCL_H(i2c_bit);
	DELAY(i2c_bit);
	ack = GET_SDA(i2c_bit);
	SCL_L(i2c_bit);
	DELAY2(i2c_bit);
	if(ignore_nack)
		return 0;
	
	return (ack==0) ? 0 : -EIO;
}

static void _i2c_sendack(gpio_adapter_t *i2c_bit, int ack)
{
	SDA_OUTPUT(i2c_bit);
	
	SET_SDA(i2c_bit, ack);
	DELAY2(i2c_bit);
	SCL_H(i2c_bit);
	DELAY(i2c_bit);
	SCL_L(i2c_bit);
	DELAY2(i2c_bit);
}

static int _i2c_writeb(gpio_adapter_t *i2c_bit, uint8_t data, int ignore_nack)
{
	int8_t i;
	uint8_t bit;
	
	SDA_OUTPUT(i2c_bit);
	for(i = 7; i >= 0; i--)
	{
		bit = (data >> i) & 1;
		SET_SDA(i2c_bit, bit);
		DELAY2(i2c_bit);
		SCL_H(i2c_bit);
		DELAY(i2c_bit);
		SCL_L(i2c_bit);
		DELAY2(i2c_bit);
	}

	return _i2c_waitack(i2c_bit, ignore_nack);
}

static uint8_t _i2c_readb(gpio_adapter_t *i2c_bit, int ack)
{
	int8_t i;
	uint8_t data;
	
	SDA_INPUT(i2c_bit);
	SDA_H(i2c_bit);
	DELAY2(i2c_bit);
	for(data = 0, i = 7; i >= 0; i--)
	{
		SCL_H(i2c_bit);
		DELAY(i2c_bit);
		data |= GET_SDA(i2c_bit) << i;
		SCL_L(i2c_bit);
		if(i != 0)
			DELAY(i2c_bit);
		else
			DELAY2(i2c_bit);
	}
	_i2c_sendack(i2c_bit, ack);
	
	return data;
}

static int _i2c_send_bytes(gpio_adapter_t *i2c_bit, struct i2c_msg *msg)
{
	int result;
	int bytes;
	uint16_t ignore_nack = msg->flags & I2C_M_IGNORE_NAK;

	for(bytes = 0; bytes < msg->len; )
	{
		result = _i2c_writeb(i2c_bit, msg->buf[bytes], ignore_nack);
		if(result == 0)
			bytes++;
		else
			break;
	}

	return bytes;
}

static int _i2c_recv_bytes(gpio_adapter_t *i2c_bit, struct i2c_msg *msg)
{
	int ack;
	int bytes;

	for(bytes = 0; bytes < msg->len; bytes++)
	{
		if((msg->flags & I2C_M_NO_RD_ACK) || (bytes >= (msg->len-1)))
			ack = 1;
		else
			ack = 0;
		msg->buf[bytes] = _i2c_readb(i2c_bit, ack);
	}
	
	return bytes;
}

static int _i2c_send_address(gpio_adapter_t *i2c_bit, struct i2c_msg *msg)
{
	uint8_t addr1;
	uint8_t addr2;
	int result;
	uint16_t ignore_nack = msg->flags & I2C_M_IGNORE_NAK;

	if(msg->flags & I2C_M_TEN)
	{
		addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);
		addr2 = msg->addr & 0xff;

		result = _i2c_writeb(i2c_bit, addr1, ignore_nack);
		if(result != 0)
			return result;
		result = _i2c_writeb(i2c_bit, addr2, ignore_nack);
		if(result != 0)
			return result;

		if(msg->flags & I2C_M_RD)
		{
			_i2c_restart(i2c_bit);
			addr1 |= 0x01;
			result = _i2c_writeb(i2c_bit, addr1, ignore_nack);
			if(result != 0)
				return result;
		}
	}
	else
	{
		/* 7-bit addr */
		addr1 = msg->addr << 1;
		if(msg->flags & I2C_M_RD)
			addr1 |= 1;
		result = _i2c_writeb(i2c_bit, addr1, ignore_nack);
		if(result != 0)
			return result;
	}

	return 0;
}

static int adapter_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
{
	struct i2c_msg *msg;
	int result;
	gpio_adapter_t *i2c_bit = container_of(i2c_adap, gpio_adapter_t, adapter);

	for(result=0; result<num; result++)
	{
		msg = &msgs[result];

		//发送开始信号或重启信号
		if((!(msg->flags & I2C_M_NOSTART)) || (result == 0))
		{
			if(result == 0)
			{
				//产生开始信号
				_i2c_start(i2c_bit);
			}
			else
			{
				//产生重启信号
				_i2c_restart(i2c_bit);
			}
			//发送设备地址
			if(_i2c_send_address(i2c_bit, msg) != 0)
			{
				_i2c_stop(i2c_bit);
				break;
			}
		}

		//传输数据
		if(msg->flags & I2C_M_RD)
		{
			//读数据
			if(_i2c_recv_bytes(i2c_bit, msg) != msg->len)
			{
				_i2c_stop(i2c_bit);
				printk("recv data failed");
				break;
			}
		}
		else {
			//写数据
			if(_i2c_send_bytes(i2c_bit, msg) != msg->len)
			{
				_i2c_stop(i2c_bit);
				printk("send data failed");
				break;
			}
		}

		//产生停止信号
		if(((msg->flags & I2C_M_STOP)) || (result >= (num-1)))
			_i2c_stop(i2c_bit);
	}

	return result;
}

static u32 adapter_func(struct i2c_adapter *adap)
{
	return I2C_FUNC_I2C | I2C_FUNC_NOSTART
		| I2C_FUNC_SMBUS_EMUL | I2C_FUNC_SMBUS_READ_BLOCK_DATA
		| I2C_FUNC_SMBUS_BLOCK_PROC_CALL | I2C_FUNC_PROTOCOL_MANGLING;
}

static const struct i2c_algorithm adapter_algorithm = {
	.master_xfer = adapter_master_xfer,
	.functionality = adapter_func,
};
//设备和驱动匹配成功执行
static int adapter_probe(struct platform_device *pdev)
{
	int result;
	gpio_adapter_t *i2c_bit;

	printk("%s\r\n", __FUNCTION__);

	//分配设备句柄
	i2c_bit = devm_kzalloc(&pdev->dev, sizeof(gpio_adapter_t), GFP_KERNEL);
	if(!i2c_bit)
	{
		printk("alloc memory failed\r\n");
		return -ENOMEM;
	}
	//复位设备句柄
	memset(i2c_bit, 0, sizeof(gpio_adapter_t));

	//获取时钟延时
	result = of_property_read_u32(pdev->dev.of_node, "delay-us", &i2c_bit->delay_us);
	if(result < 0)
	{
		printk("get dev id failed\r\n");
		return result;
	}

#ifndef I2C_BIT_OUTPUT_OD
	//获取SCL引脚，并输出高电平
	i2c_bit->scl = devm_gpiod_get(&pdev->dev, "scl", GPIOD_OUT_HIGH);
	if(IS_ERR(i2c_bit->scl))
	{
		printk("get scl gpio failed\r\n");
		return PTR_ERR(i2c_bit->scl);
	}
	//获取SDA引脚，并输出高电平
	i2c_bit->sda = devm_gpiod_get(&pdev->dev, "sda", GPIOD_OUT_HIGH);
	if(IS_ERR(i2c_bit->sda))
	{
		printk("get sda gpio failed\r\n");
		return PTR_ERR(i2c_bit->sda);
	}
#else
	//获取SCL引脚，并输出高电平
	i2c_bit->scl = devm_gpiod_get(&pdev->dev, "scl", GPIOD_OUT_HIGH);
	if(IS_ERR(i2c_bit->scl))
	{
		printk("get scl gpio failed\r\n");
		return PTR_ERR(i2c_bit->scl);
	}
	//获取SDA引脚，并设置为输入
	i2c_bit->sda = devm_gpiod_get(&pdev->dev, "sda", GPIOD_IN);
	if(IS_ERR(i2c_bit->sda))
	{
		printk("get sda gpio failed\r\n");
		return PTR_ERR(i2c_bit->sda);
	}
#endif

	//初始化I2C适配器
	i2c_bit->adapter.owner = THIS_MODULE;
	i2c_bit->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_DDC | I2C_CLASS_SPD;
	i2c_bit->adapter.nr = -1;
	i2c_bit->adapter.algo = &adapter_algorithm;
	i2c_bit->adapter.dev.of_node = pdev->dev.of_node;
	i2c_bit->adapter.dev.parent = &pdev->dev;
	snprintf(i2c_bit->adapter.name, sizeof(i2c_bit->adapter.name), "gpio-i2c-bus");
	//添加I2C适配器
	result = i2c_add_adapter(&i2c_bit->adapter);
	if(result < 0)
	{
		printk("add adapter failed\r\n");
		return result;
	}

	//设置平台设备的驱动私有数据
	pdev->dev.driver_data = (void*)i2c_bit;

	return 0;
}

//设备或驱动卸载时执行
static int adapter_remove(struct platform_device *pdev)
{
	gpio_adapter_t *i2c_bit;

	printk("%s\r\n", __FUNCTION__);

	i2c_bit = (gpio_adapter_t*)pdev->dev.driver_data;

	i2c_del_adapter(&i2c_bit->adapter);

	return 0;
}

/* 匹配列表，用于设备树和平台驱动匹配 */
static const struct of_device_id adapter_of_match[] = {
	{.compatible = "alientek,gpio-i2c"},
	{ /* Sentinel */ }
};
//平台驱动
static struct platform_driver adapter_drv = {
	.driver = {
		.name = "gpio_adapter",
		.owner = THIS_MODULE,
		.pm = NULL,
		.of_match_table = adapter_of_match,
	},
	.probe = adapter_probe,
	.remove = adapter_remove,
};
static int __init adapter_drv_init(void)
{
	int result;

	printk("%s\r\n", __FUNCTION__);

	//注册平台驱动
	result = platform_driver_register(&adapter_drv);
	if(result != 0)
	{
		printk("add cdev failed\r\n");
		return result;
	}

	return result;
}

static void __exit adapter_drv_exit(void)
{
	printk("%s\r\n", __FUNCTION__);

	//注销平台驱动
	platform_driver_unregister(&adapter_drv);
}

module_init(adapter_drv_init);
module_exit(adapter_drv_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("LF");
MODULE_DESCRIPTION("adapter_dev");

编写驱动测试程序

驱动测试程序可以使用在9.4在内核空间使用I2C总线章节中编写的AP3216C驱动及其对应的测试程序。

上机测试

  1. 根据硬件原理图对设备树进行修改，然后用命令make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- dtbs -j8编译设备树，并用新的设备树启动目标板。
  2. 从这里下载代码并进行编译，得到GPIO模拟I2C适配器的驱动，然后将编译出来的.ko文件拷贝到目标板根文件系统的root目录中。
  3. 从这里下载代码并进行编译，得到AP3216C的驱动及其测试程序，然后将编译出来的.ko文件和.out文件拷贝到目标板根文件系统的root目录中。
    在这里插入图片描述
  4. 执行命令insmod i2c_adapter.ko加载I2C适配器驱动。
    在这里插入图片描述
  5. 执行命令insmod ap3216c.ko加载AP3216C驱动，此时在/dev/目录下生成ap3216c_0设备文件。
    在这里插入图片描述
  6. 执行命令./app.out /dev/ap3216c_0启动ap3216c的测试程序。测试程序会通过系统的read函数调用AP3216C驱动的read函数，AP3216C驱动的read函数又通过GPIO模拟I2C适配器驱动控制GPIO读取AP3216C的寄存器，然后将寄存器的值返回应用层。
    在这里插入图片描述
lf282481431
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java linux 设备驱动_《Linux设备驱动开发详解：基于最新的Linux4.0内核
weixin_31517893的博客
02-13 214
图书目录：赞誉推荐序一推荐序二前言第1章 Linux设备驱动概述及开发环境构建1.1 设备驱动的作用1.2 无操作系统时的设备驱动1.3 有操作系统时的设备驱动1.4 Linux设备驱动1.4.1 设备的分类及特点1.4.2 Linux设备驱动与整个软硬件系统的关系1.4.3 Linux设备驱动的重点、难点1.5 Linux设备驱动的开发环境构建1.5.1 PC上的Linux环境1.5.2 QEM...
精通LINUX设备驱动程序开发
05-24
158 7.3　调试 159 7.4　查看源代码 160 第8章　i2c协议 161 8.1　i2c/smbus是什么 161 8.2　i2c核心 162 8.3　总线事务 164 8.4　设备实例：eeprom 164 8.4.1　初始化 165 8.4.2　探测设备 167 8.4.3　检查适配器的...
Linux驱动框架学习——I2C驱动体系
weixin_53351963的博客
02-10 663
Linux系统定义了I2C驱动体系结构，将I2C驱动分为三部分:I2C核心、I2C总线驱动和I2C设备驱动
linux驱动开发
嵌入式分享
06-08 4446
liunx驱动开发
主机模拟i2c检测设备时出现错误死循环_适用于PLC/DCS应用，支持HART和Modbus连接的模拟I/O系统...
weixin_39688378的博客
10-29 456
评估和设计支持电路评估板CN-0414电路评估板(EVAL-CN0414-ARDZ)CN-0418电路评估板(EVAL-CN0418-ARDZ)CN-0416电路评估板(EVAL-CN0416-ARDZ)ADALM-UARTJTAG板Arduino尺寸开发平台(EVAL-ADICUP3029)设计和集成文件PLC/DCS Wiki用户指南原理图、布局文件、物料清单、软件电路功能与优势可编程逻辑控制...
9.触摸屏驱动（IIC）移植实战
luoguoxian12的博客
07-07 3376
转自 https://edu.csdn.net/lecturer/505 朱老师物联网大讲堂 《5.linux驱动开发-第9部分-5.9.触摸屏驱动移植实战》 第一部分、章节目录 5.9.1.触摸屏驱动概览 5.9.2.内核中的竞争状态和互斥1 5.9.3.内核中的竞争状态和互斥2 5.9.4.中断的上下半部1 5.9.5.中断的上下半部2 5.9.6.linux内核的I2C子系统详解1 5.9.7.linux内核的I2C子系统详解2 5.9.8.linux内核的I2C子系统详解3 5.9.9.linux
linux设备驱动开发详解孔夫子,Linux设备驱动开发详解 。、
weixin_30636449的博客
05-11 193
【内容简介】本书是一本介绍Linux设备驱动开发理论、框架与实例的书，本书以Linux2.6版本内核为蓝本，详细介绍自旋锁、信号量、完成量、中断顶/底半部、定时器、内存和I/O映射以及异步通知、阻塞I/O、非阻塞I/O等Linux设备驱动理论；字符设备、块设备、TTY设备、I2C设备、LCD设备、音频设备、USB设备、网络设备、PCI设备等Linux设备驱动的架构和框架中各个复杂数据架构和函数的关...
linux驱动程序的好书,好书推荐----Linux驱动开发入门与实战
weixin_28866303的博客
05-01 952
内容简介本书由浅入深，全面、系统地介绍了linux驱动开发技术，提供了大量实例供读者实战演练。另外，作者在实例讲解中详细分析了各种重要的理论知识，让读者能够举一反三。本书共分3篇。第1篇介绍了linux驱动开发概述、嵌入式处理器和开发板、构建嵌入式驱动程序开发环境、构建嵌入式linux操作系统、第一个驱动程序、简单的字符设备驱动程序等内容；第2篇介绍了设备驱动中的并发控制、阻塞和同步机制、中断与时...
不兼容结构的协调——适配器模式
papaya的博客
01-03 431
本文转载自 ：http://blog.csdn.net/lovelion/article/details/8624325 我的笔记本电脑的工作电压是20V，而我国的家庭用电是220V，如何让20V的笔记本电脑能够在220V的电压下工作？答案是引入一个电源适配器(AC Adapter)，俗称充电器或变压器，有了这个电源适配器，生活用电和笔记本电脑即可兼容，如图9-1所示：
《Linux设备驱动开发详解(第2版)》隆重出版
宋宝华
11-04 5583
Linux设备驱动开发详解(第2版)(前一版狂销3万册，畅销书最新升级） [新品]
visual C++_Turbo C串口通信编程实践
07-30
9.5 在已经编好的串口通信程序中加入网络通信功能 9.5.1参照MFC AppWizard创建WinSockets程序 9.5.2 利用Windows Sockets API和第三方提供的类进行编程 9.6串口通信用于遥控操作简例 第10章 计算机串口与其它...
Visual C++/Turbo C串口通信编程实践及源代码-2
01-09
9.5 在已经编好的串口通信程序中加入网络通信功能 260 9.5.1参照mfc appwizard创建winsockets程序 261 9.5.2 利用windows sockets api和第三方提供的类进行编程 262 9.6 串口通信用于遥控操作简例 262 第10章 ...
Linux：基础命令学习
qq_55038440的博客
07-20 1129
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
GNU/Linux - Bazaar版本管理工具
最新发布
guoqx的专栏
07-24 297
根据 Jelmer Vernooij 的说法，Canonical 的 Bazaar 团队的成员在 2012 年初被分配到不同的任务，他本人在7年来为该项目做出贡献后，于2012年底停止了对 Bazaar 的贡献。同样，Bugzilla项目在2014 3月从 Bazaar 改为使用 git，其中一个原因是 Bazaar 几乎已被放弃的印象：“每个月可能有 2-3 次向主干提交。并用来进行Ubuntu项目的版本控制。Bazaar 可以由一个开发本地内容的多个分支的开发人员使用，也可以由跨网络协作的团队使用。
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 1069
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 916
Shell脚本的使用
Linux 注意事项
m0_74012211的博客
07-19 613
Linux 与 Windows 是两个相互独立的操作系统，两者有较大差距
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值