51单片机---编程实现流水灯----键盘控制数码管显示--利用74LS164扩展并行输出口---定时中断方式驱动一个数码管

captain_dong

已于 2023-07-07 07:51:19 修改

阅读量6.9k

点赞数 6

分类专栏：单片机平时学习文章标签：计算机外设

于 2023-07-06 15:18:14 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/m0_63064861/article/details/131577035

版权

平时学习同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

7 篇文章 1 订阅

订阅专栏

目录

基于51单片机，用c语言编程实现流水灯

使用C语言编写的基于51单片机的键盘控制数码管显示

基于51单片机，用c语言编程实现利用74LS164扩展并行输出口

基于51单片机，用c语言编程实现定时中断方式驱动一个数码管

基于51单片机，用c语言编程实现流水灯

代码：

1-

#include <reg51.h>

// 定义延时时间（单位：毫秒）
#define DELAY_TIME 500

// 左往右亮流水灯
void leftToRight() {
    unsigned char pattern = 0x01;
    
    while (1) {
        P1 = pattern;
        pattern <<= 1;
        
        if (pattern == 0x00) {
            pattern = 0x01;
        }
        
        delay();
    }
}

// 右往左亮流水灯
void rightToLeft() {
    unsigned char pattern = 0x80;
    
    while (1) {
        P1 = pattern;
        pattern >>= 1;
        
        if (pattern == 0x00) {
            pattern = 0x80;
        }
        
        delay();
    }
}

// 左往右亮然后右往左亮流水灯
void leftThenRight() {
    unsigned char pattern = 0x01;
    unsigned char direction = 0;  // 0表示左往右，1表示右往左
    
    while (1) {
        P1 = pattern;
        
        if (direction == 0) {
            pattern <<= 1;
            
            if (pattern == 0x00) {
                pattern = 0x80;
                direction = 1;
            }
        } else {
            pattern >>= 1;
            
            if (pattern == 0x00) {
                pattern = 0x01;
                direction = 0;
            }
        }
        
        delay();
    }
}

// 延时函数
void delay(){
    unsigned int i, j;
    for(i=0; i<DELAY_TIME; i++){
        for(j=0; j<1000; j++);
    }
}

int main() {
    while(1) {
        // 从左往右亮流水灯
        leftToRight();
        
        // 从右往左亮流水灯
        rightToLeft();
        
        // 从左往右亮然后从右往左亮流水灯
        leftThenRight();
    }
    return 0;
}

2-

#include <reg51.h> // 包含51单片机的寄存器定义和常量

// 定义延时函数
void delay(unsigned int time) {
  unsigned int i, j;
  for (i = 0; i < time; i++) {
    for (j = 0; j < 125; j++) {
      // 延时一段时间
    }
  }
}

void main() {
  unsigned char pattern = 0x01; // 流水灯的显示模式，初始为第一个LED亮，其余LED灭

  while (1) {
    P1 = pattern; // 将当前模式的值写入P1口控制LED灯亮灭
    delay(500); // 延时一段时间，控制流水灯移动速度

    pattern <<= 1; // 模式左移一位，实现流水灯效果

    // 如果已经移到最后一颗LED，重新回到第一个LED
    if (pattern == 0x00) {
      pattern = 0x01;
    }
  }
}

上述代码中，使用P1口控制了8颗LED灯，通过将不同的模式值写入P1口，实现了流水灯灯光在8颗LED之间的移动。delay函数用于延时一定的时间，控制流水灯移动的速度。流水灯效果通过将模式值左移一位并判断是否移到最后一颗LED来实现。

使用C语言编写的基于51单片机的键盘控制数码管显示

最终版：

1-

#include <reg51.h>
sbit key1 = P2^0;
sbit key2 = P2^1;

// 定义数码管显示的数字
unsigned char code digit[] = {
    0xC0,  // 0
    0xF9,  // 1
    0xA4,  // 2
    0xB0,  // 3
    0x99,  // 4
    0x92,  // 5
    0x82,  // 6
    0xF8,  // 7
    0x80,  // 8
    0x90   // 9
};

// 定义延时函数
void delay(unsigned int ms) {
    unsigned int i, j;
    for (i = 0; i < ms; i++) {
        for (j = 0; j < 120; j++);
    }
}

void main() {
    unsigned char i = 0;
    unsigned char direction = 1;  // 1表示从小到大，0表示从大到小

    // 设置P1口为输出
    P1 = 0xFF;
    while (1) 
	{
        if (key1 == 0) {  // 第一个按键按下
			delay(200);
			if(key1 == 0)
            	direction = 1;  // 从小到大
        }
        if (key2 == 0) {  // 第二个按键按下
			delay(200);
			if(key2 == 0)
            	direction = 0;  // 从大到小
        }

        if (direction) {  // 从小到大
			i=0;
            P1 = digit[i];
            i++;
            if (i == 8) {
                i = 0;
            }
        } else {  // 从大到小
			i = 8;
            P1 = digit[i];
            i--;
            if (i == 0) {
                i = 8;
            }
        }

        delay(500);  // 延时500ms
    }
}

2-

#include <reg52.h>

// 数码管显示函数
void displayDigit(unsigned char digit) {
    unsigned char digitMap[] = {
        0b00111111,  // 数字0的7段码
        0b00000110,  // 数字1的7段码
        0b01011011,  // 数字2的7段码
        0b01001111,  // 数字3的7段码
        0b01100110,  // 数字4的7段码
        0b01101101,  // 数字5的7段码
        0b01111101,  // 数字6的7段码
        0b00000111,  // 数字7的7段码
        0b01111111,  // 数字8的7段码
        0b01101111   // 数字9的7段码
    };

// 延时函数
void delay() {
    // 延时逻辑
    // ...
}

int main() {
    unsigned char number = 0; // 初始数字为0

    while (1) {
        if (P1 == 0xFE) { // 第一个按键按下
            // 从大到小变化
            for (unsigned char i = number; i >= 0; i--) {
                number = i;
                displayDigit(number);
                delay();
            }
        }

        if (P1 == 0xFD) { // 第二个按键按下
            // 从小到大变化
            for (unsigned char i = number; i <= 9; i++) {
                number = i;
                displayDigit(number);
                delay();
            }
        }
    }

    return 0;
}

用于基于51单片机实现键盘控制数码管的显示（共阳极显示）：

#include <reg51.h>

// 定义键盘引脚和数码管引脚连接方式
#define KEYPAD_PORT P1
#define DISPLAY_PORT P2

// 声明函数
void delay(unsigned int ms);
unsigned char readKeypad();
void displayDigit(unsigned char digit);

// 全局变量
unsigned char displayNumber = 0;

// 主函数
void main() {
  unsigned char key;
  
  while(1) {
    key = readKeypad(); // 检测键盘按键状态
    
    // 检测数字键
    if(key >= '0' && key <= '9') {
      displayNumber = key - '0'; // 更新显示数字
    }
    // 检测按下第一个键
    else if(key == 'A') {
      if(displayNumber > 0) {
        displayNumber--; // 更新显示数字
      }
    }
    // 检测按下第二个键
    else if(key == 'B') {
      if(displayNumber < 9) {
        displayNumber++; // 更新显示数字
      }
    }
    
    displayDigit(displayNumber); // 显示数字到数码管
  }
}

// 延时函数
void delay(unsigned int ms) {
  unsigned int i, j;
  for(i = 0; i < ms; i++) {
    for(j = 0; j < 123; j++);
  }
}

// 读取键盘状态
unsigned char readKeypad() {
  unsigned char row, col;
  
  // 设置列为输入，行为输出
  KEYPAD_PORT = 0xF0;
  P0 = 0xFF;
  
  // 检测哪一行被按下
  row = KEYPAD_PORT & 0xF0;
  
  // 如果无按键按下
  if(row == 0xF0) {
    return 0; // 返回0表示无按键按下
  }
  
  // 延时，等待按键稳定
  delay(10);
  
  // 检测列是否有响应
  col = KEYPAD_PORT & 0xF0;
  
  // 检测按下的键值
  if(col == 0xE0) return '1';
  if(col == 0xD0) return '2';
  if(col == 0xB0) return '3';
  if(col == 0x70) return 'A';
  if(col == 0xD0) return '4';
  if(col == 0xB0) return '5';
  if(col == 0x70) return '6';
  if(col == 0xE0) return 'B';
  if(col == 0xB0) return '7';
  if(col == 0x70) return '8';
  if(col == 0xE0) return '9';
  if(col == 0xD0) return '0';
  
  return 0; // 返回0表示无按键按下
}

// 数码管显示函数
void displayDigit(unsigned char digit) {
  unsigned char digitPattern;
  switch(digit) {
    case 0: digitPattern = 0xC0; break; // 共阳极的编码方式，可根据具体数码管更改
    case 1: digitPattern = 0xF9; break;
    case 2: digitPattern = 0xA4; break;
    case 3: digitPattern = 0xB0; break;
    case 4: digitPattern = 0x99; break;
    case 5: digitPattern = 0x92; break;
    case 6: digitPattern = 0x82; break;
    case 7: digitPattern = 0xF8; break;
    case 8: digitPattern = 0x80; break;
    case 9: digitPattern = 0x98; break;
    default: digitPattern = 0xFF;
  }
  
  DISPLAY_PORT = digitPattern; // 输出到数码管
}

代码：

#include <reg51.h> // 包含51单片机的寄存器定义和常量

// 定义延时函数
void delay(unsigned int time) {
  unsigned int i, j;
  for (i = 0; i < time; i++) {
    for (j = 0; j < 125; j++) {
      // 延时一段时间
    }
  }
}

void main() {
  unsigned char seg_code[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F}; // 数码管的段码值
  unsigned char keys[4][4] = {{0x01, 0x02, 0x03, 0x0F},
                              {0x04, 0x05, 0x06, 0x0E},
                              {0x07, 0x08, 0x09, 0x0D},
                              {0x00, 0x00, 0x00, 0x0C}}; // 键盘矩阵映射

  unsigned char keycode, row, col, digit;

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

  while (1) {
    for (row = 0; row < 4; row++) {
      P2 = ~(0x01 << row); // 设置当前行为低电平
      delay(10); // 延时一段时间，等待稳定

      col = P2 & 0x0F; // 获取当前列的键值

      if (col != 0x0F) { // 如果当前列有按键按下
        // 查找按下的键值
        if (col == 0x0E) {
          digit = 0; // 1键按下
        } else if (col == 0x0D) {
          digit = 1; // 2键按下
        } else if (col == 0x0B) {
          digit = 2; // 3键按下
        } else if (col == 0x07) {
          digit = 3; // 4键按下
        }

        // 显示按键对应的数字
        if (keys[row][digit] != keycode) {
          keycode = keys[row][digit];
          P0 = seg_code[keycode]; // 数码管显示对应的数字
        }
      }
    }
  }
}

上述代码中，使用P2口作为键盘的输入引脚，并通过设置相应的行和列的电平状态，来判断按下的键值。根据按下的键值，在数码管上显示对应的数字。seg_code数组中存储了数码管的段码值，keys数组中存储了键盘矩阵的映射。

基于51单片机，用c语言编程实现利用74LS164扩展并行输出口

代码：

#include <reg51.h>

// 延时函数
void delay(unsigned int time) {
  unsigned int i, j;
  for (i = 0; i < time; i++) {
    for (j = 0; j < 125; j++) {
      // 延时一段时间
    }
  }
}

// 数据写入74LS164
void writeData(unsigned char data) {
  unsigned char i;
  P1 = data; // 将数据写入P1口
  for (i = 0; i < 8; i++) {
    P2 &= ~0x02; // 将74LS164的DS引脚置低
    P2 |= 0x02; // 将74LS164的DS引脚置高，写入数据
    data >>= 1; // 数据右移1位，准备写入下一位
  }
  P2 &= ~0x01; // 将74LS164的ST_CP引脚置低
  P2 |= 0x01; // 将74LS164的ST_CP引脚置高，数据锁存到输出端口
}

void main() {
  while (1) {
    // 输出的数据
    unsigned char data = 0xFF; // 11111111

    // 将数据写入74LS164
    writeData(data);

    // 延时一段时间
    delay(100); // 延时100ms

    // 输出的数据
    data = 0x00; // 00000000

    // 将数据写入74LS164
    writeData(data);

    // 延时一段时间
    delay(100); // 延时100ms
  }
}

上述代码中，利用P2口控制74LS164扩展并行输出，通过P1口向74LS164输入数据，然后通过控制P2口的引脚（DS和ST_CP），将P1口输入的数据从74LS164并行输出端口传输到外部设备（例如LED等）。

最终：

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

sbit SDA = P1 ^ 0; //定义IIC总线数据线
sbit SCL = P1 ^ 1; //定义IIC总线时钟线

uchar code digit[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90}; //定义数码管显示的数字

void delay(uint z) //延时函数
{
    uint x, y;
    for (x = z; x > 0; x--)
        for (y = 110; y > 0; y--)
            ;
}

void write_byte(uchar dat) //写入一个字节
{
    uchar i;
    for (i = 0; i < 8; i++)
    {
        SDA = dat >> (7 - i);
        SCL = 1;
        delay(1);
        SCL = 0;
    }
}

void write_data(uchar addr, uchar dat) //写入一个字节数据到指定地址
{
    SDA = 0;
    SCL = 0;
    SCL = 1;
    write_byte(0xa0);
    SCL = 1;
    write_byte(addr);
    SCL = 1;
    write_byte(dat);
    SCL = 1;
}

void main()
{
    uchar i;
    while (1)
    {
        for (i = 0; i < sizeof(digit); i++)
        {
            write_data(i + 1, digit[i]);
            delay(100);
        }
    }
}

74LS164 是一个 8 位串行输入并行输出的移位寄存器，可以用来扩展单片机的输出口。下面是一个基于 51 单片机，用 C 语言编程实现利用 74LS164 扩展并行输出口的例子：

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

sbit DS=P2^0;
sbit SHCP=P2^1;
sbit STCP=P2^2;

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

void main()
{
    uchar i;
    while(1)
    {
        for(i=0;i<8;i++)
        {
            DS=0;
            SHCP=0;
            SHCP=1;
            DS=(P1>>i)&0x01;
            SHCP=0;
        }
        STCP=1;
        STCP=0;
        delay(100);
    }
}

在这个例子中，使用了三个 IO 口来控制 74LS164。DS 口用来输入数据，SHCP 口用来控制数据的移位，STCP 口用来控制数据的锁存。
在主函数中，使用一个循环来控制数据的输出。首先将 DS 口置为低电平，然后将 SHCP 口置为低电平。接着将 SHCP 口置为高电平，然后将 DS 口设置为需要输出的数据。最后将 SHCP 口置为低电平。这样就完成了一次数据的移位。
当移位完成后，将 STCP 口置为高电平，然后再置为低电平。这样就完成了一次数据的锁存。

这个例子中，使用了三个 IO 口来控制 74LS164。DS 口用来输入数据，SHCP 口用来控制数据的移位，STCP 口用来控制数据的锁存。
在主函数中，使用一个循环来控制数据的输出。首先将 DS 口置为低电平，然后将 SHCP 口置为低电平。接着将 SHCP 口置为高电平，然后将 DS 口设置为需要输出的数据。最后将 SHCP 口置为低电平。这样就完成了一次数据的移位。
当移位完成后，将 STCP 口置为高电平，然后再置为低电平。这样就完成了一次数据的锁存。
在这个例子中，使用了 74LS164 来扩展单片机的输出口。DS 口用来输入数据，SHCP 口用来控制数据的移位，STCP 口用来控制数据的锁存。在主函数中，使用一个循环来控制数据的输出。首先将 DS 口置为低电平，然后将 SHCP 口置为低电平。接着将 SHCP 口置为高电平，然后将 DS 口设置为需要输出的数据。最后将 SHCP 口置为低电平。这样就完成了一次数据的移位。当移位完成后，将 STCP 口置为高电平，然后再置为低电平。这样就完成了一次数据的锁存。

基于51单片机，用c语言编程实现定时中断方式驱动一个数码管

方一：

1--

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

sbit SDA = P1 ^ 0; //定义IIC总线数据线
sbit SCL = P1 ^ 1; //定义IIC总线时钟线

uchar code digit[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90}; //定义数码管显示的数字

void delay(uint z) //延时函数
{
    uint x, y;
    for (x = z; x > 0; x--)
        for (y = 110; y > 0; y--)
            ;
}

void write_byte(uchar dat) //写入一个字节
{
    uchar i;
    for (i = 0; i < 8; i++)
    {
        SDA = dat >> (7 - i);
        SCL = 1;
        delay(1);
        SCL = 0;
    }
}

void write_data(uchar addr, uchar dat) //写入一个字节数据到指定地址
{
    SDA = 0;
    SCL = 0;
    SCL = 1;
    write_byte(0xa0);
    SCL = 1;
    write_byte(addr);
    SCL = 1;
    write_byte(dat);
    SCL = 1;
}

void timer() interrupt 1 //定时器中断函数
{
    static uchar cnt = 0; //静态变量，只初始化一次，每次调用保留上次的值
    TH0 = (65536 - 50000) / 256; //重新赋初值，定时50ms
    TL0 = (65536 - 50000) % 256;
    cnt++;
    if (cnt == sizeof(digit))
        cnt = 0;
    write_data(cnt + 1, digit[cnt]); //显示下一个数字
}

void main()
{
    TMOD |= 0x01; //设置定时器T0为模式1（16位自动重装载）
    TH0 = (65536 - 50000) / 256; //赋初值，定时50ms
    TL0 = (65536 - 50000) % 256;
    ET0 = 1; //开启定时器T0中断
    EA = 1; //开启总中断
    TR0 = 1; //启动定时器T0

    while (1)
        ;
}

2--

代码：

#include <reg51.h>

// 数码管显示表，从0到9
unsigned char displayTable[] = {
  0xC0,   // 0
  0xF9,   // 1
  0xA4,   // 2
  0xB0,   // 3
  0x99,   // 4
  0x92,   // 5
  0x82,   // 6
  0xF8,   // 7
  0x80,   // 8
  0x90    // 9
};

// 共阴极数码管引脚连接的IO口
sbit digit1 = P1^0;  // 第一位数码管
sbit digit2 = P1^1;  // 第二位数码管
sbit digit3 = P1^2;  // 第三位数码管
sbit digit4 = P1^3;  // 第四位数码管

// 数码管显示的值
volatile unsigned char displayValue = 0;

// 定时器中断处理函数
void timerInterrupt() interrupt 1 {
  static unsigned char digit = 0;  // 当前显示的位数
  
  // 设置当前要显示的数码管
  switch (digit) {
    case 0:
      digit1 = 1;
      digit2 = 0;
      digit3 = 0;
      digit4 = 0;
      P0 = displayTable[displayValue % 10];  // 显示个位数
      break;
    case 1:
      digit1 = 0;
      digit2 = 1;
      digit3 = 0;
      digit4 = 0;
      P0 = displayTable[displayValue / 10 % 10];  // 显示十位数
      break;
    case 2:
      digit1 = 0;
      digit2 = 0;
      digit3 = 1;
      digit4 = 0;
      P0 = displayTable[displayValue / 100 % 10];  // 显示百位数
      break;
    case 3:
      digit1 = 0;
      digit2 = 0;
      digit3 = 0;
      digit4 = 1;
      P0 = displayTable[displayValue / 1000];  // 显示千位数
      break;
  }
  
  digit++;  // 切换到下一个要显示的数码管
  if (digit >= 4) {
    digit = 0;
  }
}

void main() {
  TMOD = 0x01;      // 设置定时器0为模式1
  TH0 = 0xFC;      // 设置定时器0的初值，定时100us
  TL0 = 0x67;
  ET0 = 1;         // 允许定时器0中断
  EA = 1;          // 允许总中断
  TR0 = 1;         // 启动定时器0
  
  while (1) {
    // 更新数码管显示的值，可以通过其他方式改变displayValue的值
    // 这里只简单地每隔一段时间递增displayValue，模拟数码管的显示
    displayValue++;
    if (displayValue > 9999) {
      displayValue = 0;
    }
  }
}

上述代码中，使用定时器0和定时中断驱动数码管的显示，通过计时中断的方式实现数码管的动态显示。其中，P0口用于连接数码管对应的引脚，需要根据实际连接情况进行修改。数码管共阴极连接的IO口通过sbit定义，根据具体的引脚连接情况进行修改。

定时器0的初始值根据实际需求进行调整，设置定时器0的初值和模式来控制定时器中断的频率。在定时器中断处理函数中，根据当前要显示的数码管位数和显示的值，设置对应的IO口和数码管段码进行显示。

方法二：

代码：

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

uchar code table[]={
    0x3f,0x06,0x5b,0x4f,
    0x66,0x6d,0x7d,0x07,
    0x7f,0x6f,0x77,0x7c,
    0x39,0x5e,0x79,0x71
};

uchar num=0;
uint cnt=0;

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

void main()
{
    TMOD=0x01;
    TH0=(65536-45872)/256;
    TL0=(65536-45872)%256;
    EA=1;
    ET0=1;
    TR0=1;
    while(1)
    {
        P1=table[num];
        delay(100);
        P1=0xff;
        delay(100);
    }
}

void timer_0() interrupt 1
{
    TH0=(65536-45872)/256;
    TL0=(65536-45872)%256;
    cnt++;
    if(cnt==100)
    {
        cnt=0;
        num++;
        if(num==16)
            num=0;
    }
}

这个例子使用定时器 T0 的中断实现长时间定时，驱动一个数码管。在这个例子中，使用了一个计数器 cnt 来计算定时器 T0 中断的次数，当计数器 cnt 等于 100 时，就将计数器清零，并将 num 加一。当 num 等于 16 时，将 num 清零。在主函数中，使用 P1 来控制数码管的显示。

首先，需要了解一下 51 单片机的定时器。51 单片机有两个定时器，分别是定时器 T0 和定时器 T1。这两个定时器都可以用来产生中断。
在这个例子中，使用了定时器 T0 来产生中断。在主函数中，首先设置了定时器 T0 的工作模式为模式 1（TMOD=0x01），这表示定时器 T0 工作在 16 位自动重装载模式。然后设置了定时器 T0 的初值（TH0 和 TL0）为 (65536-45872)，这样就可以让定时器 T0 每隔一段时间产生一次中断。
在主函数的 while 循环中，使用 P1 来控制数码管的显示。每隔一段时间，就将 num 加一，并将 num 显示在数码管上。当 num 等于 16 时，将 num 清零。
在 timer_0() 函数中，首先重新设置了定时器 T0 的初值（TH0 和 TL0），然后将计数器 cnt 加一。当计数器 cnt 等于 100 时，就将计数器清零，并将 num 加一。当 num 等于 16 时，将 num 清零。

使用定时中断方式驱动一个数码管

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

sbit SDA = P1 ^ 0; //定义IIC总线数据线
sbit SCL = P1 ^ 1; //定义IIC总线时钟线

uchar code digit[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90}; //定义数码管显示的数字

void delay(uint z) //延时函数
{
    uint x, y;
    for (x = z; x > 0; x--)
        for (y = 110; y > 0; y--)
            ;
}

void write_byte(uchar dat) //写入一个字节
{
    uchar i;
    for (i = 0; i < 8; i++)
    {
        SDA = dat >> (7 - i);
        SCL = 1;
        delay(1);
        SCL = 0;
    }
}

void write_data(uchar addr, uchar dat) //写入一个字节数据到指定地址
{
    SDA = 0;
    SCL = 0;
    SCL = 1;
    write_byte(0xa0);
    SCL = 1;
    write_byte(addr);
    SCL = 1;
    write_byte(dat);
    SCL = 1;
}

void timer() interrupt 1 //定时器中断函数
{
    static uchar cnt = 0; //静态变量，只初始化一次，每次调用保留上次的值
    TH0 = (65536 - 50000) / 256; //重新赋初值，定时50ms
    TL0 = (65536 - 50000) % 256;
    cnt++;
    if (cnt == sizeof(digit))
        cnt = 0;
    write_data(cnt + 1, digit[cnt]); //显示下一个数字
}

void main()
{
    TMOD |= 0x01; //设置定时器T0为模式1（16位自动重装载）
    TH0 = (65536 - 50000) / 256; //赋初值，定时50ms
    TL0 = (65536 - 50000) % 256;
    ET0 = 1; //开启定时器T0中断
    EA = 1; //开启总中断
    TR0 = 1; //启动定时器T0

    while (1)
        ;
}

关注

6
点赞
踩
44

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

打赏作者

captain_dong 你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。