码迷，mamicode.com
首页 > 其他好文 > 详细

略略略

时间：2019-03-01 19:59:09      阅读：182      评论：0      收藏：0      [点我收藏+]

标签：div   uac   check   lsb   faac   com   time   har   没有   

 
技术图片 
#include <lcd.h>

void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}

void LcdWriteCom(uchar com)
{
    LCD1602_E = 0;
    LCD1602_RS = 0;
    LCD1602_RW = 0;
    
    LCD1602_DATAPINS = com;
    delay(1);
    
    LCD1602_E = 1;
    delay(5);
    LCD1602_E = 0;
}


void LcdWriteData(uchar dat)
{
    LCD1602_E = 0;
    LCD1602_RS = 1;
    LCD1602_RW = 0;
    
    LCD1602_DATAPINS = dat;
    delay(1);
    
    LCD1602_E = 1;
    delay(5);
    LCD1602_E = 0;
}

void LcdInit()
{
    LcdWriteCom(0x38);
    LcdWriteCom(0x0c);
    LcdWriteCom(0x05);
    LcdWriteCom(0x01);
//    LcdWriteCom(0x80);
    LcdWriteCom(0x90);
}
lcd.c
技术图片 
#ifndef __LCD_H_
#define __LCD_H_

#include <reg51.h>

#ifndef uchar
#define uchar unsigned char
#endif

#ifndef uint
#define uint unsigned int
#endif

#define LCD1602_DATAPINS P0
sbit LCD1602_E = P2^7;
sbit LCD1602_RW = P2^5;
sbit LCD1602_RS = P2^6;

void delay(uint);
void LcdWriteCom(uchar);
void LcdWriteData(uchar);
void LcdInit();

#endif
lcd.h 
技术图片 
/*
    S16 µÈÓÚ S4 ÍËλ S8¸´Î»
    S15 
    K1~K4¼Ó¼õ³Ë³ý
*/

#include <reg51.h>
#include <lcd.h>
#define uchar unsigned char
#define uint unsigned int

sbit k1 = P3^1;
sbit k2 = P3^0;
sbit k3 = P3^2;
sbit k4 = P3^3;

uchar Ans[10];
uchar code todig[] = 
{
    7,8,9,0,4,5,6,0,1,2,3,0,0,0,0,0
};
uchar Disp[50];

uchar flag, MKValue, cnt, i, ope;
int ans1, ans2;

uchar MatrixKeyScan(void);
uchar KeyScan(void);
double getdig(int);
void DisplayAns();
void Cal(void);
double oper(double, double, char);

int main()
{
    LcdInit();
    while (1)
    {
        flag = 0;
        flag = MatrixKeyScan();
        KeyScan();
        if (flag == 1)//Êý×Ö¼ü
        {
            Disp[++cnt] = todig[MKValue]+‘0‘;
            LcdWriteData(Disp[cnt]);
        }
        
        if (flag == 2)//µÈÓÚ
        {
            LcdWriteData(‘=‘);
            Disp[++cnt] = ‘=‘;
            //¼ÆËã
            Cal();
        }
        
        if (flag == 3)//ÍËλ¼ü
        {
            cnt--;
            LcdWriteCom(0x01);
            LcdWriteCom(0x90);
            for (i = 1; i <= cnt; i++)
                LcdWriteData(Disp[i]);
        }
        
        if (flag == 4)//¸´Î»¼ü
        {
            LcdWriteCom(0x01);
            LcdWriteCom(0x90);
            cnt = 0;
        }
        if (flag == 5)
        {
            LcdWriteData(‘.‘);
            Disp[++cnt] = ‘.‘;
        }
    }        
}

void Cal(void)
{
    uchar i = 1;
    while (Disp[i] >= ‘0‘ && Disp[i] <= ‘9‘)
    {
        ans1 = ans1 * 10 + Disp[i] - ‘0‘;
        i++;
    }
    
    while (Disp[i] != ‘=‘)//¼ì²âµ½"="Ìø³öÑ­»·
    {
        ope = Disp[i];//´æ´¢·ûºÅλ
        i++;
        while (Disp[i] >= ‘0‘ && Disp[i] <= ‘9‘)
        {
            ans2 = ans2 * 10 + Disp[i] - ‘0‘;
            i++;
        }
        switch (ope)
        {
            case(‘+‘): ans1 = ans1+ans2;break;
            case(‘-‘): ans1 = ans1-ans2;break;
            case(‘*‘): ans1 = ans1*ans2;break;
            case(‘/‘): ans1 = ans1/ans2;break;
        }
        ans2 = 0;
    }
    DisplayAns();
}

void DisplayAns()//´¦Àí½á¹û²¢ÏÔʾ
{
    int z = 0, i;//z λÊý
    if (ans1 < 0)
    {
        LcdWriteData(‘-‘);
        ans1 *= -1;
    }
    
    if(ans1 == 0)
        Ans[++z] = 0;
    else
        while (ans1)
        {
            Ans[++z] = ans1%10;
            ans1 /= 10;
        }    
    for (i = z; i > 0; i--)
    {
        LcdWriteData(Ans[i]+48);
    }
}

uchar MatrixKeyscan()
{
    uchar a = 0;
    P1 = 0x0f;
    if (P1 != 0x0f)
    {
        delay(10);
        if (P1 != 0x0f)
        {
            P1 = 0x0f;
            switch (P1)
            {
                case (0x07):    MKValue = 0; break;
                case (0x0b):    MKValue = 1; break;
                case (0x0d):    MKValue = 2; break;
                case (0x0e):    MKValue = 3; break;
            }
            P1 = 0xf0;
            switch (P1)
            {
                case (0xb0):    MKValue += 4; break;
                case (0xd0):    MKValue += 8; break;
                case (0xe0):    MKValue += 12; break;
            }
        }
        while ((a < 50)&&(P1 != 0xf0))
        {
            delay(10);
            a++;
        }
        if ((MKValue==0)||(MKValue==1)||(MKValue==2)||(MKValue==4)||(MKValue==5)||
            (MKValue==6)||(MKValue==8)||(MKValue==9)||(MKValue==10)||(MKValue==13))//°´ÏÂÊý×Ö¼ü
            return 1;
        if (MKValue == 15)//µÈÓÚ
            return 2;
        if (MKValue == 3)//ÍËλ¼ü
            return 3;
        if (MKValue == 7)//¸´Î»¼ü
            return 4;
        if (MKValue == 14)//СÊýµã
            return 5;
    }
    return 0;//ÎÞЧ¼ü
}



uchar KeyScan()
{
    
    if (k1 == 0)
    {
        delay (10);
        if (k1 == 0)
        {
            while (!k1);
            LcdWriteData(‘+‘);
            Disp[++cnt] = ‘+‘;
        }
    }
    
    if (k2 == 0)
    {
        delay (10);
        if (k2 == 0)
        {
            while (!k2);
            LcdWriteData(‘-‘);
            Disp[++cnt] = ‘-‘;
        }
    }
    
    if (k3 == 0)
    {
        delay (10);
        if (k3 == 0)
        {
            while (!k3);
            LcdWriteData(‘*‘);
            Disp[++cnt] = ‘*‘;
        }
    }
    
    if (k4 == 0)
    {
        delay (10);
        if (k4 == 0)
        {
            while (!k4);
            LcdWriteData(‘/‘);
            Disp[++cnt] = ‘/‘;
        }
    }
    return 0;
}
智能车第一题main.c

 

技术图片 
/*
    k1k2 ·¢Çò k3k4½ÓÇò
*/

#include <reg52.h>
#include <intrins.h>

#define uint unsigned int
#define uchar unsigned char

sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;
sbit k1 = P3^1;
sbit k2 = P3^0;
sbit k3 = P3^2;
sbit k4 = P3^3;
sbit beep = P1^5;

uchar code table[] = 
{
    0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
};

uchar score1 = 0, score2 = 0;
uchar flag = 0, i, a, dire;// dire = 1 l->r dire = 2 r->l
uint v = 300, v0;

void delay(uint);
void Display(void);
void Led(uchar);
void Int0Init(void);
void Int1Init(void);
void Beep(void);

int main()
{
    Int0Init();
    Int1Init();
    while (1)
    {
        if (dire != 0)
        {
            flag = 0;
            Led(dire);
            if (flag == 0)//½ÓÇòʧ°Ü
            {                    
                Beep();//·äÃùÆ÷Ïì
                if (dire == 1)
                    score1++;
                else
                    score2++;
                dire = 0;
                a = 1000;
                while(a--)
                    Display();
            }
        }
        else                    //·¢Çò
        {
            if (k1 == 0)
            {
                delay(10);
                if (k1 == 0)
                {
                    dire = 1;
                }
                while (!k1);
            }
            
            if (k2 == 0)
            {
                delay(10);
                if (k2 == 0)
                {
                    dire = 2;
                }
                while (!k2);
            }
        }
    }
}
/*·äÃùÆ÷*/
void Beep(void)
{
    uchar i = 100;
    while (i--)
    {
        beep = ~beep;
        delay(5);
    }
    delay(5);
}

/*Á÷Ë®µÆº¯Êý*/
void Led(uchar x)
{
    if (x == 1)
    {
        P2 = 0x7f;
        delay(v);
        for (i = 0; i < 7; i++)
        {
            P2 = _cror_(P2,1);
            delay(v);
        }
    }
    
    if (x == 2)
    {
        P2 = 0xfe;
        delay(v);
        for (i = 0; i < 7; i++)
        {
            P2 = _crol_(P2,1);
            delay(v);
        }
    }
}

/*ÊýÂë¹ÜÏÔʾº¯Êý*/
void Display()
{
    LSA = 0; LSB = LSC = 1; P0 = table[score1 / 10];delay(1);P0 = 0x00;
    LSA = LSC = 1; LSB = 0; P0 = table[score1 % 10];delay(1);P0 = 0x00;
    LSA = LSB = 0; LSC = 1; P0 = 0x40;delay(1);P0 = 0x00;
    LSA = LSB = 1; LSC = 0; P0 = 0x40;delay(1);P0 = 0x00;
    LSA = LSC = 0; LSB = 1; P0 = table[score2 / 10];delay(1);P0 = 0x00;
    LSA = 1; LSC = LSB = 0; P0 = table[score2 % 10];delay(1);P0 = 0x00;
}

/*INT0³õʼ»¯º¯Êý*/
void Int0Init(void)
{
    IT0 = 1;//ϽµÑØÓÐЧ
    EX0 = 1;//´ò¿ªINT0ÖжÏÔÊÐí
    EA = 1;
}


void Int0() interrupt 0
{
    delay(10);
    if (k3 == 0)
    {
        if (P2 == 0x7f)//½ÓÇò³É¹¦
        {
            P0 = 0x00;
            dire = 1;
            flag = 1;
        }
    }
    while (!k3);
}

/*INT1³õʼ»¯º¯Êý*/
void Int1Init(void)
{
    IT1 = 1;//ϽµÑØÓÐЧ
    EX1 = 1;//´ò¿ªINT0ÖжÏÔÊÐí
    EA = 1;
}

void Int1() interrupt 2
{
    delay(10);
    if (k4 == 0)
    {
        if (P2 == 0xfe)//½ÓÇò³É¹¦
        {
            P0 = 0x00;
            dire = 2;
            flag = 1;
        }
    }
    while (!k4);
}

/*ÑÓʱº¯Êý xms*/
void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}
智能车第二题 乒乓球

 

技术图片 
/*Åжϲ»ÔÚͬһÐС¢Í¬Ò»ÁеĶà¸ö¼ü°´ÏÂ*/

#include <reg52.h>
#include <intrins.h>
#define uint unsigned int
#define uchar unsigned char

sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;
uchar code table[] = 
{
    0x00,0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
    0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71
};
uint MKValue, a, flag, flag1, DValue = 0, P1s,MKValue2;

void delay(uint);
void MatrixKeyScan(void);

int main()
{
    LSA = LSB = LSC = 1;
    while (1)
    {
        MatrixKeyScan();
        if (flag == 1)
            P0 = table[MKValue];
    }
}


void delay(uint x)
{
    uint j, k;
    for (j = x; j > 0; j--)
        for (k = 110; k > 0; k--);
}

void MatrixKeyScan(void)
{
    flag = 0;
    P1 = 0x0f;
    if (P1 != 0x0f)
    {
        delay(10);
        if (P1 != 0x0f)
        {
            P1 = 0x0f;
            switch (P1)//?
            {
                case(0x07):    MKValue = 1; break;
                case(0x0b):    MKValue = 2; break;
                case(0x0d):    MKValue = 3; break;
                case(0x0e):    MKValue = 4; break;
            }
            P1 = 0xf0;
            switch (P1)//?
            {
                case(0xb0):    MKValue += 4; break;
                case(0xd0):    MKValue += 8; break;
                case(0xe0):    MKValue += 12; break;
            }
            
            P1s = P1;
            while ( P1 != 0xf0)//P1ľÓÐËÉ¿ª
            {
                if (P1 != P1s)//¼ì²âµ½µÚ¶þ¸ö¼ü°´ÏÂ
                {
                    delay(10);
                    if (P1 != P1s)
                    {
                        P1 = 0x0f;
                        switch (P1)//DValue ´æ´¢×éºÏ¼üµÄÖµ
                        {
                            case(0x03):    DValue = 1; break;
                            case(0x05):    DValue = 2; break;
                            case(0x06):    DValue = 3; break;
                            case(0x09):    DValue = 4; break;
                            case(0x0a):    DValue = 5; break;
                            case(0x0c):    DValue = 6; break;
                        }
                        P1 = 0xf0;
                        switch (P1)//?
                        {
                            case(0x50):    DValue += 6; break;
                            case(0x60):    DValue += 12; break;
                            case(0x90):    DValue += 18; break;
                            case(0xa0):    DValue += 24; break;
                            case(0xc0):    DValue += 30; break;
                        }
                        switch (DValue)//¼ÆËãÁíÒ»¸ö¼üµÄÖµ´æÈëMKV2ÖÐ
                        {
                            case(1):if (MKValue == 1)    MKValue2 = 6;    
                                    if (MKValue == 2)    MKValue2 = 5;
                                    if (MKValue == 5)    MKValue2 = 2;
                                    if (MKValue == 6)    MKValue2 = 1;//-->7-MKV
                                    while(P1 == 0x30);//µÚ¶þ¸ö¼üËÉ¿ª
                                    P0 = table[MKValue2];
                                    break;
                            case(2):MKValue2 = 8 - MKValue;
                                    while(P1 == 0x30);
                                    P0 = table[MKValue2];
                                    break;
                            case(3):
                            case(4):MKValue2 = 9 - MKValue;
                                    while(P1 == 0x30);
                                    P0 = table[MKValue2];
                                    break;
                            case(5):MKValue2 = 10 - MKValue;
                                    while(P1 == 0x30);
                                    P0 = table[MKValue2];
                                    break;
                            case(6):MKValue2 = 11 - MKValue;
                                    while(P1 == 0x30);
                                    P0 = table[MKValue2];
                                    break;    
                            case(7):MKValue2 = 11 - MKValue;
                                    while(P1 == 0x50);
                                    P0 = table[MKValue2];
                                    break;    
                            case(8):MKValue2 = 12 - MKValue;
                                    while(P1 == 0x50);
                                    P0 = table[MKValue2];
                                    break;    
                            case(9):
                            case(10):MKValue2 = 13 - MKValue;
                                    while(P1 == 0x50);
                                    P0 = table[MKValue2];
                                    break;    
                            case(11):MKValue2 = 14 - MKValue;
                                    while(P1 == 0x50);
                                    P0 = table[MKValue2];
                                    break;    
                            case(12):MKValue2 = 15 - MKValue;
                                    while(P1 == 0x50);
                                    P0 = table[MKValue2];
                                    break;    
                            case(13):MKValue2 = 15 - MKValue;
                                    while(P1 == 0x60);
                                    P0 = table[MKValue2];
                                    break;    
                            case(14):MKValue2 = 16 - MKValue;
                                    while(P1 == 0x60);
                                    P0 = table[MKValue2];
                                    break;    
                            case(15):
                            case(16):MKValue2 = 17 - MKValue;
                                    while(P1 == 0x60);
                                    P0 = table[MKValue2];
                                    break;    
                            case(17):MKValue2 = 18 - MKValue;
                                    while(P1 == 0x60);
                                    P0 = table[MKValue2];
                                    break;    
                            case(18):MKValue2 = 19 - MKValue;
                                    while(P1 == 0x60);
                                    P0 = table[MKValue2];
                                    break;    
                            case(19):MKValue2 = 15 - MKValue;
                                    while(P1 == 0x90);
                                    P0 = table[MKValue2];
                                    break;    
                            case(20):MKValue2 = 16 - MKValue;
                                    while(P1 == 0x90);
                                    P0 = table[MKValue2];
                                    break;    
                            case(21):
                            case(22):MKValue2 = 17 - MKValue;
                                    while(P1 == 0x90);
                                    P0 = table[MKValue2];
                                    break;    
                            case(23):MKValue2 = 18 - MKValue;
                                    while(P1 == 0x90);
                                    P0 = table[MKValue2];
                                    break;    
                            case(24):MKValue2 = 19 - MKValue;
                                    while(P1 == 0x90);
                                    P0 = table[MKValue2];
                                    break;    
                            case(25):MKValue2 = 19 - MKValue;
                                    while(P1 == 0xa0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(26):MKValue2 = 20 - MKValue;
                                    while(P1 == 0xa0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(27):
                            case(28):MKValue2 = 21 - MKValue;
                                    while(P1 == 0xa0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(29):MKValue2 = 22 - MKValue;
                                    while(P1 == 0xa0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(30):MKValue2 = 23 - MKValue;
                                    while(P1 == 0xa0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(31):MKValue2 = 23 - MKValue;
                                    while(P1 == 0xc0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(32):MKValue2 = 24 - MKValue;
                                    while(P1 == 0xc0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(33):
                            case(34):MKValue2 = 25 - MKValue;
                                    while(P1 == 0xc0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(35):MKValue2 = 26 - MKValue;
                                    while(P1 == 0xc0);
                                    P0 = table[MKValue2];
                                    break;    
                            case(36):MKValue2 = 27 - MKValue;
                                    while(P1 == 0xc0);
                                    P0 = table[MKValue2];
                                    break;    
                        }
                            DValue = 0;
                    }
                }
            }
            flag = 1;
        }
    }
}
智能车第三题 矩阵键盘

 

技术图片 
/*k1 ¼õËÙ k2 ¼ÓËÙ k3 ÔÝÍ£/¼ÌÐø k4 ºôÎüµÆ*/

#include <reg52.h>
#include <intrins.h>
#define uchar unsigned char
#define uint unsigned int
    
sbit k0 = P3^1;
sbit k1 = P3^0;
sbit k2 = P3^2;
sbit k3 = P3^3;

uchar flag = 0, flag1 = 0, P2ram;//ÔÝÍ£flag ºôÎüµÆflag1
uint PWM_Low, Clock = 500, i;
uint v;

void KeyScan(void);
void delay1ms(uint);
void delay10us(uint);
void PWMLed(void);
void Timer0Init(void);

int main()
{
    Timer0Init();
    P2 = 0xfe;
    while(1)
    {
        KeyScan();
        if (flag1 == 1)
        {
            PWMLed();
        }
        delay1ms(100+v);
    }
}
void Timer0Init()
{
    TMOD |= 0x01;
    TH0 = (65535-50000) / 256;
    TL0 = (65535-50000) % 256;
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void Timer0() interrupt 1
{
    TH0 = (65535-50000) / 256;//50ms
    TL0 = (65535-50000) % 256;
    i ++;
    if (i*50>v+100)
    {
        i = 0;
        if (flag != 1)
            P2 = _crol_(P2,1);
        else
            P2ram = _crol_(P2ram,1);//P2Ϊ0xffʱ ÓÃP2ram´úÌæP2ÒÆλ
    }
}
void KeyScan(void)
{
    if (k0 == 0)
    {
        delay1ms(10);
        if (k0 == 0)
        {
            while (!k0);
            v -= 30;
        }
    }
    
    if (k1 == 0)
    {
        delay1ms(10);
        if (k1 == 0)
        {
            while (!k1);
            v += 30;
        }
    }
    
    if (k2 == 0)
    {
        delay1ms(10);
        if (k2 == 0)
        {
            while (!k2);
            TR0 = ~TR0;
        }
    }
    
    if (k3 == 0)
    {
        delay1ms(10);
        if (k3 == 0)
        {
            while (!k3);
            flag1 ^= 1;//ºôÎüµÆ¿ª¹Øflag
        }
    }
}

void PWMLed()
{
    for (PWM_Low = Clock; PWM_Low > 0; PWM_Low --)
    {
        KeyScan();
        if (flag1 == 0)
            break;
        delay10us(PWM_Low);//µÍµçƽdelay

        P2ram = P2;
        P2 = 0xff;
        flag = 1;//¶¨Ê±Æ÷P2ÒÆλflag flag = 1ÓÉP2ram´úÌæP2ÒÆλ
        delay10us(Clock-PWM_Low);//¸ßµçƽdelay
        P2 = P2ram;
        flag = 0;
    }
}

void delay1ms(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}

void delay10us(uint x)
{
    while (x--);
}
智能车第四题 独立按键控制流水灯

 

技术图片 
/*
    k3-ÔÝÍ£ k4-ÒÆλ k1 +1
*/
#include <reg52.h>
#define uchar unsigned char
#define uint unsigned int

sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;

sbit k1 = P3^1;
sbit k2 = P3^0;
sbit k3 = P3^2;
sbit k4 = P3^3;

uchar code table[] = 
{
    0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
};
uchar tab[10];
uchar i, p = 1;//pÖ¸Ïò¸Ä±äλ

void Timer0Init(void);
void Int0Init(void);
void Display(void);
void delay(uint);
void KeyPros(void);

int main()
{
    Timer0Init();
    Int0Init();
    while (1)
    {
        KeyPros();
        Display();
    }
}
void KeyPros()
{
    if (k1 == 0)
    {
        delay(10);
        if (k1 == 0)
        {
            tab[p]++;
            if ((p%2 == 1) && (tab[p] == 6))
                tab[p] = 0;
            if ((p%2 == 0) && (tab[p] == 10))
                tab[p] = 0;
        }
        while (!k1);
    }

    if (k2 == 0)
    {
        delay(10);
        if (k2 == 0)
        {
            
        }
        while (!k2);
    }

    if (k4 == 0)
    {
        delay(10);
        if (k4 == 0)
        {
            p++;
            if (p > 6)
                p = 1;
        }
        while (!k4);
    }
}

void Display()
{
    LSA = LSB = LSC = 1; P0 = table[tab[1]];delay(1);P0 = 0x00;
    LSA = 0; LSB = LSC = 1; P0 = table[tab[2]];delay(1);P0 = 0x00;
    LSA = LSC = 1; LSB = 0; P0 = 0x40;delay(1);P0 = 0x00;
    LSA = LSB = 0; LSC = 1; P0 = table[tab[3]];delay(1);P0 = 0x00;
    LSA = LSB = 1; LSC = 0; P0 = table[tab[4]];delay(1);P0 = 0x00;
    LSA = LSC = 0; LSB = 1; P0 = 0x40;delay(1);P0 = 0x00;
    LSA = 1; LSC = LSB = 0; P0 = table[tab[5]];delay(1);P0 = 0x00;
    LSA = LSB = LSC = 0; P0 = table[tab[6]];delay(1);P0 = 0x00;
}

void Int0Init(void)
{
    IT0 = 1;//ϽµÑØÓÐЧ
    EX0 = 1;//´ò¿ªINT0ÖжÏÔÊÐí
    EA = 1;
}

void Int0() interrupt 0
{
    delay(10);
    if (k3 == 0)
        TR0 = ~TR0;
}

void Timer0Init(void)
{
    TMOD |= 0x01;
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    ET0 = 1;
    TR0 = 1;
    EA = 1;
}

void Timer0() interrupt 1
{
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    i++;
    if (i == 20)
    {
        i = 0;
        tab[6] ++;
        if (tab[6] == 10)//ÒÔÏ´¦Àí½øλ
        {
            tab[6] = 0;
            if (tab[5] != 5)
                tab[5] ++;
            else
            {
                tab[5] = 0;
                tab[4] ++;
                if (tab[4] == 10)
                {
                    tab[4] = 0;
                    if(tab[3] != 5)
                        tab[3] ++;
                    else
                    {
                        tab[3] = 0;
                        tab[2] ++;
                        if (tab[2] == 10)
                        {
                            tab[2] = 0;
                            if (tab[1] != 5)
                                tab[1]++;
                            else
                                tab[1] = 0;
                        }
                    }
                }
            }
        }
    }
    
}

void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}
智能车第五题 数码管时钟

 

技术图片 
/*
    k1ÏÔʾÃû×Ö    k2ÏÔʾÉúÈÕ
*/

#include <reg51.h>
#include <intrins.h>
#define uchar unsigned char
#define uint unsigned int
#define COMMONPORTS P0

sbit SER = P3^4;
sbit RCLK = P3^5;
sbit SRCLK = P3^6;
sbit k0 = P3^1;
sbit k1 = P3^0;


/*ÁÐѡͨ¿ØÖÆ*/
uchar code TAB[] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};
//µãÕó×ÖÂë(ÁÐ)
uchar code lattice[4][8] = 
{
    {0x31,0xaa,0x64,0x3a,0x21,0x18,0x01,0x7f},
    {0x50,0x61,0xf6,0x6a,0x5b,0x6e,0xf0,0x60},
    {0x38,0x00,0xff,0x40,0xbf,0x68,0x6f,0xb9},
    {0x00,0x07,0x05,0x77,0x00,0x00,0x00,0x77}
};
void delay(uint);
void Hc595SendByte(uchar);
uint KeyScan(void);

int main()
{
    uint i, j, k, flag;
    while(1)
    {
        flag = KeyScan();
        if (flag == 1)
        {
            for (j = 0; j < 3; j++)
            {
                for (k = 0; k < 50; k++)    //Á½¸ö×ÖÖ®¼äµÄɨÃè¼ä¸ôʱ¼ä
                {
                    for (i = 0; i < 8; i++)
                    {
                        Hc595SendByte(0x00);
                        COMMONPORTS = TAB[i];
                        Hc595SendByte(lattice[j][i]);
                        delay(2);
                    }
                }
            }
            Hc595SendByte(0x00);//ÏûÓ°
        }
        else if (flag == 2)
        {
            for (k = 0; k < 50; k++)    //Á½¸ö×ÖÖ®¼äµÄɨÃè¼ä¸ôʱ¼ä
            {
                for (i = 0; i < 8; i++)
                {
                    Hc595SendByte(0x00);
                    COMMONPORTS = TAB[i];
                    Hc595SendByte(lattice[3][i]);
                    delay(2);
                }
            }
            Hc595SendByte(0x00);//ÏûÓ°
        }
    }
}

/*ÑÓʱº¯Êý*/
void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 110; j > 0; j--);
}

/*ÏòHc595·¢ËÍÒ»¸ö×Ö½ÚµÄÊý¾Ý*/
void Hc595SendByte(uchar dat)
{
    uchar i;
    SRCLK = 0;
    RCLK = 0;
    for (i = 0; i < 8; i++)
    {
        SER = dat >> 7;
        dat <<= 1;
        
        SRCLK = 1;
        _nop_();
        _nop_();
        SRCLK = 0;
    }
    RCLK = 1;
    _nop_();
    _nop_();
    RCLK = 0;
}

/*°´¼üɨÃ躯Êý*/
uint KeyScan(void)
{
    if (k0 == 0)
    {
        delay(10);
        if (k0 == 0)
        {
            while (!k0);
            return 1;
        }
    }
    
    if (k1 == 0)
    {
        delay(10);
        if (k1 == 0)
        {
            while (!k1);
            return 2;
        }
    }
}
智能车第六题 显示名字/生日 按键切换

 

技术图片 
/*
    S8 ¸´Î» S12 ÔÝÍ£ S16È·¶¨
    S1~3 5~7 9~11 14 Êý×Ö¼ü 
*/
#include <reg52.h>
#include <intrins.h>
#define uchar unsigned char
#define uint unsigned int

sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;
sbit beep = P1^5;

uchar code table[] = 
{
    0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
};
uchar code dig[] = 
{
    7,8,9,0,4,5,6,0,1,2,3,0,0,0,0,0
};
uchar tab[10];//´æ´¢¼üÈëÊý±í

uchar MKValue, flag = 0, cnt = 0, cnt0 = 0, p = 0,a = 0;
uint num = 0, num0;
uchar i, t;

uchar MatrixKeyScan(void);
void delay(uint);
void Display(void);
void Timer0Init(void);
void Led(void);
void Beep(void);

int main()
{
    Timer0Init();
    while (1)
    {
        flag = MatrixKeyScan();
        if (flag == 1)
        {
            tab[++cnt] = dig[MKValue];
            num = num*10 + dig[MKValue];
        }
        if (flag == 2)//¼Æʱ¿ªÊ¼~
        {
            TR0 = 1;
        }
        if (flag == 3)
        {
            TR0 = ~TR0;
        }
        if (flag == 4)
        {
            num = 0;
            for (i = 1; i < cnt; i ++)
                tab[i] = 0;
            cnt = 0;
        }
        flag = 0;
        Display();
    }
}

/*·äÃùÆ÷Ïì*/
void Beep(void)
{
    uchar i = 100;
    while (i--)
    {
        beep = ~beep;
        delay(5);
    }
    delay(5);
}

/*Á÷Ë®µÆº¯Êý*/
void Led(void)
{
    uchar i = 16;
    P2 = 0xfe;
    while (i--)
    {
        P2 = _crol_(P2,1);
        delay(50);
    }
    P2 = 0xff;
}

/*¼ÆʱÆ÷0³õʼ»¯º¯Êý*/
void Timer0Init(void)
{
    TMOD |= 0x01;
    TH0 = (65535 - 45872) / 256;//50ms
    TL0 = (65535 - 35872) % 256;
    ET0 = 1;
    EA = 1;
}

void Timer0() interrupt 1
{
    TH0 = (65535 - 45872) / 256;
    TL0 = (65535 - 35872) % 256;
    a++;
    if (a == 20)
    {
        a = 0;
        p = 0;
        cnt0 = 0;//³õʼ»¯£¡£¡£¡
        num --;
        
        num0 = num;
        while (num0)//´¦ÀíÍËλ ×¢Òânum == 0 ÌØÊâÇé¿ö
        {
            num0 /= 10;
            cnt0++;
        }
        num0 = num;
        if ((cnt > cnt0) && (num != 0))
            cnt--;
        
        for (i = cnt; i >= 1; i--)
        {
            tab[i] = num0 % 10;
            num0 /= 10;
        }
        
        if (num == 0)//ʱ¼äµ½
        {
            Led();
            Beep();Beep();Beep();Beep();
            TR0 = 0;
        }
    }
}
void Display(void)
{
    char pos = cnt-1;
    pos = cnt - 1;
    while (pos >= 0 && num != 0)
    {
        LSC = pos / 4;
        LSB = (pos%4) / 2;
        LSA = (pos%2);
        P0 = table[tab[cnt - pos]];
        pos --;
        delay(2);
        P0 = 0x00;
    }
    if (num == 0)//²»Ó°ÏìÁ÷Ë®µÆ
    {
        LSA = LSB = LSC = 1;
        P0 = 0x00; 
    }
}

uchar MatrixKeyscan()
{
    uchar a = 0;
    P1 = 0x0f;
    if (P1 != 0x0f)
    {
        delay(10);
        if (P1 != 0x0f)
        {
            P1 = 0x0f;
            switch (P1)
            {
                case (0x07):    MKValue = 0; break;
                case (0x0b):    MKValue = 1; break;
                case (0x0d):    MKValue = 2; break;
                case (0x0e):    MKValue = 3; break;
            }
            P1 = 0xf0;
            switch (P1)
            {
                case (0xb0):    MKValue += 4; break;
                case (0xd0):    MKValue += 8; break;
                case (0xe0):    MKValue += 12; break;
            }
        }
        while ((a < 50)&&(P1 != 0xf0))
        {
            delay(10);
            a++;
        }
        if ((MKValue==0)||(MKValue==1)||(MKValue==2)||(MKValue==4)||(MKValue==5)||
            (MKValue==6)||(MKValue==8)||(MKValue==9)||(MKValue==10)||(MKValue==13))//°´ÏÂÊý×Ö¼ü
            return 1;
        if (MKValue == 15)//È·¶¨¼ü
            return 2;
        if (MKValue == 11)//ÔÝÍ£¼ü
            return 3;
        if (MKValue == 7)//¸´Î»¼ü
            return 4;
    }
    return 0;//ÎÞЧ¼ü
}

void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}
智能车第七题 倒计时器（数码管+定时器）

 

 

技术图片 
/*
    S1~S3 S7~S7 S9~S11 S14Êý×Ö¼ü
    S4ÇåÁã S12Í˸ñ
    S8 ±£´æ S13 ÏÔʾÉϴα£´æÊý¾Ý 
    S16 È·ÈÏ 
*/

#include <reg52.h>
#include <intrins.h>
#include <i2c.h>

#define uchar unsigned char
#define uint unsigned int

sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;
sbit beep = P1^5;

uchar code table[] = 
{
    0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
};
uchar code dig[] = 
{
    7,8,9,0,4,5,6,0,1,2,3,0,0,0,0,0
};
uchar code SongTone[]=
{
    212,212,106,126,159,169,190,119,119,126,159,142,159,0
};

uchar code SongLong[]=
{
    9,3,12,12,12,12,12,9,3,12,12,12,24,0
};
uchar tab[20];
uchar Password[20];

uchar MKValue, flag = 0, cnt = 0, cnt0 = 0, cnt1 = 0, Useflag = 0;
uint num = 0;
uchar i, t,WrongTime;

uchar MatrixKeyScan(void);
void delay(uint);
void Display(void);
void Timer0Init(void);
void Led(void);
void Beep(void);
void Use(void);
uint Check(void);
void EnterPassword(void);
void UsartInit(void);
void Sing(void);

int main()
{
    UsartInit();
    Timer0Init();
    while (1)
    {
        flag = MatrixKeyScan();
        if (flag == 1)
        {
            tab[++cnt] = dig[MKValue];
            num = num*10 + dig[MKValue];
        }
        if (flag == 2)//½øÈëʹÓÃģʽ
        {
            Use();
        }
        if (flag == 3)//Í˸ñ
        {
            cnt --;
        }
        if (flag == 4)//Çå³ý
        {
            num = 0;
            for (i = 1; i <= cnt; i ++)
                tab[i] = 0;
            cnt = 0;
        }
        if (flag == 5)//±£´æµ±Ç°ÏÔʾµÄÃÜÂë
        {
            At24c02Write(20,cnt);
            delay(20);
            for (i = 1; i <= cnt; i++)
            {
                At24c02Write(i,tab[i]);
                delay(20);
            }
        }
        if (flag == 6)//ÏÔʾÉϴα£´æµÄÃÜÂë
        {
            cnt = At24c02Read(20);
            delay(20);
            for (i = 1; i <= cnt; i++)
            {
                tab[i] = At24c02Read(i);
                delay(20);
            }
        }
        flag = 0;
        Display();
    }
}

/*******************************************************************************
*    º¯ÊýÃû       :UsartInit()
*    º¯Êý¹¦ÄÜ    :ÉèÖô®¿Ú
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void UsartInit(void)
{
    SCON = 0x50;                        // ÉèÖÃΪ¹¤×÷·½Ê½1
    TMOD = 0x20;                        //ÉèÖö¨Ê±Æ÷1¹¤×÷·½Ê½2
    PCON = 0x80;                        //²¨ÌØÂʼӱ¶
    TH1 = 0xF3;                            //²¨ÌØÂÊ4800
    TL1 = 0xF3;
    ES = 1;                                //´®¿ÚÖжÏÔÊÐí
    EA = 1;                                //¿ª×ÜÖжÏ
    TR1 = 1;                            //¿ª¶¨Ê±Æ÷ÖжÏ
}
/*******************************************************************************
*    º¯ÊýÃû        :Usart()
*    º¯Êý¹¦ÄÜ    :´®¿ÚÖжϺ¯Êý
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Usart() interrupt 4
{
    uchar receiveData;                    //receivedata 8λ 0~255
    
    receiveData = SBUF;                    //½ÓÊÕÊý¾Ý
    tab[++cnt] = receiveData-48;        //ASCIIÂëACSIIÂëASCIIÂë
    num = num*10 + (receiveData-48);
    RI = 0;                                //Çå³ý½ÓÊÕÖжϱêÖ¾
}
/*******************************************************************************
*    º¯ÊýÃû        :Use()
*    º¯Êý¹¦ÄÜ    :ʹÓÃģʽ
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Use(void)
{
    Useflag = 1;
    WrongTime = 0;
    while(1)
    {
        cnt1 = 0;
        EnterPassword();
        if (Check())
        {
            Led();
            Sing();
            Use();
        }
        else
        {
            WrongTime++;
            if (WrongTime >= 3)
            {
                Beep();
                Use();
            }
        }
    }
    Useflag = 0;
}
/*******************************************************************************
*    º¯ÊýÃû        :Check()
*    º¯Êý¹¦ÄÜ    :¼ì²éÃÜÂëÕýÎó
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £º1/0
*******************************************************************************/
uint Check(void)
{
    uint i;
    if (cnt != cnt1)
        return 0;
    for (i = 0; i < cnt; i++)
        if (Password[i] != tab[i])
            return 0;
    return 1;
}
/*******************************************************************************
*    º¯ÊýÃû        :EnterPassword()
*    º¯Êý¹¦ÄÜ    :ÊäÈëÒ»×éÃÜÂë
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void EnterPassword(void)
{
    char pos;
    while(1)
    {
        if(MatrixKeyScan())
        {
            if (MKValue == 15)//È·ÈÏ
                return;
            if (MKValue == 11)//Í˸ñ
                cnt1 --;
            else
            {
                Password[++cnt1] = dig[MKValue];
            }
        }
        Display();
    }
}

/*******************************************************************************
*    º¯ÊýÃû        :Beep()
*    º¯Êý¹¦ÄÜ    :·äÃùÆ÷±¨¾¯
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Beep(void)
{
    uchar i = 100;
    while (i--)
    {
        beep = ~beep;
        delay(5);
    }
    delay(5);
}
/*******************************************************************************
*    º¯ÊýÃû        :Sing()
*    º¯Êý¹¦ÄÜ    :·äÃùÆ÷³ª¸è
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Sing()
{
    uint i=0,j,k;
    while(SongLong[i]!=0||SongTone[i]!=0)
    { 
        for(j=0;j<SongLong[i]*20;j++)
        {
            beep=~beep;
            for(k=0;k<SongTone[i]/5;k++);
        }
        delay(50);
        i++;
    }
}

/*******************************************************************************
*    º¯ÊýÃû        :Led()
*    º¯Êý¹¦ÄÜ    :Á÷Ë®µÆº¯Êý
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Led(void)
{
    uchar i = 16;
    P2 = 0xfe;
    while (i--)
    {
        P2 = _crol_(P2,1);
        delay(50);
    }
    P2 = 0xff;
}
/*******************************************************************************
*    º¯ÊýÃû        :Timer0Init()
*    º¯Êý¹¦ÄÜ    :¼ÆʱÆ÷0³õʼ»¯º¯Êý
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Timer0Init(void)
{
    TMOD |= 0x01;
    TH0 = (65535 - 45872) / 256;//50ms
    TL0 = (65535 - 35872) % 256;
    ET0 = 1;
    EA = 1;
}
/*******************************************************************************
*    º¯ÊýÃû        :Timer0()
*    º¯Êý¹¦ÄÜ    :¼ÆʱÆ÷0¹¦Äܺ¯Êý
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Timer0() interrupt 1
{
    
}

/*******************************************************************************
*    º¯ÊýÃû        :Display()
*    º¯Êý¹¦ÄÜ    :ÊýÂë¹ÜÏÔʾÊý×Ö
*    ÊäÈë        £ºÎÞ
*    ·µ»Ø        £ºÎÞ
*******************************************************************************/
void Display(void)
{
    char pos = cnt-1;
    if (Useflag == 0)
    {
        if (pos >= 8)
            pos = 7;
        while (pos >= 0)
        {
            LSC = pos / 4;
            LSB = (pos%4) / 2;
            LSA = (pos%2);
            P0 = table[tab[cnt - pos]];
            pos --;
            delay(2);
            P0 = 0x00;
        }
    }    
    else
    {
        pos = cnt1-1;
        while (pos >= 0)
        {
            LSC = pos / 4;
            LSB = (pos%4) / 2;
            LSA = (pos%2);
            P0 = 0x40;
            pos --;
            delay(2);
            P0 = 0x00;
        }
    }
    
    
}
/*******************************************************************************
*    º¯ÊýÃû        :MatrixKeyscan()
*    º¯Êý¹¦ÄÜ    :ɨÃè¼üÅÌ
*    ÊäÈë        :ÎÞ
*    ·µ»Ø        :°´¼üÀàÐÍ
*******************************************************************************/
uchar MatrixKeyscan()
{
    uchar a = 0;
    P1 = 0x0f;
    if (P1 != 0x0f)
    {
        delay(10);
        if (P1 != 0x0f)
        {
            P1 = 0x0f;
            switch (P1)
            {
                case (0x07):    MKValue = 0; break;
                case (0x0b):    MKValue = 1; break;
                case (0x0d):    MKValue = 2; break;
                case (0x0e):    MKValue = 3; break;
            }
            P1 = 0xf0;
            switch (P1)
            {
                case (0xb0):    MKValue += 4; break;
                case (0xd0):    MKValue += 8; break;
                case (0xe0):    MKValue += 12; break;
            }
        }
        while ((a < 50)&&(P1 != 0xf0))
        {
            delay(10);
            a++;
        }
        if ((MKValue==0)||(MKValue==1)||(MKValue==2)||(MKValue==4)||(MKValue==5)||
            (MKValue==6)||(MKValue==8)||(MKValue==9)||(MKValue==10)||(MKValue==13))//°´ÏÂÊý×Ö¼ü
            return 1;
        if (MKValue == 15)//È·¶¨¼ü
            return 2;
        if (MKValue == 11)//Í˸ñ¼ü
            return 3;
        if (MKValue == 3)//¸´Î»¼ü
            return 4;
        if (MKValue == 7)//±£´æÃÜÂë
            return 5;
        if (MKValue == 12)//ÏÔʾÉϴα£´æµÄÃÜÂë
            return 6;
    }
    return 0;//ÎÞЧ¼ü
}

/*******************************************************************************
*    º¯ÊýÃû        :Delay()
*    º¯Êý¹¦ÄÜ    :ÑÓʱxms
*******************************************************************************/
void delay(uint x)
{
    uint i, j;
    for (i = x; i > 0; i--)
        for (j = 100; j > 0; j--);
}
高频第一题
技术图片 
#include <i2c.h>

#define uchar unsigned char
#define uint unsigned int

/*******************************************************************************
*     函数名        :Delay10us()     
*    函数功能    ：延时10us 
*******************************************************************************/ 
    
void Delay10us(void)
{
    unsigned char a, b;
    for (b = 1; b > 0; b--)
        for (a = 2; a > 0; a--);
}


/*******************************************************************************
*     函数名        :I2cStart()     
*    函数功能    ：起始信号，在SCL时钟信号在高电平期间SDA信号产生一个下降沿
*    输入        ：无 
*     输出        ：无 
*    备注        ：起始之后SDA和SCL都为0 
*******************************************************************************/ 


void I2cStart()
{
    SDA = 1;
    Delay10us();
    SCL = 1;
    Delay10us();
    SDA = 0;
    Delay10us();
    SCL = 0;
    Delay10us();
}

/*******************************************************************************
*     函数名        :I2cStop()     
*    函数功能    ：终止信号，在SCL时钟信号在高电平期间SDA信号产生一个上升沿
*    输入        ：无 
*     输出        ：无 
*    备注        ：结束之后SDA和SCL都为1，表示总线空闲 
*******************************************************************************/ 

void I2cStop()
{
    SDA = 0;
    Delay10us();
    SCL = 1;
    Delay10us();
    SDA = 1;
    Delay10us();
}

/*******************************************************************************
*     函数名        :I2cSendByte()     
*    函数功能    ：通过IIC发送一个字节。在SCL时钟信号高电平期间，保持发送信号SDA稳定 
*    输入        ：待发送字节num 
*     输出        ：0或1 表示发送成功或失败 
*    备注        ：发送完一个字节SCL = 0，SDA = 1 
*******************************************************************************/ 

uchar I2cSendByte(uchar dat)
{
    uchar a = 0, b = 0;
    for (a = 0; a < 8; a++)//先取最高位，再左移一位令次高位成为最高位 
    {
        SDA = dat>>7;//起始信号后SCL = 0，此时可以直接改变SDA的值 
        dat <<= 1;
        Delay10us();
        SCL = 1;//时钟信号高电平，SDA稳定 
        Delay10us();
        SCL = 0;//时钟信号低电平，等待下一位读入 
        Delay10us();
    }
    SDA = 1;
    Delay10us();
    SCL = 1;//SDA SCL都拉高 等待应答 
    while(SDA)//如果应答 SDA为低电平 跳出循环 
    {
        b++; 
        if (b > 200)//如果超过2000us没有应答则接收结束 
        {
            SCL = 0;
            Delay10us();
            return 0;
        }
    }
    SCL = 0;//SCL置0以发送/读取下一字节 
    Delay10us();
    return 1;
}

/*******************************************************************************
*     函数名        :I2cReadByte()     
*    函数功能    ：通过IIC读取一个字节。在SCL时钟信号高电平期间，保持发送信号SDA稳定 
*    输入        ：无 
*     输出        ：读取字节dat 
*    备注        ：接收完一个字节SCL = 0，SDA = 1 
*******************************************************************************/ 
uchar I2cReadByte()
{
    uchar a = 0, dat = 0;
    SDA = 1;//起始或发送字节后SCL都为0 
    Delay10us();
    for (a = 0; a < 8; a++)//接收8个字节 
    {
        SCL = 1;//SDA稳定 
        Delay10us();
        dat <<= 1;
        dat |= SDA;
        Delay10us();
        SCL = 0;
        Delay10us();
    }
    return dat;
}

/*******************************************************************************
*     函数名        :At24c02Write(uchar,uchar)     
*    函数功能    ：向24c02中写入一个数据 
*    输入        ：要写入的内存地址 写入的数据 
*     输出        ：无 
*******************************************************************************/ 
void At24c02Write(uchar addr, uchar dat)
{
    I2cStart();    //起始信号 
    I2cSendByte(0xa0);//发送写器件地址 
    I2cSendByte(addr);//发送写入内存地址 
    I2cSendByte(dat);//发送数据 
    I2cStop();//终止信号 
}

/*******************************************************************************
*     函数名        :At24c02Read(uchar)     
*    函数功能    ：读取24c02一个地址的一个数据 
*    输入        ：读取内存地址 
*     输出        ：读取字节num 
*******************************************************************************/ 

uchar At24c02Read(uchar addr)
{
    uchar num;
    I2cStart();//起始信号 
    I2cSendByte(0xa0);//发送写器件地址 
    I2cSendByte(addr);//发送写入内存地址 
    I2cStart();//起始信号 
    I2cSendByte(0xa1);//发送读器件地址 
    num = I2cReadByte();//读取数据 
    I2cStop();
    return num;
}
i2c.c
技术图片 
#ifndef _I2C_H
#define _I2C_H

#include <reg52.h>

sbit SCL = P2^1;
sbit SDA = P2^0;

void At24c02Write(unsigned char, unsigned char);
unsigned char At24c02Read(unsigned char);

#endif
i2c.h

 

技术图片 
#include <reg52.h>
#include <ds1302.h>

#define uint unsigned int
#define uchar unsigned char
    
sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;

uchar code table[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar DisplayDataA[8];
uchar DisplayDataB[8];

void DataPros(void);
void DigDisplay(uchar);
void delay(uchar);

int main()
{
    uchar i;
    Ds1302Init();
    while(1)
    {
        i = 10000000;
        while(i --) 
        {
            DataPros();
            DigDisplay(1);
        }
        i = 5000000;
        while(i --) 
        {
            DataPros();
            DigDisplay(2);
        }
    }
}

void DataPros()
{
    Ds1302ReadTime();
    DisplayDataA[0] = table[TIME[2] / 16];
    DisplayDataA[1] = table[TIME[2] % 16];
    DisplayDataA[2] = 0x40;
    DisplayDataA[3] = table[TIME[1] / 16];
    DisplayDataA[4] = table[TIME[1] % 16];
    DisplayDataA[5] = 0x40;
    DisplayDataA[6] = table[TIME[0] / 16];
    DisplayDataA[7] = table[TIME[0] % 16];
    
    DisplayDataB[0] = table[TIME[6] / 16];
    DisplayDataB[1] = table[TIME[6] % 16];
    DisplayDataB[2] = 0x40;
    DisplayDataB[3] = table[TIME[4] / 16];
    DisplayDataB[4] = table[TIME[4] % 16];
    DisplayDataB[5] = 0x40;
    DisplayDataB[6] = table[TIME[3] / 16];
    DisplayDataB[7] = table[TIME[3] % 16];
}

void DigDisplay(uchar x)
{
    uchar i;
    for (i = 0; i < 8; i ++)
    {
        LSC = i / 4;
        LSB = i%4 / 2;
        LSA = i%2;
        if (x == 1)
            P0 = DisplayDataA[7-i];
        else
            P0 = DisplayDataB[7-i];
            
        delay(1);
        P0 = 0x00;
    }
    
}

void delay(uchar x)
{
    uint i, j;
    for (i = 100; i > 0; i--)
        for (j = x; j > 0; j--);
}
高频第二题 main.c
技术图片 
#include <ds1302.h>
#define uchar unsigned char
#define uint unsigned int

uchar code READ_ADDR[7] = {0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
uchar code WRITE_ADDR[7] = {0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};

uchar TIME[7] = {0x00,0x35,0x21,0x20,0x02,0x03,0x19};

void Ds1302Write(uchar addr, uchar dat)
{
    uchar i;
    RST = 0;
    _nop_();
    
    SCLK = 0;
    _nop_();
    RST = 1;
    _nop_();
    
    for (i = 0; i < 8; i++)
    {
        DSIO = addr & 0x01;
        addr >>= 1;
        SCLK = 1;
        _nop_();
        SCLK = 0;
        _nop_();
    }
    
    for (i = 0; i < 8; i++)
    {
        DSIO = dat & 0x01;
        dat >>= 1;
        SCLK = 1;
        _nop_();
        SCLK = 0;
        _nop_();
    }
    RST = 0;
    _nop_();
}

uchar Ds1302Read(uchar addr)
{
    uchar i, dat = 0, dat1;
    RST = 0;
    _nop_();
    
    SCLK = 0;
    _nop_();
    RST = 1;
    _nop_();
    
    for (i = 0; i < 8; i++)
    {
        DSIO = addr & 0x01;
        addr >>= 1;
        SCLK = 1;
        _nop_();
        SCLK = 0;
        _nop_();
    }
    _nop_();
    for (i = 0; i < 8; i++)
    {
        dat1 = DSIO;
        dat = (dat >> 1)|(dat1 << 7);
        SCLK = 1;
        _nop_();
        SCLK = 0;
        _nop_();
    }
    
    RST = 0;
    _nop_();
    SCLK = 1;//?
    _nop_();
    DSIO = 0;
    _nop_();
    DSIO = 1;
    _nop_();
    return dat;
}

void Ds1302Init()
{
    uchar i;
    Ds1302Write(0x8e,0x00);
    for (i = 0; i < 7; i++)
    {
        Ds1302Write(WRITE_ADDR[i], TIME[i]);
    }
    Ds1302Write(0x8e,0x80);
}

void Ds1302ReadTime()
{
    uchar i;
    for (i = 0; i < 7; i++)
    {
        TIME[i] = Ds1302Read(READ_ADDR[i]);
    }
}
ds1302.c
技术图片 
#ifndef __DS1302_H_
#define __DS1302_H_

#include <reg52.h>
#include <intrins.h>

#ifndef uchar
#define uchar unsigned char
#endif

#ifndef uint 
#define uint unsigned int
#endif

sbit DSIO = P3^4;
sbit SCLK = P3^6;
sbit RST = P3^5;


void Ds1302Write(uchar addr, uchar dat);
uchar Ds1302Read(uchar addr);
void Ds1302Init();
void Ds1302ReadTime();

extern uchar TIME[7];

#endif
ds1302.h

 

略略略

标签：div   uac   check   lsb   faac   com   time   har   没有   

原文地址：https://www.cnblogs.com/liumengyue/p/10391729.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！