EEPW论坛

在代码的学习上，使用了郭天祥的单片机资料：
郭天祥十天学会51单片机教程.rar
同时还有部分练习答案：
程序.doc

0欧电阻作用

模拟地和数字地单点接地
只要是地，最终都要接到一起，然后入大地。如果不接在一起就是”浮地”，存在压差，容易积累电荷，造成静电。地是参考0电位，所有电压都是参考地得出 的，地的标准要一致，故各种地应短接在一起。人们认为大地能够吸收所有电荷，始终维持稳定，是最终的地参考点。虽然有些板子没有接大地，但发电厂是接大地 的，板子上的电源最终还是会返回发电厂入地。如果把模拟地和数字地大面积直接相连，会导致互相干扰。不短接又不妥，理由如上有四种方法解决此问题：1、用 磁珠连接；2、用电容连接；3、用电感连接；4、用0欧姆电阻连接。
磁珠的等效电路相当于带阻限波器，只对某个频点的噪声有显著抑制作用，使用时需要预先估计噪点频率，以便选用适当型号。对于频率不确定或无法预知的情况，磁珠不合。
电容隔直通交，造成浮地。
电感体积大，杂散参数多，不稳定。
0欧电阻相当于很窄的电流通路，能够有效地限制环路电流，使噪声得到抑制。电阻在所有频带上都有衰减作用(0欧电阻也有阻抗)，这点比磁珠强。
*跨接时用于电流回路*
当分割电地平面后，造成信号最短回流路径断裂，此时，信号回路不得不绕道，形成很大的环路面积，电场和磁场的影响就变强了，容易干扰/被干扰。在分割区上跨接0欧电阻，可以提供较短的回流路径，减小干扰。
*配置电路*
一般，产品上不要出现跳线和拨码开关。有时用户会乱动设置，易引起误会，为了减少维护费用，应用0欧电阻代替跳线等焊在板子上。
空置跳线在高频时相当于天线，用贴片电阻效果好。
*其他用途* 布线时跨线
调试/测试用
临时取代其他贴片器件
作为温度补偿器件

===============================================

0欧姆电阻的作用

1,在电路中没有任何功能，只是在PCB上为了调试方便或兼容设计等原因。
2,可以做跳线用，如果某段线路不用，直接不贴该电阻即可（不影响外观）
3,在匹配电路参数不确定的时候，以0欧姆代替，实际调试的时候，确定参数，再以具体数值的元件代替。
4,想测某部分电路的耗电流的时候，可以去掉0ohm电阻，接上电流表，这样方便测耗电流。
5,在布线时,如果实在布不过去了,也可以加一个0欧的电阻
6,在高频信号下，充当电感或电容。（与外部电路特性有关）电感用，主要是解决EMC问题。如地与地，电源和IC Pin间
7,单点接地（指保护接地、工作接地、直流接地在设备上相互分开,各自成为独立系统。）
8,熔丝作用

*模拟地和数字地单点接地*

　　只要是地，最终都要接到一起，然后入大地。如果不接在一起就是"浮地"，存在压差，容易积累电荷，造成静电。地是参考0电位，所有电压都是参考地得出 的，地的标准要一致，故各种地应短接在一起。人们认为大地能够吸收所有电荷，始终维持稳定，是最终的地参考点。虽然有些板子没有接大地，但发电厂是接大地 的，板子上的电源最终还是会返回发电厂入地。如果把模拟地和数字地大面积直接相连，会导致互相干扰。不短接又不妥，理由如上有四种方法解决此问题：

1、用磁珠连接；
2、用电容连接；
3、用电感连接；
4、用0欧姆电阻连接。

　　磁珠的等效电路相当于带阻限波器，只对某个频点的噪声有显著抑制作用，使用时需要预先估计噪点频率，以便选用适当型号。对于频率不确定或无法预知的情况，磁珠不合。

　　电容隔直通交，造成浮地。

　　电感体积大，杂散参数多，不稳定。

　　0欧电阻相当于很窄的电流通路，能够有效地限制环路电流，使噪声得到抑制。电阻在所有频带上都有衰减作用(0欧电阻也有阻抗)，这点比磁珠强。

*跨接时用于电流回路*

　　当分割电地平面后，造成信号最短回流路径断裂，此时，信号回路不得不绕道，形成很大的环路面积，电场和磁场的影响就变强了，容易干扰/被干扰。在分割区上跨接0欧电阻，可以提供较短的回流路径，减小干扰。

*配置电路*

　　一般，产品上不要出现跳线和拨码开关。有时用户会乱动设置，易引起误会，为了减少维护费用，应用0欧电阻代替跳线等焊在板子上。

空置跳线在高频时相当于天线，用贴片电阻效果好。

*其他用途*  

布线时跨线

调试/测试用

临时取代其他贴片器件

作为温度补偿器件

更多时候是出于EMC对策的需要。另外，0欧姆电阻比过孔的寄生电感小，而且过孔还会影响地平面（因为要挖孔）。

方便软件的分别布线区域范围:主要功能是跳线，运用的目的主要是为了在PCB补线的时候软件可以区分不同的区域。也就是说为了使的每一部分的电源和地有不 同的回路，如果没有这个电阻，软件会乱连，导致的结果是比如数字地和模拟地混乱，数字电源和模拟电源的互相干扰等等。所以总结就是为了方便软件的分别布线 区域范围

 

呵呵呵

今天去参加TI研讨会，更新至此，突发奇想，能不能用TI的ADS1118芯片作为模拟采集芯片，做个高速数字信号处理部件，由51控制。

谢谢楼主，我的也是公头， 下午按照你的方法调试下，。。

画了张PCB，实现的是基本的数模转换，用到转换芯片AD0804


PCB图

/*
4.按下矩阵键盘第一行时以1200bps发送，1，2，3，4，第二行时以2400bps发送5，6，7，8，第三行以4800bps发送，9，10，11，12，第四行以9600pbs 发送，13，14，15，16.
*/
#include <reg52.h>
typedef unsigned int uint;
typedef unsigned char uchar;
sbit dula=P3^7;
sbit wela=P2^0;

uchar ge,num,temp,freq,flag;

uchar code table[]={
0xc0,0xf9,0xa4,0xb0,
0x99,0x92,0x82,0xf8,
0x80,0x90,0x88,0x83,
0xa7,0xa1,0x86,0x8e,0};
uchar keyscan(),keynum;
void transmit();
void buadset();
void delay(uint z)
{
    uint x,y;
    for(x=87;x>0;x--)
        for(y=z;y>0;y--);
}
void init();
void display(uchar one);
void main()
{
    init();
    while(1)
    {
    keynum=keyscan();
    display(keynum-1);
    if(flag==1)
        {
            flag=0;
            ES=0;
            transmit();
            ES=1;   
        }

    }
}



void ser() interrupt 4
{

    while(RI==1)//判断RI是否为1
    {
    RI=0;
    }
    flag=1;


}

void buadset()
{
TH1=freq;
TL1=freq;
}

void transmit()//数据发送函数
{
    switch(keynum)
    {
        case 1 :
            keynum=17;
            freq=0xf4;
            buadset();

            SBUF=0x20;
            while(!TI);
            TI=0;

            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x31;
            while(!TI);
            TI=0;
        break;

        case 2 :
            keynum=17;
            freq=0xe8;
            buadset();
            SBUF=0x32;
            while(!TI);
            TI=0;
        break;

        case 3 :
            keynum=17;
            freq=0xe8;
            buadset();
            SBUF=0x33;
            while(!TI);
            TI=0;
        break;
        case 4 :
            keynum=17;
            freq=0xe8;
            buadset();
            SBUF=0x34;
            while(!TI);
            TI=0;
        break;

        case 5 :
            keynum=17;
            freq=0xe8;
            buadset();
            SBUF=0x35;
            while(!TI);
            TI=0;
        break;
 
        case 6 :
            keynum=17;
            freq=0xf4;
            buadset();
            SBUF=0x36;
            while(!TI);
            TI=0;
        break;
        case 7 :
            freq=0xf4;
            buadset();
            SBUF=0x37;
            while(!TI);
            TI=0;
        break;
        case 8 :
            freq=0xf4;
            buadset();
            SBUF=0x38;
            while(!TI);
            TI=0;
        break;
        case 9 :
            freq=0xfa;
            buadset();
            SBUF=0x39;
            while(!TI);
            TI=0;
        break;

        case 10 :
            freq=0xfa;
            buadset();
            SBUF=0x30;
            while(!TI);
            TI=0;
            SBUF=0x31;
            while(!TI);
            TI=0;
        break;

        case 11 :
            freq=0xfa;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x31;
            while(!TI);
            TI=0;
        break;

        case 12 :
            freq=0xfa;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x32;
            while(!TI);
            TI=0;
        break;

        case 13 :
            freq=0xfd;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x33;
            while(!TI);
            TI=0;
        break;
        case 14 :
            freq=0xfd;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x34;
            while(!TI);
            TI=0;
        break;
        case 15 :
            freq=0xfd;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x35;
            while(!TI);
            TI=0;
        break;
        case 16 :
            freq=0xfd;
            buadset();
            SBUF=0x31;
            while(!TI);
            TI=0;
            SBUF=0x36;
            while(!TI);
            TI=0;
        break;


    }
}

void display(uchar one)//数据显示函数
{
    wela=1;
    P0=0x80;
    wela=0;
    dula=1;
    P0=table[one];
    dula=0;
    delay(10);
}   
void init()
{
    P3=0xFF;
    TMOD=0x20;//选择定时器1的工作方式2

    TR1=1;//启动中断
    EA=1;//总中断开
    ES=1;//串行口中断开
    REN=1;//允许串行接收位。由软件置REN=1，则启动串行口接收数据
    SM0=0;//选择串行方式1，10位异步收发器
    SM1=1;
}uchar keyscan()
{
            P3=0xfe;
            temp=P3;
            temp=temp&0xf0;
            while(temp!=0xf0)
                {
                    delay(5);
                    temp=P3;
                    temp=temp&0xf0;
                    while(temp!=0xf0)
                    {
                        temp=P3;
                    switch(temp)
                        {
                            case 0xee:num=1;
                                break;
                            case 0xde:num=2;
                                break;
                            case 0xbe:num=3;
                                break;
                            case 0x7e:num=4;
                                break;
                        }
                    while(temp!=0xf0)
                        {
                            temp=P3;
                            temp=temp&0xf0;
                        }
                    }
                }

            P3=0xfd;
            temp=P3;
            temp=temp&0xf0;
            while(temp!=0xf0)
                {
                    delay(5);
                    temp=P3;
                    temp=temp&0xf0;
                    while(temp!=0xf0)
                    {
                        temp=P3;
                    switch(temp)
                        {
                            case 0xed:num=5;
                                break;
                            case 0xdd:num=6;
                                break;
                            case 0xbd:num=7;
                                break;
                            case 0x7d:num=8;
                                break;
                        }
                    while(temp!=0xf0)
                        {
                            temp=P3;
                            temp=temp&0xf0;
                        }
                    }
                }


            P3=0xfb;
            temp=P3;
            temp=temp&0xf0;
            while(temp!=0xf0)
                {
                    delay(5);
                    temp=P3;
                    temp=temp&0xf0;
                    while(temp!=0xf0)
                    {
                        temp=P3;
                    switch(temp)
                        {
                            case 0xeb:num=9;
                                break;
                            case 0xdb:num=10;
                                break;
                            case 0xbb:num=11;
                                break;
                            case 0x7b:num=12;
                                break;
                        }
                    while(temp!=0xf0)
                        {
                            temp=P3;
                            temp=temp&0xf0;
                        }
                    }
                }


            P3=0xf7;
            temp=P3;
            temp=temp&0xf0;
            while(temp!=0xf0)
                {
                    delay(5);
                    temp=P3;
                    temp=temp&0xf0;
                    while(temp!=0xf0)
                    {
                        temp=P3;
                    switch(temp)
                        {
                            case 0xe7:num=13;
                                break;
                            case 0xd7:num=14;
                                break;
                            case 0xb7:num=15;
                                break;
                            case 0x77:num=16;
                                break;
                        }
                    while(temp!=0xf0)
                        {
                            temp=P3;
                            temp=temp&0xf0;
                        }
                    }
                }
return num;

}

AD0804电路板实现结果

/*
按下16个矩阵键盘依次在数码管上显示1-16的平方。如按下第一个显示1，第二个显示4...
*/
#include <reg52.h>
typedef unsigned int uint;
typedef unsigned char uchar;

sbit wela=P2^0;
sbit dula=P3^7;
uint t0;
uint aa,num;
uchar ge,shi,bai;
uchar temp;

uchar code table[]={
0xc0,0xf9,0xa4,0xb0,
0x99,0x92,0x82,0xf8,
0x80,0x90,0x88,0x83,
0xa7,0xa1,0x86,0x8e};
void delay(uint z)
{
    uint x,y;
    for(x=118;x>0;x--)
        for(y=z;y>0;y--);
}
void display(uchar,uchar,uchar);
uint keyscan();
void main()
{
    P3=0xFF;
    t0=0;
    TMOD=0x01;
    TH0=(65536-10000)/256;
    TL0=(65536-10000)%256;
    EA=1;
    ET0=1;
    TR0=1;
    while(1)
    {
    aa=keyscan();
    bai=aa/100;
    shi=aa%100/10;
    ge=aa%10;
    display(ge,shi,bai);
    }
}

void timer0() interrupt 1
{
    TH0=(65536-10000)/256;
    TL0=(65536-10000)%256;
    t0++;
    bai=t0/100;
    shi=t0%100/10;
    ge=t0%10;
    if(t0==1000)
        t0=0;
}

void display(uchar ge,uchar shi,uchar bai)
{
    wela=1;
    P0=0x80;
    wela=0;
    dula=1;
    P0=table[ge];
    dula=0;
    delay(10);
   
    wela=1;
    P0=0x40;
    wela=0;
    dula=1;
    P0=table[shi];
    dula=0;
    delay(10);

    wela=1;
    P0=0x20;
    wela=0;
    dula=1;
    P0=table[bai];
    dula=0;
    delay(10);   
}

uint keyscan()
{
    P3=0xfe;
    temp=P3;
    temp=temp & 0xf0;
    while(temp!=0xf0)
    {
        delay(5);
        P3=0xfe;
        temp=P3;
        temp=temp & 0xf0;   
        while(temp!=0xf0)   
        {
            temp=P3;
            switch(temp)
            {
                case 0xee : num=1;
                break;
                case 0xde : num=4;
                break;
                case 0xbe : num=9;
                break;
                case 0x7e : num=16;
                break;
            }       
            while(temp!=0xf0)
            {   
                temp=P3;
                temp=temp & 0xf0;
            }
        }
    }

    P3=0xfd;
    temp=P3;
    temp=temp & 0xf0;
    while(temp!=0xf0)
    {
        delay(5);
        P3=0xfd;
        temp=P3;
        temp=temp & 0xf0;   
        while(temp!=0xf0)   
        {
            temp=P3;
            switch(temp)
            {
                case 0xed : num=25;
                break;
                case 0xdd : num=36;
                break;
                case 0xbd : num=49;
                break;
                case 0x7d : num=64;
                break;
            }       
            while(temp!=0xf0)
            {   
                temp=P3;
                temp=temp & 0xf0;
            }
        }
    }

    P3=0xfb;
    temp=P3;
    temp=temp & 0xf0;
    while(temp!=0xf0)
    {
        delay(5);
        P3=0xfb;
        temp=P3;
        temp=temp & 0xf0;   
        while(temp!=0xf0)   
        {
            temp=P3;
            switch(temp)
            {
                case 0xeb : num=81;
                break;
                case 0xdb : num=100;
                break;
                case 0xbb : num=121;
                break;
                case 0x7b : num=144;
                break;
            }       
            while(temp!=0xf0)
            {   
                temp=P3;
                temp=temp & 0xf0;
            }
        }
    }

    P3=0xf7;
    temp=P3;
    temp=temp & 0xf0;
    while(temp!=0xf0)
    {
        delay(5);
        P3=0xf7;
        temp=P3;
        temp=temp & 0xf0;   
        while(temp!=0xf0)   
        {
            temp=P3;
            switch(temp)
            {
                case 0xe7 : num=169;
                break;
                case 0xd7 : num=196;
                break;
                case 0xb7 : num=225;
                break;
                case 0x77 : num=256;
                break;
            }       
            while(temp!=0xf0)
            {   
                temp=P3;
                temp=temp & 0xf0;
            }
        }
    }


return num;
}