精华内容
下载资源
问答
  • 我们个项目,了一个基于TX2核心板的硬件板卡,这个板卡除了相关算法的检测之外,还得提供一些控制LED啊、通过拨码开关这些来设置一些内容的小功能,你说气不气,这些小功能还必须要实现。如果LED和拨码开关...

    #PS:要转载请注明出处,本人版权所有

    #PS:这个只是 《 我自己 》理解,如果和你的

    #原则相冲突,请谅解,勿喷

    起因

    我们有个项目,做了一个基于TX2核心板的硬件板卡,这个板卡除了做相关算法的检测之外,还得提供一些控制LED啊、通过拨码开关这些来设置一些内容的小功能,你说气不气,这些小功能还必须要实现。如果LED和拨码开关直接挂载到tx2的gpio上的话,就没有必要写本文了,没意义,因为只要学过嵌入式的人,给他一个板子,再差劲,读取和设置一个gpio的高低电平总会吧。如果不会,建议还多学学嵌入式基础知识(从单片机玩起来,先裸奔,再上OS)。

    这里我们知道,其实对于芯片来说,引脚是非常珍贵的,如果芯片所需要实现的功能复杂,那么通用的io管脚异常珍贵,这里就出现了一个种器件,叫做IO扩展器(所实话,我都不知道这样翻译对不对),从名字可知,就是较少的引脚扩展出更多的引脚,本文就是用两个引脚扩展出了16个引脚。

    TX2上,由于使用了Linux,读取和设置gpio也是非常简单的,直接打开相关的gpio设备,读写即可。不要问我为啥要用linux,不用其他os,或者直接裸机控制,我只能够回答曰:我是想啊,可是我实力不允许啊,什么caffe、opencv、ncnn、cuda等等堆到其他系统或者裸机下,我着实能力不够,弄不过去,关键还麻烦。

    IO扩展器

    IO扩展器原理简介

    其实本文的核心就是IO扩展器,这个器件由于我玩的板子少,见识少,我是第一次见到这种器件。下图就是这种器件在tx2手册里面的推荐使用方法。
    在这里插入图片描述
    这种器件就是通过某种总线,然后扩展出尽可能多的io口。这里的这个器件通过I2C总线,扩展出16个io口。
    这里我们可以看到:
    SCL和SDA是I2C通信总线,A0和A1是可编程配置I2C从器件地址。(这里不懂也没关系,就是这个器件的地址可以编程设置,至于为啥要有这个地址,可以简单理解为一个总线挂载多个设备,某一时刻总线只能为其中一个设备提供服务,这些设备的区分就是通过地址来完成的。)

    P00-P17是扩展出来的IO口。

    知道以上足够了,没学过的也足够了。

    这个器件的特性是:
    通过I2C协议操作他的寄存器,他有8个8位寄存器,0-1寄存器是INPUT用,2-3寄存器是OUTPUT用,4-5好像是优先级裁决,6-7是配置寄存器,就是配置IO口是输出还是输入,如果接触过单片机、stm32这种的GPIO程序的话,是很好理解的。(手动滑稽,我出了校门就没接触过了)
    不要问下图的是什么器件(问就是不知道,手动滑稽),这只是举个例子,这个io扩展器的寄存器分配以及功能就是这样的。
    在这里插入图片描述
    在这里插入图片描述

    IO扩展器编程操作—shell command

    首先这个器件是通过I2C协议操作的,不用关心I2C是什么,他们你可以类比为HTTP。
    那么Linux上怎么通过I2C操作这个器件呢?
    首先,Linux上有一组工具:i2c-tool,它可以读取所有芯片的i2c bus上挂载的芯片,设置和读取寄存器等等,拿来做测试或者封装一个程序都是不错的。TX2的ubuntu16.04是自带这个工具的,他的详细用法大家去百度,我不造轮子了。
    在Ubuntu里面操作I2C是非常简单的,你不需要关心I2C的具体传输规定,不用管时序这些烦人的事情。
    首先我们先用工具来测试,美滋滋:
    还记得上文我提了这个IO扩展器的从地址的事情吗?由于我的A0和A1都是接的低电平,在这里我的器件地址是0x74,怎么来的,看下图。
    在这里插入图片描述
    然后通过i2cdetect查看我们器件的位置(0x74)(注意,这个命令需要传入一个I2C总线序号,我这里是0,也就是说你要知道你这个IO扩展器挂载到哪个总线上的,这和SCL和SDL接线有关,有兴趣的可以去翻一翻手册就知道了,UU代表有人在占用这个设备)

    shell:>i2cdetect -y -r -a 0

    在这里插入图片描述
    i2cdump可以通过标准i2c协议探测出所有的寄存器的值,下图8个寄存器的值就的出来了,分别对应上面的寄存器说明。XX代表没有这个寄存器。
    shell:>i2cdump -f -y 0 0x74
    在这里插入图片描述
    然后:
    i2cset -f -y i2c_bus_num slave_addr reg_num value 设置寄存器值
    i2cget -f -y i2c_bus_num slave_addr reg_num 获取寄存器值

    其实通过上面的操作就可以完成整个io扩展器的操作,我们可以通过程序执行shell命令的方式设置和操作值。

    IO扩展器编程操作—syscall

    实际上,linux做了很多东西,我们可以用标准的linux sys-api来完成以上内容,其实这些api就是i2ctool使用的部分。
    下面不墨迹,直接给出led操作的接口,有需要的参考吧。

    int open_led_device(const char * i2c_bus_num, int slave_addr){
    
        int fd = 0; 
    
        if ( 0 > (fd = open(i2c_bus_num, O_RDWR)) ){//打开i2c总线
    
            perror("open i2c bus error:");
            return -1;
        }
    
        if(ioctl(fd, I2C_SLAVE_FORCE, DEVICE_I2C_ADDR) < 0) {//设置从器件地址,这里使用I2C_SLAVE_FORCE进行强行设置,那么这个设备忙
    
            perror("set device slave addr error:"); 
            return -1; 
        }
    
        if ( 0 > write_led_register(fd, LED_REG1_CFG_ADDR, LED_REG1_CFG_VAL) ){//设置写寄存器值,这两个宏和你的硬件连线有关。这里不给出。
    
            printf("init pin for output-mode failed.\n");
            close(fd);
            return -1;
        }
    
        return fd;
    
    }
    
    int read_led_register(int fd, char reg_addr, char *read_val){//读寄存器
    
        if (write(fd, &reg_addr, 1) != 1){//write reg addr ,从器件地址通过open接口设置好后,先写入要读的reg地址
    
            perror("set reg addr error:"); 
            return -1; 
        }
    
        if ( read(fd, read_val, 1) != 1 ){//read data,等待i2c返回刚刚要查询的reg值
    
            perror("read reg error:"); 
            return -1; 
        }
        return 0;
    }
    
    int write_led_register(int fd, char reg_addr, char data){//写寄存器
    
        char tmp_buf[2];
    
    
        tmp_buf[0] =  reg_addr;//reg 地址
        tmp_buf[1] = data;//reg 值
    
    
        if (write(fd, tmp_buf, 2) != 2){//write data
    
            perror("write data error:"); 
            return -1; 
        }
    
        return 0;
    }
    
    void close_led_device(int fd){//关闭
    
        close(fd);
    }
    

    LED灯

    此处省略XXX字。
    相信每个人都知道,常规情况下,在LED灯的两边加电源正极和负极,灯就能亮。在电路设计上,一般来说,LED灯的一端都是和电源正极或者负极是连接好的,另一端和GPIO口接上。如果GPIO输出的电压和另一端电压逻辑一致(比如都是高电平、都是低电平),灯就不亮,反之就亮。
    注意:这段话是有毛病的,但是一般人这样理解就行了(不了解电子电路的就看到这就行了)。对于懂的人,这里多说一句,这里还有一个三极管做开关作用,也是就说LED灯两端都接在电源正负极,中间有个三极管开关。

    拨码开关

    这种器件,又是另外一种新奇的东西了,感觉我这两年写的“祖传屎山“太多了,现在看到各种硬件器件都是眼前一亮的感觉。
    就是类似下图这种。
    在这里插入图片描述
    在这里插入图片描述
    其作用是:
    你可以人为的按这个±号按钮,设置数字,这个数字会反应到电路上,从而芯片可以读取你设置的数字。
    说白了,你的系统中有个数字参数,你可以通过这种器件进行手动设置,通过驱动程序,就可以更改这个系统参数,是不是 so 简单。

    这里简单说明一下电路是怎么反应出对应的数字的:
    我就举个栗子,下图是个例子拨码开关(手动滑稽,这里多说一句,上图的拨码开关,是4个拨码开关合在一起的,下图的这个输出编码是一个拨码开关的)
    在这里插入图片描述
    这里可以简单理解为:
    一个拨码开关有5个引脚,一个引脚是C,接GND或者VCC,其他4个是编码引脚,是需要接GPIO,并去取编码的。
    其实很简单:
    例如:C端我接VCC,1248默认值为0,那么数字1,1号引脚接通,那么8421io口输出二进制就是0001,转换为10进制,就是1.
    然后写个程序读取这4个脚的值,转换一下,就OK。
    #PS:请尊重原创,不喜勿喷

    #PS:要转载请注明出处,本人版权所有.

    有问题请留言,看到后我会第一时间回复

    展开全文
  • 2、初学者一般都自己的51开发板,闲置是一种浪费,如果一个FPGA核心板转DIP40的模块,搭上合适简单的外围,就可以利用上51开发板的外围,也是一个不错的选择,价格会低一点点。 3、学的深一些的同学,可以搞个51...
  • 每天都要家庭作业,所以希望家长能帮忙督促孩子认真完成作业,必要时要检查,签字。 4、创造和睦,祥和,稳定的家庭气氛.一个成天吵架问题成堆的家庭是无法教育好孩子的. 5、经常与老师取得联系,与老师...
  • 非常成熟,任何应用也没有障碍,只是总觉得脱离了前后端分离的大趋势,技术太旧了。 但是新的应该是什么路线呢?大致上,我们选择是mybatis+springboot+vue,那么: 1、应该完全放弃后台渲染吗? mvc 和前后...
  • 你可以看到,每个错误都3种表示法:即一个消息ID(这是你可以在源代码中使用的一个宏,以便与GetLastError的返回值进行比较),消息文本(对错误的英文描述)和一个号码(你应该避免使用这个号码,而应该使用消息...
  • 一、太阳能供电系统必要部件介绍 太阳能供电系统由太阳能电池组件、太阳能控制器、蓄电池(组)组成。如输出电源为交流220V或110V,还需要配置逆变器。 系统由以下几部分组成:  (一)太阳能电池组件...
  • <div><p>前面的文章已经详细记述了Vue的核心执行过程。相当于已经搞定了主线剧情。后续的文章都会对其中没有介绍的细节进行展开。 现在我们就来讲讲其他支线任务:nextTick和microtask。 <p>Vue的nextTick api的实现...
  • 学习shopex

    2012-10-10 14:32:05
    其中放的是shopex系统核心文件夹,模板制作时不到必要建议不要修改这个文件夹中的任何文件。 plugins文件夹 其中的widgets文件夹下 放着所有的挂件(挂件以后会详细的谈)。 config文件夹 其中放着shopex系统配置...
  • lambda表达式:它没有名称,但参数列表、函数体、返回类型,必要的时候还有抛出的异常的列表。 下面来看看lambda的特征 匿名:它没有名称,集中精力正事。 函数化:lambda表达式不像其他方法属于特定类,但是...

    lambda表达式:它没有名称,但有参数列表、函数体、返回类型,必要的时候还有抛出的异常的列表。

    下面来看看lambda的特征

    • 匿名:它没有名称,集中精力做正事。
    • 函数化:lambda表达式不像其他方法属于特定类,但是比方法要简单多,人恨话不多,直奔核心主题,执行代码块。
    • 传递:可以作为方法的参数也可以存贮在变量中。
    • 简洁:不需要像匿名类那样写模板,是不按套路走的兄弟。

    基本语法

    (parameters) -> expression
    
    (parameters) -> { statements; }

    可以看到lambda完全是纯爷们,一眼就看透了,没错它的语法就是那么简单。还想再详细可以看我java8:lambda新特性

    示例:

    根据上述语法规则,以下哪个不是有效的Lambda表达式?

    (1) () -> {}
    (2) () -> "Raoul"
    (3) () -> {return "Mario";}
    (4) (Integer i) -> return "Alan" + i;
    (5) (String s) -> {"IronMan";}

    答案:只有45是无效的Lambda

    (1) 这个Lambda没有参数,并返回void。它类似于主体为空的方法:public void run() {}

    (2) 这个Lambda没有参数,并返回String作为表达式。

    (3) 这个Lambda没有参数,并返回String(利用显式返回语句)。

    (4) return是一个控制流语句。要使此Lambda有效,需要使花括号,如下所示:

    (Integer i) -> {return "Alan" + i;}

    (5)Iron Man”是一个表达式,不是一个语句。要使此Lambda有效,你可以去除花括号

    和分号,如下所示:(String s) -> "Iron Man"。或者如果你喜欢,可以使用显式返回语

    句,如下所示:(String s)->{return "IronMan";}

     

    使用案例 示例
    布尔表达式 (List<String> list)->list.isEmpty()
    创建对象 ()->new IPhone()
    消费一个对象 (Apple a)->{System.out.println(a.getApple);}
    从一个对象中选择/抽取 (String s)->s.length()
    组合两个值 (a,b)->a*b
    ......  


    在哪里以及如何使用lambda

    一般lambda表达式都式配合函数式接口一起使用的,如何使用如上图示例。

    函数式接口

    就是只定义了一个抽象方法的接口。注意是一个抽象方法,在java8后在接口中可以有默认的实现方法但不妨碍函数式接口的定义,一般都会在接口上加@FunctionInterface,其实只要只有一个抽象方法不加注解也是可以的。java8中添加了一个java.util.function的包里面全是函数式接口

    那么函数式接口可以干嘛?

    可以让lambda表达式直接以内联的形式为函数式接口的方式提供实现,并把整个表达式作为函数式接口的实例(跟创建一个对象差不多),比匿名类要简单的多。下面示例的代码时等效的。

    Runnable r1 = () -> System.out.println("Hello World 1");
    Runnable r2 = new Runnable(){ 
     public void run(){ 
     System.out.println("Hello World 2"); 
     } 
    };

    使用函数式接口

                                                                                       java 8中常用函数式接口

    函数式接口 函数描述符 原始类型特化
    Predicate<T> T->boolean IntPredicate,LongPredicate,DoublePredicate
    Consumer<T> T->void IntConsumer,LongConsumer,DoubleConsumer
    Function<T,R> T->R

    IntFunction<R>,IntToDoubleFunction,IntToLongFunction

    LongFunction<R>,LongToIntFunction,LongToDoubleFunction

    DoubleFunction<R>,DoubleToIntFunction,DoubleToLongFunction

    ToIntFunction<T>,ToLongFunction<T>,ToDoubleFunction<T>

    Supplier<T> ()->T BooleanSupplier,IntSupplier,LongSupplier,DoubleSupplier
    UnaryOperator<T> T->T

    IntUnaryOperator

    LongUnaryOperator

    DoubleUnaryOperator

    BinaryOperator<T> (T,T)->T

    IntBinaryOperator

    LongBinaryOperator

    DoubleBinaryOperator

    BiPredicate<L,R> (L,R)->boolean  
    BiConsumer<T,U> (T,U)->void

    ObjIntConsumer<T>

    ObjLongConsumer<T>

    ObjDoubleConsumer<T>

    BiFunction<T,U,R> (T,U)->R

    ToIntBiFunction<T,U>

    ToLongBiFunction<T,U>

    ToDoubleBiFunction<T,U>

    java8中的util包中提供很多的函数式接口,已经可以我满足绝大多数需求啦,如果还不行你还可以自己去定义。

    Lambda的类型检查、类型推断以及限制

    提到Lambda表达式时,说它可以为函数式接口生成一个实例。然而,Lambda表达式本身并不包含它在实现哪个函数函数式接口的信息。为了全面了解Lambda表达式,我们应该知道Lambda实际类型是什么。

    1.Lambda的类型是从使用Lambda的上下文推断出来的。上下文(比如,接收它传递的方法的参数吗,或接收它的值的局部变量)中Lambda表达式需要的类型称为目标类型

    List<Apple> heavierThan150g = 
     filter(inventory, (Apple a) -> a.getWeight() > 150);//筛选大于150克的苹果

    类型检查分解如下:

    • 首先,找出filter方法的声明
    • 第二,要求它是Predicate<Apple>目标类型
    • 第三,Predicate<Apple>是一个函数式接口,它的抽象方法是test(Apple apple)
    • 第四,test的函数描述符(方法的签名),是接收一个Apple的类,并返回一个boolean
    • 最后,filter的实际参数必须匹配

    这段代码是有效的,因为我们所传递的Lambda表达式也同样接受Apple为参数,并返回一个 boolean。请注意,如果Lambda表达式抛出一个异常,那么抽象方法所声明的throws语句也必 须与之匹配。

    2.同样的Lambda,不同的函数式接口

    有了目标类型的概念,同一个Lambda表达式就可以与不同的函数式接口联系起来,只要他们的抽象想法签名能够兼容。

    示例

    @FunctionalInterface
    public interface Callable<V> {
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }
    public interface PrivilegedAction<T> {
        /**
         * Performs the computation.  This method will be called by
         * {@code AccessController.doPrivileged} after enabling privileges.
         *
         * @return a class-dependent value that may represent the results of the
         *         computation. Each class that implements
         *         {@code PrivilegedAction}
         *         should document what (if anything) this value represents.
         * @see AccessController#doPrivileged(PrivilegedAction)
         * @see AccessController#doPrivileged(PrivilegedAction,
         *                                     AccessControlContext)
         */
        T run()

    下面两个赋值时是等效的

    Callable<Integer> c = () -> 42; 
    PrivilegedAction<Integer> p = () -> 42;

    特别注意:如果一个Lambda主体语句是一个语句表达式,它就和一个返回void的函数描述符兼容(当然需要参数列表也兼容)。例如,一下两行都是合法的,尽管List的add方法返回了一个boolean,而不是Consumer上下文(T->void)

     
    // Predicate返回了一个boolean 
    Predicate<String> p = s -> list.add(s); 
    // Consumer返回了一个void 
    Consumer<String> b = s -> list.add(s);

    3.类型推断

    我们还可以进一步简化代码,Java编译器会从上下文(目标类型)推断出用什么函数式接口来配合Lambda表达式,这意味着它也可以推断出适合Lambda表达式的签名,因为函数描述符可以通过目标类型来得到。这样做的好处在于,编译器可以了解Lambda表达式的参数类型,这样就可以在Lambda中省去标注参数类型

    4.使用局部变量

    Lambda表达式不只可以用主体里面的参数,还可以使用自由变量(外层作用域中定义的变量),就像匿名类一样。

    int portNumber = 1337; 
    Runnable r = () -> System.out.println(portNumber);

    注意:Lambda可以没有限制的使用实例变量和静态变量,但局部变量必须式final类型,实际上java编译器会默认给变量声明为final,就像上例。

    为什么会对局部变量做这些限制

    第一,实例变量和局部变量背后的实现有一个关键不同,实例变量都存储在堆中,而局部变量都保存在栈上。如果Lambda可以直接访问局部变量,而且是在一个线程中使用,可能会在分配该变量的线程将这个变量回收后去访问这个变量(局部变量已经销毁),因此访问局部变量其实是访问它的副本,而不是原始变量,这其实涉及到一点JMM.如果局部变量仅仅访问一次,那么怎么访问都是没有区别的。

    进一步简化Lambda表达式:方法引用

    方法引用是让我可以重复的使用现有的方法定义,提高编码效率,实现代码重用。

    inventory.sort((Apple a1, Apple a2) 
     -> a1.getWeight().compareTo(a2.getWeight()));//根据苹果的重量进行排序
    
    inventory.sort(comparing(Apple::getWeight));//java.util.Comparator.comparing
    

    根据现有的方法直接进行方法的引用。

    方法引用其实可以看做是Lambda表达式的语法糖(在编译语言中添加某些语法,但不影响编译语言本身,使代码有更好的可读性)。

    构建方法引用

    (1)指向静态方法的方法引用,例如:Integer::parseInt

       (2)指向任意类型实例方法的引用,例如:String::length

       (3)指向现有对象的实例方法引用 , 例如 Person:;getName

    第二种和第三种方法的引用可能乍看起来有点晕,类似于String::length的第二种方法引用就是你在引用一个对象的方法,而这个对象本身是Lambda的一个参数。例如,Lambda表达式(String s )->s.toUpperCase()可以写作String::toUpperCase。但第三种方法引用指的是,你在Lambda中调用一个已经存在的外部对象的方法

    重构实例

    还有针对构造函数、数组构造函数和父类调用(super-all)的一些特殊形式的方法引用。比方说我们想要对一个字符串的List排序,忽略大小写。List的sort方法需要一个Comparator作为参数。Comparator描述了一个具有(T,T)->int签名的函数描述,String类中的compareToIgnoreCase方法来定义Lambda表达式。

    List<String> str = Arrays.asList("a","b","A","B"); 
    str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

    Lambda表达式的签名与Comparator的函数描述兼容。所以可以改写为

    List<String> str = Arrays.asList("a","b","A","B"); 
    str.sort(String::compareToIgnoreCase);

    注意编译器会进行一种与Lambda表达式类似检查过程,来确定对于给定的函数式接口,这个方法引用是否有效;方法的引用的签名必须和上下文文类型匹配。

    构造引用

    对于现有的构造函数,可以利用它的类名称和关键字new来创建它的一个引用:ClassName::new。它的功能与指向静态方法的引用类似。例如,假设有一个构造函数没有参数。它适合Supplier的签名()->Apple。

    Supplier<Apple> c1 = Apple::new; 
    Apple a1 = c1.get();

    这等价于

    Supplier<Apple> c1 = () -> new Apple(); 
    Apple a1 = c1.get();

    如果构造函数签名是Apple(Integer weight),那么它就适合Function接口的签名,于是可以这样写

    Function<Integer, Apple> c2 = Apple::new;
    Apple a2 = c2.apply(110);

    等价于

    Function<Integer, Apple> c2 = (weight) -> new Apple(weight);
    Apple a2 = c2.apply(110);

    在下面的代码中,一个由Integer构成的List中每个元素都通过我们前面定义的类似的map方法传递给了Apple的构造函数,得到了一个具体不同重量苹果的List:

    List<Integer> weights = Arrays.asList(7, 3, 4, 10); 
    List<Apple> apples = map(weights, Apple::new); 
    public static List<Apple> map(List<Integer> list, 
     Function<Integer, Apple> f){ 
     List<Apple> result = new ArrayList<>(); 
     for(Integer e: list){ 
     result.add(f.apply(e)); 
     } 
     return result; 
    }

    如果具有两个参数的构造函数Apple(String color,Integer weight),那么它就适合BiFunction接口签名,就可以这样写:

    BiFunction<String, Integer, Apple> c3 = Apple::new; 
    Apple c3 = c3.apply("green", 110);

    等价于

    BiFunction<String, Integer, Apple> c3 = 
     (color, weight) -> new Apple(color, weight);
    Apple c3 = c3.apply("green", 110);

    不将构造函数实例化却能够引用它,这个功能有一些有趣的应用。例如可以将构造函数映射到字符串。可以创建一个giveMeFruit方法,给他一个String和一个Integer,他就可以创建出不同重量的各种水果。

    static Map<String, Function<Integer, Fruit>> map = new HashMap<>(); 
    static { 
     map.put("apple", Apple::new); 
     map.put("orange", Orange::new); 
     // etc... 
    } 
    public static Fruit giveMeFruit(String fruit, Integer weight){ 
     return map.get(fruit.toLowerCase()) 
     .apply(weight);
    }

    如果还需要更多的参数,可以自己创建相应的函数式接口。

     

    展开全文
  • TMS WEB CORE特性 现代的单页面web应用程序模型。...必要的编译器魔法,您就可以从浏览器Chrome和FireFox中全面调试您的应用程序了。您可以通过您的Pascal代码、设置表、Pascal代码中的断点等等……
  • Linux内核工作原理 word版本 强烈推荐

    热门讨论 2010-04-25 17:03:30
    当然有时它们还是联系的,比如说,如果你没有理解虚拟内存工作原理就无法描叙进程。 硬件基本概念一章对现代PC了简要介绍。操作系统必须与硬件系统紧密结合在一起协同工作。操作系统需要一些只能够由硬件提供的...
  • 谭晓生: 云端的重要性,我想没有必要再重复了。就是安全方面,其实是已经早就走向云端了。过去大家的概念认为杀毒软件,防护软件是一种客户端软件,实际这种在一年多以前,已经是大规模走向云端,其中一个原因是...
  • 当对某个语法,程序的性能、功能等等都没兴趣了,就会对软件产品兴趣了,没有行业知识就技术性的产品,丰富的行业知识后就行业通用产品。毕竟语法和技巧是难销售出去的,还是需要靠产品。 当非常大...
  • 投影机原理及分类

    2019-04-26 10:29:40
    应该说这部分知识对于普通消费者来说较为深奥而且实际意义不大,因此我们没有必要去深究技术方面的东西,而主要了解一下这些技术相应的都哪些厂家在就可以了:七大DLP光学引擎制造商:明基BenQ,美国德州仪器...
  • 候运行一下,时候忘了,可我没有感觉到多大的差别,也可能我的电脑内存比较大?说不清) 如果你是在原有系统不变、系统硬盘上xx作系统的情况下重新安装XP,在安装的过程中会出现《升 级/全新安装》对话框,...
  • java j2ee 课程设计报告

    2011-08-31 13:59:12
    所以,对于我们初学者,首先利用课程设计这样的较小项目锻炼自己的科学研究精神和提高创新能力,是很有必要的。 四、Java拼图游戏的可行性论证: 拼图游戏是一个经典的游戏,它因操作简单、娱乐性强而广受欢迎。我...
  • 宏昕医院管理软件,医院收费系统

    热门讨论 2011-04-12 10:16:59
    服务器是网络系统的“核心”部件,应选用稳定性好,安全性高的机器作为服务器,至于工作站相对来说,便可以不需象服务器一样要求高,主要应考虑到系统的应用和价格。收费处打印发票用到的打印机应采用针式打印机。...
  • 对于想阅读 Linux源代码的操作系统爱好者,本书可以提供阅读前所必要的知识储备,而这些知识储备不但在本书中完整的涉及,而且在很多 Linux书籍中是没有提到的。 特别要提到的是,对于想通过阅读 Andrew S. ...
  • 对于想阅读 Linux源代码的操作系统爱好者,本书可以提供阅读前所必要的知识储备,而这些知识储备不但在本书中完整的涉及,而且在很多 Linux书籍中是没有提到的。 特别要提到的是,对于想通过阅读 Andrew S. ...
  • 关,如果没有定义这个宏,系统调用 drivers/nand/nand.c 中的 nand_init();否则调用自己在 本文件中的 nand_init()函数,本例使用后者。fs2410.c代码如下: #if defined(CONFIG_CMD_NAND) typedef enum { NFCE_...
  • 但是DBA要求的是稳定压倒一切,DBA必须去适应自己所使用的产品,而不能期待产品去适应自己,更没有机会去改变产品,因此了解这个产品的工作原理是非常必要的。  现在网络发达,遇到问题时,论坛、BBS各种渠道...
  • 所谓工作流引擎是指workflow作为应用系统的一部分,并为之提供对各应用系统决定作用的根据角色、分工和条件的不同决定信息传递路由、内容等级等核心解决方案。 例如开发一个系统最关键的部分不是系统的界面,也...
  • 提供的是本书的课后习题源代码,也就是《C++程序设计语言(特别版)题解》的源代码。非书中源代码。 本版本是高清版,是第1版第18次印刷,是书签最全最好的版本。 基本信息 原书名: The C++ ...16.2.2 基类的...
  • 适合高校面向对象编程课程的教科书,也可作为c++爱好者的参考书。 [center] [a href=http://www.china-pub.com/main/sale/c++tb.htm target=_blank]c++之父bjarne stroustrup博士专访[/a]  [a href=...

空空如也

空空如也

1 2 3 4
收藏数 63
精华内容 25
关键字:

有没有必要做核心板