常用术语解释.docx

常用术语解释.docx

《常用术语解释.docx》由会员分享，可在线阅读，更多相关《常用术语解释.docx（21页珍藏版）》请在冰豆网上搜索。

常用术语解释

漏极开路输出是怎么回事？

为什么要外加上拉电阻？

漏极开路是驱动电路的输出三极管的发射极开路，可以通过外接的上啦电阻提高驱动能力。

这种输出用的是一个场效应三极管或金属氧化物管（MOS），这个管子的栅极和输出连接，源极接公共端，漏极悬空（开路）什么也没有接，因此使用时需要接一个适当阻值的电阻到电源，才能使这个管子正常工作，这个电阻就叫上拉电阻。

漏极开路输出，一般情况下都需要外接上拉电阻，以使电路输出呈现三态之高阻态，例如，在有些芯片的引脚就定义为漏极开路输出；还有一些带漏极开路输出的反向器等都需要外接上拉电阻才能正常工作。

.什么是推挽结构

一般是指两个三极管分别受两互补信号的控制,总是在一个三极管导通的时候另一个截止，要实现线与需要用OC（opencollector）门电路。

如果输出级的有两个三极管，始终处于一个导通、一个截止的状态，也就是两个三级管推挽相连，这样的电路结构称为推拉式电路或图腾柱（Totem-pole）输出电路（可惜，图无法贴上）。

当输出低电平时，也就是下级负载门输入低电平时，输出端的电流将是下级门灌入T4；当输出高电平时，也就是下级负载门输入高电平时，输出端的电流将是下级门从本级电源经T3、D1拉出。

这样一来，输出高低电平时，T3一路和T4一路将交替工作，从而减低了功耗，提高了每个管的承受能力。

又由于不论走哪一路，管子导通电阻都很小，使RC常数很小，转变速度很快。

因此，推拉式输出级既提高电路的负载能力，又提高开关速度。

供你参考。

推挽电路是两个参数相同的三极管或MOSFET,以推挽方式存在于电路中,各负责正负半周的波形放大任务,电路工作时，两只对称的功率开关管每次只有一个导通，所以导通损耗小效率高。

输出既可以向负载灌电流，也可以从负载抽取电流。

#ifndef

　　#ifndefx

　　#definex

　　...

　　#endif

　　这是宏定义的一种，它可以根据是否已经定义了一个变量来进行分支选择，一般用于调试等等

　　#ifndefx

　　//先测试x是否被定义过

　　#definex

　　//如果没有定义下面就定义x并执行下面的语句

　　...

　　#endif

　　//如果已经定义了则执行#endif后面的语句

　　条件指示符#ifndef检查预编译常量在前面是否已经被定义。

如果在前面没有被定义,则条件指示符的值为真，于是从#ifndef到#endif之间的所有语句都被包含进来进行处理。

相反，如果#ifndef指示符的值为假，则它与#endif指示符之间的行将被忽略。

条件指示符#ifndef的最主要目的是防止头文件的重复包含和编译。

.h文件和.c文件

2007-04-1720:

44

H文件和C文件怎么用呢？

一般来说，H文件中是declare（声明），C文件中是define（定义）。

因为C文件要编译成库文件（Windows下是.obj/.lib，UNIX下是.o/.a），如果别人要使用你的函数，那么就要引用你的H文件，所以，H文件中一般是变量、宏定义、枚举、结构和函数接口的声明，就像一个接口说明文件一样。

而C文件则是实现细节。

H文件和C文件最大的用处就是声明和实现分开。

这个特性应该是公认的了，但我仍然看到有些人喜欢把函数写在H文件中，这种习惯很不好。

（如果是C++话，对于其模板函数，在VC中只有把实现和声明都写在一个文件中，因为VC不支持export关键字）。

而且，如果在H文件中写上函数的实现，你还得在makefile中把头文件的依赖关系也加上去，这个就会让你的makefile很不规范。

最后，有一个最需要注意的地方就是：

带初始化的全局变量不要放在H文件中！

例如有一个处理错误信息的结构：

    char*errmsg[]={

        /*0*/       "Noerror",                

        /*1*/       "Openfileerror",        

        /*2*/       "Failedinsending/receivingamessage",  

        /*3*/       "Badarguments",  

        /*4*/       "Memeroyisnotenough",

        /*5*/       "Serviceisdown;trylater",

        /*6*/       "Unknowinformation",

        /*7*/       "Asocketoperationhasfailed",

        /*8*/       "Permissiondenied",

        /*9*/       "Badconfigurationfileformat",  

        /*10*/      "Communicationtimeout",

        ......

        ......

    };

请不要把这个东西放在头文件中，因为如果你的这个头文件被5个函数库（.lib或是.a）所用到，于是他就被链接在这5个.lib或.a中，而如果你的一个程序用到了这5个函数库中的函数，并且这些函数都用到了这个出错信息数组。

那么这份信息将有5个副本存在于你的执行文件中。

如果你的这个errmsg很大的话，而且你用到的函数库更多的话，你的执行文件也会变得很大。

正确的写法应该把它写到C文件中，然后在各个需要用到errmsg的C文件头上加上externchar*errmsg[];的外部声明，让编译器在链接时才去管他，这样一来，就只会有一个errmsg存在于执行文件中，而且，这样做很利于封装。

我曾遇到过的最疯狂的事，就是在我的目标文件中，这个errmsg一共有112个副本，执行文件有8M左右。

当我把errmsg放到C文件中，并为一千多个C文件加上了extern的声明后，所有的函数库文件尺寸都下降了20%左右，而我的执行文件只有5M了。

一下子少了3M啊。

［备注］

—————

有朋友对我说，这个只是一个特例，因为，如果errmsg在执行文件中存在多个副本时，可以加快程序运行速度，理由是errmsg的多个复本会让系统的内存换页降低，达到效率提升。

像我们这里所说的errmsg只有一份，当某函数要用errmsg时，如果内存隔得比较远，会产生换页，反而效率不高。

这个说法不无道理，但是一般而言，对于一个比较大的系统，errmsg是比较大的，所以产生副本导致执行文件尺寸变大，不仅增加了系统装载时间，也会让一个程序在内存中占更多的页面。

而对于errmsg这样数据，一般来说，在系统运行时不会经常用到，所以还是产生的内存换页也就不算频繁。

权衡之下，还是只有一份errmsg的效率高。

即便是像logmsg这样频繁使用的的数据，操作系统的内存调度算法会让这样的频繁使用的页面常驻于内存，所以也就不会出现内存换页问题了。

二、关于const的具体作用

        ——const作用就灵活了，一个表达式中const放置的位置不同，效果可能就不一样了。

下面分具体情况分

析（当然，所举的情况并非覆盖全部情况）

        A。

const最经常的用法

          1.为了防止传递的函数参数不被修改，在调用函数的形参中用const关键字.

              //Example->

              intFindNum（constintarray[],intnum,intconut）;//声明函数

              //code...

              intFindNum（constintarray[],intnum,intcount）

              {

                          inti;

                          intflag=1;

                          for（i=0;（i

                          {

                                  if（array[i]==num）

                                  {

                                          flag=0;

                                          break;

                                  }

                          }

                          returnflag;

                }

                //code...

          上面这例子中，编译器会把array[]当作常量数据的数组看待。

所以，假如你不小心给数组赋值，那么

，编译器就会报错了。

因此，当你不需要也不想修改数组的数据时，最好用const把数组定义为常量数组。

          2.const可以用来创建数组常量、指针常量、指向常量的指针等：

            constcharch='a';

            constinta[5]={1,2,3,4,5};  

            constint*p=a;              //a是一个数组的首地址.p是指向常量的指针

            int*constp=a;            //a是一个数组的首地址.p是指针常量；

            constint*constp=a;    //a是一个数组的首地址。

p是指向常量的指针常量

            前两种情况很简单，现在着重分析一下后三种用法，因为这3种情况容易出错，偶就有时候怕用错了

刚脆不用const.

            ——constint*p=a;      //p是指向常量的指针，因此，不可以通过给指针赋值来改变数组

                                                  //中的数据，例如：

                                                  //*p=10;      /*错误*/

                                                  //*（p+2）=1;  /*错误*/

                                                  //假如指向常量指针可以改变值，那么，就等于也改变了数组的数  

                                                  //据了。

假如你不理解，偶倒有一个办法让你理解，你就想你和一  

                                                  //个人绑在一起，有可能你移动了位置而他不跟着你移动吗！

哈哈

            ——int*constp=a;      //看这表达式，const的位置和第一个不同吧！

他们的用法和作用  

                                                    //就完全不一样了。

这时候p是指针常量，我们知道，指针是指向  

                                                    //了一个数组的首地址，那么，它的位置就不可以改变了。

但是你  

                                                  //现在应该和第一个表达式比较了，现在的数组并不是常量数组，  

                                                  //所以数组的数据是可以改变的，而指针这时候它是不可以移动的  

                                                  //，指向数组第一个数据，所以它可以而且只可以改变数组第一个  

                                                  //数据的值。

这一点请别误解，指针常量只是它的地址不可以改变  

                                                  //，并不是它指向的内容一定不可以改变，这一点切记！

                                                  //好啦。

假如你又不理解，偶又有一个比较形象的例子来说明：

                                                  //假如有一个固定的人拉着另外一个人的手，注意，固定的人相当  

                                                  //于他是不可以由其他人来替换的。

但是他可以拉其他人的手啊，  

                                                  //并不一定规定他必须拉同一个人的手啊。

现在你应该可以有个比  

                                                  //较深的印象和理解吧：

P

                                                  //下面举几个例子帮助理解：

                                                  //  *p=2;          /*可以*/

                                                //  *（p+1）=10;    /*可以*/

                                                //  p++;            /*不可以*/

            ——constint*constp=a;//假如前面两种表达式的本质你理解了，这种表达式你来理解根本

                                        //没有问题，const现在有两个，而且一个const的位置是第一种情  

                                        //况的位置,第二个const是第二种情况的位置，所以这表达式的功  

                                        //能就是前两种情况的作用总合。

这里不多说！

                                        //下面举几个例子帮助理解：

                                        //  *p=2;            /*不可以*/

                                        //  *（p+2）=10;  /*不可以*/

                                        //  p++;                /*不可以*/

        B。

const并不会阻止参数的修改

          之所以把这作为一点来谈，就是因为有一些朋友可能会以为在函数参数中用了const就一定不可以改变

参数，这实际上是错误的理解，因为，它并不阻止参数的修改，下面举个简单的例子来阐述一下；

          #include

          #include

          voidChangeStr（constchar*String）;

          intmain（void）

          {

                    charstr[]="TheCprogramme";

                    Change（str）;

                    printf（str）;

                    system（"Pause"）;

                    return0;

            }

            voidChangeStr（constchar*String）

            {

                    char*Source=（char*）String;

                    while（*Source）

                    {

                              *Source=toupper（*Source）;

                              Source++;

                    }

            }

            //end

            上面的程序把字符串中的每个字符都转换成大写字母了。

因为*String把地址给了*Source，而

*Source的值的改变编译器并不干涉，可能有的编译器会发出警告之类。

上面的程序只是为了说明const并不会阻止

参数的修改，如果象上面程序那样，个人感觉没什么意义，只会让人容易混乱而已。

        关于CONST的用法和理解本人也就只能说这么多了，当然，很可能有更多高级或者少用的用法，由于水平

和经验有限，确实不能再说些什么。

CRC字节型算法

比特型算法逐位进行运算，效率比较低，不适用于高速通信的场合。

数字通信系统（各种通信标准）一般是对一帧数据进行CRC校验，而字节是帧的基本单位。

最常用的是一种按字节查表的快速算法。

该算法基于这样一个事实：

计算本字节后的CRC码，等于上一字节余式CRC码的低8位左移8位，加上上一字节CRC右移8位和本字节之和后所求得的CRC码。

如果我们把8位二进制序列数的CRC（共256个）全部计算出来，放在一个表里，编码时只要从表中查找对应的值进行处理即可。

CRC-ITU的计算算法如下：

a.寄存器组初始化为全"1"（0xFFFF）。

b.寄存器组向右移动一个字节。

c.刚移出的那个字节与数据字节进行异或运算，得出一个指向值表的索引。

d.索引所指的表值与寄存器组做异或运算。

f.数据指针加1，如果数据没有全部处理完，则重复步骤b。

g.寄存器组取反，得到CRC，附加在数据之后。

CRC-ITU的验证算法如下：

a.寄存器组初始化为全"1"（0xFFFF）。

b.寄存器组向右移动一个字节。

c.刚移出的那个字节与数据字节进行异或运算，得出一个指向值表的索引。

d.索引所指的表值与寄存器组做异或运算。

e.数据指针加1，如果数据没有全部处理完，则重复步骤b（数据包括CRC的两个字节）。

f.寄存器组的值是否等于“MagicValue”（0xF0B8），若相等则通过，否则失败。

下面是通用的CRC-ITU查找表以及计算和验证CRC的C语言程序：

//CRC-ITU查找表

constu16crctab16[]=

{

0x0000,0x1189,0x2312,0x329b,0x4624,0x57ad,0x6536,0x74bf,

0x8c48,0x9dc1,0xaf5a,0xbed3,0xca6c,0xdbe5,0xe97e,0xf8f7,

0x1081,0x0108,0x3393,0x221a,0x56a5,0x472c,0x75b7,0x643e,

0x9cc9,0x8d40,0xbfdb,0xae52,0xdaed,0xcb64,0xf9ff,0xe876,

0x2102,0x308b,0x0210,0x1399,0x6726,0x76af,0x4434,0x55bd,

0xad4a,0xbcc3,0x8e58,0x9fd1,0xeb6e,0xfae7,0xc87c,0xd9f5,

0x3183,0x200a,0x1291,0x0318,0x77a7,0x662e,0x54b5,0x453c,

0xbdcb,0xac42,0x9ed9,0x8f50,0xfbef,0xea66,0xd8fd,0xc974,

0x4204,0x538d,0x6116,0x709f,0x0420,0x15a9,0x2732,0x36bb,

0xce4c,0xdfc5,0xed5e,0xfcd7,0x8868,0x99e1,0xab7a,0xbaf3,

0x5285,0x430c,0x7197,0x601e,0x14a1,0x0528,0x37b3,0x263a,

0xdecd,0xcf44,0xfddf,0xec56,0x98e9,0x8960,0xbbfb,0xaa72,

0x6306,0x728f,0x4014,0x519d,0x2522,0x34ab,0x0630,0x17b9,

0xef4e,0xfec7,0xcc5c,0xddd5,0xa96a,0xb8e3,0x8a78,0x9bf1,

0x7387,0x620e,0x5095,0x411c,0x35a3,0x242a,0x16b1,0x0738,

0xffcf,0xee46,0xdcdd,0xcd54,0xb9eb,0xa862,0x9af9,0x8b70,

0x8408,0x9581,0xa71a,0xb693,0xc22c,0xd3a5,0xe13e,0xf0b7,

0x0840,0x19c9,0x2b52,0x3adb,0x4e64,0x5fed,0x6d76,0x7cff,

0x