C语言俄罗斯方块时钟

已于 2023-09-02 21:23:12 修改
阅读量434 收藏 4
点赞数 1
分类专栏： rtthread stm32f746 俄罗斯方块 文章标签： c语言 开发语言
于 2022-08-13 11:29:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32629351/article/details/126316728
版权

C语言俄罗斯方块时钟

这个小程序是因为在某宝上看见一款点阵屏俄罗斯方块时钟，感觉很有意思就想在自己的stm32f469开发板上抄袭一下，看看效果，大家想玩一玩的可以参考一下，核心代码在下面。

先看一下效果图

在这里插入图片描述当时间改变，每个数字是由小的俄罗斯方块逐渐累加起来的，不是视频看不到效果。

下面是一些const数据用来定义俄罗斯方块基础形状及每个数字下落的方块序列


/* config  grid */
#define GRID_SIZE               14
#define GRID_ROW_NUM            (RK043FN48H_HEIGHT/GRID_SIZE-6)
#define GRID_COL_NUM            (RK043FN48H_WIDTH/GRID_SIZE-1)

/* config number and colon position */
#define NUMBER_COUNT            4
#define FIRST_NUMBER_OFFSET     1
#define SECOND_NUMBER_OFFSET    8
#define THIRD_NUMBER_OFFSET     18
#define FOURTH_NUMBER_OFFSET    25
#define COLON_OFFSET_X          15
#define COLON_OFFSET_Y          5

uint16_t u16GridMap[GRID_ROW_NUM * GRID_COL_NUM];
uint8_t u8ClockNumber[NUMBER_COUNT+1] = {0, 0, 0, 0, 0};
stTetrisClockHandle stTetrisNumHandle[NUMBER_COUNT];
struct tm *p_tm;

const uint32_t u32ColorRgb565Table[] =
{
    SCRLET           ,
    CAMEL            ,
    SUN_ORANGE       ,
    LAWN_GREEN       ,
    FOREST_GREEN     ,
    MARINE_BLUE      ,
    CHROME_YELLOW    ,
    DARK_SLATE_BLUE  ,
    CAYN_BLUE        ,
    RUBY             ,
    MIDIUM_TURQUOISE ,
    VERIDIAN         ,
    LIGHT_LIME       ,
    INDIAN_RED       ,
    MAROON           ,
    MISTY_ROSE       ,
    LIGHT_CORAL      ,
    HELIOTROPE       ,
};

const stNumSeqBase au8NumZeroTerisSeq[] =
{
    {18, 3}, {4,  1}, {9, 3}, {9, -1}, {5, 0}, {5, 4}, {5, 4}, {11, 0}, {0,  0}, {9,  0},
    {6,  2}, {19, 4}
};
const stNumSeqBase au8NumOneTerisSeq[] =
{
    {3, 4}, {17, 3}, {19, 4}, {17, 3}, {19, 4}
};
const stNumSeqBase au8NumTwoTerisSeq[] =
{
    {18, 3}, {14, 0}, {1, 1}, {2, 4}, {18, 3}, {14, 0}, {1, 1}, {2, 4}, {2,  2}, {0,  1}, {0, 0}
};
const stNumSeqBase au8NumThreeTerisSeq[] =
{
    {18, 3}, {14, 0}, {1, 1}, {0, 5}, {19, 3}, {14, 0}, {1, 1}, {2, 4}, {1,  1}, {12, 3}, {16, 0}
};
const stNumSeqBase au8NumFourTerisSeq[] =
{
    {2, 4}, {2, 4}, {2, 0}, {2, 0}, {18, 3}, {14, 0}, {1, 1}, {2, 4}, {2, 4}
};
const stNumSeqBase au8NumFiveTerisSeq[] =
{
    {2, 4, 8}, {2, 2, 8}, {0, 1}, {0, 0}, {1, 1}, {16, 0, 4}, {12, 3}, {2, 4}, {1, 1}, {12, 3},
    {16, 0}
};
const stNumSeqBase au8NumSixTerisSeq[] =
{
    {2, 4, 8}, {2, 2, 8}, {0, 1}, {0, 0}, {1, 1}, {16, 0}, {12, 3}, {2, 4}, {2, 0}, {1, 1},
    {12, 3},{16, 0}
};
const stNumSeqBase au8NumSevenTerisSeq[] =
{
    {18, 3}, {14, 0}, {1, 1}, {17, 3}, {0, 5}, {13, 3}, {2, 4}
};
const stNumSeqBase au8NumEightTerisSeq[] =
{
    {15, 4}, {1, 0}, {1, 1}, {7, 4}, {7, 0}, {16, 0}, {12, 1}, {9, 3}, {7, 0}, {12, 2}, {0, 5},
    {9, -1},{1, 1}
};
const stNumSeqBase au8NumNineTerisSeq[] =
{
    {10, 2}, {4, 0}, {5, 4}, {9, -1}, {12, 2}, {0, 5}, {5, 0}, {1, 1}, {2, 4}, {1, 2}, {1, 2}, {2, 0}
};

const stNumSeqBase *stNumSeqArrayTable[] =
{
    au8NumZeroTerisSeq  ,
    au8NumOneTerisSeq   ,
    au8NumTwoTerisSeq   ,
    au8NumThreeTerisSeq ,
    au8NumFourTerisSeq  ,
    au8NumFiveTerisSeq  ,
    au8NumSixTerisSeq   ,
    au8NumSevenTerisSeq ,
    au8NumEightTerisSeq ,
    au8NumNineTerisSeq  ,
};

const uint16_t u16NumSeqArraySize[] =
{
    sizeof(au8NumZeroTerisSeq )/sizeof(stNumSeqBase),
    sizeof(au8NumOneTerisSeq  )/sizeof(stNumSeqBase),
    sizeof(au8NumTwoTerisSeq  )/sizeof(stNumSeqBase),
    sizeof(au8NumThreeTerisSeq)/sizeof(stNumSeqBase),
    sizeof(au8NumFourTerisSeq )/sizeof(stNumSeqBase),
    sizeof(au8NumFiveTerisSeq )/sizeof(stNumSeqBase),
    sizeof(au8NumSixTerisSeq  )/sizeof(stNumSeqBase),
    sizeof(au8NumSevenTerisSeq)/sizeof(stNumSeqBase),
    sizeof(au8NumEightTerisSeq)/sizeof(stNumSeqBase),
    sizeof(au8NumNineTerisSeq )/sizeof(stNumSeqBase),
};

//这个是俄罗斯方块在一个9x9像素点中的坐标
//就是这样(x,x)(x,x)(x,x)(x,x),每个坐标2bit, 组成一个16bit数据
const uint16_t u16BasicModelTable[20] = {
    /*  #
     *  #
     *  #
     *  #
     */
    0xC840,/* 0 */
    /*  # # # #
     */
    0x3210,/* 1 */
    /*  # #
     *  # #
     */
    0x5410,/* 2 */
    /*  # #
     *  # #
     */
    0x5410,/* 3 */
    /*  # #
     *    # #
     */
    0x6510,/* 4 */
    /*    #
     *  # #
     *  #
     */
    0x8541,/* 5 */
    /*    # #
     *  # #
     */
    0x5421,/* 6 */
    /*  #
     *  # #
     *    #
     */
    0x9540,/* 7 */
    /*    #
     *  # # #
     */
    0x6541,/* 8 */
    /*  #
     *  # #
     *  #
     */
    0x9651,/* 9 */
    /*  # # #
     *    #
     */
    0x9654,/* 10 */
    /*    #
     *  # #
     *    #
     */
    0x9541,/* 11 */
    /*      #
     *  # # #
     */
    0x6542,/* 12 */
    /*  #
     *  #
     *  # #
     */
    0xA951,/* 13 */
    /*  # # #
     *  #
     */
    0x8654,/* 14 */
    /*  # #
     *    #
     *    #
     */
    0x9510,/* 15 */
    /*  #
     *  # # #
     */
    0x6540,/* 16 */
    /*  # #
     *  #
     *  #
     */
    0x9521,/* 17 */
    /*  # # #
     *      #
     */
    0xA654,/* 18 */
    /*    #
     *    #
     *  # #
     */
    0x9851, /* 19 */
};

下面是显示的main函数，10ms调用周期，可以自己改，把对应延时设置好就可以。

void tetris_main(void)
{
    static uint8_t u8LastSec = 0xff;
    static uint8_t u8LastDay = 0xff;
    static uint32_t u8AnimDelay = 0;
    stTetrisClockHandle *handle = NULL;
    uint32_t u32RandomColor = 0;
    int16_t xx, yy;
    uint8_t u8RandomNum = 0;

    uint8_t u8MinuteChange = TetrisClockUpdateTime(u8ClockNumber);
    if (u8MinuteChange) {
        /* clean screen and grid map */
        BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
        BSP_LCD_FillRect(0, 0, RK043FN48H_WIDTH, 200);
        rt_memset(u16GridMap, 0, sizeof(u16GridMap));

        /* init handle */
        for (uint16_t i = 0; i < NUMBER_COUNT; i++) {
            handle = &stTetrisNumHandle[i];
            u8RandomNum = HAL_RNG_GetRandomNumber(&hrng);

            /* set clock number offset */
            (i == 0) && (handle->u16TerisXOffset = FIRST_NUMBER_OFFSET);
            (i == 1) && (handle->u16TerisXOffset = SECOND_NUMBER_OFFSET);
            (i == 2) && (handle->u16TerisXOffset = THIRD_NUMBER_OFFSET);
            (i == 3) && (handle->u16TerisXOffset = FOURTH_NUMBER_OFFSET);

            /* init paramter */
            handle->pNumSeq = stNumSeqArrayTable[u8ClockNumber[i]];
            handle->u8SeqIdx = u16NumSeqArraySize[u8ClockNumber[i]] - 1;
            handle->u32TerisColor = u32ColorRgb565Table[u8RandomNum % (sizeof(u32ColorRgb565Table)/sizeof(uint32_t))];
            handle->u16TerisMode = u16BasicModelTable[handle->pNumSeq[handle->u8SeqIdx].u8ModeIdx];
            handle->u16TerisX = handle->pNumSeq[handle->u8SeqIdx].u8DefX + handle->u16TerisXOffset;
            handle->u16TerisY = 0;
            handle->u8EndFlag = 0;
        }
    }

    /* delay 80 ms */
    if (++u8AnimDelay % 8 == 0) {
        /* draw clock number loop */
        for (uint16_t i = 0; i < NUMBER_COUNT; i++) {
            handle = &stTetrisNumHandle[i];

            /* update next tetris mode */
            if (handle->u8EndFlag) {
                if (handle->u8SeqIdx == 0)
                    continue;

                u8RandomNum = HAL_RNG_GetRandomNumber(&hrng);
                handle->u8SeqIdx--;
                handle->u32TerisColor = u32ColorRgb565Table[u8RandomNum % (sizeof(u32ColorRgb565Table)/sizeof(uint32_t))];
                handle->u16TerisMode = u16BasicModelTable[handle->pNumSeq[handle->u8SeqIdx].u8ModeIdx];
                handle->u16TerisX = handle->pNumSeq[handle->u8SeqIdx].u8DefX + handle->u16TerisXOffset;
                handle->u16TerisY = 0;
                handle->u8EndFlag = 0;
            }

            /* clear last tetris base mode */
            for (uint16_t i = handle->u16TerisMode; xx = handle->u16TerisX + (i&0x3), yy = handle->u16TerisY + ((i>>2)&0x3), i; i >>= 4)
            {
                u16GridMap[yy * GRID_COL_NUM + xx] = 0;
                DrawTetrisRect(xx, yy, GRID_SIZE, GRID_SIZE, LCD_COLOR_BLACK, LCD_COLOR_BLACK);
            }

            /* down */
            down(handle);

            /* draw new tetris base mode */
            for (uint16_t i = handle->u16TerisMode; xx = handle->u16TerisX + (i&0x3), yy = handle->u16TerisY + ((i>>2)&0x3), i; i >>= 4)
            {
                u16GridMap[yy * GRID_COL_NUM + xx] = 1;
                DrawTetrisRect(xx, yy, GRID_SIZE, GRID_SIZE, handle->u32TerisColor, LCD_COLOR_BLACK);
            }
        }
    }

    /* flash colon */
    if (u8LastSec != u8ClockNumber[NUMBER_COUNT]) {
        /* get random color */
        u8RandomNum = HAL_RNG_GetRandomNumber(&hrng);
        u32RandomColor = u32ColorRgb565Table[u8RandomNum % (sizeof(u32ColorRgb565Table)/sizeof(uint32_t))];

        for (uint16_t i = u16BasicModelTable[2]; xx = COLON_OFFSET_X + (i&0x3), yy = COLON_OFFSET_Y + ((i>>2)&0x3), i; i >>= 4) {
            if (u8LastSec%2 == 0) {
                DrawTetrisRect(xx, yy, GRID_SIZE, GRID_SIZE, u32RandomColor, LCD_COLOR_BLACK);
                DrawTetrisRect(xx, yy+4, GRID_SIZE, GRID_SIZE, u32RandomColor, LCD_COLOR_BLACK);
            } else {
                DrawTetrisRect(xx, yy, GRID_SIZE, GRID_SIZE, LCD_COLOR_BLACK, LCD_COLOR_BLACK);
                DrawTetrisRect(xx, yy+4, GRID_SIZE, GRID_SIZE, LCD_COLOR_BLACK, LCD_COLOR_BLACK);
            }
        }

        u8LastSec = u8ClockNumber[NUMBER_COUNT];
    }

    /* update calendar */
    if (u8LastDay != p_tm->tm_mday) {
        /* show calendar */
        const char* str;
        str = solar_calendar(p_tm->tm_mon+1, p_tm->tm_mday, p_tm->tm_wday);
        show_str(170, 205, 200, 16, (uint8_t*)str, CH_FONT16);
        str = lunar_calendar(p_tm->tm_year+1900, p_tm->tm_mon+1, p_tm->tm_mday);
        show_str(170, 224, 440, 16, (uint8_t*)str, CH_FONT16);
        u8LastDay = p_tm->tm_mday;
    }
}

其他几个函数用来更新俄罗斯方块下落后的坐标，及获取时间还有画每个小方块的函数，
画图和获取时间的函数用到了其他接口，可以根据自己的工程修改。

static void DrawTetrisRect(uint16_t TetrisX, uint16_t TetrisY, uint16_t Width, uint16_t Height,
        uint32_t Fcolor, uint32_t Bcolor)
{
    BSP_LCD_SetTextColor(Fcolor);
    BSP_LCD_FillRect(TetrisX*(Width+1), TetrisY*(Height+1), Width, Height);
    if (Fcolor != Bcolor) {
        BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
        BSP_LCD_DrawRect(TetrisX*(Width+1), TetrisY*(Height+1), Width-1, Height-1);
    }
}

static uint8_t TetrisClockUpdateTime(uint8_t *data)
{
    static uint8_t u8LastMinute = 0xff;
    uint8_t u8MinuteChange = 0;
    rt_device_t rtc_dev = NULL;
    time_t time_stamp = 0;

    rtc_dev = rt_device_find("rtc");
    if (rtc_dev != NULL) {
        rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &time_stamp);
    }

    p_tm = localtime(&time_stamp);
    //rt_kprintf("year %d day %d h:%d m:%d\n", p_tm->tm_year, p_tm->tm_mday, p_tm->tm_hour, p_tm->tm_min);

    data[0] = p_tm->tm_hour/10%10;
    data[1] = p_tm->tm_hour%10;
    data[2] = p_tm->tm_min/10%10;
    data[3] = p_tm->tm_min%10;
    data[4] = p_tm->tm_sec;

    if (u8LastMinute != p_tm->tm_min) {
        u8LastMinute = p_tm->tm_min;
        u8MinuteChange = 1;
    }

    return u8MinuteChange;
}
void down(stTetrisClockHandle *handle)
{
    int16_t xx, yy;

    handle->u16TerisY += 1;
    for (uint16_t i = handle->u16TerisMode; xx = handle->u16TerisX + (i&0x3), yy = handle->u16TerisY + ((i>>2)&0x3), i; i >>= 4)
    {
        if (yy >= GRID_ROW_NUM-handle->pNumSeq[handle->u8SeqIdx].u8DefY|| u16GridMap[yy * GRID_COL_NUM + xx]) {
            /* crash bottom */
            handle->u16TerisY -= 1;
            handle->u8EndFlag = 1;
        }
    }
}

头文件

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-08-06     Administrator       the first version
 */
#ifndef APPLICATIONS_TETRIS_TETRIS_CLOCK_H_
#define APPLICATIONS_TETRIS_TETRIS_CLOCK_H_

#include <stdint.h>
#include <stdlib.h>

#include <rtthread.h>
#include "main.h"


#define SCRLET              0xFF2400
#define CAMEL               0xA16B47
#define SUN_ORANGE          0xFF7300
#define LAWN_GREEN          0x7CFC00
#define FOREST_GREEN        0x228B22
#define MARINE_BLUE         0x00477D
#define CHROME_YELLOW       0xFFD700
#define DARK_SLATE_BLUE     0x483D8B
#define CAYN_BLUE           0x0DBF8C
#define RUBY                0xCC0080
#define MIDIUM_TURQUOISE    0x48D1CC
#define VERIDIAN            0x127436
#define LIGHT_LIME          0xCCFF00
#define INDIAN_RED          0xCD5C5C
#define MAROON              0x800000
#define MISTY_ROSE          0xFFE4E1
#define LIGHT_CORAL         0xF08080
#define HELIOTROPE          0x5000B8

typedef struct{
    uint8_t u8ModeIdx;
    int8_t u8DefX;
    int8_t u8DefY;
    int8_t u8BottomOffset;
}stNumSeqBase;

typedef struct{
    const stNumSeqBase *pNumSeq;
    uint16_t u16TerisMode;
    uint16_t u16TerisX;
    uint16_t u16TerisXOffset;
    uint16_t u16TerisY;
    uint32_t u32TerisColor;
    uint8_t u8SeqIdx;
    uint8_t u8EndFlag;
}stTetrisClockHandle;

extern RNG_HandleTypeDef hrng;

void tetris_main(void);

#endif /* APPLICATIONS_TETRIS_TETRIS_CLOCK_H_ */
亮釒釒
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
使用ESP8266的带有P10 RGB矩阵的俄罗斯方块时钟-电路方案
04-20
我使用ESP8266和@ 2dom的PxMatrix库，使用ESP8266控制的P10 RGB矩阵制作了这款俄罗斯方块时计。 硬件组件: 9 x 20毫米的木条× 1 22 x 13厘米的亚克力玻璃× 1 用于窗户的单向镜面箔（灰色）× 1 NodeMCU ESP8266分线板× 1 Micro-USB转USB线（通用）× 1 USB电源× 1 Adafruit P10 32x16 RGB LED矩阵× 1 杜邦跳线电缆× 1 M3螺丝× 1 软件应用程序和在线服务: Microsoft Visual Studio代码 Platform.io 手动工具和制造机器: 3D打印机（通用）
万众期待！俄罗斯方块时钟&数字变化时钟开模版本，众筹开卖！
karaxiaoyu的专栏
08-11 557
去年12月29号，在公众号做了一个调查，两个WiFi时钟版本，看大家更喜欢哪一个，评论区两者喜欢的粉丝都挺多的，今年也是因为缺芯的事情，公司产品一直在做各种替代方案以及功能验证，所以花了不...
基于STM32F407的俄罗斯方块小游戏的设计
capture3333的博客
07-08 5098
随着嵌入式系统的迅速发展,其游戏娱乐功能越来越受到重视。而俄罗斯方块是一个非常经典的小游戏，常在各大游戏平台都能看见它的身影。它的实现需要记录所有类型的方块，他有7种不同类型的方块，如果再算上旋转的方块类型就有19种不同的类型，我们可以把它们编码后存储于一个数组的元素中，并且控制它在一个方块下落结束后继续产生新的方块，并且给予下一个产生的方块以提示，用户根据开发板的四个按键或者红外线遥控器进行向左，向右，向下，翻转操作，还能查看游戏的得分与用时。我们利用STM32F407开发板设计并实现了俄罗斯方块游戏,
C语言项目小游戏之俄罗斯方块
sclwc的博客
07-18 1658
今天给大家带来一个用C语言实现的俄罗斯方块小游戏游戏截图：首先我们先创建一个名为mywindows.h的头文件。用来设置我们操作台的各种功能实现。
C语言俄罗斯方块时钟。
08-13
一个基于stm32f469开发板和rtthread操作系统写的C语言俄罗斯方块时钟，感兴趣可以自己移植。
JS俄罗斯方块，显示时钟
02-04
纯Javascript+DIV+CSS制作的俄罗斯方块 里面包含时钟模块 源代码可以任意修改
C语言俄罗斯方块
07-14
《C语言实现俄罗斯方块》 C语言版的俄罗斯方块是一款经典的课程设计项目，它通过编程技术实现了这个深受玩家喜爱的游戏。这个电子版的课程设计提供了完整的代码和详细的解释，确保代码的正确性，为学习者提供了很好...
c语言 俄罗斯方块
10-11
### C语言实现的俄罗斯方块游戏解析 #### 游戏简介 本文将深入解析一个用C语言编写的俄罗斯方块游戏。此版本的俄罗斯方块不仅功能完备，而且每行代码都附有详细的注释，方便读者理解其背后的逻辑与算法。 #### ...
c语言——俄罗斯方块
03-19
*俄罗斯方块源程序 */ #include #include #include #include <graphics.h> /*图形函数库*/ /*定义按键码*/ #define VK_LEFT 0x4b00 #define VK_RIGHT 0x4d00 #define VK_DOWN 0x5000 #define VK_UP 0x4800 #...
c语言俄罗斯方块实验报告和代码详解.pdf
10-14
"C语言俄罗斯方块实验报告和代码详解" 本文档主要介绍了使用C语言实现的俄罗斯方块游戏的设计报告和代码详解。该游戏的主要功能包括界面、方块下落、旋转、判断是否还能下落、左右移动、分数、速度设置、清楚满的每...
基于STM32F4实现俄罗斯方块
最新发布
06-24
一、 课程设计目的 1、 进一步巩固掌握嵌入式系统课程所学STM32F4各功能模块的工作原理； 2、 进一步熟练掌握STM32F4各功能模块的配置与使用方法； 3、 进一步熟练掌握开发环境Keil MDK5的使用与程序调试技巧； 4、 自学部分功能模块的原理、配置与使用方法，培养自学能力； 5、 培养设计复杂嵌入式应用软、硬件系统的分析与设计能力。 二、 课程设计内容 本次课程设计选题为：俄罗斯方块。 要求： 1、 查阅资料，自学STM32F4与LCD的接口设计，完成LCD液晶屏驱动程序的设计，将游戏界面显示在LCD上； 2、 能正常地随机生成方块，并给予下一个方块信息提示； 3、 能正常控制方块移动，并成功设置边界判定； 4、 能正常实现堆满一行时，方块得以消除并使得分加一； 5、 能正常显示得分和当前等级，当得分到达10分时升为等级2，方块下落速度加快，游戏难度升级；当得分到达20时升为等级3，方块下落速度再次加快，以此类推； 6、 能成功设置游戏结束的判定，当方块高度达到上限时，判定为游戏结束，自动重新开始。 7、 当游戏结束时，播放游戏失败的音乐，并显示游戏失败，loading
tetris-clock:俄罗斯方块时钟
06-18
俄罗斯方块时钟 俄罗斯方块时钟是一个用 HTML5 和一些 CSS3 酱构建的项目。 它没有完全实现俄罗斯方块功能并包含一些快捷方式/硬编码机制。 我基本上是为了好玩而构建的。
STM32F407飞机大战游戏代码
04-23
本系统主要是基于STM32F407开发板为基础来对整个系统进行控制，本系统主要通过摇杆来控制安卓手机上的飞机大战游戏，本系统具有无线控制飞机的上下左右飞行的方向控制，从而实现游戏的控制，不仅仅局限于摇杆控制，同时还支持触摸屏的控制，并且还会通过OLED屏幕显示项目名，飞行方向也会根据不同状态来实时显示，并且在OLED上我们还模拟了电量的显示，图标和百分比同时显示。 资料内容：开发文档，视频讲解，源代码，硬件连接图
基于stm32f4设计
03-06
基于stm32f4设计，包括硬件ad板子和软件，算法有ahrs和椭圆拟合等
基于stm32设计的俄罗斯方块.rar
08-19
基于stm32mini开发板设计的俄罗斯方块小游戏。
使用stm32实现一个俄罗斯方块
weixin_42596214的博客
02-13 812
要使用STM32实现俄罗斯方块，您需要学习如何在STM32开发板上编写程序，并了解STM32的硬件特性。您可以使用C或C++语言编写程序，并利用STM32的显示器、按键和其他硬件资源进行开发。 实现俄罗斯方块的步骤如下： 了解俄罗斯方块的基本游戏规则。 设计游戏的界面，并确定游戏所需的硬件资源。 编写程序，使用STM32的硬件特性实现游戏的各项功能。 在STM32开发板上测试程序，确保游戏...
基于STM32F407的俄罗斯方块游戏代码分析
capture3333的博客
07-14 4339
这里只给了关键代码进行分析，并非全部代码。首先需要知道俄罗斯方块本质上为4个小方块组成的正方形。总共有7种基本类型。每种方块又可以通过旋转而变化出1到4种形状，一共就有19种。
esp8266 tetrisClock 俄罗斯方块时钟
I'm Hexesdesu
02-14 401
32*16的版本有虚影问题，还没找到解决方案，可能和是4扫屏有关，代码随后上传git
用javascript和css写简单的网页钟表
qq_43936346的博客
06-16 339
用javascript和css写简单的网页钟表 一.首先需要表示时针，分针和秒针。 有的人可能这样想 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>wrong</title&
c语言俄罗斯方块游戏代码
01-03
很抱歉，我无法提供完整的C语言俄罗斯方块游戏代码。但是，我可以给你一些关于C语言俄罗斯方块游戏代码的思路和方法。 在C语言中实现俄罗斯方块游戏，你可以使用控制台来显示游戏界面和方块。以下是一些实现俄罗斯...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值