C++博客-昨夜西风凋碧树，独上高楼，望尽天涯路！-随笔分类-单片机

51串口通信

小果子 — Sun, 01 Aug 2010 08:11:00 GMT

//网上看了下资料,借鉴了别人的一些好的东西，同时自己封装了下

#ifndef __mycom__h__
#define __mycon__h__
#include <string.h>
//数据格式
//W 8  
#define SUCCESS 1
#define ERROR   0

#define uchar unsigned char
#define uint  unsinged int

#define BUF_LEN 30  //传冲区大小
#define RECIEVED_MAX_DATA_LEN 16
#define SEND_MAX_DATA_LEN 25
#define END_NUM 4   //结束符长度


typedef void (*PTRFUN)(uchar*,uchar);
PTRFUN ptrFun;
 
uchar END_CODE[4]="#end";
uchar end_num=0;
uchar data_num=0;       //接受数据个数
uchar data_buf[BUF_LEN];//缓冲区大小
uchar data_addr=0;      //数据在data_buf位置
bit isComplete=0;     //处理

typedef  struct
{
char name[10];   //姓名
int age;         //年龄
char sex[5];     //性别
}st;

st b;

//初始化
void init_serialcomm(void)
{
    SCON = 0x50;       //SCON: serail mode 1, 8-bit UART, enable ucvr
    TMOD |= 0x20;       //TMOD: timer 1, mode 2, 8-bit reload
    PCON |= 0x80;       //SMOD=1;
    TH1   = 0xF4;       //Baud:4800 fosc=11.0592MHz
    IE   |= 0x90;       //Enable Serial Interrupt
    TR1   = 1;          // timer 1 run
   // TI=1;
}

//*******数据转换*********************
uchar decoderData(){
    uchar state,i;
    state=0;
    i=2;
    //-----------------------计算地址-------------------------------
    while(1){
        if( (data_buf[i]>47)&&(data_buf[i]<58) )             // 是‘0’-‘9’？
            state = (state*10)+(data_buf[i]-48);        // 计算
        else if( data_buf[i]==' ' )    break;            // 是空格,跳出
        else                                                     // 非'0'-'9'和' '
        {
            return ERROR;                                    // 返回错误
        }
        if( i>4 )                                            // 输入数字过大
        {
            return ERROR;
        }
        i++;
    }
    data_buf[1]=state;//数据个数
    data_addr=++i;
    return SUCCESS;
}
//***************************接收处理**************************************
void afterRecived(void)
{
    if( decoderData()==ERROR )    return;            // 错误，返回
    if( data_buf[1]>RECIEVED_MAX_DATA_LEN )                                    // 写入个数判断
    {
        return;                                            // 数据个数太多，返回
    }
    ptrFun(&data_buf[data_addr],data_buf[1]);
}

//向串口发送一个字符
void send_char_com(unsigned char ch)  
{
    SBUF=ch;
    while(TI==0);
    TI=0;
}

//向串口发送一个字符串，strlen为该字符串长度
void send_string_com(unsigned char *str,uchar len)
{
    unsigned int k=0;
    do
    {
        send_char_com(*(str + k));
        k++;
    } while(k < len);
}
void sendBefore(void* p){
    char* m=(char*)p;
    uchar len=sizeof(st);
    send_string_com(m,len);
}
//串口接收中断函数
void serial () interrupt 4 using 3
{
    unsigned char state;
    if( RI==1 )
    {
        state = SBUF;                // 缓存接收到的数据
        RI = 0;                        // 接收标志清零
//---------------------检测结束命令#end---------------------------
        if( state==END_CODE[end_num] )    
        {
            end_num++;
            if( end_num==END_NUM )
            {
                end_num = 0;
                isComplete = 1;
                ES=0;
            }
        }
        else end_num = 0;
//---------------------串口数据处理-------------------------------
        if( data_num>SEND_MAX_DATA_LEN )        
        {
            data_num = 0;
            //ERROR 接受数据过长
        }
        data_buf[data_num++] = state;
    }
}


#endif

#include <REGX52.H>
#include "51com.h"
#include "util.h"

unsigned char key_map[]={0,7,8,9,'/',4,5,6,'*',1,2,3,'-','c',0,'=','+'};
unsigned char tab[]={0xFE,0x30,0x6d,0x79,0x33,0x5b,0x5f,0x70,0x7f,0x7b};

void process(uchar* p,len){
    P1=tab[string_to_int(p,len)];
}

void main(void)
{
    init_serialcomm(); //初始化串口
    ptrFun=process;

    b.age=10;

    sendBefore(&b);

   //send_string_com("b",1);
    while(1)
    {
        if( isComplete==1 )                 // 串口接收到一串数据
        {
            isComplete = 0;                    // 标志清零
            if( data_buf[0]=='R' )afterRecived();
            else if( data_buf[0]=='S' )send_string_com("b",1);
            data_num = 0;              // 重新开始接收数据
            ES = 1;                            // 允许串口中断
        }
    }
}

小果子 2010-08-01 16:11 发表评论

crc 原理及实现

小果子 — Fri, 30 Jul 2010 09:34:00 GMT

引言

CRC的全称为Cyclic Redundancy Check，中文名称为循环冗余校验。它是一类重要的线性分组码，编码和解码方法简单，检错和纠错能力强，在通信领域广泛地用于实现差错控制。实际上，除数据通信外，CRC在其它很多领域也是大有用武之地的。例如我们读软盘上的文件，以及解压一个ZIP文件时，偶尔会碰到“Bad CRC”错误，由此它在数据存储方面的应用可略见一斑。

差错控制理论是在代数理论基础上建立起来的。这里我们着眼于介绍CRC的算法与实现，对原理只能捎带说明一下。若需要进一步了解线性码、分组码、循环码、纠错编码等方面的原理，可以阅读有关资料。

利用CRC进行检错的过程可简单描述为：在发送端根据要传送的k位二进制码序列，以一定的规则产生一个校验用的r位监督码(CRC码)，附在原始信息后边，构成一个新的二进制码序列数共k+r位，然后发送出去。在接收端，根据信息码和CRC码之间所遵循的规则进行检验，以确定传送中是否出错。这个规则，在差错控制理论中称为“生成多项式”。

1 代数学的一般性算法

在代数编码理论中，将一个码组表示为一个多项式，码组中各码元当作多项式的系数。例如 1100101 表示为
1·x⁶+1·x⁵+0·x⁴+0·x³+1·x²+0·x+1，即 x⁶+x⁵+x²+1。

设编码前的原始信息多项式为P(x)，P(x)的最高幂次加1等于k；生成多项式为G(x)，G(x)的最高幂次等于r；CRC多项式为R(x)；编码后的带CRC的信息多项式为T(x)。

发送方编码方法：将P(x)乘以xr(即对应的二进制码序列左移r位)，再除以G(x)，所得余式即为R(x)。用公式表示为
T(x)=x^rP(x)+R(x)

接收方解码方法：将T(x)除以G(x)，如果余数为0，则说明传输中无错误发生，否则说明传输有误。

举例来说，设信息码为1100，生成多项式为1011，即P(x)=x³+x²，G(x)=x³+x+1，计算CRC的过程为

      x^rP(x)     x³(x³+x²)     x⁶+x⁵                    x
     -------- = ---------- = -------- = (x³+x²+x) + --------
       G(x)       x³+x+1      x³+x+1                 x³+x+1

即 R(x)=x。注意到G(x)最高幂次r=3，得出CRC为010。

如果用竖式除法，计算过程为

               1110
            -------   
      1011 /1100000     (1100左移3位)
            1011
            ----
             1110
             1011
             -----
              1010
              1011
              -----
               0010
               0000
               ----
                010

因此，T(x)=(x⁶+x⁵)+(x)=x⁶+x⁵+x, 即 1100000+010=1100010

如果传输无误，

       T(x)     x⁶+x⁵+x
      ------ = --------- = x³+x²+x,
       G(x)     x³+x+1

无余式。回头看一下上面的竖式除法，如果被除数是1100010，显然在商第三个1时，就能除尽。

上述推算过程，有助于我们理解CRC的概念。但直接编程来实现上面的算法，不仅繁琐，效率也不高。实际上在工程中不会直接这样去计算和验证CRC。

下表中列出了一些见于标准的CRC资料：

名称	生成多项式	简记式^*	应用举例
CRC-4	x⁴+x+1		ITU G.704
CRC-12	x¹²+x¹¹+x³+x+1
CRC-16	x¹⁶+x¹²+x²+1	1005	IBM SDLC
CRC-ITU^**	x¹⁶+x¹²+x⁵+1	1021	ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCS
CRC-32	x³²+x²⁶+x²³+...+x²+x+1	04C11DB7	ZIP, RAR, IEEE 802 LAN/FDDI, IEEE 1394, PPP-FCS
CRC-32c	x³²+x²⁸+x²⁷+...+x⁸+x⁶+1	1EDC6F41	SCTP

    *  生成多项式的最高幂次项系数是固定的1，故在简记式中，将最高的1统一去掉了，如04C11DB7实际上是104C11DB7。
    ** 前称CRC-CCITT。ITU的前身是CCITT。

4.CRC算法的实现
---------------
要用程序实现CRC算法，考虑对第2节的长除法做一下变换，依然是M = 11100110，G = 1011，
其系数r为3。

             11001100                      11100110000
         -------------                     1011
    1011 )11100110000                      -----------
          1011.......                       1010110000
          ----.......                      1010110000
           1010......                      1011
           1011......        ===>          -----------
           ----......                       001110000
              1110...                      1110000
              1011...                      1011
              ----...                      -----------
               1010..                       101000
               1011..                      101000
               ----                        1011
                  100 <---校验码          -----------
                                            00100
                                            100           <---校验码

程序可以如下实现：
    1)将Mx^r的前r位放入一个长度为r的寄存器；
    2)如果寄存器的首位为1，将寄存器左移1位(将Mx^r剩下部分的MSB移入寄存器的LSB)，
      再与G的后r位异或，否则仅将寄存器左移1位(将Mx^r剩下部分的MSB移入寄存器的LSB)；
    3)重复第2步，直到M全部Mx^r移入寄存器；
    4)寄存器中的值则为校验码。

用CRC16-CCITT的生成多项式0x1021，其C代码(本文所有代码假定系统为32位，且都在VC6上
编译通过)如下：

unsigned short do_crc(unsigned char *message, unsigned int len)
{
    int i, j;
    unsigned short crc_reg;

    crc_reg = (message[0] << 8) + message[1];
    for (i = 0; i < len; i++)
    {
        if (i < len - 2)
            for (j = 0; j <= 7; j++)
            {
                if ((short)crc_reg < 0)
                    crc_reg = ((crc_reg << 1) + (message[i + 2] >> (7 - i))) ^ 0x1021;
                else
                    crc_reg = (crc_reg << 1) + (message[i + 2] >> (7 - i));
            }
         else
            for (j = 0; j <= 7; j++)
            {
                if ((short)crc_reg < 0)
                    crc_reg = (crc_reg << 1) ^ 0x1021;
                else
                    crc_reg <<= 1;
            }
    }
    return crc_reg;
}

显然，每次内循环的行为取决于寄存器首位。由于异或运算满足交换率和结合律，以及与0异
或无影响，消息可以不移入寄存器，而在每次内循环的时候，寄存器首位再与对应的消息位
异或。改进的代码如下：

unsigned short do_crc(unsigned char *message, unsigned int len)
{
    int i, j;
    unsigned short crc_reg = 0;
    unsigned short current;

    for (i = 0; i < len; i++)
    {
        current = message[i] << 8;
        for (j = 0; j < 8; j++)
        {
            if ((short)(crc_reg ^ current) < 0)
                crc_reg = (crc_reg << 1) ^ 0x1021;
            else
                crc_reg <<= 1;
            current <<= 1;
        }
    }
    return crc_reg;
}

以上的讨论中，消息的每个字节都是先传输MSB，CRC16-CCITT标准却是按照先传输LSB，消息
右移进寄存器来计算的。只需将代码改成判断寄存器的LSB，将0x1021按位颠倒后(0x8408)与
寄存器异或即可，如下所示：

unsigned short do_crc(unsigned char *message, unsigned int len)
{
    int i, j;
    unsigned short crc_reg = 0;
    unsigned short current;

    for (i = 0; i < len; i++)
    {
        current = message[i];
        for (j = 0; j < 8; j++)
        {
            if ((crc_reg ^ current) & 0x0001)
                crc_reg = (crc_reg >> 1) ^ 0x8408;
            else
                crc_reg >>= 1;
            current >>= 1;
        }
    }
    return crc_reg;
}

该算法使用了两层循环，对消息逐位进行处理，这样效率是很低的。为了提高时间效率，通
常的思想是以空间换时间。考虑到内循环只与当前的消息字节和crc_reg的低字节有关，对该
算法做以下等效转换：

unsigned short do_crc(unsigned char *message, unsigned int len)
{
    int i, j;
    unsigned short crc_reg = 0;
    unsigned char index;
    unsigned short to_xor;

    for (i = 0; i < len; i++)
    {
        index = (crc_reg ^ message[i]) & 0xff;
        to_xor = index;
        for (j = 0; j < 8; j++)
        {
            if (to_xor & 0x0001)
                to_xor = (to_xor >> 1) ^ 0x8408;
            else
                to_xor >>= 1;
        }
        crc_reg = (crc_reg >> 8) ^ to_xor;
    }
    return crc_reg;
}

现在内循环只与index相关了，可以事先以数组形式生成一个表crc16_ccitt_table，使得
to_xor = crc16_ccitt_table[index]，于是可以简化为：

unsigned short do_crc(unsigned char *message, unsigned int len)
{
    unsigned short crc_reg = 0;

    while (len--)
        crc_reg = (crc_reg >> 8) ^ crc16_ccitt_table[(crc_reg ^ *message++) & 0xff];

    return crc_reg;
}

crc16_ccitt_table通过以下代码生成：

int main()
{
    unsigned char index = 0;
    unsigned short to_xor;
    int i;

    printf("unsigned short crc16_ccitt_table[256] =\n{");
    while (1)
    {
        if (!(index % 8))
            printf("\n");

        to_xor = index;
        for (i = 0; i < 8; i++)
        {
            if (to_xor & 0x0001)
                to_xor = (to_xor >> 1) ^ 0x8408;
            else
                to_xor >>= 1;
        }
        printf("0x%04x", to_xor);

        if (index == 255)
        {
            printf("\n");
            break;
        }
        else
        {
            printf(", ");
            index++;
        }
    }
    printf("};");
    return 0;
}

生成的表如下：

unsigned short crc16_ccitt_table[256] =
{
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,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};

这样对于消息unsigned char message[len]，校验码为：
    unsigned short code = do_crc(message, len);
并且按以下方式发送出去：
    message[len] = code & 0x00ff;
    message[len + 1] = (code >> 8) & 0x00ff;

接收端对收到的len + 2字节执行do_crc，如果没有差错发生则结果应为0。

在一些传输协议中，发送端并不指出消息长度，而是采用结束标志，考虑以下几种差错：
    1)在消息之前，增加1个或多个0字节；
    2)消息以1个或多个连续的0字节开始，丢掉1个或多个0；
    3)在消息(包括校验码)之后，增加1个或多个0字节；
    4)消息(包括校验码)以1个或多个连续的0字节结尾，丢掉1个或多个0；

显然，这几种差错都检测不出来，其原因就是如果寄存器值为0，处理0消息字节(或位)，寄
存器值不变。为了解决前2个问题，只需寄存器的初值非0即可，对do_crc作以下改进：

unsigned short do_crc(unsigned short reg_init, unsigned char *message, unsigned int len)
{
    unsigned short crc_reg = reg_init;

    while (len--)
        crc_reg = (crc_reg >> 8) ^ crc16_ccitt_table[(crc_reg ^ *message++) & 0xff];

    return crc_reg;
}

在CRC16-CCITT标准中reg_init = 0xffff，为了解决后2个问题，在CRC16-CCITT标准中将计
算出的校验码与0xffff进行异或，即：
    unsigned short code = do_crc(0xffff, message, len);
    code ^= 0xffff;
    message[len] = code & 0x00ff;
    message[len + 1] = (code >> 8) & 0x00ff;

显然，现在接收端对收到的所有字节执行do_crc，如果没有差错发生则结果应为某一常值
GOOD_CRC。其满足以下关系：
    unsigned char p[]= {0xff, 0xff};
    GOOD_CRC = do_crc(0, p, 2);
其结果为GOOD_CRC = 0xf0b8。

小果子 2010-07-30 17:34 发表评论

c51 串口理解(转)

小果子 — Fri, 30 Jul 2010 05:38:00 GMT

摘要: 串行接口 8051单片机的通讯方式有两种：并行通讯:数据的各位同时发送或接收。串行通讯:数据一位一位顺序发送或接收。串行通讯的方式： ... 阅读全文

小果子 2010-07-30 13:38 发表评论

c51 串口波特率的计算

小果子 — Fri, 30 Jul 2010 05:32:00 GMT

波特率计算


在串行通信中,收发双方对发送或接收的数据速率要有一定的约定，我们通过软件对MCS—51串行口编程可约定四种工作方式。其中，方式0和方式2的波特率是固定的，而方式1和方式3的波特率是可变的，由定时器T1的溢出率决定。串行口的四种工作方式对应着三种波特率。由于输人的移位时钟的来源不同，所以，各种方式的波特率计算公式也不同。一、方式0的波特率方式0时，移位时钟脉冲由56(即第6个状态周期，第12个节拍)给出，即每个机器周期产生一个移位时钟，发送或接收一位数据。所以，波特率为振荡频率的十二分之一，并不受 PCON寄存器中SMOD的影响，即：方式0的波特率＝fosc／12 三、方式l和方式3的波特率方式1和方式3的移位时钟脉冲由定时器T1的溢出率决定，故波特宰由定时器T1的溢出率与SMOD值同时决定，即：方式1和方式3的波特率＝2SMOD/32·T1溢出率其中，溢出率取决于计数速率和定时器的预置值。计数速率与TMOD寄存器中C／T的状态有关。当C／T＝0时，计数速率＝fosc／2；当C／T＝1时，计数速率取决于外部输入时钟频率。当定时器Tl作波特率发生器使用时，通常选用可自动装入初值模式(工作方式2)，在工作方式2中，TLl作为计数用，而自动装入的初值放在THl中，设计数初值为x，则每过“256一x”个机器周期，定时器T1就会产生一次溢出。为了避免因溢出而引起中断，此时应禁止T1中断。这时，溢出周期为：系统晶振频率选为11．0592MHZ就是为了使初值为整数，从而产生精确的波特率。如果串行通信选用很低的波特率，可将定时器Tl置于工作方式0或工作方式1，但在这种情况下，T1溢出时，需用中断服务程序重装初值。中断响应时间和执行指令时间会使波特率产生一定的误差，可用改变初值的办法加以调整。表6—2列出了各种常用的波特率及其初值。

小果子 2010-07-30 13:32 发表评论

键盘扫描之终结者一

小果子 — Thu, 29 Jul 2010 07:42:00 GMT

static bit isKeyDown(){
    KEY=0x0f;
    if((KEY&0x0f)!=0x0f)
        return 1;
    else return 0;
}
//线反转法 返回键盘索引
unsigned char KeyScan_XF(){
    unsigned char r=0,c=0;
    if(isKeyDown()){
        delayms(20); //去抖动
        if(isKeyDown()){
            KEY=0x0f;
            switch(KEY){
                case 0x0e:c=0;break;   //第一列
                case 0x0d:c=1;break; //第二列
                case 0x0b:c=2;break;   //第三列
                case 0x07:c=3;break; //第四列
                default:  break;
            }
            KEY=0xf0;//电平反向
            switch(KEY){
                case 0xe0:r=0;break;   //第一行
                case 0xd0:r=1;break; //第二行
                case 0xb0:r=2;break;   //第三行
                case 0x70:r=3;break; //第四行
                default:  break;
            }

            while(!isKeyDown());//  按键释放，处理长按
            return  r*4+c+1;
        }
   }
   return 0;          
}

//查询法 返回键盘索引
unsigned char getRorC(){
    KEY&=0x0F;
    KEY|=0x70;     //0111

    if((KEY&0x0f)!=0x0f){
        return 3;
    }

    KEY&=0x0f;
    KEY|=0xB0;       //1011
    if((KEY&0x0f)!=0x0f){
        return 2;
    }

    KEY&=0x0f;
    KEY|=0xD0;   //1101
    if((KEY&0x0f)!=0x0f){
        return 1;
    }

    KEY&=0x0f;
    KEY|=0xE0;  //1110
    if((KEY&0x0f)!=0x0f){
        return 0;
    }
    return -1;//impossible
}
unsigned char KeyScan_CS(){
    unsigned char r=0,c=0;
    if(isKeyDown()){
        delayms(20); //去抖动
        if(isKeyDown()){
            switch(KEY){
                case 0x0e:c=0;break;//第一列
                case 0x0d:c=1;break;//第二列
                case 0x0b:c=2;break;//第三列
                case 0x07:c=3;break;//第四列
                default:break;
            }
            r=getRorC();
            return r*4+c+1;
        }
    }
    KEY=0x0f;

    return 0;
}

小果子 2010-07-29 15:42 发表评论

c51 外部中断触发经验(转)

小果子 — Thu, 29 Jul 2010 07:37:00 GMT

关于51单片机“外部中断触发方式”的经验总结

下面是本人使用51单片机的一点经验，写出来分享，请批评指正。

51单片机的外部中断有两种触发方式可选：电平触发和边沿触发。选择电平触发时，单片机在每个机器周期检查中断源口线，检测到低电平，即置位中断请求标志，向CPU请求中断。选择边沿触发方式时，单片机在上一个机器周期检测到中断源口线为高电平，下一个机器周期检测到低电平，即置位中断标志，请求中断。

这个原理很好理解。但应用时需要特别注意的几点：

1) 电平触发方式时，中断标志寄存器不锁存中断请求信号。也就是说，单片机把每个机器周期的S₅P₂采样到的外部中断源口线的电平逻辑直接赋值到中断标志寄存器。标志寄存器对于请求信号来说是透明的。这样当中断请求被阻塞而没有得到及时响应时，将被丢失。换句话说，要使电平触发的中断被CPU响应并执行，必须保证外部中断源口线的低电平维持到中断被执行为止。因此当CPU正在执行同级中断或更高级中断期间，产生的外部中断源（产生低电平）如果在该中断执行完毕之前撤销（变为高电平）了，那么将得不到响应，就如同没发生一样。同样，当CPU在执行不可被中断的指令（如RETI）时，产生的电平触发中断如果时间太短，也得不到执行。

2) 边沿触发方式时，中断标志寄存器锁存了中断请求。中断口线上一个从高到低的跳变将记录在标志寄存器中，直到CPU响应并转向该中断服务程序时，由硬件自动清除。因此当CPU正在执行同级中断（甚至是外部中断本身）或高级中断时，产生的外部中断（负跳变）同样将被记录在中断标志寄存器中。在该中断退出后，将被响应执行。如果你不希望这样，必须在中断退出之前，手工清除外部中断标志。

3) 中断标志可以手工清除。一个中断如果在没有得到响应之前就已经被手工清除，则该中断将被CPU忽略。就如同没有发生一样。

4) 选择电平触发还是边沿触发方式应从系统使用外部中断的目的上去考虑，而不是如许多资料上说的根据中断源信号的特性来取舍。比如，有的书上说（《Keil C51使用技巧及实战》），就有类似的观点。

小果子 2010-07-29 15:37 发表评论

89c51 存储结构

小果子 — Wed, 28 Jul 2010 05:25:00 GMT

ROM区:
Flash ROM,寻址范围000h-fffh=2^12=4k,存放程序代码
RAM区:
00h-1fh,32个字节,分4组工作寄存器，每组8个字节,r0-r7,psw寄存器RS0,RS1 2位控制使用哪组;
20h-2fh,16个字节除了一般RAM功能外,可以对每个字节进行位寻址,从20h的第一位到2fh的最后一位，总共128位,有固定的位地址;
30h-7fh,80个字节,普通的RAM区
80h-ffh,SPR区,共用21个特殊寄存器,每个寄存器8位

寻址引脚p0,p2,p0低8位，p2高8位

小果子 2010-07-28 13:25 发表评论

proteus中英文元件对照表

小果子 — Wed, 28 Jul 2010 03:56:00 GMT

Proteus isis 的元件库中英对照

[ 2009-12-2 8:29:00 | By: zydlyq ]

Proteus 元件名称对照1
元件名称中文名说明
7407        驱动门
1N914        二极管
74Ls00        与非门
74LS04        非门
74LS08        与门
74LS390        TTL 双十进制计数器
7SEG        4针BCD-LED 输出从0-9 对应于4根线的BCD码
7SEG        3-8译码器电路BCD-7SEG[size=+0]转换电路
ALTERNATOR 交流发电机
AMMETER-MILLI mA安培计
AND        与门
BATTERY        电池/电池组
BUS        总线
CAP        电容
CAPACITOR 电容器
CLOCK        时钟信号源
CRYSTAL        晶振
D-FLIPFLOP D触发器
FUSE        保险丝
GROUND        地
LAMP        灯
LED-RED        红色发光二极管
LM016L        2行16列液晶可显示2行16列英文字符，有8位数据总线D0-D7，RS，R/W，EN三个控制端口（共14线），工作电压为5V。没背光，和常用的1602B功能和引脚一样（除了调背光的二个线脚）
LOGIC ANALYSER 逻辑分析器
LOGICPROBE 逻辑探针
LOGICPROBE[BIG] 逻辑探针用来显示连接位置的逻辑状态
LOGICSTATE 逻辑状态用鼠标点击,可改变该方框连接位置的逻辑状态
LOGICTOGGLE 逻辑触发
MASTERSWITCH 按钮手动闭合,立即自动打开
MOTOR        马达
OR        或门
POT-LIN        三引线可变电阻器
POWER        电源
RES        电阻
RESISTOR 电阻器
SWITCH        按钮手动按一下一个状态
SWITCH-SPDT 二选通一按钮
VOLTMETER 伏特计
VOLTMETER-MILLI mV伏特计
VTERM        串行口终端
Electromechanical 电机
Inductors 变压器
Laplace Primitives 拉普拉斯变换
Memory Ics
Microprocessor Ics
Miscellaneous 各种器件 AERIAL-天线；ATAHDD；ATMEGA64；BATTERY；CELL；CRYSTAL-晶振；FUSE；METER-仪表；
Modelling Primitives 各种仿真器件是典型的基本元器模拟，不表示具体型号，只用于仿真，没有PCB
Optoelectronics 各种发光器件发光二极管，LED，液晶等等
PLDs & FPGAs
Resistors 各种电阻
Simulator Primitives 常用的器件
Speakers & Sounders
Switches & Relays 开关，继电器，键盘
Switching Devices 晶阊管
Transistors 晶体管（三极管，场效应管）
TTL 74 series
TTL 74ALS series
TTL 74AS series
TTL 74F series
TTL 74HC series
TTL 74HCT series
TTL 74LS series
TTL 74S series
Analog Ics 模拟电路集成芯片
Capacitors 电容集合
CMOS 4000 series
Connectors 排座，排插
Data Converters ADC,DAC
Debugging Tools 调试工具
ECL 10000 Series
------------------------------------------------------------

PROTEUS元件库元件名称及中英对照
AND 与门
ANTENNA 天线
BATTERY 直流电源
BELL 铃,钟
BVC 同轴电缆接插件
BRIDEG 1 整流桥(二极管)
BRIDEG 2 整流桥(集成块)
BUFFER 缓冲器
BUZZER 蜂鸣器
CAP 电容
CAPACITOR 电容
CAPACITOR POL 有极性电容
CAPVAR 可调电容
CIRCUIT BREAKER 熔断丝
COAX 同轴电缆
CON 插口
CRYSTAL 晶体整荡器
DB 并行插口
DIODE 二极管
DIODE SCHOTTKY 稳压二极管
DIODE VARACTOR 变容二极管
DPY_3-SEG 3段LED
DPY_7-SEG 7段LED
DPY_7-SEG_DP 7段LED(带小数点)
ELECTRO 电解电容
FUSE 熔断器
INDUCTOR 电感
INDUCTOR IRON 带铁芯电感
INDUCTOR3 可调电感
JFET N N沟道场效应管
JFET P P沟道场效应管
LAMP 灯泡
LAMP NEDN 起辉器
LED 发光二极管
METER 仪表
MICROPHONE 麦克风
MOSFET MOS管
MOTOR AC 交流电机
MOTOR SERVO 伺服电机
NAND 与非门
NOR 或非门
NOT 非门
NPN NPN三极管
NPN-PHOTO 感光三极管
OPAMP 运放
OR 或门
PHOTO 感光二极管
PNP 三极管
NPN DAR NPN三极管
PNP DAR PNP三极管
POT 滑线变阻器
PELAY-DPDT 双刀双掷继电器
RES1.2 电阻
RES3.4 可变电阻
RESISTOR BRIDGE ? 桥式电阻
RESPACK ? 电阻
SCR 晶闸管
PLUG ? 插头
PLUG AC FEMALE 三相交流插头
SOCKET ? 插座
SOURCE CURRENT 电流源
SOURCE VOLTAGE 电压源
SPEAKER 扬声器
SW ? 开关
SW-DPDY ? 双刀双掷开关
SW-SPST ? 单刀单掷开关
SW-PB 按钮
THERMISTOR 电热调节器
TRANS1 变压器
TRANS2 可调变压器
TRIAC ? 三端双向可控硅
TRIODE ? 三极真空管
VARISTOR 变阻器
ZENER ? 齐纳二极管
DPY_7-SEG_DP 数码管
SW-PB 开关
----------------------------------------------------------------------

      PROTEUS原理图元器件库详细说明
Device.lib           包括电阻、电容、二极管、三极管和PCB的连接器符号
ACTIVE.LIB           包括虚拟仪器和有源器件
DIODE.LIB          包括二极管和整流桥
DISPLAY.LIB       包括LCD、LED
BIPOLAR.LIB       包括三极管
FET.LIB                 包括场效应管
ASIMMDLS.LIB    包括模拟元器件
VALVES .LIB           包括电子管
ANALOG.LIB           包括电源调节器、运放和数据采样IC
CAPACITORS.LIB 包括电容
COMS.LIB             包括   4000系列
ECL.LIB                包括ECL10000系列
MICRO.LIB             包括通用微处理器
OPAMP.LIB              包括运算放大器
RESISTORS.LIB    包括电阻
FAIRCHLD .LIB        包括FAIRCHLD 半导体公司的分立器件
LINTEC.LIB             包括 LINTEC公司的运算放大器
NATDAC.LIB          包括国家半导体公司的数字采样器件
NATOA.LIB             包括国家半导体公司的运算放大器
TECOOR.LIB          包括TECOOR公司的 SCR 和TRIAC
TEXOAC.LIB              包括德州仪器公司的运算放大器和比较器
ZETEX .LIB                 包括ZETEX 公司的分立器件

小果子 2010-07-28 11:56 发表评论

keil c51 延时(转)

小果子 — Wed, 28 Jul 2010 02:58:00 GMT

摘要: EDN博客精华文章作者：mycaibo Keil C51程序设计中几种精确延时方法摘要实际的单片机应用系统开发过程中，由于程序功能的需要，经常编写各种延时程序，延时时间从数微秒到数秒不等，对于许多C51开发者特别是初学者编制非常精确的延时程序有一定难度。本文从实际应用出发，讨论几种实用的编制精确延时程序和计算程序执行时间的方法，并给出各种方法使用的详细步骤，以便... 阅读全文

小果子 2010-07-28 10:58 发表评论

51单片机之-跑马灯

小果子 — Wed, 28 Jul 2010 02:45:00 GMT

#include<reg52.h> //52系列单片机头文件
#include <intrins.h>
//初始化

void init(){
    //中断初始化
    //IE
    EA=1;//中断总开关
    ET0=1;//定时器0开关

    //TCON
    TF0=0;
    TR0=1;

    //TMOD
    TMOD=0x01;//定时器0使用,工作方式1

    //初始化预置值
    TH0=0x3C;//预值为3c+b0=15536
    TL0=0xB0;

    //
    P1=0x01;
}
void delay1s(){
    #pragma asm
    mov    r5,#08h         ;//1001.401ms   
    time1s_1:               mov    r6,#0f4h        ;//125.173ms   
    time1s_2:               mov    r7,#0ffh        ;//511us   
                            djnz   r7,$   
                            djnz   r6,time1s_2  
                            djnz   r5,time1s_1
    #pragma endasm
}
void time0(void) interrupt 1 using 2{
     delay1s();
    #pragma asm
    mov a,p1
    rl a
    mov p1,a
    #pragma endasm
    
}

void main(void){
    init();
    while(1){};
}

初学单片机,记下学习路程
跑灯闪的时间间隔不是1s

//头文件intrins.h介绍
内部函数描述
_crol_ 字符循环左移
_cror_ 字符循环右移
_irol_ 整数循环左移
_iror_ 整数循环右移
_lrol_ 长整数循环左移
_lror_ 长整数循环右移
_nop_ 空操作8051 NOP 指令
_testbit_ 测试并清零位8051 JBC 指令

DSN:http://www.cppblog.com/Files/guojingjia2006/keil/main.DSN.rar

小果子 2010-07-28 10:45 发表评论

Keil编译模式的选择

小果子 — Tue, 27 Jul 2010 06:43:00 GMT

Keil Cx51编译器提供三条编译模式控制命令：SMALL,COMPACT,LARGE，它们对变量存储器空间的影响如下。
SMALL：所有变量都被定义在8051单片机的片内RAM中，对这种变量的访问速度最快。另外，堆栈也必须位于片内RAM中，而堆栈的长度是很重要的，实际栈长取决与不同函数的嵌套深度。采用SMALL编译模式与定义变量时指定data存储器类型具有相同效果。

COMPACT：所有变量被定义在分页寻址的片外XRAM中，每一页片外XRAM的长度为256字节。这时对变量的访问是通过寄存器间接寻址（MOVX @R0,MOVX @R1）进行的，变量的低8位地址由R0和R1确定，变量的高8位地址由P2口确定。采用这种模式时，必须适当改变配置文件STARTUP.A51中的参数：PDATASTART和PDATALEN；同时还必须对uVision2的“Options选项/BL51 Locator 标签页/Pdata框”中键入合适的地址参数，以确保P2口能输出所需要的高8位地址。采用COMPACT编译模式与定义变量时指定pdata存储器类型具有相同效果。

LARGE：所有变量被定义在片外XRAM中（最大可达64KB），使用数据指针DPTR来间接访问变量（MOVX @DPTR），这种编译模式对数据访问的效率最低，而且将增加程序的代码长度。采用LARGE编译模式与定义变量时指定xdata存储器类型具有相同效果。”
摘自《Keil Cx51 V7.0单片机高级语言编程与uVision2应用实践》

小果子 2010-07-27 14:43 发表评论