基于 C51 单片机的经典俄罗斯方块：8*8 点阵屏 + 矩阵键盘的全流程实现详解【实时控制与状态机设计】 #

//列选信号数组，依次选中第1-4列
static unsigned char idata ColPins[] = {0x08, 0x04, 0x02, 0x01};
//按键值映射表
static unsigned char idata KeyMap[4][4] = {
    {1 ,  2,  3,  4},
    {5 ,  6,  7,  8},
    {9 , 10, 11, 12},
    {13, 14, 15, 16}
};

static unsigned char idata keyState[4][4] = {0};  				//按键状态 0-未按下 1-按下
static unsigned char idata keyDebounce[4][4] = {0};				//消抖计数
static unsigned char currentKey = 0;       						//当前按键值
static unsigned char scanCol = 0;         						//当前扫描列

/**
 * @brief  定时器中断中调用的键盘扫描函数
 * @param  无
 * @retval 无
 */
void NonBlockKey_Scan(void) {
    unsigned char row, rowVal;
    
    //先将所有列置高，再将当前列置低
    P1 = 0xFF;
    P1 &= ~ColPins[scanCol];
    
    //读取行状态
    rowVal = (P1 >> 4) & 0x0F; // 取P1_7-P1_4的值
    
    //检测每一行
    for(row = 0; row < 4; row++) {
        if(!(rowVal & (1 << (3 - row)))) {
            //按键按下，增加消抖计数
            if(keyDebounce[row][scanCol] < 10) {
                keyDebounce[row][scanCol]++;
                //消抖计数达到阈值，确认按键按下
                if(keyDebounce[row][scanCol] == 10) {
                    keyState[row][scanCol] = 1;
                    currentKey = KeyMap[row][scanCol];
                }
            }
        } else {
            //按键未按下，重置消抖计数和状态
            if(keyDebounce[row][scanCol] > 0) {
                keyDebounce[row][scanCol]--;
                if(keyDebounce[row][scanCol] == 0) {
                    keyState[row][scanCol] = 0;
                }
            }
        }
    }
    
    //切换到下一列
    scanCol = (scanCol + 1) % 4;
}

/**
 * @brief  获取当前按键值（非阻塞，仅返回一次有效按键）
 * @param  无
 * @retval 按键值（1~16，无按键时返回 0）
 */
unsigned char NonBlockKey_GetKey(void) {
    unsigned char temp = currentKey;
    currentKey = 0;  // 读取后清除，确保只获取一次
    return temp;
}

/**
 * @brief  向74HC595写入一个字节
 * @param  Byte 要写入的字节
 * @retval 无
 */
void MatrixLED_WriteByte(unsigned char Byte)
{
    unsigned char i;
    for(i = 0; i < 8; i++)
    {
        SER = Byte & (0x80 >> i);  // 取出当前位数据
        SCK = 1;                   // 移位时钟线拉高，数据移入
        SCK = 0;                   // 移位时钟线拉低，准备下一次移位
    }
    RCK = 1;                       // 存储时钟线拉高，数据输出
    RCK = 0;                       // 存储时钟线拉低，准备下一次输出
}

/**
 * @brief  显示点阵屏的一列数据
 * @param  Column 列号，范围0-7，0为最左边
 * @param  Data 列数据，高位在上，低位在下，1为亮，0为灭
 * @retval 无
 */
void MatrixLED_ShowColumn(unsigned char Column, unsigned char Data)
{
    MatrixLED_WriteByte(Data);               // 写入列数据
    MATRIX_LED_PORT = ~(0x80 >> Column);     // 选择列（低电平有效）
    Delay1ms(1);                             // 延时1ms，保证亮度
    MATRIX_LED_PORT = 0xFF;                  // 关闭所有列，防止串扰
}

/**
 * @brief  显示一帧完整的点阵图像
 * @param  Frame 指向图像数据的指针，包含8个字节，每个字节代表一列
 * @retval 无
 */
void MatrixLED_ShowFrame(unsigned char *Frame)
{
    unsigned char i;
    for(i = 0; i < 8; i++)
    {
        MatrixLED_ShowColumn(i, Frame[i]);
    }
}

//定时器中断函数
void Timer0_Routine() interrupt 1{
    static unsigned int T0Count;
    static unsigned int animCount;
    
    //重新赋初值保证计时为1ms
    TL0 = 0x66;				//设置定时初始值
    TH0 = 0xFC;				//设置定时初始值
    
    //键盘扫描（每1ms扫描一次）
    NonBlockKey_Scan();
    
    if(isGameOver){
        //游戏结束时更新动画计数器
        animCount++;
        if(animCount >= 200){  //约200ms切换一次状态
            animCount = 0;
            gameOverAnimState = ~gameOverAnimState;
        }
    }else{
        //正常游戏时处理方块下落
        T0Count++;
        if (T0Count >= Score_GetFallInterval()){
            T0Count = 0; //初始化计数
            blockFallFlag = 1; //置位下落标志
        }
    }
}

// 模块内部变量（私有）
static unsigned int score = 0;          // 积分值
static unsigned int fallInterval = 1000; // 初始下落间隔1000ms

/**
 * @brief 初始化积分系统
 */
void Score_Init() {
    score = 0;
    fallInterval = 1000;
}

/**
 * @brief 根据消除行数增加积分
 * @param lines 消除的行数（1-3）
 */
void Score_Add(unsigned char lines) {
    // 积分规则：多消行奖励递增
    switch(lines) {
        case 1: score += 1; break;
        case 2: score += 3; break;
        case 3: score += 6; break;
    }
    // 限制最大积分（防止溢出）
    if(score > 9999) score = 9999;
    // 更新难度（下落速度）
    Score_GetFallInterval();
}

/**
 * @brief 根据积分计算下落间隔（难度曲线）
 * @return 下落间隔（ms），最低200ms
 */
unsigned int Score_GetFallInterval() {
    // 每增加10分，速度提升100ms（原初始间隔1000ms保持不变）
    unsigned int newInterval = 1000 - (score / 10) * 100;
    // 限制最低间隔为200ms，保持原样
    fallInterval = (newInterval < 200) ? 200 : newInterval;
    return fallInterval;
}
    

/**
 * @brief  初始化游戏状态
 * @param  无
 * @retval 无
 */
void GameInit(){
		unsigned char col, row;
    isGameOver = 0;
    isPaused = 0;
    gameOverAnimCount = 0;
    gameOverAnimState = 0;
		Score_Init();				//积分系统初始化
    Timer0Init();					//定时器初始化
    MatrixLED_Init();				//8*8点阵屏初始化
    srand(TH0);						//以定时器初始值作为随机数种子
    
    //清空游戏区域
    for(col = 0; col < GAME_WIDTH; col++){
        for(row = 0; row < GAME_HEIGHT; row++){
            gameArea[col][row] = 0;
        }
    }
    
    //初始化方块生成
    curBlockType = rand() % 4;
    curRotate = rand() % 4;
    curX = 3;			//X初值
    curY = 7;			//Y初值
    nextBlockType = rand() % 4;
}

void main(){
    //游戏初始化
    GameInit();
    
    //游戏主循环
    while(1){
        //处理定时下落
        if(blockFallFlag == 1){
            blockFallFlag = 0;
            BlockFall();
        }
        
        //处理键盘输入
        key = NonBlockKey_GetKey();  //使用非阻塞键盘函数
        if(key != 0){
            if(isGameOver){
                //游戏结束时，按16号键重新开始
                if(key == 16){
                    ResetGame();
                }
            }else{
                HandleKeyInput(key);
            }
        }
        
        //绘制画面
        if(isGameOver){
            GameOverAnimation();
        }else{
            DrawGame();
        }
    }
}

/**
 * @brief  处理方块下落逻辑
 * @param  无
 * @retval 无
 */
void BlockFall(){
    if(isGameOver || isPaused){  //游戏结束或暂停时不处理
        return;
    }
    
    //计算下落后的Y坐标
    newY = curY - 1;
    
    if(!CheckCollision(curX, newY)){  //无碰撞，允许下落
        curY = newY;
    }else{  //有碰撞，固定当前方块并生成新方块
        FixBlock();
        ClearFullLines();  //检查并消除已满的行
        GenerateNewBlock();
    }
}

/**
 * @brief  方块左移
 * @param  无
 * @retval 无
 */
void BlockMoveLeft(){
    if(isGameOver || isPaused) return;  //游戏结束或暂停时不响应
    newX = curX - 1;      //计算左移后的X坐标
    if(!CheckCollision(newX, curY)){    //检测无碰撞则移动
        curX = newX;
    }
}

/**
 * @brief  方块右移
 * @param  无
 * @retval 无
 */
void BlockMoveRight(){
    if(isGameOver || isPaused) return;
    newX = curX + 1;      //计算右移后的X坐标
    if(!CheckCollision(newX, curY)){    //检测无碰撞则移动
        curX = newX;
    }
}

/**
 * @brief  方块下移
 * @param  无
 * @retval 无
 */
void BlockMoveDown(){
    if(isGameOver || isPaused) return;
    newY = curY - 1;      //计算下移后的X坐标
    if(!CheckCollision(newX, curY - 1)){    //检测无碰撞则移动
        curY = newY;
    }
}

/**
 * @brief  方块旋转（顺时针）
 * @param  无
 * @retval 无
 */
void BlockRotate(){
		unsigned char oldRotate;
    if(isGameOver || isPaused) return;
    oldRotate = curRotate;          //保存当前旋转状态
    curRotate = (curRotate + 1) % 4;              //计算新旋转状态（0-3循环）
    if(CheckCollision(curX, curY)){               //若旋转后碰撞
        curRotate = oldRotate;                    //恢复原旋转状态
    }
}

bit isGameOver = 0;																									//游戏结束标志
bit isPaused = 0;																										//游戏暂停标志
bit blockFallFlag = 0;																							//方块下落标志
bit gameOverAnimState = 0;																					//游戏结束动画状态

/**
 * @brief  绘制游戏画面
 * @param  无
 * @retval 无
 */
void DrawGame(){
    unsigned char frame[8] = {0};  //帧缓存，8列，每列1字节（bit7=最上行，bit0=最下行）
    unsigned char col, row, r, c, realCol, realRow;
		
    //1.绘制游戏区域中已固定的方块
    for(col = 0; col < GAME_WIDTH; col++){
        for(row = 0; row < GAME_HEIGHT; row++){
            if(gameArea[col][row] == 1){
                //行号row对应bit位（row=0→bit0，row=7→bit7），置1表示点亮
                frame[col] |= (1 << row);
            }
        }
    }
    
    //2.绘制当前活动方块（3x3矩阵）
    for(r = 0; r < 3; r++){  //遍历方块的3行
        for(c = 0; c < 3; c++){  //遍历方块的3列
            //若方块当前位置有像素（1表示有方块）
            if(Block[curBlockType][curRotate][r][c] == 1){
                //计算实际坐标（以方块中心为基准偏移，3x3矩阵中心在(1,1)）
                realCol = curX + (c - 1);  //列坐标：当前列 + 列偏移
                realRow = curY + (r - 1);  //行坐标：当前行 + 行偏移
                
                //确保坐标在8x8点阵范围内（防止越界）
                if(realCol < GAME_WIDTH && realRow < GAME_HEIGHT){
                    frame[realCol] |= (1 << realRow);  //点亮对应像素
                }
            }
        }
    }
    
    //3.显示最终帧缓存
    MatrixLED_ShowFrame(frame);
}

/**
 * @brief  游戏结束动画
 * @param  无
 * @retval 无
 */
void GameOverAnimation(){
    unsigned char frame[8] = {0};
    unsigned char col;
    
    //根据动画状态设置帧
    for(col = 0; col < 8; col++){
        //交替显示列
        if((col % 2) == gameOverAnimState){
            frame[col] = 0xFF;  //点亮整列
        }else{
            frame[col] = 0x00;  //熄灭整列
        }
    }
    
    MatrixLED_ShowFrame(frame);
}

//定时器中断函数
void Timer0_Routine() interrupt 1{
    static unsigned int T0Count;
    static unsigned int animCount;
    
    //重新赋初值保证计时为1ms
    TL0 = 0x66;				//设置定时初始值
    TH0 = 0xFC;				//设置定时初始值
    
    //键盘扫描（每1ms扫描一次）
    NonBlockKey_Scan();
    
    if(isGameOver){
        //游戏结束时更新动画计数器
        animCount++;
        if(animCount >= 200){  //约200ms切换一次状态
            animCount = 0;
            gameOverAnimState = ~gameOverAnimState;
        }
    }else{
        //正常游戏时处理方块下落
        T0Count++;
        if (T0Count >= Score_GetFallInterval()){
            T0Count = 0; //初始化计数
            blockFallFlag = 1; //置位下落标志
        }
    }
}