驱动移植基础

最新推荐文章于 2024-02-15 12:12:19 发布
最新推荐文章于 2024-02-15 12:12:19 发布
阅读量63 收藏 1
点赞数
分类专栏： c linux ARM 文章标签： arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51732151/article/details/131231616
版权
c 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
linux
13 篇文章 0 订阅
订阅专栏
ARM
2 篇文章 0 订阅
订阅专栏

linux模块框架

linux模块框架

/*头文件    头文件路径*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <asm/io.h>

#include "mycmd.h"


#define MA 500
#define MI 0

#define GPF3CON 0x114001e0 /*led*/
#define GPF3DAT 0x114001e4

#define ADCCFG 0x10010118/*adc*/
#define ADCCON 0x126C0000
#define ADCDAT 0x126C000c
#define ADCMUX 0x126c001c

static dev_t no = 0;
static unsigned count = 1;
const char* name = "myDev02";
static struct cdev mydev;

static char buf[20]={0};

static unsigned int* gpf3con = NULL;
static unsigned int* gpf3dat = NULL;

static unsigned int* adccfg = NULL;
static unsigned int* adccon = NULL;
static unsigned int* adcdat = NULL;
static unsigned int* adcmux = NULL;






static void adc_init(void)
{
    adccfg = ioremap(ADCCFG,4);//物理地址映射到虚拟地址 
    adccon = ioremap(ADCCON,4);//物理地址映射到虚拟地址 
    adcmux = ioremap(ADCMUX,4);//物理地址映射到虚拟地址 
    adcdat = ioremap(ADCDAT,4);//物理地址映射到虚拟地址 

    writel(0x3,adcmux);
    writel(readl(adccfg)&~(0x1<<16),adccfg);
    writel((0x1<<16)|(0x1<<14)|(0xff<<6)|(0x1<<1),adccon);
}
static int adc_getData(void)
{
    return readl(adcdat)&0xfff;
}



static int myopen(struct inode* pi,struct file* pf)
{
    printk("myopen.\n");
    return 0;
}
static int myrelease(struct inode* pi,struct file* pf)
{
    printk("myrelease.\n");
    return 0;
}



static ssize_t myread(struct file* pf, char __user* rbuf, size_t len, loff_t* pl)
{
    int count = 0;

    printk("myread.\n");
    if(NULL==rbuf)
    {
        printk("wbuf is NULL");
        return -1;
    }
    while(buf[count])
    {
        rbuf[count] = buf[count];
        count++;
    }
    return count;

}
static ssize_t mywrite (struct file* pf, const char __user* wbuf, size_t len, loff_t* pl)
{
    int count = 0;

    printk("mywrite.\n");
    if(NULL==wbuf)
    {
        printk("wbuf is NULL");
        return -1;
    }
    while(wbuf[count])
    {
        buf[count] = wbuf[count];
        count++;
    }
    return count;
}



long myioctl (struct file* pf, unsigned int cmd, unsigned long arg)
{
    switch(cmd)
    {
        case LED_ON:
            printk("LED_ON.\n");
            writel(readl(gpf3dat)|(0x1<<4),gpf3dat);
            break;
        case LED_OFF:
            printk("LED_OFF.\n");
            writel(readl(gpf3dat)&~(0x1<<4),gpf3dat);
            break;
        case ADC_GET:
            //printk("ADC:%d.%dV.\n",adc_getData()*18/4095/10,adc_getData()*18/4095%10);
            return adc_getData();
            break;
        default:
            break;
    }
    return 0;
}

static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .read = myread,
    .write = mywrite,
    .unlocked_ioctl = myioctl,
};

static int myInit(void)
{
    int ret  = 0;
    int cret = 0;
    printk("mod02 init.\n");

    no = MKDEV(MA,MI);//生成唯一dev号
    ret = register_chrdev_region(no,count,name);//注册
    if(ret!=0)
    {
        printk("register failed.\n");
        return ret;
    }
    else
    {
        printk("register success.\n");
    }

    cdev_init(&mydev,&myfops);//cdev初始化

    cret = cdev_add(&mydev,no,count);//cdev添加
    if(cret!=0)
    {
        printk("cdev_add failed.\n");
        unregister_chrdev_region(no,count);//dev注销
        return -cret;
    }
    else
    {
        printk("cdev_add success.\n");
    }



    gpf3con = ioremap(GPF3CON,4);//物理地址映射到虚拟地址
    writel((readl(gpf3con)&~(0xf<<16))|(0x1<<16),gpf3con);//读修改写
    gpf3dat = ioremap(GPF3DAT,4);



    adc_init();
    return 0;
}
static void myExit(void)
{
    cdev_del(&mydev);//cdev删除
    unregister_chrdev_region(no,count);//dev注销
    printk("mod02 exit.\n");
}

module_init(myInit);
module_exit(myExit);

MODULE_LICENSE("GPL");

并发

init exit
file_operation    open,read ... ...
        |                    |        |
     user               open   read

互斥机制

中断屏蔽：只在单cpu下有效
原子操作：操作整型数据
自旋锁：不允许调度，“锁上就解”；解锁的时候，被锁住的任务获得执行效率高
信号量：在锁住的时候，cpu不会被占用，总体性能不会下降；解锁的时候，被锁住的时候不会马上执行，开销大
互斥锁：与信号量差不多

阻塞、非阻塞、异步

阻塞：获取资源，获取不到，一直等待
非阻塞：while(1){获取资源，获取不到，立马next} 轮询
异步通知
等待队列 阻塞

自旋锁

/*驱动*/
#include <linux/sys.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/spinlock.h>

#define MA 500
#define MI 0

#define LOCK 2
#define UNLOCK 3

static dev_t no = 0;
static struct cdev mydev;
const char* name = "myDev3";
static int count = 1;
static spinlock_t mylock; 
static char buf[50]={0};

static ssize_t myread(struct file* pf, char __user* rbuf, size_t len, loff_t* pl)
{
    int count = 0;
    if(NULL==rbuf)
    {
        printk("rbuf is NULL");
        return -1;
    }
    if(spin_is_locked(&mylock))
    {
        return LOCK; 
    }
    spin_lock(&mylock);
    count = copy_to_user(rbuf,buf,len);
    spin_unlock(&mylock);
    if(0!=count)
    {
        return -1;
    }
    return count;
}

static ssize_t mywrite (struct file* pf, const char __user* wbuf, size_t len, loff_t* pl)
{
    int count = 0;
    if(NULL==wbuf)
    {
        printk("wbuf is NULL");
        return -1;
    }
    if(spin_is_locked(&mylock))
    {
        return LOCK; 
    }
    spin_lock(&mylock);
    count = copy_from_user(buf,wbuf,len);
    spin_unlock(&mylock);
    if(0!=count)
    {
        return -1;
    }
    return count;
}

static struct file_operations myops={
    .read = myread,
    .write = mywrite,
}; 

static int myinit(void)
{
    int rret = 0;
    int cret = 0;
    printk("init\n");
    no = MKDEV(MA,MI);
    rret = register_chrdev_region(no,count,name);
    if(rret!=0)
    {
        printk("register failed\n");
        return rret;
    }
    else
    {
        printk("register successed\n");
    }
    cdev_init(&mydev,&myops);
    cret = cdev_add(&mydev,no,count);
    if(cret!=0)
    {
        printk("cdev_add failed\n");
        unregister_chrdev_region(no,count);
        return -cret;
    }
    else
    {
        printk("cdev_add successed\n");
    }
    spin_lock_init(&mylock);
    return 0;
}

static void myexit(void)
{
    cdev_del(&mydev);
    unregister_chrdev_region(no,count);
    printk("mod03 exit\n");
    return;
}

module_init(myinit);
module_exit(myexit);

MODULE_LICENSE("GPL");

异步信号

/*驱动*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>

#define MA 500
#define MI 0
#define MAX_LEN 16

static dev_t no = 0;
static unsigned count = 1;
static const char *name = "mydev";
static struct cdev mydev;
static char kbuf[MAX_LEN] = {0};
static int w = 0;
struct fasync_struct *async_queue = NULL;

static int myopen(struct inode *pi, struct file *pf)
{
    return 0;
}

static int myrelease(struct inode *pi, struct file *pf)
{
    return 0;
}

ssize_t myread(struct file *pf, char __user *ubuf, size_t len, loff_t *poff)
{
    int ret = -1;
    if(len>MAX_LEN)
        return -EINVAL;
    ret = copy_to_user(ubuf,kbuf,len);
    if(0!=ret)
        return -1;
    w = 0;
    return len;
}

ssize_t mywrite(struct file *pf, const char __user *ubuf, size_t len, loff_t *poff)
{
    int ret = -1;
    if(len>MAX_LEN)
        return -EINVAL;
    ret = copy_from_user(kbuf,ubuf,len);
    if(0!=ret)
        return -1;
    w = 1;
    kill_fasync(&async_queue, SIGIO, POLL_IN);
    return len;
}

static int myfasync(int fd, struct file *filp, int mode)
{
	return fasync_helper(fd, filp, mode, &async_queue);
}

static const struct file_operations myops={
    .open = myopen,
    .release = myrelease,
    .read = myread,
    .write = mywrite,
    .fasync = myfasync,
};
    
static int myinit(void)
{
    int ret = -1;
    no = MKDEV(MA,MI);
    ret = register_chrdev_region(no, count, name);
    if(ret != 0)
    {
        printk("register failed.\n");
        return ret;
    }
    cdev_init(&mydev, &myops);
    ret = cdev_add(&mydev,no,count);
    if(ret != 0)
    {
        unregister_chrdev_region(no,count);
        return ret;
    }
    printk("init ok\n");
    return 0;
}

static void myexit(void)
{
    cdev_del(&mydev);
    unregister_chrdev_region(no,count);
    printk("exit ok.\n");
}

module_init(myinit);
module_exit(myexit);

MODULE_LICENSE("GPL");

/*应用*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>

int main(int argc, char *argv[])
{
    int fd = open("dev/mydev",O_RDWR);
    int oflags = 0;
    signal(SIGIO, sig_handler);
    fcntl(fd, F_SETOWN, getpid());//关联设备与进程
    oflags = fcntl(fd, F_GETFL); //获得文件状态标志
    fcntl(fd, F_SETFL, oflags | FASYNC);//设置文件状态标志
    sleep(2);
    write(fd, wbuf, sizeof(wbuf));
    while(1);
    return 0;
}

平台设备

设备模型：分层分级
4个重要组成： dev drv bus class（设备 驱动 总线 设备类）
要在设备树文件中添加设备相关信息

平台驱动

/*驱动*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include "mycmd.h"

#define MA 400
#define MI 0

static dev_t no = 0;
static unsigned count = 1;
const char* name = "myDevLed";
static struct cdev mydev;
static unsigned int* gpf3con = NULL;
static unsigned int* gpf3dat = NULL;

static int myopen(struct inode* pi,struct file* pf)
{
    printk("myopen.\n");
    return 0;
}

static int myrelease(struct inode* pi,struct file* pf)
{
    printk("myrelease.\n");
    return 0;
}

long myioctl (struct file* pf, unsigned int cmd, unsigned long arg)
{
    switch(cmd)
    {
        case LED_ON:
            printk("LED_ON.\n");
            writel(readl(gpf3dat)|(0x1<<4),gpf3dat);
            break;
        case LED_OFF:
            printk("LED_OFF.\n");
            writel(readl(gpf3dat)&~(0x1<<4),gpf3dat);
            break;
        default:
            break;
    }
    return 0;
}

static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .unlocked_ioctl = myioctl,
};

static int myInit(struct platform_device* pdev)
{
    int ret  = 0;
    int cret = 0;
    struct resource* rescon = NULL;
    struct resource* resdat = NULL;
    printk("init.\n");
    no = MKDEV(MA,MI);//生成唯一dev号
    ret = register_chrdev_region(no,count,name);//注册
    if(ret!=0)
    {
        printk("register failed.\n");
        return ret;
    }
    else
    {
        printk("register success.\n");
    }
    cdev_init(&mydev,&myfops);//cdev初始化
    cret = cdev_add(&mydev,no,count);//cdev添加
    if(cret!=0)
    {
        printk("cdev_add failed.\n");
        unregister_chrdev_region(no,count);//dev注销
        return -cret;
    }
    else
    {
        printk("cdev_add success.\n");
    }
    
    rescon = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    resdat = platform_get_resource(pdev, IORESOURCE_MEM, 1);
    gpf3con = ioremap(rescon->start,4);
    gpf3dat = ioremap(resdat->start,4);
    writel((readl(gpf3con)&~(0xf<<16))|(0x1<<16),gpf3con);//读修改写
    return 0;
}

static int myExit(struct platform_device* pdev)
{
    cdev_del(&mydev);//cdev删除
    unregister_chrdev_region(no,count);//dev注销
    printk("exit.\n");
    return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id mydev_of_matches[] = {
	{ .compatible = "fs4412,led", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mydev_of_matches);
#endif

static struct platform_driver mydev_driver = {
	.driver	= {
		.name    = "mydevled",
		.owner	 = THIS_MODULE,
		.of_match_table = of_match_ptr(mydev_of_matches),
	},
	.probe   = myInit,
	.remove  = myExit,
};

module_platform_driver(mydev_driver);

MODULE_LICENSE("GPL");

共享内存

/*驱动*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <linux/gfp.h>
#include <linux/mm.h>
#include <linux/slab.h>

#define MA 500
#define MI 0

static dev_t no = 0;
static unsigned count = 1;
const char* name = "myDev02";
static struct cdev mydev;
char* kbuf = NULL;

static int myopen(struct inode* pi,struct file* pf)
{
    printk("myopen.\n");
    return 0;
}

static int myrelease(struct inode* pi,struct file* pf)
{
    printk("myrelease.\n");
    return 0;
}

int mymmap(struct file *pf, struct vm_area_struct *vma)
{
    vma->vm_flags |= VM_IO; 
    vma->vm_flags |= VM_DONTEXPAND |VM_DONTDUMP; 
    if(remap_pfn_range(vma,
                vma->vm_start,
                virt_to_phys(kbuf)>>PAGE_SHIFT,
                vma->vm_end - vma->vm_start,
                vma->vm_page_prot))
    {  
        return -EAGAIN;  
    }  
    return 0;  
}


static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .mmap = mymmap,
};

static int myInit(void)
{
    int ret  = 0;
    int cret = 0;
    printk("init.\n");
    no = MKDEV(MA,MI);//生成唯一dev号
    ret = register_chrdev_region(no,count,name);//注册
    if(ret!=0)
    {
        printk("register failed.\n");
        return ret;
    }
    else
    {
        printk("register success.\n");
    }
    cdev_init(&mydev,&myfops);//cdev初始化
    cret = cdev_add(&mydev,no,count);//cdev添加
    if(cret!=0)
    {
        printk("cdev_add failed.\n");
        unregister_chrdev_region(no,count);//dev注销
        return -cret;
    }
    else
    {
        printk("cdev_add success.\n");
    }
    kbuf = (char*)kmalloc(PAGE_SIZE,GFP_KERNEL);
    return 0;
}

static void myExit(void)
{
    cdev_del(&mydev);//cdev删除
    unregister_chrdev_region(no,count);//dev注销
    printk("exit.\n");
}

module_init(myInit);
module_exit(myExit);

MODULE_LICENSE("GPL");

中断

/*按键中断驱动*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>

#define MA 500
#define MI 0

static dev_t no = 0;
static unsigned count = 1;
const char* name = "myDevKey";
static struct cdev mydev;
struct fasync_struct *async_queue = NULL;

static int myopen(struct inode* pi,struct file* pf)
{
    printk("myopen.\n");
    return 0;
}

static int myrelease(struct inode* pi,struct file* pf)
{
    printk("myrelease.\n");
    return 0;
}

static int myfasync(int fd, struct file *filp, int mode)
{
    return fasync_helper(fd, filp, mode, &async_queue);
}

static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .fasync = myfasync,
};

irqreturn_t handler(int no,void* arg)
{
    printk("key3\n");
    kill_fasync(&async_queue, SIGIO, POLL_IN);
    return IRQ_HANDLED;
}

static int myInit(struct platform_device* pdev)
{
    int ret  = 0;
    int cret = 0;
    int reqret = 0;
    struct resource* resirq = NULL;
    printk("init.\n");
    no = MKDEV(MA,MI);//生成唯一dev号
    ret = register_chrdev_region(no,count,name);//注册
    if(ret!=0)
    {
        printk("register failed.\n");
        return ret;
    }
    else
    {
        printk("register success.\n");
    }
    cdev_init(&mydev,&myfops);//cdev初始化
    cret = cdev_add(&mydev,no,count);//cdev添加
    if(cret!=0)
    {
        printk("cdev_add failed.\n");
        unregister_chrdev_region(no,count);//dev注销
        return -cret;
    }
    else
    {
        printk("cdev_add success.\n");
    }
    resirq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    reqret = request_irq(resirq->start,handler,resirq->flags,"myirp",NULL);
    return 0;
}

static int myExit(struct platform_device* pdev)
{
    cdev_del(&mydev);//cdev删除
    unregister_chrdev_region(no,count);//dev注销
    printk("exit.\n");
    return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id mydev_of_matches[] = {
	{ .compatible = "fs4412,key", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mydev_of_matches);
#endif

static struct platform_driver mydev_driver = {
	.driver	= {
		.name    = "mydevkey",
		.owner	 = THIS_MODULE,
		.of_match_table = of_match_ptr(mydev_of_matches),
	},
	.probe   = myInit,
	.remove  = myExit,
};

module_platform_driver(mydev_driver);

MODULE_LICENSE("GPL");
qq_51732151
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
驱动开发基础知识
kris_paul的博客
11-04 2822
驱动开发前部分知识储备
Linux驱动基础开发
01-27
（1）Linux应用软件工程师...（2）Linux固件工程师（FirmwareEngineer）：主要进行Bootloader、Linux的移植及Linux设备驱动程序的设计工作。一般而言，固件工程师的要求要高于应用软件工程师的层次，而其中的Linux设
VxWorks驱动移植基础知识
egbert123的博客
07-31 4012
VxWorks驱动架构: 一、在最新发布的VxWorks6.x版本中，devicedriver可以通过两种方式来实现 1、 VxBus-enabled devicedrivers 这种架构下编写的driver为OS和设备定义了一系列标准接口来和driver交互 2、as legacy(pre-VxBus) device drivers 这种结构下编写的驱动没有为OS和设备提供标准接口 ...
NandFlash驱动移植基础知识
Seal--学海无涯
04-24 2890
NandFlash驱动移植基础知识 文章借鉴博文：http://blog.csdn.net/leibniz_zsu/article/details/4977842 博文写的不错，谢谢分享 MTD 驱动程序是专门针对嵌入式 Linux 的一种驱动程序，相对于常规块设备驱动程序（比如PC 中的 IDE 硬盘）而言， MTD 驱动程序能更好的支持和管理闪存设备，因为它本身就是专为闪存设备而设计的。
mtk spi驱动移植
影子在动
02-26 5233
spi驱动移植
图文讲解 WiFi 驱动移植过程，很肝~
李肖遥的专栏
06-05 1644
关注、星标公众号，直达精彩内容来源：嵌入式基础学习作者：小二本篇文章打算对WiFi 驱动移植文章进行一次系统性的总结、复盘，分享一下自己的思考过程，遇到的问题等。希望对您有点帮助?????...
《Android系统移植和驱动开发》 PDF
08-25
本书共12章，开篇介绍了Android底层开发和嵌入式开发之间的关系，接着介绍Android系统的编译和移植，在这个基础上进一步阐述了Android驱动开发的原理，最后给出了一个Android智能家居的实例。 本书是大学院校嵌入式...
把stm32上的st7735驱动移植到使用wiringPi的设备上源码+项目使用说明.zip
10-11
把stm32上的st7735驱动移植到使用wiringPi的设备上源码+项目使用说明.zip 把stm32上的st7735驱动移植到使用wiringPi的设备上 ### 设备支持情况 st7735 - 160*80 st7735 - 168*128 st7735 - 128*128 ### 使用 *...
Android驱动开发与移植实战详解
12-04
Android驱动开发与移植实战详解 认识驱动 linux核心基础 分析安卓远吗
LED照明
汽车以太网和SOA
02-15 4010
LED照明
基于关键词搜索结果的微博爬虫（下载即用）.zip
05-21
基于关键词搜索结果的微博爬虫（下载即用）.zip本项目适合计算机相关专业(如软件工程、计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，当然也适合小白学习进阶。如果基础还行，可以在此代码基础上进行修改，以实现其他功能。 基于关键词搜索结果的微博爬虫（下载即用）.zip本项目适合计算机相关专业(如软件工程、计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，当然也适合小白学习进阶。如果基础还行，可以在此代码基础上进行修改，以实现其他功能。 基于关键词搜索结果的微博爬虫（下载即用）.zip本项目适合计算机相关专业(如软件工程、计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，当然也适合小白学习进阶。如果基础还行，可以在此代码基础上进行修改，以实现其他功能。 基于关键词搜索结果的微博爬虫（下载即用）.zip本项目适合计算机相关专业(如软件工程、计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，当然也适合小白学习进阶。如果基础还行，可以在此代码基础上进行修改
node-v4.4.1-headers.tar.xz
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
J波模拟matlab代码.zip
05-21
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Obsidian quickadd插件
05-21
Obsidian quickadd插件
Fraunhofer Versatile Video Encoder (VVenC) v0.1
05-21
这份文件是关于Fraunhofer Versatile Video Encoder (VVenC) v0.1版本的文档，由Fraunhofer Heinrich Hertz Institute (HHI)的视频编码与分析部门的Jens Brandenburg, Adam Wieckowski, Tobias Hinz, Benjamin Bross撰写
node-v8.0.0-headers.tar.xz
最新发布
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Windows系统nodejs安装及环境配置
05-21
附件是windows系统nodejs安装及环境配置教程，文件格式是markdown，文件绿色安全，请大家放心下载，仅供交流学习使用，无任何商业目的！
JAVA基于J2ME的手机游戏开发(lw+源代码).zip
05-21
随着通信技术的发展和手机的普及，手机游戏的开发技术越来越为人们所关注。以J2ME为开发平台，利用Java提供强大工具，不但可以在手机上实现静态HTML技术所无法实现的计算处理、数据存储、与服务器的通信等功能，而且能够开发各种手机游戏。本文在介绍J2ME及其体系结构的基础上，以贪吃蛇游戏为实例，描述了借助J2ME的MIDlet类库开发手机游戏的过程。
5.21前端基础（1）
05-21
html基础
如何学习LINUX驱动移植
03-09
学习 LINUX 驱动移植需要掌握 LINUX 操作系统的基础知识和驱动开发的相关技术。可以通过阅读相关书籍、参加培训课程、实践项目等方式进行学习。建议先学习 LINUX 操作系统的基础知识，了解驱动的工作原理和开发流程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值