jetson agx xavier gpio-user驱动

最新推荐文章于 2024-08-12 15:29:21 发布
最新推荐文章于 2024-08-12 15:29:21 发布
阅读量1k 收藏 11
点赞数 2
分类专栏： arm # nvidia 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43479963/article/details/115326444
版权
这篇博客详细介绍了如何在Linux系统中为Tegra平台实现用户空间GPIO驱动。内容涉及设备树配置、内核源码分析以及驱动程序的编写，包括GPIO方向、边沿触发、活动电平的读写操作。通过示例展示了如何创建设备节点并将其挂载到sysfs文件系统，以便用户空间应用进行交互。最后，提供了编译和加载驱动的步骤以及测试验证。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

设备树

Linux_for_Tegra/source/public/hardware/nvidia/platform/t19x/galen/kernel-dts/tegra194-p2888-0001-p2822-0000.dts

#include "common/tegra194-p2888-0001-p2822-0000-common.dtsi"
#include "common/tegra194-p2822-camera-modules.dtsi"
#include "t19x-common-modules/tegra194-camera-plugin-manager.dtsi"
#include "user/user-gpio.dtsi"

Linux_for_Tegra/source/public/hardware/nvidia/platform/t19x/galen/kernel-dts/user/user-gpio.dtsi

#include <dt-bindings/gpio/tegra194-gpio.h>

/ {
        user-gpios {
                compatible = "user,user-init-gpio";
                status = "okay";
                
                out-gpios-num = <2>;
                out-1-gpios = <&tegra_main_gpio TEGRA194_MAIN_GPIO(N, 1) GPIO_ACTIVE_HIGH>;
                out-2-gpios = <&tegra_main_gpio TEGRA194_MAIN_GPIO(H, 7) GPIO_ACTIVE_LOW>;

                input-gpios-num = <1>;
                in-1-gpios = <&tegra_main_gpio TEGRA194_MAIN_GPIO(H, 0) GPIO_ACTIVE_HIGH>;
        };
};

驱动

Linux_for_Tegra/source/public/kernel/kernel-4.9/drivers/gpio/gpio-user.c

#include <linux/list.h>
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/time.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/kthread.h>

#include <dt-bindings/gpio/tegra194-gpio.h>

#define GPIOX_MAX_NUM 30

enum direction_type_t {
	GPIO_IN,
	GPIO_OUT,
	GPIO_IRQ
};

struct gpiox_device_t {
	int gpio;
	struct device * dev;

	int active_low;
	int direction;
	int edge;
	int value;
	int irq_num;
};

struct gpiox_class_t {
	struct class *gpio_class;
	struct gpiox_device_t gpio_devs[GPIOX_MAX_NUM];
	int gpio_cnt;
};


static ssize_t gpiox_active_low_show(struct device * dev, struct device_attribute * attr, char * buf)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "active_low")){
		if(xdev->active_low == 0)
			return strlcpy(buf, "0\n", 3);
		else
			return strlcpy(buf, "1\n", 3);
	}
	return strlcpy(buf, "0\n", 3);
}

static ssize_t gpiox_active_low_store(struct device * dev, struct device_attribute * attr, const char * buf, size_t count)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	unsigned long on = simple_strtoul(buf, NULL, 10);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "active_low")){
	}
	xdev->active_low = on ? 1 : 0;
	return count;
}

static ssize_t gpiox_direction_show(struct device * dev, struct device_attribute * attr, char * buf)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "direction")){
		switch(xdev->direction){
		case GPIO_IN:
			return strlcpy(buf, "in\n", 4);
		break;
		case GPIO_OUT:
			return strlcpy(buf, "out\n", 5);
		break;
		case GPIO_IRQ:
			return strlcpy(buf,"irq\n", 5);
		break;
		}
	}
	return strlcpy(buf, "none\n", 6);
}

static ssize_t gpiox_direction_store(struct device * dev, struct device_attribute * attr, const char * buf, size_t count)
{
	int direction = 0;
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	unsigned long on = simple_strtoul(buf, NULL, 10);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "direction")){
		direction = (on==1)? GPIO_OUT :(on==0)? GPIO_IN:GPIO_IRQ; /* not used */
	}

	return 0;
}

static ssize_t gpiox_edge_show(struct device * dev, struct device_attribute * attr, char * buf)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "edge")){
		if(xdev->edge == 0)
			return strlcpy(buf, "0\n", 3);
		else
			return strlcpy(buf, "1\n", 3);
	}
	return strlcpy(buf, "0\n", 3);
}

static ssize_t gpiox_edge_store(struct device * dev, struct device_attribute * attr, const char * buf, size_t count)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	unsigned long on = simple_strtoul(buf, NULL, 10);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "edge")){
		if(on)
			gpio_direction_output(xdev->gpio, 1);
		else
			gpio_direction_output(xdev->gpio, 0);
	}
	xdev->edge = on ? 1 : 0;
	return count;
}


static ssize_t gpiox_value_show(struct device * dev, struct device_attribute * attr, char * buf)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "value")){
		switch(xdev->direction){
		case GPIO_IN:
			xdev->value = gpio_get_value(xdev->gpio);
		case GPIO_OUT:
			if(xdev->value == 0)
				return strlcpy(buf, "0\n", 3);
			else
				return strlcpy(buf, "1\n", 3);
		break;
		case GPIO_IRQ:
		break;
		}
	}
	return strlcpy(buf, "0\n", 3);
}

static ssize_t gpiox_value_store(struct device * dev, struct device_attribute * attr, const char * buf, size_t count)
{
	struct gpiox_device_t * xdev = dev_get_drvdata(dev);

	unsigned long on = simple_strtoul(buf, NULL, 10);
	if(xdev == NULL)
		return 0;

	if(!strcmp(attr->attr.name, "value")){
		if(on)
			gpio_direction_output(xdev->gpio, 1);
		else
			gpio_direction_output(xdev->gpio, 0);
	}
	xdev->value = on ? 1 : 0;
	return count;
}

static DEVICE_ATTR(value, 0664, gpiox_value_show, gpiox_value_store);
static DEVICE_ATTR(direction, 0664, gpiox_direction_show, gpiox_direction_store);
static DEVICE_ATTR(edge, 0664, gpiox_edge_show, gpiox_edge_store);
static DEVICE_ATTR(active_low, 0664, gpiox_active_low_show, gpiox_active_low_store);
static struct attribute * gpiox_attrs[] = {
	&dev_attr_value.attr,
	&dev_attr_direction.attr,
	&dev_attr_edge.attr,
	&dev_attr_active_low.attr,
	NULL
};


static const struct attribute_group gpiox_group = {
	.attrs = gpiox_attrs,
};

static int init_device_data(struct gpiox_device_t *dev,int gpio,int active,int direction,int edge,int value)
{
	int irq_num;

	if(dev == NULL)
		return -1;

	value =(value==0)?1:0;
	dev->gpio = gpio;
	dev->active_low = active;
	dev->direction = direction;
	dev->edge = edge;
	dev->value = value;

	switch(direction){ 
	case GPIO_IN:
		printk("set gpio%d direction input \n",dev->gpio);
		gpio_direction_input(dev->gpio);
	break;
	case GPIO_OUT:
		printk("set gpio%d direction output[%d] \n",dev->gpio,value);
		gpio_direction_output(dev->gpio,value);
	break;
	case GPIO_IRQ:
		irq_num = gpio_to_irq(dev->gpio);
		dev->irq_num = (irq_num>0)?irq_num:-1;
	break;
	}

	return 0;
}

static int create_device_nodes(struct gpiox_class_t *cls,int gpio_num,enum direction_type_t direction,int flag)
{
	int ret = 0;
	char name[10];
	if(cls == NULL)
		return -1;
	if(cls->gpio_cnt>=GPIOX_MAX_NUM)	
		return -2;
	
	memset(name,0,sizeof(name));
	sprintf(name,"gpio%d",gpio_num);
	cls->gpio_devs[cls->gpio_cnt].dev = device_create(cls->gpio_class, NULL,MKDEV(0, cls->gpio_cnt), NULL, "%s", name);
	ret = sysfs_create_group(&cls->gpio_devs[cls->gpio_cnt].dev->kobj,&gpiox_group);

	init_device_data(&cls->gpio_devs[cls->gpio_cnt],gpio_num,1,direction,0,flag);
	
	dev_set_drvdata(cls->gpio_devs[cls->gpio_cnt].dev, &cls->gpio_devs[cls->gpio_cnt]);

	cls->gpio_cnt++;

	return 0;
}

static int user_gpio_probe(struct platform_device * pdev)
{
	struct device_node * node = pdev->dev.of_node;
	struct gpiox_class_t * gpiox_class;
	enum of_gpio_flags flags;
	int gpio;
	int ret,i;
	int cnt = 0;
	char gpio_name[32];

	if(!node)
		return -ENODEV;

	gpiox_class = kzalloc(sizeof(struct gpiox_class_t), GFP_KERNEL);
	if (!gpiox_class){
		printk("%s -ENOMEM\n",__func__);
		return -ENOMEM;
	}
	gpiox_class->gpio_cnt = 0;
	gpiox_class->gpio_class = class_create(THIS_MODULE, "gpio_usr");
	
	ret = of_property_read_u32(node, "out-gpios-num", &cnt);
	if (ret || !cnt) {
		pr_err("no gpio\n");
		goto INIT_ERR_FREE;
	}
	printk("get out-gpios-num:%d\n",cnt);
  
	for (i = 0; i < cnt; i++) {
		sprintf(gpio_name, "out-%d-gpios", i + 1);
		//gpio = of_get_named_gpio(node, gpio_name,0);
		gpio = of_get_named_gpio_flags(node, gpio_name,0,&flags);

		if (gpio_request(gpio, NULL)) {
			pr_err("out-%d-gpios(%d) gpio_request fail\n",i + 1,gpio);
			continue;
		}
		printk("out-%d-gpios(%d) gpio_is_valid\n", i + 1, gpio);
		create_device_nodes(gpiox_class,gpio,GPIO_OUT,flags);
	}
	
	ret = of_property_read_u32(node, "input-gpios-num", &cnt);
	if (ret || !cnt) {
		pr_err("no in gpio\n");
		cnt = 0;
	}
	printk("get input-gpios-num:%d\n",cnt);

	for (i = 0; i < cnt; i++) {
		sprintf(gpio_name, "in-%d-gpios", i + 1);
		gpio = of_get_named_gpio(node, gpio_name,0);

		if (gpio_request(gpio, NULL)) {
			pr_err("in-%d-gpios(%d) gpio_request fail\n",i + 1,gpio);
			continue;
		}
		printk("in-%d-gpios(%d) gpio_is_valid\n", i + 1, gpio);
		create_device_nodes(gpiox_class,gpio,GPIO_IN,flags);
	}

	dev_set_drvdata(&pdev->dev, gpiox_class);
	pr_info("gpio_init finish\n");
	return 0;

INIT_ERR_FREE:
	pr_err("gpio_init err\n");
	kfree(gpiox_class);
	return -1;
}

static int user_gpio_remove(struct platform_device *pdev)
{
	int i = 0;
	struct gpiox_class_t * xdev = dev_get_drvdata(&pdev->dev);
	if(xdev != NULL){
		for(i=0;i<xdev->gpio_cnt;i++){
	 		gpio_free(xdev->gpio_devs[i].gpio);
			printk("gpio%d free %d\n",i,xdev->gpio_devs[i].gpio);
			sysfs_remove_group(&xdev->gpio_devs[i].dev->kobj, &gpiox_group);
			
			device_destroy(xdev->gpio_class,MKDEV(0, i));
		}
		class_destroy(xdev->gpio_class);
	}
	return 0;
}

#ifdef CONFIG_PM
static int user_gpio_suspend(struct device *dev)
{
	return 0;
}

static int user_gpio_resume(struct device *dev)
{
	return 0;
}
#else
#define user_gpio_suspend NULL
#define user_gpio_resume NULL
#endif

static const struct dev_pm_ops user_gpio_pm_ops = {
	.suspend = user_gpio_suspend,
	.resume = user_gpio_resume,
};

static struct of_device_id user_gpio_of_match[] = {
	{ .compatible = "user,user-init-gpio" },
	{},
};
MODULE_DEVICE_TABLE(of, user_gpio_of_match);

static struct platform_driver user_gpio_driver = {
	.driver		= {
		.name	= "user-gpio",
		.owner	= THIS_MODULE,
		.pm	= &user_gpio_pm_ops,
		.of_match_table	= of_match_ptr(user_gpio_of_match),
	},
	.probe		= user_gpio_probe,
	.remove		= user_gpio_remove,
};
module_platform_driver(user_gpio_driver);

MODULE_DESCRIPTION("user gpio driver");
MODULE_AUTHOR("zhengweiqing, 1548889230@qq.com");
MODULE_LICENSE("GPL");

Makefile

Linux_for_Tegra/source/public/kernel/kernel-4.9/drivers/gpio/Makefile
最后添加：

obj-$(CONFIG_GPIO_USER)    += gpio-user.o

Kconfig

Linux_for_Tegra/source/public/kernel/kernel-4.9/drivers/gpio/Kconfig
增加GPIO_USER部分：

config GPIO_LOONGSON1
        tristate "Loongson1 GPIO support"
        depends on MACH_LOONGSON32
        select GPIO_GENERIC
        help
          Say Y or M here to support GPIO on Loongson1 SoCs.

config GPIO_USER
        tristate "USER GPIO support"
        depends on GPIOLIB
        default m
        help
          Say Y or M here to support USER GPIO .

endmenu

menu "Port-mapped I/O GPIO drivers"

tegra_defconfig

Linux_for_Tegra/source/public/kernel/kernel-4.9/arch/arm64/configs/tegra_defconfig
增加

CONFIG_GPIO_USER=m

编译

cd  Linux_for_Tegra/source/public/kernel/kernel-4.9
./build.sh

build.sh内容:

export CROSS_COMPILE=aarch64-linux-gnu-
make ARCH=arm64 tegra_defconfig
make ARCH=arm64 -j12

#TOP_PATH=/home/z/nvidia/Linux_for_Tegra
TOP_PATH=`pwd`/../../../../
cp arch/arm64/boot/Image $TOP_PATH/kernel/Image
cp arch/arm64/boot/dts/* $TOP_PATH/kernel/dtb/

sudo make ARCH=arm64 modules_install INSTALL_MOD_PATH=$TOP_PATH/rootfs/

更新设备树以及驱动上传

agx进入Recovery模式后，执行

cd  Linux_for_Tegra

./flash.sh -k kernel-dtb jetson-agx-xavier-devkit mmcblk0p1

更新完成后，重启板子，将生成驱动文件 gpio-user.ko放到板子中加载。

测试

sudo insmod gpio-user.ko 

ls /sys/class/gpio_usr/
gpio344  gpio351  gpio393

~$ cat /sys/class/gpio_usr/gpio351/direction 
out
~$ cat /sys/class/gpio_usr/gpio393/direction 
out
~$ cat /sys/class/gpio_usr/gpio344/direction 
in

~$ cat /sys/class/gpio_usr/gpio344/value
0
AGX Xavier GPIO 调试记录汇总
bingdund的博客
07-28 348
sudo cat /sys/kernel/debug/gpio (查看GPIO 状态）查看输入设备及节点信息： cat /proc/bus/input/devices。
基于Jetson Agx Xavier的驱动开发----------一个字符设备驱动(多设备驱动)
weixin_44927463的博客
07-10 1416
文章目录前言一、字符设备驱动开发的主要流程？二、驱动程序的编写1.驱动程序的组成2.驱动入口函数总结 前言 这段时间学习驱动开发，手里只有一块jetson开发板，但是所有驱动开发教程都是针对于特定的学习板，针对于jetson开发板没有，虽然他们的开发流程可以借鉴，但是有许多地方不一样，在此记录一下开发流程和踩到的坑，如需具体理论知识，请参考正点原子的驱动开发教程/顺便提一嘴，之前以为正点原子只是在裸板开发上的教程特别好，这段时间看了他们嵌入式linux驱动开发指南，不得不说，是真的好，建议小白去学习一下.
AGX Xavier GPIO
在路上@Amos
12-12 927
NVIDIA Jetson AGX Xavier GPIO Header Pinout
玩转NVIDIA Jetson AGX Xavier（16）--- 驱动开发之GPIO的应用
木子山石的学习笔记
06-25 4966
操作GPIO是使用硬件的开始，本篇介绍如何使用jetson的GPIO，这里使用的语言是C语言。 操作GPIO包含两种方法： 终端使用命令直接操作 程序操作 命令控制 第一种方法可以帮我们了解GPIO在linux系统中的存在形式。建议大家了解这种方法，自己去操作一下，会对写代码非常有帮助。 我们打开终端，进入GPIO的目录下 /sys/class/gpio ls一下该目录下的文件 可以看到，最开始的gpiochipX是一组GPIO的控制器，不是具体的GPIO，如果我们想要控制具体的一个，首先查看jet
Jetson Xavier gpio编程 （8）
乐于分享
08-25 1214
GPIO lines are attached to gpiochips. Look in /sys/class/gpio and you should see gpiochip240, 248, and 288. I haven’t yet determined which GPIOs are connected to 240. If you download the pinmux spreadsheet and unhide column G you’ll see GPIO names l...
NVIDIA Jetson TX1，TX2，TX2 NX，AGX Xavier 和 Nano开发板GPIO口配置及应用
博客首页
06-27 2974
通过Jetson TX2 NX的GPIO接口控制继电器非常简单。只需要连接继电器模块到正确的GPIO引脚上，安装Jetson GPIO库，编写Python脚本并运行即可。这个技巧可以帮助实现各种下位机控制应用。
JETSON AGX XAVIER学习资料.pdf
08-13
NVIDIA Jetson AGX Xavier是一款高性能的嵌入式计算平台，专为机器人控制器和人工智能应用设计。这款开发套件基于NVIDIA的新一代Xavier处理器，提供了强大的计算能力，相较于前代产品Jetson TX2，其性能提升了20倍...
评测Jetson AGX Xavier性能
热门推荐
qq_27353621的博客
11-06 2万+
NVIDIA Jetson AGX Xavier的GPU有512个核，是Jetson TX2的两倍，并且搭载了深度学习加速器，以及视觉加速器。Xavier的CPU表现也有了提升，从原来的6核提升到了8核，速度变为原来的两倍，Xavier的内存也由原来的8GB提升为16GB。这些提升对于我们的机器人来讲是至关重要的，因为机器人不仅仅需要板载深度学习运算，还需要一些控制算法运行在CPU上面，以及用于通信等，Xavier在这方面的提升进一步提高了我们机器人的性能。 我们的自平衡自行车利用Xavier解决实时跟踪目
Jetson Xavier NX and Jetson AGX Xavier Series启动流程
DecadeLive的博客
03-24 4662
文章目录BootROMBootLoader Components加载程序组成通用驱动程序框架Microboot1， MB1TegraBootTegraBoot BPMPTegraBoot-CPUCboot，Cold bootextlinux.conf定义内核启动顺序 这是Nvidia的Jetson NX启动的大致流程介绍，适用于Jetson Xavier NX和Jetson AGX Xiavier系列。其他系列的启动流程与本文档有差异。 英文版原文可参考： https://docs.nvidia.com/j
Jetson_agx_xavier_developer_kit_user_guide.pdf
02-04
Jetson agx xavier developer kits userguide.The Jetson AGX Xavier™ Developer Kit provides a full-featured development platform designed to get you up and running quickly. The included carrier board exposes many standard hardware interfaces, enabling a highly flexible and extensible platform for rapid prototyping.
jetson-gpio:一个Python库，可使用Jetson的GPIO
05-03
Jetson.GPIO-适用于TegraLinux Jetson TX1，TX2，AGX Xavier和Nano开发板包含一个40针GPIO接头，类似于Raspberry Pi中的40针接头。 可以使用Jetson GPIO库软件包中提供的Python库来控制这些GPIO的数字输入和输出。 该库与用于Raspberry Pi的RPi.GPIO库具有相同的API，以便提供一种将在Raspberry Pi上运行的应用程序移动到Jetson板上的简便方法。 本文档介绍了Jetson GPIO库软件包中包含的内容，如何配置系统和运行提供的示例应用程序以及库API。 包装组件 除本文档外，Jetson GPIO库软件包还包含以下内容： lib/python/子目录包含实现所有库功能的Python模块。 gpio.py模块是将被导入到应用程序中的主要组件，并提供所需的API。 的gpio_eve
jetson-gpio:通过REST API提供对NVIDIA Jetson GPIO引脚的访问的容器
04-05
杰森·皮皮奥 该容器通过端口6667上的REST API公开了NVIDIA Jetson GPIO引脚。到目前为止，该容器仅在NVIDIA Jetson Nano 2GB和Nano 4GB上进行了测试，但我认为它应该在其他型号上也可以使用。 如果您在其他Jetson型号上进行验证，请告诉我。 主机设定 Jetson要求主机配置GPIO功能（例如，使用SPI，PWM，I2S，麦克风或麦克风阵列等）。 如果要为以下类型的硬件外围设备配置Jetson，请在主机上运行以下命令： sudo /opt/nvidia/jetson-io/jetson-io.py 否则，您可以在没有主机配置的情况下继续使用GPIO或I2C外设。 首先，您需要使用Tegra SOC中的芯片编号或板子丝网印刷上显示的Jetson物理引脚编号来决定引用它们的方式。 用法： make build make run 完成之后，
Jetson Nano GPIO
weifengdq的专栏
12-18 6413
文章目录前言启用Jetson-GPIOGPIO测试Example微信公众号 前言 jetson-gpio 是一个可以使用Jetson 系列 GPIOs的Python库, Github地址为: https://github.com/NVIDIA/jetson-gpio Jetson TX1, TX2, AGX Xavier, 和 Nano开发板上都有一个40 Pin的接口, 类似于树莓派, 可以方便...
Jetson Xavier NX python的GPIO库的使用（笔记）
qq_64516728的博客
01-11 822
【代码】Jetson Xavier NX python的GPIO库的使用（笔记）
NVIDIA Jetson Xavier NX 控制GPIO
蜉蝣的博客
02-02 6722
NVIDIA Jetson Xavier NX 控制GPIO 文章目录NVIDIA Jetson Xavier NX 控制GPIO前言一、简介二、代码实例1.gpio.h2.gpio.cpp 前言 在linux系统中以文件io的方式控制GPIO示例，开发板为NVIDIA Jetson Xavier NX，其它公司的开发板也可使用。 一、简介 GPIO09接入蜂鸣器，高电平开启，低电平关闭。 二、代码实例 1.gpio.h 代码如下（示例）： #ifndef GPIO_H #define GPIO_H
Jetson AGX xavier nx 使用c++点灯gpio
最新发布
weixin_46151178的博客
08-12 558
为了确保无论是按Ctrl+C终止程序，还是程序自动退出时都能关闭所有的灯，你可以使用signal处理来捕捉SIGINT信号（即Ctrl+C），同时结合atexit来在正常退出时关闭灯。以下是修改后的代码，加入了对SIGINT。
Jetson Xavier NX （15） -- Jetson.GPIO
Techblog of HaoWANG
08-16 2569
Python Jetson GPIO Src: https://pypi.org/project/Jetson.GPIO/ NVIDIA: Jetson TX1, TX2, AGX Xavier, and Nano development boards contain a 40 pin GPIO header, similar to the 40 pin header in the Raspberry Pi. These GPIOs can be controlled for digita...
Jetson AGX Orin 找到GPIO编号 GPIO Number
Pandako's Blog
07-06 2145
使用Kernel debugfs 不用计算得到GPIO 编号
英伟达Xavier NX 开发系列之kernel层的GPIO控制开发
hezhensheng007的专栏
03-05 783
在开发gpio之前，先了接一下dts的入口先，因为该dts非常重要，找到入口后面任何节点相关信息都是通过此来include进来的，对dts有所研究的都应该能理解此点。to 287 on device: gpiochip1 (tegra-gpio-aon)//说明248为tegra-gpio-aon的基值。在回到通过kernel的打印，找到信息找出每组GPIO的分配范围，目的是找出不同的GPIO组的偏移值。这个文件，因为该文件是Xavier NX系列的gpio定义说明，后面的分析会用到这点。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值