rk3568-Android11-韦根输出驱动

已于 2024-04-15 17:06:20 修改
阅读量286 收藏
点赞数
分类专栏： RK3568-Android 文章标签： 驱动开发 c语言 android
于 2023-02-15 17:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52393257/article/details/129047689
版权

由于之前没接触过韦根，现公司分配需求给我就试韦根输入输出。只能硬着头皮查资料看代码完成需求。


//#include "wiegand.h"
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/hrtimer.h>
#include <linux/init.h>
#include <linux/ioctl.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/semaphore.h>
#include <linux/string.h>
#include <linux/wait.h>
#include <linux/uaccess.h>

// msleep:实现毫秒级的延时，该延时保证至少延时所设置的延时时间，不会提前超时返回，会让出CPU
#define delay_1ms(x) msleep(x)
#define IOCTL_SET_DATA0    0x26
#define IOCTL_SET_DATA1    0x34
#define IOCTL_SET_LOW_TIME 0x01
#define IOCTL_SET_HIGH_TIME    0x02
#define GPIO2_D5    93
#define GPIO2_D4    92
#define DEVICE_DATA0_LABEL "wiegand_out_d0"
#define DEVICE_DATA1_LABEL "wiegand_out_d1"
#define DELAY_60    udelay(400)
#define DELAY_800   udelay(2000)
#define DELAY_2000  mdelay(5)
struct wiegand26 {
bool flag;
char data[27];
} wiegand26;

struct wiegand34 {
bool flag;
char data[35];
} wiegand34;

struct wiegand66 {
bool flag;
char data[67];
} wiegand66;

static struct workqueue_struct *queue = NULL;
//static struct work_struct work;
static int major;
static struct class *class = NULL;
static struct device *dev = NULL;
static int WG_DATA1 = GPIO2_D4;
static int WG_DATA0 = GPIO2_D5;
static int LOW_TIME = 100;
static int HIGH_TIME = 1500;
static int isStartGPIO = false;

//设置相应GPIO引脚为输出，并输出为高
void gpio_set_output(void) {
    gpio_direction_output(WG_DATA0, 1); // DATA0初始为高
    gpio_direction_output(WG_DATA1, 1); // DATA1初始为高
  //  return 0;
}

//初始化相应GPIO
void gpio_init(void) {
    gpio_request(WG_DATA0, DEVICE_DATA0_LABEL);
    gpio_request(WG_DATA1, DEVICE_DATA1_LABEL);
    gpio_set_output();
  //  return 0;
}
void Send_Weigand26(unsigned char *str)
{

    unsigned char one_num = 0;
    unsigned char even = 0;
    unsigned char odd = 0;
    unsigned char check_temp,i,j;

    check_temp = *str;
    
    printk("start wiegand26!\n");
    printk("Send WG26: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x1)
            one_num++;
        check_temp >>= 1;
    }

    check_temp = *(str + 1);
    for(i = 0;i < 4;i++)
    {
        if(check_temp & 0x80)
            one_num++;
        check_temp <<= 1;
    }

    if(one_num % 2 )
        even = 1;
    else
        even = 0;

    one_num = 0;

    check_temp = *(str + 1);
    for(i = 0;i < 4;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    check_temp = *(str + 2);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    if(one_num % 2 )
        odd = 0;
    else
        odd = 1;

    one_num = 0;

    gpio_direction_output(WG_DATA0, 1); 
    gpio_direction_output(WG_DATA1, 1);

    DELAY_800;
    if(even)
    {
        gpio_set_value(WG_DATA1, 0);
        DELAY_60;
        gpio_set_value(WG_DATA1, 1);
    }
    else
    {
        gpio_set_value(WG_DATA0, 0);
        DELAY_60;
        gpio_set_value(WG_DATA0, 1);
    }

    DELAY_800;

    gpio_set_value(WG_DATA0, 1);
    gpio_set_value(WG_DATA1, 1);

    for(j=0;j<3;j++)
    {
        check_temp = *(str + j);
        for(i = 0;i < 8;i++)
        {
        //    gpio_set_value(WG_DATA1, 1);
         //   gpio_set_value(WG_DATA0, 1);
            if(check_temp&0x80)
            {
                gpio_set_value(WG_DATA1, 0);
                DELAY_60;
                gpio_set_value(WG_DATA1, 1);
            }
            else
            {
                gpio_set_value(WG_DATA0, 0);
                DELAY_60;
                gpio_set_value(WG_DATA0, 1);
            }

            check_temp <<= 1;
            DELAY_800;
        }
    }

    gpio_set_value(WG_DATA0, 1);
    gpio_set_value(WG_DATA1, 1);

    if(odd)
    {
        gpio_set_value(WG_DATA1, 0);
        DELAY_60;
        gpio_set_value(WG_DATA1, 1);
    }
    else
    {
        gpio_set_value(WG_DATA0, 0);
        DELAY_60;
        gpio_set_value(WG_DATA0, 1);
    }

    printk("Send WG26-1: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
    DELAY_800;
    //return *str;
}

void Send_Weigand34(unsigned char *str)
{
    unsigned char one_num = 0;
    unsigned char even = 0;
    unsigned char odd = 0;
    unsigned char check_temp,i,j;

    check_temp = *str;
    
    printk("start wiegand34!\n");
    printk("Send WG34: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    check_temp = *(str + 1);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    if(one_num % 2 )
        even = 1;
    else
        even = 0;

    one_num = 0;

    check_temp = *(str + 2);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    check_temp = *(str + 3);
    for(i = 0;i < 8;i++)
    {
        if(check_temp & 0x01)
            one_num++;
        check_temp >>= 1;
    }

    if(one_num % 2 )
        odd = 0;
    else
        odd = 1;

    one_num = 0;

    gpio_direction_output(WG_DATA0, 1); 
    gpio_direction_output(WG_DATA1, 1);

    DELAY_800;
    if(even)
    {
        gpio_set_value(WG_DATA1, 0);
        DELAY_60;
        gpio_set_value(WG_DATA1, 1);
    }
    else
    {
        gpio_set_value(WG_DATA0, 0);
        DELAY_60;
        gpio_set_value(WG_DATA0, 1);
    }

    DELAY_800;

    gpio_set_value(WG_DATA0, 1);
    gpio_set_value(WG_DATA1, 1);

    for(j=0;j<4;j++)
    {
        check_temp = *(str + j);
        for(i = 0;i < 8;i++)
        {
            gpio_set_value(WG_DATA1, 1);
            gpio_set_value(WG_DATA0, 1);
            if(check_temp&0x80)
            {
                gpio_set_value(WG_DATA1, 0);
                DELAY_60;
                gpio_set_value(WG_DATA1, 1);
            }
            else
            {
                gpio_set_value(WG_DATA0, 0);
                DELAY_60;
                gpio_set_value(WG_DATA0, 1);
            }

            check_temp <<= 1;
            DELAY_800;
        }
    }

    gpio_set_value(WG_DATA0, 1);
    gpio_set_value(WG_DATA1, 1);

    if(odd)
    {
        gpio_set_value(WG_DATA1, 0);
        DELAY_60;
        gpio_set_value(WG_DATA1, 1);
    }
    else
    {
        gpio_set_value(WG_DATA0, 0);
        DELAY_60;
        gpio_set_value(WG_DATA0, 1);
    }

    printk("Send WG34-1: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
    DELAY_2000;
}

int gpio_wgo_send(int wgtype, unsigned long wgdata)
{
    unsigned char weigen26[3]= {0x0,0x0,0x0};
    unsigned char weigen34[4]= {0x0,0x0,0x0,0x0};

    printk("gpio_wgo_send start\n ");
    if (wgtype == 26) {
        weigen26[0] = (wgdata & 0xff0000)>>16;
        weigen26[1] = (wgdata & 0xff00)>>8;
        weigen26[2] = wgdata & 0xff;
        Send_Weigand26(&weigen26[0]);
        printk("weigand26 send end\n");
    } else if (wgtype == 34) {
        weigen34[0] = (wgdata & 0xff000000)>>24;
        weigen34[1] = (wgdata & 0xff0000)>>16;
        weigen34[2] = (wgdata & 0xff00)>>8;
        weigen34[3] = wgdata & 0xff;
        Send_Weigand34(&weigen34[0]);
        printk("weigand34 send end\n");
    } else if (wgtype == 37) {
        printk(" unsupport wiegand37 output\n");
    }
    return 0;
}
void wiegand26_int_to_char(int wgdata) {
gpio_wgo_send(26, wgdata); 
}

void wiegand34_int_to_char(int wgdata) {
gpio_wgo_send(34, wgdata); 
}
static ssize_t wiegand26_show(struct device *dev, struct device_attribute *attr,
char *str) {
    printk("Send WG26-3: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
return sprintf(str, "%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
}

static ssize_t wiegand26_store(struct device *dev,
struct device_attribute *attr, const char *str,
size_t count) {
long long val = 0;
if (isStartGPIO == false) {
//注册及初始化GPIO
gpio_init();
isStartGPIO = true;
}
printk("str = %s\n", str);
sscanf(str, "%lld", &val);
printk("val = %lld\n", val);
//printk("Send WG26-12: Data:%02x%02x%02x\n",str[0], str[1], str[2]);
wiegand26_int_to_char(val);
wiegand26.flag = true;
//INIT_WORK(&work, work_handler);
//schedule_work(&work);
return count;
}

static ssize_t wiegand34_show(struct device *dev, struct device_attribute *attr,
char *str) {
    printk("Send WG34-3: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
    
return sprintf(str, "%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
}

static ssize_t wiegand34_store(struct device *dev,
struct device_attribute *attr, const char *str,
size_t count) {
long long val = 0;
if (isStartGPIO == false) {
//注册及初始化GPIO
gpio_init();
isStartGPIO = true;
}

printk("str = %s\n", str);
sscanf(str, "%lld", &val);
printk("val = %lld\n", val);
//printk("Send WG34-12: Data:%02x%02x%02x%02x\n",str[0], str[1], str[2], str[3]);
wiegand34_int_to_char(val);
wiegand34.flag = true;
//INIT_WORK(&work, work_handler);
//schedule_work(&work);

return count;
}

static ssize_t wiegand66_show(struct device *dev, struct device_attribute *attr,
char *str) {
return sprintf(str, "%s\n", wiegand66.data);
}

static ssize_t wiegand66_store(struct device *dev,
struct device_attribute *attr, const char *str,
size_t count) {
long long val = 0;
if (isStartGPIO == false) {
//注册及初始化GPIO
gpio_init();
isStartGPIO = true;
}
printk("str = %s\n", str);
sscanf(str, "%lld", &val);
printk("val = %lld\n", val);
//wiegand66_int_to_char(val);
wiegand66.flag = true;
//INIT_WORK(&work, work_handler);
//schedule_work(&work);
return count;
}

static DEVICE_ATTR(wiegand26, 0664, wiegand26_show, wiegand26_store);
static DEVICE_ATTR(wiegand34, 0664, wiegand34_show, wiegand34_store);
static DEVICE_ATTR(wiegand66, 0664, wiegand66_show, wiegand66_store);

static struct attribute *wiegand_out_attributes[] = {
&dev_attr_wiegand26.attr, &dev_attr_wiegand34.attr, &dev_attr_wiegand66.attr, NULL};

static struct attribute_group wiegand_out_attribute_group = {
.attrs = wiegand_out_attributes};

static int wiegand_out_open(struct inode *inode, struct file *file) {
return 0;
}

static int wiegand_out_close(struct inode *inode, struct file *file) {
return 0;
}

static ssize_t wiegand_out_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos) {
    unsigned char wgobuff[12] = {0};

    if (count > 12)
        return -EFAULT;

    if (copy_from_user(wgobuff, buf, count))
        return -EFAULT;

    if (wgobuff[0] == 26) {
        Send_Weigand26(&wgobuff[1]);
    } else if (wgobuff[0] == 34) {
        Send_Weigand34(&wgobuff[1]);
    }

    return count;
}

static long wiegand_out_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {
/* 检查设备类型 */
/*if (_IOC_TYPE(cmd) != IOC_MAGIC) {
//pr_err("[%s] command type [%c] error!\n", func, _IOC_TYPE(cmd));
return -ENOTTY;
}*/

switch (cmd) {
case IOCTL_SET_DATA0:
WG_DATA0 = arg;
break;
case IOCTL_SET_DATA1:
WG_DATA1 = arg;
break;
case IOCTL_SET_LOW_TIME:
LOW_TIME = arg;
break;
case IOCTL_SET_HIGH_TIME:
HIGH_TIME = arg;
break;
default:
break;
}
printk("wiegand %u,%ld\n", cmd, arg);
return 0;
}

static struct file_operations wiegand_out_fops = {
.owner = THIS_MODULE,
.open = wiegand_out_open,
.release = wiegand_out_close,
.write = wiegand_out_write,
.compat_ioctl = wiegand_out_ioctl,
.unlocked_ioctl = wiegand_out_ioctl,
};

static int wiegand_out_probe(struct platform_device *pdev) {
int ret = 0;

printk("wiegand_out_probe\n");

//注册设备驱动
major = register_chrdev(0, "wiegand_out", &wiegand_out_fops);
//创建类
class = class_create(THIS_MODULE, "wiegand_out");
//创建设备节点
dev = device_create(class, NULL, MKDEV(major, 0), NULL, "wiegand_out_dev");
if (IS_ERR(dev)) {
// return -1;
}
//在/sys/class/wiegand_out/wiegand_out目录下创建属性文件wiegand26
ret = device_create_file(dev, &dev_attr_wiegand26);
if (ret < 0) {
}
//在/sys/class/wiegand_out/wiegand_out_dev目录下创建属性文件wiegand34
ret = device_create_file(dev, &dev_attr_wiegand34);
if (ret < 0) {
}

//在/sys/class/wiegand_out/wiegand_out_dev目录下创建属性文件wiegand66
ret = device_create_file(dev, &dev_attr_wiegand66);
if (ret < 0) {
}

//创建属性文件的sysfs接口函数
ret = sysfs_create_group(&pdev->dev.kobj, &wiegand_out_attribute_group);

wiegand26.flag = false;
wiegand34.flag = false;
wiegand66.flag = false;

printk("wiegand_out_probe, end ret=%d\n", ret);

return ret;
}

static int wiegand_out_remove(struct platform_device *pdev) {
printk("wiegand_out_remove\n");

//删除接口函数
sysfs_remove_group(&pdev->dev.kobj, &wiegand_out_attribute_group);

device_remove_file(dev, &dev_attr_wiegand26);
device_remove_file(dev, &dev_attr_wiegand34);
device_remove_file(dev, &dev_attr_wiegand66);
//删除设备节点
device_unregister(dev);
//注销创建的设备类
class_destroy(class);
//取消注册设备驱动
unregister_chrdev(major, "wiegand_out");

if (isStartGPIO == true) {
//释放注册的GPIO编号
gpio_free(WG_DATA0);
gpio_free(WG_DATA1);
}
return 0;
}

static struct platform_driver wiegand_out_drv = {
//完成具体设备的初始化操作
.probe = wiegand_out_probe, //匹配到dev之后调用probe
//完成具体设备的退出操作
.remove = wiegand_out_remove,
.driver =
{
.name = "wiegand_out", .owner = THIS_MODULE,
//.of_match_table = of_match_ptr(wiegand_out_of_match),
},
};

static void wiegand_out_device_release(struct device *dev) { return; }

static struct platform_device wiegand_out_device = {
.name = "wiegand_out",
.id = -1,
//必须有release函数，否则卸载模块时会报"Device 'wiegand_out' does not have a
// release() function, it is broken and must be fixed."
.dev = {
.release = wiegand_out_device_release,
}};

//设备驱动模块加载函数
static int __init wiegand_out_init(void) {
int ret = 0;

printk("wiegand_out_init\n");

//创建一个单线程的工作队列
queue = create_singlethread_workqueue("weigand_send");
if (!queue) {
printk(KERN_ERR "create_singlethread_workqueue failed\n");
return -1;
}

//平台驱动注册
ret = platform_driver_register(&wiegand_out_drv);
if (ret) {
printk(KERN_ERR "platform_driver_register failed\n");
destroy_workqueue(queue);
return -1;
}

//平台设备注册
ret = platform_device_register(&wiegand_out_device);
if (ret) {
printk(KERN_ERR "platform_device_register failed\n");
platform_driver_unregister(&wiegand_out_drv);
destroy_workqueue(queue);
return -1;
}

return 0;
}

//设备驱动模块卸载函数
static void __exit wiegand_out_exit(void) {
printk("wiegand_out_exit\n");

//平台设备注销
platform_device_unregister(&wiegand_out_device);
//平台驱动注销
platform_driver_unregister(&wiegand_out_drv);
//释放工作队列所占的资源
destroy_workqueue(queue);
}

module_init(wiegand_out_init);
module_exit(wiegand_out_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("hq@hqvt.ai");

以上就试韦根输出，继续看韦根输入。。。。。。

懒到爆的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RK3568平台开发系列讲解（驱动篇） linux设备驱动模型
内核笔记
05-08 3668
平台 内核版本 安卓版本 Hi3751V811 Linux4.1 Android8.0 文章目录抓log查看屏幕信息关闭内核打印海思`procfs`文件接口Interrupts:中断相应信息log:调试信息输出控制Media-mem：业务内存使用信息Hdmi版本号：内核启动参数 抓log 遇到问题的同时，把 log 保存下来发送给问题处理人，可以节省较多来回沟通的时间。 抓log前先 logcat –c清除出错前的打印，只抓出错时间段的打印。如果需要时间信息：logcat -v time...
RK3568平台开发系列讲解（驱动篇）completion机制基本概念
内核笔记
12-14 1994
completion机制基本概念 完成量：用于进程/线程同步，与信号量/互斥量类似 语义 信号量/互斥量：资源对所有进程/线程是公平的，按先来后到顺序使用 完成量：一个线程的运行依赖另一个线程 completion结构体 include/linux/completion.h struct completion { unsigned int done; wait_queue_head_t wait; }; done：表示当前completion的状态 wait：等待队列头 初始化completion
Android系统韦根调试从驱动到应用（一）
blueheart05的专栏
05-14 2512
Android系统韦根调试从驱动到应用 软件开发平台：android P 源码。 硬件开发平台：nxp imx8m mini开发板。 本文记录在nxp 8m mini 硬件平台， androidP 源码的软件平台上调试韦根驱动，增加韦根的framework 层，并能在APP 应用层 获取韦根数据的流程。 一．韦根驱动调试 硬件设计 可以将Wiegand接口的Data0和Data1两个输出接到MCU的两个IO脚上，采用查询的方式接收数据，但这样接收并不可靠。比较好的方法是将Data0和Data1接到MCU的两
rk3568 can使用
qq_42767071的博客
03-02 893
rk3568 can
F1C200S 添加韦根驱动笔记（驱动编写）
最新发布
wwddgod的专栏
05-10 241
irqflags是中断处理的属性，若设置了IRQF_DISABLED （老版本中的SA_INTERRUPT，本版zhon已经不支持了），则表示中断处理程序是快速处理程序，快速处理程序被调用时屏蔽所有中断，慢速处理程序不屏蔽；若设置了IRQF_SHARED （老版本中的SA_SHIRQ），则表示多个设备共享中断，若设置了IRQF_SAMPLE_RANDOM（老版本中的SA_SAMPLE_RANDOM），表示对系统熵有贡献，对系统获取随机数有好处。，中断发生时，系统调用这个函数，dev_id参数将被传递给它。
RK3568的CAN驱动适配
qq_28643619的博客
10-07 3104
RK3568的CAN接口驱动适配应用
RK3568平台开发系列讲解（驱动基础篇）misc 设备驱动简介
内核笔记
08-16 1891
📢Linux MISC 驱动是最简单的字符设备驱动，学习 MISC 驱动将会为学习字符设备驱动奠定基础。
linux-android-韦根驱动+JNI.rar
06-04
韦根26/34协议发送接收Linux驱动+JNI代码+测试程序，RK平台验证通过，其他平台通用
wg_output.rar_bf533_linux 韦根_韦根 驱动_韦根输出_韦根驱动
07-13
linux 2.4 的用gpio 模拟韦根输出的驱动!与标准韦根设备对接.反应灵敏!
RK3288 IO 驱动程序
03-21
该IO 驱动程序不限IO ，所有IO 口均可使用,已经 测试可以。添入到内核中即可
海康威视DS-K2600系列接韦根读卡器操作手册.docx
10-11
海康威视DS-K2600系列接韦egen读卡器操作手册 本手册介绍了海康威视DS-K2600系列接韦egen读卡器的操作流程、配置步骤和相关的技术信息。 一、操作流程（配置流程） 1. 读卡器选择韦egen模式。...
ARM Linux 韦根驱动
04-03
Linux中断驱动，中断接收韦根，26码，全部使用驱动默认，默认GPIO中断默认接收26码韦根信号，可以方便集成进Linux驱动里面，可以对接市面上的RFID，方便修改成34码，66码的韦根。 基于原作者的代码修改为tab编码风格，毕竟空格看着非常的变扭。
RK平台Can通讯驱动实现
04-07
资源基于android RK3568平台，实现Can通讯驱动；
RK3568 CAN驱动更新说明
weixin_55163060的博客
09-14 1176
RK3568 CAN驱动更新说明 RK3568 CAN驱动更新说明 RK3568 CAN驱动更新说明
RK3568 Android11 无法自动创建以usb开头的驱动
10-17 637
usb开头的驱动在/dev/下无法显示的原因
RK3568 Android11&linux驱动入门到修行
qq_24093081的博客
12-18 774
从大学到现在一直是在做嵌入式开发，从简单的单片机到实时操作系统再到linux开发，可以说是过五关斩六将，一步一个脚印摸索过来，所以写下这个专栏目的是记录自己在开发中学习到的技术和遇见的问题，另个就是现在互联网时代，学习Linux&andriod对我们的职业发展是很有益处。1.本专栏的开发环境是基于瑞芯微的RK3568进行开发，所以要有一个开发板，这是学习必不可少的。3.掌握常见的Camera 、LCD、触摸屏，wifi/蓝牙等驱动的移植和开发知识。4.掌握和嵌入式相关的安卓知识。
STM32 韦根输入输出技术方案
white_loong的博客
07-10 6848
对于韦根具体格式不做详述，具体参见： https://baike.baidu.com/item/%E9%9F%A6%E6%A0%B9%E5%8D%8F%E8%AE%AE?fr=aladdin https://www.cnblogs.com/han-bing/p/6785632.html MCU : STM32C8T6 1、韦根输入（WG26,WG34,WG66） 1）、硬件上WG0 WG...
RK3288 韦根发送驱动
qq_37803273的博客
12-13 2783
#include <linux/module.h> #include <linux/init.h> #include <linux/workqueue.h> #include <linux/platform_device.h> #include <linux/types.h> #include <linux/fs.h> #in...
rk3399 android 11 kernel gpio 控制时间点
chgh1306的专栏
08-30 698
rk3399 android 11 gpio控制时间点
linux-android-韦根驱动+jni.rar
07-19
总之，Linux是操作系统，Android是基于Linux的移动操作系统，韦根驱动是用于与韦根协议进行通信的驱动程序，而韦根驱动JNI.rar可能是一个包含了韦根驱动的本地代码的压缩文件，用于在Android平台上实现与韦根协议...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值