// 51单片机 GPIO 输出高电平
P1_0 = 1;  // 或 P1 |= 0x01;
// 此时 P1.0 引脚电压 ≈ 5V

// 输出低电平
P1_0 = 0;  // 或 P1 &= ~0x01;
// 此时 P1.0 引脚电压 ≈ 0V

#include <reg52.h>

sbit LED = P1^0;  // 定义 P1.0 为 LED 控制引脚

void delay_ms(unsigned int ms) {
    unsigned int i, j;
    for(i = ms; i > 0; i--)
        for(j = 110; j > 0; j--);  // 12MHz 晶振约 1ms
}

void main() {
    while(1) {
        LED = 0;  // 输出低电平 → LED 亮（共阳极接法）
        delay_ms(500);
        LED = 1;  // 输出高电平 → LED 灭
        delay_ms(500);
    }
}

#include <reg52.h>

sbit KEY = P3^2;   // 按键接 P3.2
sbit LED = P1^0;   // LED 接 P1.0

void main() {
    KEY = 1;  // 设置为输入（写1使能内部上拉）

    while(1) {
        if(KEY == 0) {    // 按键按下（低电平）
            LED = 0;      // 点亮 LED
        } else {          // 按键松开（高电平）
            LED = 1;      // 熄灭 LED
        }
    }
}

#include <reg52.h>

void uart_init() {
    SCON = 0x50;   // 8位数据，可变波特率
    TMOD |= 0x20;  // 定时器1，模式2（自动重装）
    TH1 = 0xFD;    // 波特率 9600（11.0592MHz 晶振）
    TL1 = 0xFD;
    TR1 = 1;       // 启动定时器1
}

void uart_send(unsigned char dat) {
    SBUF = dat;
    while(!TI);    // 等待发送完成
    TI = 0;        // 清除发送标志
}

void main() {
    uart_init();
    while(1) {
        uart_send(0x55);  // 发送 0b01010101（方波）
        // 可用示波器观察 TXD (P3.1) 引脚波形
    }
}

// 方式1：整体操作
P1 = 0x00;        // P1 口全部输出低电平
P1 = 0xFF;        // P1 口全部输出高电平
P1 = 0x0F;        // P1.0-P1.3 高，P1.4-P1.7 低

// 方式2：位操作（需要 sbit 定义）
sbit LED = P1^0;  // 定义 P1.0
LED = 0;          // P1.0 输出低电平
LED = 1;          // P1.0 输出高电平

// 方式3：位运算
P1 |= 0x01;       // P1.0 置 1，其他位不变
P1 &= ~0x01;      // P1.0 置 0，其他位不变
P1 ^= 0x01;       // P1.0 取反，其他位不变

void uart_init() {
    SCON = 0x50;   // 模式1（SM0=0,SM1=1），允许接收（REN=1）
    TMOD &= 0x0F;  // 清除定时器1设置
    TMOD |= 0x20;  // 定时器1，模式2（8位自动重装）
    TH1 = 0xFD;    // 波特率 9600（11.0592MHz）
    TL1 = 0xFD;    // 初值
    TR1 = 1;       // 启动定时器1
    ES = 1;        // 使能串口中断（可选）
    EA = 1;        // 使能总中断（可选）
}

void timer0_init() {
    TMOD &= 0xF0;  // 清除定时器0设置
    TMOD |= 0x01;  // 定时器0，模式1（16位）
    TH0 = 0xFC;    // 初值高8位
    TL0 = 0x66;    // 初值低8位
    TR0 = 1;       // 启动定时器0
    ET0 = 1;       // 使能定时器0中断
    EA = 1;        // 使能总中断
}

// 定时器0中断服务函数
void timer0_isr() interrupt 1 {
    TH0 = 0xFC;    // 重装初值
    TL0 = 0x66;
    // 每 1ms 执行一次的代码
}

// 外部中断0（按键触发）
void int0_isr() interrupt 0 {
    // 处理代码
}

// 定时器0中断
void timer0_isr() interrupt 1 {
    TH0 = 0xFC; TL0 = 0x66;  // 重装初值
}

// 串口中断
void uart_isr() interrupt 4 {
    if(RI) {                  // 接收中断
        unsigned char dat = SBUF;
        RI = 0;               // 清标志
    }
    if(TI) {                  // 发送中断
        TI = 0;               // 清标志
    }
}

sbit CE   = P3^5;
sbit IO   = P3^4;
sbit SCLK = P3^6;

// 写一个字节（对照时序图理解）
void ds1302_write_byte(unsigned char dat) {
    unsigned char i;
    for(i = 0; i < 8; i++) {
        IO = dat & 0x01;   // ① 取最低位放到 I/O 线
        SCLK = 1;          // ② 上升沿，DS1302 采样
        SCLK = 0;          // ③ 为下一位做准备
        dat >>= 1;         // ④ 右移，准备下一位
    }
}

// 十进制 → BCD（写入 DS1302 前转换）
unsigned char dec_to_bcd(unsigned char dec) {
    return ((dec / 10) << 4) | (dec % 10);
}

// BCD → 十进制（从 DS1302 读出后转换）
unsigned char bcd_to_dec(unsigned char bcd) {
    return (bcd >> 4) * 10 + (bcd & 0x0F);
}

#include <reg52.h>

sbit CE   = P3^5;
sbit IO   = P3^4;
sbit SCLK = P3^6;

// 写一个字节
void ds1302_write_byte(unsigned char dat) {
    unsigned char i;
    for(i = 0; i < 8; i++) {
        IO = dat & 0x01;
        SCLK = 1; SCLK = 0;
        dat >>= 1;
    }
}

// 读一个字节
unsigned char ds1302_read_byte() {
    unsigned char i, dat = 0;
    for(i = 0; i < 8; i++) {
        dat >>= 1;
        if(IO) dat |= 0x80;
        SCLK = 1; SCLK = 0;
    }
    return dat;
}

// 写寄存器
void ds1302_write(unsigned char addr, unsigned char dat) {
    CE = 0; SCLK = 0;
    CE = 1;
    ds1302_write_byte(addr);  // 发命令
    ds1302_write_byte(dat);   // 发数据
    CE = 0;
}

// 读寄存器
unsigned char ds1302_read(unsigned char addr) {
    unsigned char dat;
    CE = 0; SCLK = 0;
    CE = 1;
    ds1302_write_byte(addr | 0x01);  // 发读命令
    dat = ds1302_read_byte();
    CE = 0;
    return dat;
}

// 使用示例
void main() {
    unsigned char hour, min, sec;

    ds1302_write(0x8E, 0x00);  // 关闭写保护
    ds1302_write(0x80, 0x00);  // 秒=0，启动时钟
    ds1302_write(0x82, 0x30);  // 分=30
    ds1302_write(0x84, 0x12);  // 时=12
    ds1302_write(0x8E, 0x80);  // 开启写保护

    while(1) {
        sec  = ds1302_read(0x81);  // 读秒（BCD）
        min  = ds1302_read(0x83);  // 读分（BCD）
        hour = ds1302_read(0x85);  // 读时（BCD）
        // 显示到数码管（需转成十进制）
    }
}

#include <reg52.h>

// UART 初始化（9600bps，11.0592MHz 晶振）
void uart_init() {
    SCON = 0x50;   // 模式1，8位数据，允许接收
    TMOD &= 0x0F;  // 清除定时器1设置
    TMOD |= 0x20;  // 定时器1，模式2（自动重装）
    TH1 = 0xFD;    // 波特率 9600
    TL1 = 0xFD;
    TR1 = 1;       // 启动定时器1
}

// 发送一个字节
void uart_send_byte(unsigned char dat) {
    SBUF = dat;       // 数据放入发送缓冲区
    while(!TI);       // 等待发送完成
    TI = 0;           // 清除发送标志
}

// 发送字符串
void uart_send_string(char *str) {
    while(*str) {
        uart_send_byte(*str++);
    }
}

// 接收一个字节（查询方式）
unsigned char uart_recv_byte() {
    while(!RI);       // 等待接收完成
    RI = 0;           // 清除接收标志
    return SBUF;      // 返回接收数据
}

void main() {
    uart_init();
    uart_send_string("Hello, 51!\r\n");

    while(1) {
        unsigned char ch = uart_recv_byte();
        uart_send_byte(ch);  // 回显
    }
}

#include <STC15F2K60S2.H>
#include <stdio.h>

// UART 初始化（9600bps，12MHz，使用定时器2）
void Uart1_Init(void) {
    SCON = 0x50;      // 8位数据，可变波特率
    AUXR |= 0x01;     // 串口1选择定时器2为波特率发生器
    AUXR &= 0xFB;     // 定时器时钟12T模式
    T2L = 0xE6;       // 设定定时初始值
    T2H = 0xFF;       // 设定定时初始值
    AUXR |= 0x10;     // 定时器2开始计时
    ES = 1;           // 使能串口1中断
    EA = 1;           // 开总中断
}

/*=====================================================
 * 串口重定向 - 核心代码
 * 重写 putchar 函数，使 printf 输出到串口
 *====================================================*/
extern char putchar(char ch)
{
    SBUF = ch;        // 将字符写入发送缓冲区
    while(TI == 0);   // 等待发送完成（TI=1 表示发送完毕）
    TI = 0;           // 手动清除发送完成标志
    return ch;        // 返回发送的字符（标准要求）
}

void main() {
    unsigned char count = 0;

    Uart1_Init();

    printf("System Start!\r\n");

    while(1) {
        printf("Count: %bu\r\n", count++);  // %bu 是 Keil 特有格式
        // 延时...
    }
}

/*=====================================================
 * 带超时保护的串口重定向
 * 避免硬件故障时程序卡死
 *====================================================*/
extern int putchar(int ch)
{
    unsigned int timeout = 10000;  // 超时计数

    SBUF = ch;
    while(TI == 0) {
        if(--timeout == 0)
            return EOF;  // 超时返回错误（EOF = -1）
    }
    TI = 0;
    return ch;  // 成功返回字符
}

// 使用示例
void debug_print() {
    int result = printf("Test\r\n");
    if(result < 0) {
        // 发送失败处理...
    }
}

#include <reg52.h>

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

// 精确延时（12MHz 晶振，约 5μs）
#define I2C_DELAY() {_nop_();_nop_();_nop_();_nop_();_nop_();}

// 返回值定义
#define I2C_ACK  0    // 收到应答
#define I2C_NACK 1    // 未收到应答

//========== 底层时序函数 ==========

// 起始条件：SCL 高时，SDA 下降沿
void i2c_start(void) {
    SDA = 1;
    SCL = 1;
    I2C_DELAY();
    SDA = 0;        // 关键：SCL 高时 SDA 下降
    I2C_DELAY();
    SCL = 0;        // 钳住总线，准备传输
}

// 停止条件：SCL 高时，SDA 上升沿
void i2c_stop(void) {
    SDA = 0;        // 确保 SDA 为低
    SCL = 1;
    I2C_DELAY();
    SDA = 1;        // 关键：SCL 高时 SDA 上升
    I2C_DELAY();
}

// 发送一个字节，返回 ACK 状态（0=有应答，1=无应答）
unsigned char i2c_send_byte(unsigned char dat) {
    unsigned char i, ack;
    for(i = 0; i < 8; i++) {
        SDA = (dat & 0x80) ? 1 : 0;  // MSB 先发
        dat <<= 1;
        I2C_DELAY();
        SCL = 1;
        I2C_DELAY();
        SCL = 0;
    }
    SDA = 1;        // 释放 SDA，准备读 ACK
    I2C_DELAY();
    SCL = 1;
    I2C_DELAY();
    ack = SDA;      // 读取 ACK：0=从机应答，1=无应答
    SCL = 0;
    return ack;
}

// 接收一个字节，send_ack=1 发送 ACK，send_ack=0 发送 NACK
unsigned char i2c_recv_byte(unsigned char send_ack) {
    unsigned char i, dat = 0;
    SDA = 1;        // 释放 SDA，准备读数据
    for(i = 0; i < 8; i++) {
        SCL = 1;
        I2C_DELAY();
        dat <<= 1;
        if(SDA) dat |= 0x01;  // MSB 先收
        SCL = 0;
        I2C_DELAY();
    }
    // 发送应答位
    SDA = send_ack ? 0 : 1;   // send_ack=1 发 ACK（拉低），=0 发 NACK（保持高）
    I2C_DELAY();
    SCL = 1;
    I2C_DELAY();
    SCL = 0;
    SDA = 1;        // 释放 SDA
    return dat;
}

//========== 应用层函数（带错误检测）==========

// 向设备寄存器写一个字节，返回 0=成功
unsigned char i2c_write_reg(unsigned char addr, unsigned char reg, unsigned char dat) {
    i2c_start();
    if(i2c_send_byte(addr << 1)) {     // 地址 + 写位(0)
        i2c_stop();
        return 1;   // 设备无响应
    }
    if(i2c_send_byte(reg)) {            // 寄存器地址
        i2c_stop();
        return 2;   // 寄存器地址 NACK
    }
    if(i2c_send_byte(dat)) {            // 写入数据
        i2c_stop();
        return 3;   // 数据 NACK
    }
    i2c_stop();
    return 0;       // 成功
}

// 从设备寄存器读一个字节
unsigned char i2c_read_reg(unsigned char addr, unsigned char reg) {
    unsigned char dat;
    i2c_start();
    i2c_send_byte(addr << 1);           // 地址 + 写位(0)
    i2c_send_byte(reg);                  // 寄存器地址
    i2c_start();                         // 重复起始条件（不发 Stop）
    i2c_send_byte((addr << 1) | 1);     // 地址 + 读位(1)
    dat = i2c_recv_byte(0);              // 读数据，发 NACK 表示结束
    i2c_stop();
    return dat;
}

// 连续读多个字节（适用于传感器批量读取）
void i2c_read_bytes(unsigned char addr, unsigned char reg,
                    unsigned char *buf, unsigned char len) {
    unsigned char i;
    i2c_start();
    i2c_send_byte(addr << 1);
    i2c_send_byte(reg);
    i2c_start();
    i2c_send_byte((addr << 1) | 1);
    for(i = 0; i < len; i++) {
        // 最后一个字节发 NACK，其余发 ACK
        buf[i] = i2c_recv_byte(i < len - 1);
    }
    i2c_stop();
}

// AT24C02 设备地址（A2A1A0 引脚全接 GND → 地址 = 0x50）
#define AT24C02_ADDR  0x50

// 毫秒延时（12MHz 晶振）
void delay_ms(unsigned int ms) {
    unsigned int i, j;
    for(i = 0; i < ms; i++)
        for(j = 0; j < 120; j++);
}

// 写一个字节到 AT24C02
// mem_addr: EEPROM 内部地址（0x00~0xFF，共 256 字节）
// dat:      要写入的数据
// 返回：0=成功，非0=失败
unsigned char at24c02_write_byte(unsigned char mem_addr, unsigned char dat) {
    unsigned char ret = i2c_write_reg(AT24C02_ADDR, mem_addr, dat);
    delay_ms(10);   // ⚠️ 关键！AT24C02 内部写操作最长 5ms，写完必须等待
    return ret;
}

// 从 AT24C02 读一个字节
unsigned char at24c02_read_byte(unsigned char mem_addr) {
    return i2c_read_reg(AT24C02_ADDR, mem_addr);
}

// 主函数：写入数据后读回验证
void main(void) {
    unsigned char wdata = 0xA5;   // 要写入的测试数据
    unsigned char rdata;

    at24c02_write_byte(0x00, wdata);    // 写入地址 0x00
    rdata = at24c02_read_byte(0x00);    // 从地址 0x00 读回

    if(rdata == wdata) {
        P1 = 0x00;   // 读写一致 → LED 全亮（成功）
    } else {
        P1 = 0xFF;   // 读写不一致 → LED 全灭（失败，检查接线/延时）
    }
    while(1);
}

#include <reg52.h>

sbit SCK  = P1^5;
sbit MOSI = P1^6;
sbit MISO = P1^7;
sbit CS   = P1^4;

// SPI 发送并接收一个字节（全双工）
unsigned char spi_transfer(unsigned char dat) {
    unsigned char i, recv = 0;
    for(i = 0; i < 8; i++) {
        MOSI = (dat & 0x80) ? 1 : 0;  // MSB 先发
        dat <<= 1;
        SCK = 1;                       // 上升沿
        recv <<= 1;
        if(MISO) recv |= 0x01;         // 采样 MISO
        SCK = 0;                       // 下降沿
    }
    return recv;
}

// 写寄存器
void spi_write_reg(unsigned char reg, unsigned char dat) {
    CS = 0;                   // 片选
    spi_transfer(reg);        // 发送寄存器地址
    spi_transfer(dat);        // 发送数据
    CS = 1;                   // 取消片选
}

// 读寄存器
unsigned char spi_read_reg(unsigned char reg) {
    unsigned char dat;
    CS = 0;
    spi_transfer(reg | 0x80); // 最高位=1 表示读
    dat = spi_transfer(0xFF); // 发送空数据，接收返回值
    CS = 1;
    return dat;
}

#include <reg52.h>

sbit DQ = P3^7;

void delay_us(unsigned int us) {
    while(us--);
}

// 复位并检测存在
unsigned char ds18b20_reset() {
    unsigned char presence;
    DQ = 0;
    delay_us(480);    // 拉低 480μs
    DQ = 1;
    delay_us(60);     // 等待
    presence = DQ;    // 读取存在脉冲（0=设备存在）
    delay_us(420);    // 等待复位完成
    return presence;
}

// 写一个字节
void ds18b20_write_byte(unsigned char dat) {
    unsigned char i;
    for(i = 0; i < 8; i++) {
        DQ = 0;
        delay_us(2);
        DQ = dat & 0x01;  // LSB 先发
        delay_us(60);
        DQ = 1;
        dat >>= 1;
    }
}

// 读一个字节
unsigned char ds18b20_read_byte() {
    unsigned char i, dat = 0;
    for(i = 0; i < 8; i++) {
        DQ = 0;
        delay_us(2);
        DQ = 1;
        delay_us(8);
        dat >>= 1;
        if(DQ) dat |= 0x80;
        delay_us(50);
    }
    return dat;
}

// 读取温度（返回 0.1℃ 为单位）
int ds18b20_read_temp() {
    unsigned char LSB, MSB;
    int temp;

    ds18b20_reset();
    ds18b20_write_byte(0xCC);  // 跳过 ROM
    ds18b20_write_byte(0x44);  // 启动温度转换

    delay_us(750);  // 等待转换完成（约 750ms）

    ds18b20_reset();
    ds18b20_write_byte(0xCC);  // 跳过 ROM
    ds18b20_write_byte(0xBE);  // 读取暂存器

    LSB = ds18b20_read_byte();
    MSB = ds18b20_read_byte();

    temp = (MSB << 8) | LSB;
    return temp * 10 / 16;  // 转换为 0.1℃
}