linux驱动(一):led

        本文主要探讨210的led驱动相关知识。 

驱动
        操作系统驱动硬件的代码,驱动上层是系统调用API,下层是硬件
        宏内核：内核整体上为一个过程实现,运行在同一地址空间,相互调用简单高效
        微内核：功能为独立过程,过程间通过IPC通信
        linux本质上是宏内核兼具微内核模块化特性
        静态模块化编译时可裁剪但需重新编译,动态模块化模块自动安装和卸载
        字符设备软件是以字节为单位进行操作的,块设备，块设备是以块(多字节)为单位操作,网络设备为网卡驱动

驱动模块命令
        lsmod打印内核已经安装模块列表
        insmod安装模块
        modinfo打印模块信息
        rmmod卸载已经安装模块
        modprobe加载或卸载模块及依赖模块
        加载：modprobe xxx
        卸载：modprobe -r xxx
        depmod载入模块依赖到modules.dep

常用宏(modinfo查看)

        MODULE_LICENSE("GPL") 模块许可包括：GPL、GPL V2、GPL and additional rights、Dial BSD/GPL、Dual         MPL/GPL、Proprietary通常为为GPL v2
        MODULE_AUTHOR("xxx")添加模块作者信息
        MODULE_DESCRIPTION("xxx")添加模块描述信息
        MODULE_ALIAS("xxxx")添加模块别名
        module_init(moudle_test_init);
        module_exit(moudle_test_exit);
        module_init宏声明驱动初始化函数,初始化函数和insmod命令绑定
        module_exit宏声明驱动卸载函数,卸载函数和rmsmod命令绑定

函数及修饰符

include/linux/init.h
#define __init        __section(.init.text) __cold notrace
#define __exit        __section(.exit.text) __exitused __cold

        __init是宏定义,__init将修饰函数放入.init.text段,内核启动时加载.init.text段模块函数初始化
        __exit是宏定义,__exit将修饰函数放入.exit.text段,内核结束时加载.init.text段模块函数释放内存

         printk为内核中包含打印级别的功能的函数,/proc/sys/kernel/printk可查看当前系统的打印级别,高于打印级别未打印出的信息用dmesg查看

include/linux/kernel.h
#define    KERN_EMERG    "<0>"    /* system is unusable            */
#define    KERN_ALERT    "<1>"    /* action must be taken immediately    */
#define    KERN_CRIT    "<2>"    /* critical conditions            */
#define    KERN_ERR    "<3>"    /* error conditions            */
#define    KERN_WARNING    "<4>"    /* warning conditions            */
#define    KERN_NOTICE    "<5>"    /* normal but significant condition    */
#define    KERN_INFO    "<6>"    /* informational            */
#define    KERN_DEBUG    "<7>"    /* debug-level messages            */

        file_operations结构体的元素主要是函数指针,设备驱动都有该结构体类型变量,设备驱动向内核注册时提供该结构体类型的变量（file_operations的详细介绍可看本博客：树莓派(四):内核驱动框架）

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    int (*readdir) (struct file *, void *, filldir_t);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    int (*open) (struct inode *, struct file *);
    int (*flush) (struct file *, fl_owner_t id);
    int (*release) (struct inode *, struct file *);
    int (*fsync) (struct file *, int datasync);
    int (*aio_fsync) (struct kiocb *, int datasync);
    int (*fasync) (int, struct file *, int);
    int (*lock) (struct file *, int, struct file_lock *);
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    int (*check_flags)(int);
    int (*flock) (struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    int (*setlease)(struct file *, long, struct file_lock **);
};
static inline int register_chrdev(unsigned int major, const char *name,
                  const struct file_operations *fops)
{
    return __register_chrdev(major, 0, 256, name, fops);
}


        register_chrdev(linux/fs.h)驱动向内核注册自己的file_operations
        major为设备驱动编号,为0则为自动分配,其他为静态注册(/proc/devices可查看驱动编号)
        name为驱动名称,fops为驱动申请的file_opearatios

copy_to_user(void __user *to, const void *from, unsigned long n)

        将数据从用户空间复制到内核空间

copy_from_user(void __user *to, const void *from, usigned long count);

        将数据从内核空间复制到用户空间

虚拟地址映射
        驱动操控硬件,操控硬件物理地址在内核中的虚拟地址
        静态虚拟地址映射：内核启动时建立静态映射表(硬编码),岁内核销毁
        动态虚拟地址映射：动态建立映射、使用、销毁映射,映射是临时的

        led驱动静态映射(s5pv210)

arch/arm/mach-s5pv210/include/mach/gpio-bank.h
#define S5PV210_GPJ0CON            (S5PV210_GPJ0_BASE + 0x00)
#define S5PV210_GPJ0DAT            (S5PV210_GPJ0_BASE + 0x04)
#define S5PV210_GPJ0PUD            (S5PV210_GPJ0_BASE + 0x08)
#define S5PV210_GPJ0DRV            (S5PV210_GPJ0_BASE + 0x0c)
#define S5PV210_GPJ0CONPDN        (S5PV210_GPJ0_BASE + 0x10)
#define S5PV210_GPJ0PUDPDN        (S5PV210_GPJ0_BASE + 0x14)
arch/arm/mach-s5pv210/include/mach/regs-gpio.h
define S5PV210_GPJ0_BASE        (S5P_VA_GPIO + 0x240)
#define S5P_VA_GPIO        S3C_ADDR(0x00500000)
#define S3C_ADDR(x)    (S3C_ADDR_BASE + (x))
#define S3C_ADDR_BASE    (0xFD000000)        //静态映射表基地址
arch/arm/plat-s5p/include/plat/map-s5p.h

        led驱动态映射

#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)

        向内核申请映射内存资源,start:物理地址,n大小,name名字

#define ioremap(cookie,size)        __arch_ioremap((cookie), (size), MT_DEVICE)

        返回映射的虚拟地址,cookie:物理地址,szie大小

#define iounmap(cookie)            __iounmap(cookie)

        解除映射虚拟地址,cookie:物理地址

#define release_mem_region(start,n)    __release_region(&iomem_resource, (start), (n))

        释放申请,start:物理地址,n大小,name名字

demo: 

        210已移植uboot(ntfs,tftp),kernel,busynox

        ubuntu安装ntfs,tftp

        led驱动(静态虚拟地址映射)

led.c

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

#define FILE    "/dev/led"

char buf[16];
char led_cmd[3][4];

void div_cmd(char *str)
{
        unsigned int m = 0;
        unsigned int n = 0;
        memset(led_cmd,'\0',sizeof(led_cmd));
 
        while(*str != '\0')
        {
                if(*str != ' ')
                {
                        led_cmd[m][n] = *str;
                        n++;
                }
                else
                {
                        led_cmd[m][n] = '\0';
                        n = 0;
                        m++;
                }
                str++;
        }
}

void write_buf()
{
        int i;

        memset(buf,'\0',sizeof(buf));
        if(!strcmp(led_cmd[1],"on"))
                buf[0] = '0';
        if(!strcmp(led_cmd[1],"off"))
                buf[0] = '1';
        buf[1] = *(led_cmd[2]);
} 

int main()
{
        int fd = -1;
        char cmd[16];
        fd = open(FILE, O_RDWR);
        if (fd < 0)
        {
                printf("open %s error.\n", FILE);
                return -1;
        }

        printf("input led cmd :led on|off 1|2|3\n");
        while(1)
        {
                memset(cmd,'\0',sizeof(cmd));
                printf(">>>>");
                fgets(cmd,16,stdin);
                if(cmd[0] == '.' && cmd[1] == 'q')
                {
                        break;
                }
                div_cmd(cmd);
                write_buf();
                write(fd,buf,strlen(buf));
        }
        close(fd);

        return 0;
}

led_static_module.c 

cat: cat: 没有那个文件或目录
#include <linux/module.h>               // module_init  module_exit
#include <linux/init.h>                 // __init   __exit
#include <linux/fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>

#define NAME "led"

int major;
char kbuf[16];

#define GPJ0CON         S5PV210_GPJ0CON
#define GPJ0DAT         S5PV210_GPJ0DAT

#define rGPJ0CON        *((volatile unsigned int *)GPJ0CON)
#define rGPJ0DAT        *((volatile unsigned int *)GPJ0DAT)

static int led_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "led_dev_open\n");
        return 0;
}


static int led_close(struct inode *inode, struct file *file)
{
        rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
        printk(KERN_INFO "led_dev_close\n");
        return 0;
}

static ssize_t led_write(struct file *file, const char __user *ubuf,size_t count, loff_t *ppos)
{
        int ret = -1;
        int led;

        memset(kbuf, 0, sizeof(kbuf));
        ret = copy_from_user(kbuf, ubuf, count);
        if (ret)
        {
                printk(KERN_ERR "copy_from_user error\n");
                return ret;
        }

        led = kbuf[1] - '0' + 2;

        if (kbuf[0] == '0')
        {
                rGPJ0DAT &= ~(1<<led);
        }
        else if (kbuf[0] == '1')
        {
                rGPJ0DAT |= (1<<led);
        }

        printk(KERN_INFO "copy_from_user ok  %d\n",led);

        return 0;
}

ssize_t led_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
        int ret = -1;

        ret = copy_to_user(buf, kbuf, size);
        if (ret)
        {
                printk(KERN_ERR "copy_to_user error\n");
                return ret;
        }
        printk(KERN_INFO "copy_to_user ok\n");

        return 0;
}


static const struct file_operations led_fops = {
        .owner          = THIS_MODULE,
        .open           = led_open,
        .release        = led_close,
        .write          = led_write,
        .read           = led_read,
};



static int __init led_dev_init()
{
        rGPJ0CON = 0x11111111;
        major = register_chrdev(0, NAME, &led_fops);
        printk(KERN_INFO "register success,major:%d\n",major);

        return 0;
}

static int __exit led_dev_exit()
{
        rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
        unregister_chrdev(major, NAME);
        printk(KERN_INFO "Cancel register\n");
        return 0;
}


module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cxb");
MODULE_DESCRIPTION("led static module");
MODULE_ALIAS("led");

Makefile 

KERN_DIR = /root/kernel

obj-m   += led_static_module.o

all:
        make -C $(KERN_DIR) M=`pwd` modules 
        arm-linux-gcc led.c -o led

cp:
        cp *.ko /root/rootfs/driver
        cp led /root/rootfs/driver


.PHONY: clean
clean:
        make -C $(KERN_DIR) M=`pwd` modules clean
        rm -rf ./led

结果显示: 

         led驱动(动态虚拟地址映射)

led.c(同上)

led_dynamic_module.c

#include <linux/module.h>               // module_init  module_exit
#include <linux/init.h>                 // __init   __exit
#include <linux/fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>

#define NAME "led"

int major;
char kbuf[16];

#define GPJ0CON_PA      0xe0200240
#define GPJ0DAT_PA      0xe0200244

unsigned int *rGPJ0CON;
unsigned int *rGPJ0DAT;

static int led_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "led_dev_open\n");
        return 0;
}


static int led_close(struct inode *inode, struct file *file)
{
        *rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
        printk(KERN_INFO "led_dev_close\n");
        return 0;
}

static ssize_t led_write(struct file *file, const char __user *ubuf,size_t count, loff_t *ppos)
{
        int ret = -1;
        int led;

        memset(kbuf, 0, sizeof(kbuf));
        ret = copy_from_user(kbuf, ubuf, count);
        if (ret)
        {
                printk(KERN_ERR "copy_from_user error\n");
                return ret;
        }

        led = kbuf[1] - '0' + 2;

        if (kbuf[0] == '0')
        {
                *rGPJ0DAT &= ~(1<<led);
        }
        else if (kbuf[0] == '1')
        {
                *rGPJ0DAT |= (1<<led);
        }

        printk(KERN_INFO "copy_from_user ok  %d\n",led);

        return 0;
}

ssize_t led_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
        int ret = -1;

        ret = copy_to_user(buf, kbuf, size);
        if (ret)
        {
                printk(KERN_ERR "copy_to_user error\n");
                return ret;
        }
        printk(KERN_INFO "copy_to_user ok\n");

        return 0;
}


static const struct file_operations led_fops = {
        .owner          = THIS_MODULE,
        .open           = led_open,
        .release        = led_close,
        .write          = led_write,
        .read           = led_read,
};



static int __init led_dev_init()
{
        major = register_chrdev(0, NAME, &led_fops);
        printk(KERN_INFO "register success,major:%d\n",major);

        if (!request_mem_region(GPJ0CON_PA, 4, "GPJ0CON"))
                return -EINVAL;
        if (!request_mem_region(GPJ0DAT_PA, 4, "GPJ0CON"))
                return -EINVAL;
        rGPJ0CON = ioremap(GPJ0CON_PA, 4);
        rGPJ0DAT = ioremap(GPJ0DAT_PA, 4);
        *rGPJ0CON = 0x11111111;

        return 0;
}

static int __exit led_dev_exit()
{
        rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
        iounmap(rGPJ0CON);
        iounmap(rGPJ0DAT);
        release_mem_region(GPJ0CON_PA, 4);
        release_mem_region(GPJ0DAT_PA, 4);
        unregister_chrdev(major, NAME);
        printk(KERN_INFO "Cancel register\n");
        return 0;
}


module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cxb");
MODULE_DESCRIPTION("led static module");
MODULE_ALIAS("led");

Makefile 

KERN_DIR = /root/kernel

obj-m   += led_dynamic_module.o

all:
        make -C $(KERN_DIR) M=`pwd` modules 
        arm-linux-gcc led.c -o led

cp:
        cp *.ko /root/rootfs/driver
        cp led /root/rootfs/driver


.PHONY: clean
clean:
        make -C $(KERN_DIR) M=`pwd` modules clean
        rm -rf ./led

结果显示: 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

从实际工作情况，介绍嵌入式(MCU)软件开发常用(通用)工具

从实际工作情况，介绍嵌入式(MCU)软件开发常用(通用)工具

目录 前言 1、代码阅读及编辑工具&#xff08;VSCode、Understand&#xff09; 2、代码对比工具&#xff08;Beyond Compare&#xff09; 3、代码仓库相关工具&#xff08;Git、SVN、Tortoise&#xff09; 4、文本编辑器&#xff08;Notepad&#xff09; 5、电脑文件搜索工…
阅读更多...
使用递归实现深拷贝

使用递归实现深拷贝

文章目录 为什么要使用递归什么深拷贝具体实现基础实现处理 函数处理 Symbol处理 Set处理 Map处理 循环引用 结语-源码 为什么要使用递归什么深拷贝 我们知道在 JavaScript 中可以通过使用JSON序列化来完成深拷贝&#xff0c;但是这种方法存在一些缺陷&#xff0c;比如对于函数…
阅读更多...
「Kafka」生产者篇

「Kafka」生产者篇

「Kafka」生产者篇 生产者发送消息流程 在消息发送的过程中&#xff0c;涉及到了 两个线程 ——main 线程和Sender 线程。 在 main 线程中创建了 一个 双端队列 RecordAccumulator。 main线程将消息发送给RecordAccumulator&#xff0c;Sender线程不断从 RecordAccumulator…
阅读更多...
＜软考高项备考＞《论文专题 - 37 采购管理（2） 》

＜软考高项备考＞《论文专题 - 37 采购管理（2） 》

2 过程1-规划采购管理 2.1 问题 4W1H过程做什么记录项目采购决策、明确采购方法&#xff0c;及识别潜在卖方的过程作用&#xff1a;确定是否从项目外部获取货物和服务&#xff0c;如果是&#xff0c;则还要确定将在什么时间、以什么方式获取什么货物和服务为什么做为如何采购…
阅读更多...
移动端开发框架mui代码在安卓模拟器上运行（HbuilderX连接到模拟器）

移动端开发框架mui代码在安卓模拟器上运行（HbuilderX连接到模拟器）

开发工具 HBuilder X 3.8.12.20230817 注意&#xff1a;开发工具尽量用最新的或较新的。太旧的版本在开发调试过程中可能会出现莫名其妙的问题。 1、电脑下载安装安卓模拟器 我这里使用的是 夜神模拟器 &#xff0c;也可以选择其他安卓模拟器 夜神模拟器官网&#xff1a;夜神安…
阅读更多...
idea实现Java连接MySQL数据库

idea实现Java连接MySQL数据库

1.下载MySQL并安装 首先如果没有mysql的需要先下载MySQL&#xff0c;可以看这个教程&#xff1a; Mysql超详细安装配置教程(保姆级)_mysql安装及配置超详细教程-CSDN博客 2.下载mysql 的jdbc驱动 官网&#xff1a;MySQL :: Download Connector/J 解压并将驱动jar包导入id…
阅读更多...
ThinkPad T14s Gen3,ThinkPad X13 Gen3(21BS,21BQ,21BR,21BN)原装出厂Win11系统

ThinkPad T14s Gen3,ThinkPad X13 Gen3(21BS,21BQ,21BR,21BN)原装出厂Win11系统

lenovo联想ThinkPad系列T14s/X13 Gen3笔记本电脑原装Windows11预装OEM系统镜像 链接&#xff1a;https://pan.baidu.com/s/1yhRMIjlkFvt86aLioOoNOA?pwdfrsp 提取码&#xff1a;frsp 原厂系统自带所有驱动、出厂主题壁纸、系统属性专属联机支持标志、Office办公软件、联想…
阅读更多...
内网常规攻击路径

内网常规攻击路径

点击星标&#xff0c;即时接收最新推文 随着网络技术的发展&#xff0c;企业内部网络架构的变化&#xff0c;网络设备多样性的增加&#xff0c;面对内网攻击&#xff0c;防御体系逐渐阶梯化&#xff0c;通过不同维度的防御联动&#xff0c;将攻击拒之门外。对于突破网络边界后进…
阅读更多...
Rust学习笔记000 安装

Rust学习笔记000 安装

安装命令 curl --proto https --tlsv1.2 -sSf https://sh.rustup.rs | sh $ curl --proto https --tlsv1.2 -sSf https://sh.rustup.rs | sh info: downloading installerWelcome to Rust!This will download and install the official compiler for the Rust programming la…
阅读更多...
Goodbye2023, Hello 2024!

Goodbye2023, Hello 2024!

2023的所有比赛结束了&#xff0c;以后 xcpc 相关的比赛应该都和我没啥关系了&#xff0c;可能只打打蓝桥天梯了&#xff0c;等到明年的时候估计很多算法的东西也都忘记了吧&#xff0c;彻底退休了。打铁人不配叫退役&#xff0c;也不敢公开这篇文章&#xff0c;只敢在没人看的…
阅读更多...
【算法】数论---欧拉函数

【算法】数论---欧拉函数

什么是欧拉函数&#xff1f; 对于正整数n&#xff0c;欧拉函数是小于或等于n的正整数中与n互质的数的数目&#xff0c;记作φ(n) φ(1)1 当m,n互质时&#xff0c;φ(mn)φ(m)∗φ(n) 一、求一个正整数的欧拉函数---&#xff08;先对它分解质因数&#xff0c;然后套公式&#xf…
阅读更多...
2024新年贺词：从“第一次”到“每一次”，锐意进取，未来可期

2024新年贺词：从“第一次”到“每一次”，锐意进取，未来可期

从“第一次”到“每一次”&#xff1a;锐意进取&#xff0c;未来可期&#xff01; 2023年&#xff0c;对和数来讲&#xff0c;是很不平凡的一年。在这一年里&#xff0c;我们共同创造并见证了很多个“第一次”。2023年8月&#xff0c;SHANHAI国际版正式在泰国上线。第一次“出…
阅读更多...
LLM之RAG实战（九）| 高级RAG 03：多文档RAG体系结构

LLM之RAG实战（九）| 高级RAG 03：多文档RAG体系结构

在RAG&#xff08;检索和生成&#xff09;这样的框架内管理和处理多个文档有很大的挑战。关键不仅在于提取相关内容&#xff0c;还在于选择包含用户查询所寻求的信息的适当文档。基于用户查询对齐的多粒度特性&#xff0c;需要动态选择文档&#xff0c;本文将介绍结构化层次检索…
阅读更多...
python+opencv实现图片/短视频一键去水印

python+opencv实现图片/短视频一键去水印

目录 0 前言1 准备工作2 读取图片或视频3 添加回调获取鼠标绘制水印区域4 调用opencv函数5 绘制蒙版主循环6 去水印主循环总结 0 前言 在制作ppt个人文章或者分享图片过程中&#xff0c;经常会遇到一些带有水印的情况&#xff0c;不少人都希望能够去除这些水印&#xff0c;提高…
阅读更多...
分布式存储考点梳理 + 高频面试题

分布式存储考点梳理 + 高频面试题

欢迎来到分布式存储模环节&#xff0c;本文我将和你一起梳理面试中分布式系统的数据库的高频考点&#xff0c;做到温故知新。 面试中如何考察分布式存储 广义的分布式存储根据不同的应用领域&#xff0c;划分为以下的类别&#xff1a; 分布式协同系统 分布式文件系统 分布式…
阅读更多...
数据结构：单调栈

数据结构：单调栈

1.单调栈 单调栈是一种数据结构&#xff0c;其中存放的数据应该是有序的&#xff0c;所以单调栈也有单调递减栈和单调递增栈 单调递增栈&#xff1a;栈顶到栈底的元素大小是从小到大 单调递减栈&#xff1a;栈顶到栈底的元素大小是从大到小 单调栈主要就是用来求一个给定序列中…
阅读更多...
上海周边公路骑行路线分享，维乐带你抓住秋天的小尾巴

上海周边公路骑行路线分享，维乐带你抓住秋天的小尾巴

路线一&#xff1a;松江郊里骑行 　　 　　在魔都上海&#xff0c;藏着一条自然风景适宜&#xff0c;能眺望黄浦江的美丽骑行路线。导航到华长路杨家角就能到达起点&#xff0c;一路向西&#xff0c;这里路况非常好&#xff0c;只有一条小道&#xff0c;没有汽车的障碍&#xf…
阅读更多...
数组(定义,静态初始化,地址值,元素访问,索引,遍历,动态初始化,两种初始化的区别,练习)

数组(定义,静态初始化,地址值,元素访问,索引,遍历,动态初始化,两种初始化的区别,练习)

文章目录 1.数组概念&#xff1a; 2.数组的定义格式一&#xff1a;格式二&#xff1a;详解&#xff1a;注意点&#xff1a; 3.数组的静态初始化完整格式&#xff1a;格式详解&#xff1a;注意点&#xff1a;简化格式:练习1&#xff1a;练习2&#xff1a;练习3&#xff1a; 4.地…
阅读更多...
使用opencv+tesseract识别图片中的表格

使用opencv+tesseract识别图片中的表格

描述 在java环境中使用opencv和tesserac识别一个图片表格 环境&#xff1a;opencv和tesseract安装在linux环境下&#xff0c;docker将运行springboot服务 opencv和tesseract的安装和docker加载可参考之前的文章 过程 将图片进行预处理&#xff0c;过滤掉颜色等干扰元素 提…
阅读更多...
基于Ubuntu环境Git服务器搭建及使用

基于Ubuntu环境Git服务器搭建及使用

基于Ubuntu环境Git服务器搭建及使用 Chapter1 搭建本地git服务器及详细操作步骤1.搭建本地git服务器1.1 环境1.2 服务端配置1.3 创建git专属用户1.4 创建git仓库1.5 配置免密登录基础 2.客户端拉取推送代码2.1客户端创建ssh公钥 2.2 免密配置3.仓库使用&#xff08;拉取及推送代…
阅读更多...
最新文章

Copyright @ 2022~2023