DM365 应用层gpio控制

最新推荐文章于 2013-11-25 11:32:04 发布
最新推荐文章于 2013-11-25 11:32:04 发布
阅读量1.7k 收藏
点赞数
文章标签： buffer struct output input null io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinazjn/article/details/6743434
版权
 

方法一：通过/sys/文件接口操作IO端口 ，转自CSDN。

gpio_operation 通过/sys/文件接口操作IO端口 GPIO到文件系统的映射

* 控制GPIO的目录位于/sys/class/gpio

* /sys/class/gpio/export文件用于通知系统需要导出控制的GPIO引脚编号

* /sys/class/gpio/unexport 用于通知系统取消导出

* /sys/class/gpio/gpiochipX目录保存系统中GPIO寄存器的信息，包括每个寄存器控制引脚的起始编号base，寄存器名称，引脚总数 导出一个引脚的操作步骤

* 首先计算此引脚编号，引脚编号 = 控制引脚的寄存器基数 + 控制引脚寄存器位数

* 向/sys/class/gpio/export写入此编号，比如12号引脚，在shell中可以通过以下命令实现，命令成功后生成/sys/class/gpio/gpio12目录，如果没有出现相应的目录，说明此引脚不可导出：

    echo 12 > /sys/class/gpio/export

* direction文件，定义输入输入方向，可以通过下面命令定义为输出

    echo out > direction

* direction接受的参数：in, out, high, low。high/low同时设置方向为输出，并将value设置为相应的1/0。

* value文件是端口的数值，为1或0.

    echo 1 > value

 此驱动位于：drivers/gpio/gpiolib.c,需要打开 CONFIG_GPIO_SYSFS 宏定义

                  

方法二：通过proc文件系统访问

/**********************  应用层 *******************************/

#define GIO_DEV_PATH "/proc/gio/"
#define GIO_MAX_ID (103)

int gio_getname( char *pName, int gio_id )
{
 if( gio_id < 0 || gio_id > GIO_MAX_ID )
 {
  printf("gio id = %d over range!!\n", gio_id);
  return -1;
 }

 sprintf( pName, GIO_DEV_PATH"gio%d", gio_id );

 return 0;
}

int gio_write( int gio_id , int IsOn)
{
 int  fd_gio = 0;
 char data[5];
 int  result = 0;
 char  dev_name[25];
 int  cnt = 0;

 /* Don't do anything on EVM */
 if( gio_id < 0 || gio_id > GIO_MAX_ID )
 {
  printf("gio id = %d over range!!\n", gio_id);
  return -1;
 }

 if( gio_getname(dev_name,gio_id) < 0 )
 {
  printf("gio get name error!!\n");
  return -1;
 }

 fd_gio = open(dev_name, O_RDWR);

 if( !fd_gio )
 {
  printf("open device error !! gio = %d\n", gio_id);
  goto GIO_QUIT;
 }

 if( IsOn == 1 )
 {
  for( cnt = 0 ; cnt < sizeof(data) ; cnt ++ )
  {
   data[cnt]='1';
  }
 }
 else if( IsOn == 0 )
 {
  for( cnt = 0 ; cnt < sizeof(data) ; cnt ++ )
  {
   data[cnt]='0';
  }

 }else{
  goto GIO_QUIT;
 }

 result = write(fd_gio,  data, 1);
 if( result <= 0 )
 {
  printf("write device error !! gio = %d\n", gio_id);
  close(fd_gio);
  goto GIO_QUIT;
 }

GIO_QUIT:
 if( fd_gio )
  close(fd_gio);

 return 0;
}

int gio_read( int gio_id )
{
 int  fd_gio = 0;
 char data[5];
 int  result = 0;
 char  dev_name[25];

 if( gio_id < 0 || gio_id > GIO_MAX_ID )
 {
  printf("gio id = %d over range!!\n", gio_id);
  return -1;
 }

 if(gio_getname(dev_name,gio_id) < 0 )
 {
  printf("gio get name error!!\n");
  return -1;
 }

 fd_gio = open(dev_name, O_RDWR);

 if( !fd_gio )
 {
  printf("open device error !! gio = %d\n", gio_id);
  return -1;
 }
 result = read(fd_gio,data,1);
 if( result <= 0 )
 {
  printf("read device error !! gio = %d\n", gio_id);
  close(fd_gio);
  return -1;
 }
 close(fd_gio);
 if( data[0] == '1')
 {
  return 1;
 }else{
  return 0;
 }

 return -1;
}

 

 

/********************** 驱动   *********************************/

/*
 * TI DaVinci GPIO Support
 *
 * Copyright (c) 2006 David Brownell
 * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/kernel.h>

#include <asm/arch/irqs.h>
#include <asm/arch/hardware.h>
#include <asm/arch/cpu.h>
#include <asm/arch/gpio.h>
#include <linux/proc_fs.h>


/* If a new chip is added with number of GPIO greater than 128, please
   update DAVINCI_MAX_N_GPIO in include/asm-arm/arch-davinci/irqs.h */
#define DM646x_N_GPIO 48
#define DM644x_N_GPIO 71
#define DM3xx_N_GPIO 104

#if defined(CONFIG_ARCH_DAVINCI644x) || defined(CONFIG_ARCH_DAVINCI_DM357)
static DECLARE_BITMAP(dm644x_gpio_in_use, DM644x_N_GPIO);
struct gpio_bank gpio_bank_dm6446 = {
 .base  = DAVINCI_GPIO_BASE,
 .num_gpio = DM644x_N_GPIO,
 .irq_num = IRQ_DM644X_GPIOBNK0,
 .irq_mask = 0x1f,
 .in_use  = dm644x_gpio_in_use,
};
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM355
static DECLARE_BITMAP(dm355_gpio_in_use, DM3xx_N_GPIO);
struct gpio_bank gpio_bank_dm355 = {
 .base  = DAVINCI_GPIO_BASE,
 .num_gpio = DM3xx_N_GPIO,
 .irq_num = IRQ_DM355_GPIOBNK0,
 .irq_mask = 0x7f,
 .in_use  = dm355_gpio_in_use,
};
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM365
static DECLARE_BITMAP(dm365_gpio_in_use, DM3xx_N_GPIO);
struct gpio_bank gpio_bank_dm365 = {
 .base  = DAVINCI_GPIO_BASE,
 .num_gpio = DM3xx_N_GPIO,
 .irq_num = 0,
 .irq_mask = 0x7f,
 .in_use  = dm365_gpio_in_use,
};
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM646x
static DECLARE_BITMAP(dm646x_gpio_in_use, DM646x_N_GPIO);
struct gpio_bank gpio_bank_dm646x = {
 .base  = DAVINCI_GPIO_BASE,
 .num_gpio = DM646x_N_GPIO,
 .irq_num = IRQ_DM646X_GPIOBNK0,
 .irq_mask = 0x7,
 .in_use  = dm646x_gpio_in_use,
};
#endif

void davinci_gpio_init(void)
{
 struct gpio_bank *gpio_bank;

#if defined(CONFIG_ARCH_DAVINCI644x) || defined(CONFIG_ARCH_DAVINCI_DM357)
 if (cpu_is_davinci_dm644x() || cpu_is_davinci_dm357())
  gpio_bank = &gpio_bank_dm6446;
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM355
 if (cpu_is_davinci_dm355())
  gpio_bank = &gpio_bank_dm355;
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM365
 if (cpu_is_davinci_dm365())
  gpio_bank = &gpio_bank_dm365;
#endif
#ifdef CONFIG_ARCH_DAVINCI_DM646x
 if (cpu_is_davinci_dm6467())
  gpio_bank = &gpio_bank_dm646x;
#endif
 if (!gpio_bank)
  BUG();

 davinci_gpio_irq_setup(gpio_bank);
}
#if CONFIG_PROC_FS

#define MAX_BUF  4*1024
#define DM3xx_N_MUX 5

static struct proc_dir_entry *gio_procdir;
static struct proc_dir_entry *gio_proc[DM3xx_N_GPIO];
static struct proc_dir_entry *gio_proc_mux[DM3xx_N_MUX];


static int proc_gio(char *page, char **start, off_t off,
      int count, int *eof, void *data)
{
 int len = 0;
 char buffer[MAX_BUF];
 volatile unsigned long *reg;

 if (!count)
  return 0;

 reg = (unsigned long *)IO_ADDRESS(DAVINCI_GPIO_BASE);
 len += sprintf(&buffer[len], "GPIO Module:\n");
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x PID                \n", reg,
      (int)reg[0]);
 reg += 2;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x BINTEN             \n", reg,
      (int)reg[0]);

 //BANK 0 AND BANK 1
 len += sprintf(&buffer[len], "GPIO Bank0 and Bank1:\n");
 reg = (unsigned long *)IO_ADDRESS(DAVINCI_GPIO_BASE + 0x10);
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Direction          \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Output Data        \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Data           \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Input Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Rising edge   \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Rising edge \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Falling edge  \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Falling edge\n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Interrupt Status   \n", reg,
      (int)reg[0]);

 //BANK 2 AND BANK 3
 len += sprintf(&buffer[len], "GPIO Bank2 and Bank3:\n");
 reg = (unsigned long *)IO_ADDRESS(DAVINCI_GPIO_BASE + 0x38);
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Direction          \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Output Data        \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Data           \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Input Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Rising edge   \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Rising edge \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Falling edge  \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Falling edge\n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Interrupt Status   \n", reg,
      (int)reg[0]);

 //BANK 4 AND BANK 5 for DM355 and BANK 4 for DM6446
 if (cpu_is_davinci_dm355())
  len += sprintf(&buffer[len], "GPIO Bank4 and Bank5:\n");
 else
  len += sprintf(&buffer[len], "GPIO Bank4:\n");
 reg = (unsigned long *)IO_ADDRESS(DAVINCI_GPIO_BASE + 0x60);
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Direction          \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Output Data        \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Data           \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Input Data         \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Rising edge   \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Rising edge \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Set Falling edge  \n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Clear Falling edge\n", reg,
      (int)reg[0]);
 reg++;
 len +=
     sprintf(&buffer[len], "  0x%p: 0x%08x Interrupt Status   \n", reg,
      (int)reg[0]);

 //BANK 6
 if (cpu_is_davinci_dm355())
 {
  len += sprintf(&buffer[len], "GPIO Bank6:\n");
  reg = (unsigned long *)IO_ADDRESS(DAVINCI_GPIO_BASE + 0x88);
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Direction          \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Output Data        \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Set Data           \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Clear Data         \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Input Data         \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Set Rising edge   \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Clear Rising edge \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Set Falling edge  \n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Clear Falling edge\n", reg,
       (int)reg[0]);
  reg++;
  len +=
      sprintf(&buffer[len], "  0x%p: 0x%08x Interrupt Status   \n", reg,
       (int)reg[0]);
 }
 if (count > len)
  count = len;
 memcpy(page, &buffer[off], count);

 *eof = 1;
 *start = NULL;
 return len;
}

static int proc_gio_read(char *page, char **start, off_t off,
    int count, int *eof, void *data)
{
 int len;

 if (count == 0)
  return 0;

 gpio_direction_input((int)data);//gpio_set_direction((int)data, GIO_DIR_INPUT);
 len = sprintf(page, "%d\n", gpio_get_value((int)data));

 *eof = 1;
 *start = 0;

 return len;
}

static int proc_gio_write(struct file *file, const char __user * buffer,
     unsigned long count, void *data)
{
 int i;

 if (!count)
  return 0;

 //gpio_set_direction((int)data, GIO_DIR_OUTPUT);

 for (i = 0; i < count; i++) {
  if (buffer[i] == '0')
  {
   gpio_direction_output((int)data,0);//gpio_set_value((int)data, 0);
  }
  if (buffer[i] == '1')
  {
   gpio_direction_output((int)data,1);//gpio_set_value((int)data, 1);
  }
 }

 return count;
}


static int proc_mux_read(char *page, char **start, off_t off,
    int count, int *eof, void *data)
{
 int len;

 if (count == 0)
  return 0;

 len = sprintf(page, "0x%x\n", davinci_readl(PINMUX0+(u32)data));

 *eof = 1;
 *start = 0;

 return len;
}

static int proc_mux_write(struct file *file, const char __user * buffer,
     unsigned long count, void *data)
{
 int i;
 unsigned long val = 0;

 if (!count)
  return 0;
 
 val = simple_strtoul(buffer, NULL, 0);

 davinci_writel(val, PINMUX0+(u32)data);

 return count;
}


int __init gio_proc_client_create(void)
{
 int i;
 char name[16];
 struct proc_dir_entry *ent;
 u32 max_gpio = 0;

 /*if (cpu_is_davinci_dm355())
  max_gpio = DM355_NUM_GIOS;
 else if (cpu_is_davinci_dm6443())
  max_gpio = DM644x_NUM_GIOS;
 */
 max_gpio = DM3xx_N_GPIO;

 gio_procdir = proc_mkdir("gio", 0);
 if (gio_procdir == NULL) {
  printk(KERN_ERR "gio: failed to register proc directory gio\n");
  return -ENOMEM;
 }

 ent = create_proc_read_entry("registers", 0, gio_procdir, proc_gio, 0);
 if (ent == NULL) {
  printk(KERN_ERR
         "gio: failed to register proc device: registers\n");
  return -ENOMEM;
 }

 for (i = 0; i < max_gpio; i++) {
  sprintf(name, "gio%d", i);
  gio_proc[i] = create_proc_entry(name, 0, gio_procdir);
  if (gio_proc[i] == NULL) {
   printk(KERN_ERR
          "gio: failed to register proc device: %s\n",
          name);
   return -ENOMEM;
  }
  gio_proc[i]->data = (void *)i;
  gio_proc[i]->read_proc = proc_gio_read;
  gio_proc[i]->write_proc = proc_gio_write;
 }

 for (i = 0; i < DM3xx_N_MUX; i++) {
  sprintf(name, "pinmux%d", i);
  gio_proc_mux[i] = create_proc_entry(name, 0, gio_procdir);
  if (gio_proc_mux[i] == NULL) {
   printk(KERN_ERR
          "gio: failed to register proc device: %s\n",
          name);
   return -ENOMEM;
  }
  gio_proc_mux[i]->data = (void *)i;
  gio_proc_mux[i]->read_proc = proc_mux_read;
  gio_proc_mux[i]->write_proc = proc_mux_write;
 }

 

 return 0;
}

#else    /* CONFIG_PROC_FS */

#define gio_proc_client_create() do {} while(0);

#endif    /* CONFIG_PROC_FS */

module_init(gio_proc_client_create);

 

方法三：写个字符设备驱动，略

 

方法四：内存映射，略

chinazjn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DM365 GPIO分析
06-12
针对该gpio.c的硬件手册是SPRUE25.pdf， 以下是两个文件gpio.c和gpio.h的浅析。
DM365 gpio
maopig的专栏
07-19 1880
davinci_cfg_reg（DM365_AEMIF_CLK_GIO50）;  davinci_cfg_reg（DM365_AEMIF_ADV_GIO51）;  err = gpio_request（LED4_ON_GIO50，"led4"）;  if（err  {   printk（"Cannot request gpio: ％d "，LED4_ON_GIO50）;   goto
dm365 驱动gpio使用
烽火yes
11-25 1834
1、为了方便使用ti内核中提供的配置引脚复用的函数davinci_cfg_reg（），首先在arch/arm/mach-davinci/dm365.c文件中static const struct mux_config dm365_pins[] = {数组添加如下内容： MUX_CFG(DM365,  GPIO84,         1,   16,    1,    1,     false)
Davinci DM6446 Linux 内核分析—— gpio.c
zhanjianshinian的专栏
06-11 1413
http://www.61ic.com/Article/DaVinci/DM644X/201201/40302.html   #include  #include  #include  #include  #include  #include   #include  #include  #include   #include  #include
Davinci GPIO模拟SPI的实现
ln_cheng的专栏
08-13 2847
Davinci GPIO模拟SPI的实现。
dm365_gpio_drv.rar_DM365 GPIO_GPIO Program_dm365_dm365 gpio driv
07-14
dm365的gpio内核驱动以及其测试程序
gpio.c.rar_DM365 GPIO_dm365
09-14
DM365的GPIO的各接口函数的使用介绍，这些接口都在gpio.c的文件夹里面有。
Android 应用层控制GPIO实现方案（例子：控制风扇开关 上/下拉GPIO脚)
02-17
git.diff 文件，包含功能实现的所有提交。...包含：编写控制GPIO脚本，内置到系统，在rc中创建运行脚本的服务，通过系统属性触发，添加selinux权限。 自行编写AndroidStudio Demo 更改系统属性 即可触发脚本，上拉GPIO
gpio.rar_DM648_DM648 Gpio_GPIO
09-21
TI DM648 gpio配置源代码,可以下接下到板子上,非常不错
达芬奇DM6446的LED驱动及GPIO驱动分析
dongshengzou95的专栏
05-03 1328
达芬奇DM6446的GPIO驱动 转载：http://www.61ic.com/Article/DaVinci/DM644X/201108/36918.html 上周五总监提了个需求，希望设备正常运行时能不断闪烁LED灯，于是我周一周二紧张忙活了两天，完成了GPIO驱动程序修改和应用编程。现在应用程序正常跑了起来，遂发文与网友分享。 其间硬件工程师帮我把LED灯焊接到了G
dm365 GPIO的使用
LYJ个人博客，记录技术、八卦、生活，分享各种心得，期待与朋友们一同进步
08-12 3251
【转帖请注明出处：blog.csdn.net/lanmanck】 最新的dvsdk4.0已经有比较大的变化，内核方面也使用了新的2.6.32版本。刚接触代码会发现比较难用，用多了也就熟了。 GPIO要使用也比较简单， 代码如下： davinci_cfg_re
引用 DM365开发之路---测试程序调试
Ubuntu 14.04配置nfs服务
09-06 93
引用 键盘棒棒 的 DM365开发之路---测试程序调试在确保你的软件平台安装成功之后，就可以连接硬件进行DM365的软件开发了，当然在开始之前运行一下官方给的测试程序是一个不错的选择，这样可以让你很快的在CCS平台下跑程序，就像我们才开始学习编程的第一个程序“hello world！”一样。在DM365的板级调试及测试程序.rar 中的全部程序都是能够运行的。当然如果你的硬件跟TI的开发...
基于matlab实现的一种新型的配电网潮流计算,基于前推回代法
05-03
基于matlab实现的一种新型的配电网潮流计算,基于前推回代法，并附有10kv配电网数据，利用新的判别手段，成功解决配电网不收敛的问题.rar
node-v5.3.0.tar.xz
05-03
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提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ASP+ACCESS网上园林设计(源代码+设计说明书).zip
05-03
ASP+ACCESS网上园林设计(源代码+设计说明书).zip
2023-04-06-项目笔记 - 第一百二十二阶段 - 4.4.2.120全局变量的作用域-120 -2024.05.03
05-03
2023-04-06-项目笔记-第一百二十二阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.120全局变量的作用域_120 - 2024-05-03
node-v10.22.0-linux-ppc64le.tar.xz
最新发布
05-03
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提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于matlab实现的电动汽车动力性经济性UI，希望对初学者有用 .rar
05-03
基于matlab实现的电动汽车动力性经济性UI，希望对初学者有用。.rar
node-v6.9.0-x64.msi
05-03
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提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
dm365 gpio操作
05-15
DM365具有多个通用IO端口（GPIO），这些端口可用于输入/输出控制、中断处理、电源管理等应用。以下是DM365 GPIO操作的一些常见用法： 1. 初始化GPIO口： 在代码中需要使用GPIO口之前，需要进行GPIO初始化。可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值