如果使用At89S52单片机控制8个LED从右到左循环显示，LED阴极接在P1.0～P1.7.阳极通过限流电阻接5V电源

好的，针对您的问题，以下是使用AT89S52单片机控制8个LED从右到左循环显示的代码：

#include <reg52.h>  // AT89S52头文件

void delay(unsigned int xms);  // 延时函数

void main()
{
    unsigned char i;
    while (1)
    {
        for (i = 0x80; i != 0x00; i >>= 1)  // 从右到左循环显示
        {
            P1 = ~i;  // 端口取反，LED阴极接在P1.0～P1.7
            delay(500);  // 500ms延时
        }
    }
}

void delay(unsigned int xms)
{
    unsigned int i, j;
    for (i = xms; i > 0; i--)
        for (j = 110; j > 0; j--);
}

注意：以上代码中的`delay`函数为简单的延时函数，可能会存在一定的误差，如果需要更精确的延时可以使用定时器。另外，代码中的`P1 = ~i`表示将`i`的二进制取反后输出到P1口，实现了LED的闪烁效果。

相关问题

串口通信控制AT89C52单片机共阴极数码管和8个led灯代码

好的，以下是一个简单的串口通信控制AT89C52单片机共阴极数码管和8个LED灯的代码示例：

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

#define FOSC 11059200L
#define BAUD 9600
#define TIMER_1 (65536 - FOSC / 12 / BAUD)

sbit LATCH1 = P1^0; // 数码管锁存信号
sbit LATCH2 = P1^1;
sbit LATCH3 = P1^2;
sbit LATCH4 = P1^3;

sbit LED1 = P2^0; // LED灯控制信号
sbit LED2 = P2^1;
sbit LED3 = P2^2;
sbit LED4 = P2^3;
sbit LED5 = P2^4;
sbit LED6 = P2^5;
sbit LED7 = P2^6;
sbit LED8 = P2^7;

unsigned char code LED_CATHODE[] = { 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F }; // 数码管段码表，共阴极
unsigned char xdata LED_BUFF[4]; // 数码管缓存

void UartInit() // 串口初始化
{
    TMOD |= 0x20; // 启用定时器1，模式2
    TH1 = TIMER_1 / 256; // 计算波特率重载值
    TL1 = TIMER_1 % 256;
    TR1 = 1; // 启动定时器1
    SCON = 0x50; // 启用串口，方式1，允许接收
    ES = 1; // 使能串口中断
    EA = 1; // 使能全局中断
}

void UartSend(unsigned char dat) // 发送一个字节
{
    SBUF = dat;
    while(!TI); // 等待发送完成
    TI = 0;
}

void UartSendString(unsigned char *s) // 发送一个字符串
{
    while(*s)
    {
        UartSend(*s++);
    }
}

void Delay10ms() // 延时10毫秒
{
    unsigned char i, j;

    i = 10;
    j = 145;
    do
    {
        while (--j);
    } while (--i);
}

void Display(unsigned char *buff) // 数码管显示函数
{
    LATCH1 = 0;
    P0 = LED_CATHODE[buff[0]];
    LATCH1 = 1;

    LATCH2 = 0;
    P0 = LED_CATHODE[buff[1]];
    LATCH2 = 1;

    LATCH3 = 0;
    P0 = LED_CATHODE[buff[2]];
    LATCH3 = 1;

    LATCH4 = 0;
    P0 = LED_CATHODE[buff[3]];
    LATCH4 = 1;
}

void Led(unsigned char led) // LED灯控制函数
{
    LED1 = led & 0x01;
    LED2 = led & 0x02;
    LED3 = led & 0x04;
    LED4 = led & 0x08;
    LED5 = led & 0x10;
    LED6 = led & 0x20;
    LED7 = led & 0x40;
    LED8 = led & 0x80;
}

void main()
{
    unsigned char i, ch;

    UartInit();

    for(i = 0; i < 4; i++)
    {
        LED_BUFF[i] = 0;
    }

    while(1)
    {
        if(RI) // 接收到数据
        {
            ch = SBUF;
            RI = 0;

            switch(ch)
            {
                case '0':
                    LED_BUFF[0] = 0;
                    break;

                case '1':
                    LED_BUFF[0] = 1;
                    break;

                case '2':
                    LED_BUFF[0] = 2;
                    break;

                case '3':
                    LED_BUFF[0] = 3;
                    break;

                case '4':
                    LED_BUFF[0] = 4;
                    break;

                case '5':
                    LED_BUFF[0] = 5;
                    break;

                case '6':
                    LED_BUFF[0] = 6;
                    break;

                case '7':
                    LED_BUFF[0] = 7;
                    break;

                case '8':
                    LED_BUFF[0] = 8;
                    break;

                case '9':
                    LED_BUFF[0] = 9;
                    break;

                case 'a':
                case 'A':
                    Led(0x01);
                    break;

                case 'b':
                case 'B':
                    Led(0x02);
                    break;

                case 'c':
                case 'C':
                    Led(0x04);
                    break;

                case 'd':
                case 'D':
                    Led(0x08);
                    break;

                case 'e':
                case 'E':
                    Led(0x10);
                    break;

                case 'f':
                case 'F':
                    Led(0x20);
                    break;

                case 'g':
                case 'G':
                    Led(0x40);
                    break;

                case 'h':
                case 'H':
                    Led(0x80);
                    break;

                default:
                    LED_BUFF[0] = 0;
                    Led(0x00);
                    break;
            }

            Display(LED_BUFF); // 显示数码管
        }

        Delay10ms();
    }
}

void UartIsr() interrupt 4 using 1 // 串口中断服务函数
{
    if(RI) // 接收到数据
    {
        RI = 0;
    }
}

以上代码中，通过串口接收数据，根据数据的不同来控制数码管和LED灯的显示。其中，使用了定时器1和中断来实现串口通信。在串口中断服务函数中，通过判断RI寄存器的值来确定是否接收到了数据。

C语言编写at89c52单片机的P2口扩展一个共阴极的LED数码管，P1口接了8个按键，当接在P1.0、P1.1、P1.2....P1.7引脚上的按键分别闭合时，数码管分别显示0、1、2、....7。试按照要求编制控制程序。注：共阴极数码管0~9的字形码为：3FH、06H、5BH、4FH、66H、6DH、7DH、07H、7FH、6FH。（12分）

根据您的要求，以下是使用C语言编写的控制程序，用于在AT89C52单片机上通过P2口扩展一个共阴极的LED数码管，并通过P1口上的8个按键控制数码管显示相应的数字：

#include <reg52.h>

unsigned char digitCodes[] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};  // 数码管显示的字形码

void delay(unsigned int time) {
    while (time--);
}

void main() {
    unsigned char key;
    unsigned char digit;

    P1 = 0xFF;     // 将P1口设置为输入模式
    P2 = 0x00;     // 初始化P2口为输出模式

    while (1) {
        key = P1;  // 读取P1口的值，检测按键状态

        if (key != 0xFF) {  // 如果有按键被按下
            for (digit = 0; digit < 8; digit++) {
                if ((key & (1 << digit)) == 0) {  // 检测对应位的按键是否按下
                    P2 = digitCodes[digit];       // 在数码管上显示对应的数字
                    delay(10000);                 // 延时一段时间，以稳定显示
                    P2 = 0x00;                    // 关闭数码管显示
                }
            }
        }
    }
}

上述代码中，我们首先定义了一个数组 `digitCodes`，其中存储了0到9的共阴极数码管的字形码。然后，在 `main` 函数中，我们设置P1口为输入模式，P2口为输出模式。在一个无限循环中，我们读取P1口的值，检测按键状态。如果有按键被按下，我们根据按键对应的位数，在数码管上显示相应的数字，并通过适当的延时来稳定显示。最后，关闭数码管的显示。

请注意，在编译和烧录程序之前，请确保使用适当的编译器和开发环境，并将数码管正确连接到单片机的P2口。