自研C语言编译器发布，STC IDE —— 面向STC32系列及AI8051U的C语言编译器,11/7更新

天黑不***

编译后自动改写 怎么关掉,撤销按钮根本没反应.

王***

天黑不*** 发表于 2026-9-7 18:13
编译后自动改写 怎么关掉,撤销按钮根本没反应.

暂时无法关掉，本质是给隐式提升写成显式提升，就算给关了内部也还是这样做的

Yang.***

搞个FAQ吧，需要设定头文件搜索目录吗？还是只能放在 root下？

王***

Yang.*** 发表于 2026-9-8 08:40
搞个FAQ吧，需要设定头文件搜索目录吗？还是只能放在 root下？

对于内置的头文件，直接引用即可
对于自己导入的头文件，通过相对路径引用即可，放在哪里都无所谓，只要相对路径写对了都可以引用到

天黑不***

王*** 发表于 2026-9-7 18:38
暂时无法关掉，本质是给隐式提升写成显式提升，就算给关了内部也还是这样做的 ...

/*******************************************************************************
*  文件名 : mian.c
*  功能   : STC32G12K128 贪吃蛇游戏
*  硬件   : 
*           P3.3~P3.7 接5个独立按键(按下为低电平)
*           P0.0~P1.7 接16x16点阵行选 第1~8行(高电平有效)
*           P2.0~P2.7 接16x16点阵行选 第9~16行(高电平有效)
*           P1.3 接74HC595的SER(数据线)
*           P1.0 接74HC595的SRCLK(移位时钟)
*           P1.1 接74HC595的RCLK(锁存时钟)
*           4个74HC595级联,第3个输出低8位列选,第4个输出高8位列选
*           16x16共阴LED点阵: 行选高电平有效,列选低电平有效
*  晶振   : 11.0592MHz
*  编译   : Keil C251 5.39, 设备选 STC32G12K128
*  注意   : 大数组用 "unsigned char xdata" 声明放在外部RAM
*******************************************************************************/

#include "stc32g.h"
#include "intrins.h"

/* ================== 按键引脚定义 ================== */
sbit KEY_UP    = P3^7;   // 方向:上
sbit KEY_DOWN  = P3^6;   // 方向:下
sbit KEY_LEFT  = P3^5;   // 方向:左
sbit KEY_RIGHT = P3^4;   // 方向:右
sbit KEY_RESET = P3^3;   // 重新开始

/* ================== 74HC595控制引脚 ================== */
sbit HC_SER   = P1^3;    // 数据输入(SER)
sbit HC_SRCLK = P1^0;    // 移位时钟(SRCLK)
sbit HC_RCLK  = P1^1;    // 锁存时钟(RCLK)

/* ================== 方向定义 ================== */
#define DIR_UP    0
#define DIR_DOWN  1
#define DIR_LEFT  2
#define DIR_RIGHT 3

/* ================== 游戏区域大小 ================== */
#define MAP_W     16      // 宽(列)16格
#define MAP_H     16      // 高(行)16格
#define MAX_LEN   32      // 蛇最大长度

/* ================== 全局变量(大数组放xdata, 类型在前!) ================== */
unsigned char xdata snake_x[MAX_LEN];   // 蛇身各节X坐标(0~15)
unsigned char xdata snake_y[MAX_LEN];   // 蛇身各节Y坐标(0~15)
unsigned char xdata disp_buf[16][2];    // 显示缓冲区[行][低/高8列]

unsigned char snake_len;          // 当前蛇身长度
unsigned char direction;          // 当前移动方向
unsigned char new_direction;      // 待更新的方向
unsigned char food_x;             // 食物X坐标
unsigned char food_y;             // 食物Y坐标
unsigned char move_count;         // 定时器中断计数
bit           move_flag;          // 蛇移动标志
bit           game_over;          // 游戏结束标志
unsigned char random_seed;        // 伪随机数种子

/* ================== 定时器0中断服务函数 ================== */
/* 每50ms进一次中断, 中断20次=1秒, 蛇移动一格 */
void TM0_Isr() interrupt 1
{
    move_count++;               // 中断计数+1
    if (move_count >= 20)       // 50ms*20 = 1000ms = 1秒
    {
        move_count = 0;         // 清零计数
        move_flag = 1;          // 置移动标志
    }
}

/* ================== 延时函数(约1ms) ================== */
void delay_ms(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
    {
        for (j = 0; j < 1000; j++)   // 大约1ms(11.0592MHz)
        {
            _nop_();
        }
    }
}

/* ================== 向74HC595发送16位列数据 ================== */
void hc595_send(unsigned char col_low, unsigned char col_high)
{
    unsigned char i;
    
    /* 先发送高8位(最终进入第4个595,控制高8列) */
    for (i = 0; i < 8; i++)
    {
        HC_SER = (col_high >> (7 - i)) & 0x01;
        HC_SRCLK = 0;
        _nop_();
        HC_SRCLK = 1;
        _nop_();
    }
    
    /* 再发送低8位(最终进入第3个595,控制低8列) */
    for (i = 0; i < 8; i++)
    {
        HC_SER = (col_low >> (7 - i)) & 0x01;
        HC_SRCLK = 0;
        _nop_();
        HC_SRCLK = 1;
        _nop_();
    }
    
    /* 再发送2个字节0x00(给第1、2个595,不使用) */
    for (i = 0; i < 16; i++)
    {
        HC_SER = 0;
        HC_SRCLK = 0;
        _nop_();
        HC_SRCLK = 1;
        _nop_();
    }
    
    /* 锁存数据 */
    HC_RCLK = 0;
    _nop_();
    HC_RCLK = 1;
    _nop_();
}

/* ================== 行选输出 ================== */
void row_select(unsigned char row)
{
    if (row < 8)
    {
        P0 = (unsigned char)(1 << row);       // 选中P1上的行(行1~8)
        P2 = 0x00;                            // 清空P2行选
    }
    else
    {
        P2 = (unsigned char)(1 << (row - 8)); // 选中P2上的行(行9~16)
        P0 = 0x00;                            // 清空P1行选
    }
}

/* ================== 刷新显示一行 ================== */
void display_row(unsigned char row)
{
    /* 列选低电平有效,取反后输出 */
    hc595_send((unsigned char)~disp_buf[row][0], (unsigned char)~disp_buf[row][1]);
    row_select(row);
}

/* ================== 刷新整个画面 ================== */
void display_refresh(void)
{
    unsigned char row;
    for (row = 0; row < 16; row++)
    {
        display_row(row);
        delay_ms(1);   // 每行约1ms,16行约16ms
    }
}

/* ================== 生成随机数 ================== */
unsigned char random_byte(void)
{
    random_seed = (unsigned char)(random_seed * 17 + 13);
    return random_seed;
}

/* ================== 生成食物 ================== */
void generate_food(void)
{
    unsigned char x, y;
    unsigned char i;
    unsigned char ok;
    
    do
    {
        x = random_byte() & 0x0F;   // 0~15
        y = random_byte() & 0x0F;   // 0~15
        ok = 1;
        
        /* 检查是否被蛇身占据 */
        for (i = 0; i < snake_len; i++)
        {
            if (snake_x[i] == x && snake_y[i] == y)
            {
                ok = 0;
                break;
            }
        }
    } while (ok == 0);
    
    food_x = x;
    food_y = y;
}

/* ================== 更新显示缓冲区 ================== */
void update_display(void)
{
    unsigned char i;
    
    /* 清空显示缓冲区 */
    for (i = 0; i < 16; i++)
    {
        disp_buf[i][0] = 0x00;
        disp_buf[i][1] = 0x00;
    }
    
    /* 绘制蛇身 */
    for (i = 0; i < snake_len; i++)
    {
        if (snake_x[i] < 8)
        {
            disp_buf[snake_y[i]][0] |= (unsigned char)(1 << snake_x[i]);
        }
        else
        {
            disp_buf[snake_y[i]][1] |= (unsigned char)(1 << (snake_x[i] - 8));
        }
    }
    
    /* 绘制食物 */
    if (food_x < 8)
    {
        disp_buf[food_y][0] |= (unsigned char)(1 << food_x);
    }
    else
    {
        disp_buf[food_y][1] |= (unsigned char)(1 << (food_x - 8));
    }
}

/* ================== 游戏初始化 ================== */
void init_game(void)
{
    snake_len = 3;
    snake_x[0] = 7;  snake_y[0] = 7;   // 蛇头
    snake_x[1] = 6;  snake_y[1] = 7;   // 身体
    snake_x[2] = 5;  snake_y[2] = 7;   // 尾巴
    
    direction = DIR_RIGHT;
    new_direction = DIR_RIGHT;
    random_seed = 0x5A;
    
    generate_food();
    update_display();
}

/* ================== 扫描按键 ================== */
void scan_keys(void)
{
    if (KEY_UP == 0)
    {
        delay_ms(10);
        if (KEY_UP == 0)
        {
            if (direction != DIR_DOWN) new_direction = DIR_UP;
            while (KEY_UP == 0);
        }
    }
    
    if (KEY_DOWN == 0)
    {
        delay_ms(10);
        if (KEY_DOWN == 0)
        {
            if (direction != DIR_UP) new_direction = DIR_DOWN;
            while (KEY_DOWN == 0);
        }
    }
    
    if (KEY_LEFT == 0)
    {
        delay_ms(10);
        if (KEY_LEFT == 0)
        {
            if (direction != DIR_RIGHT) new_direction = DIR_LEFT;
            while (KEY_LEFT == 0);
        }
    }
    
    if (KEY_RIGHT == 0)
    {
        delay_ms(10);
        if (KEY_RIGHT == 0)
        {
            if (direction != DIR_LEFT) new_direction = DIR_RIGHT;
            while (KEY_RIGHT == 0);
        }
    }
    
    if (KEY_RESET == 0)
    {
        delay_ms(10);
        if (KEY_RESET == 0)
        {
            game_over = 0;
            init_game();
            while (KEY_RESET == 0);
        }
    }
}

/* ================== 蛇移动逻辑 ================== */
void update_game(void)
{
    unsigned char new_x, new_y;
    unsigned char i;
    
    direction = new_direction;
    
    new_x = snake_x[0];
    new_y = snake_y[0];
    
    switch (direction)
    {
        case DIR_UP:    new_y--; break;
        case DIR_DOWN:  new_y++; break;
        case DIR_LEFT:  new_x--; break;
        case DIR_RIGHT: new_x++; break;
    }
    
    /* 穿墙处理: 撞墙从对面出来 */
    if (new_y == 0xFF) new_y = 15;   // 先判断下溢 ← 必须先执行!
                if (new_x == 0xFF) new_x = 15;
                if (new_y >= MAP_H) new_y = 0;   // 再判断上溢
                if (new_x >= MAP_W) new_x = 0;
    
    /* 检查是否撞到自己 */
    for (i = 1; i < snake_len; i++)
    {
        if (snake_x[i] == new_x && snake_y[i] == new_y)
        {
            game_over = 1;
            return;
        }
    }
    
    /* 判断是否吃到食物 */
    if (new_x == food_x && new_y == food_y)
    {
        /* 吃到食物: 整体后移, 新头插入 */
        for (i = snake_len; i > 0; i--)
        {
            snake_x[i] = snake_x[i - 1];
            snake_y[i] = snake_y[i - 1];
        }
        snake_x[0] = new_x;
        snake_y[0] = new_y;
        snake_len++;
        
        if (snake_len >= MAX_LEN)
        {
            game_over = 1;
            return;
        }
        generate_food();
    }
    else
    {
        /* 没吃到食物: 去掉尾巴 */
        for (i = snake_len; i > 0; i--)
        {
            snake_x[i] = snake_x[i - 1];
            snake_y[i] = snake_y[i - 1];
        }
        snake_x[0] = new_x;
        snake_y[0] = new_y;
    }
    
    update_display();
}

/* ================== 硬件初始化 ================== */
void init_hardware(void)
{
    P_SW2 |= 0x80;      // 使能访问XFR(扩展寄存器区)
    WTST = 0x00;        // 程序代码等待参数设为最快
    
    /* P3: 按键输入(准双向) */
    P3M0 = 0x00;
    P3M1 = 0x00;
    
    /* P1: 行选输出(推挽) */
    P0M0 = 0xFF;
    P0M1 = 0x00;
    
    /* P2: 行选输出(推挽) */
    P2M0 = 0xFF;
    P2M1 = 0x00;
    
    /* P1: P1.2/P1.3/P1.4推挽输出 */
    P1M0 = 0xFF;        // bit2,3,4 = 1
    P1M1 = 0x00;
    
    /* 定时器0: 16位自动重装载, 12T模式 */
    TMOD &= 0xF0;       // 清T0位
    AUXR &= ~0x80;      // T0x12=0 → 12T模式
    
    /* 定时50ms: 初值=65536-46080=19456=0x4C00 */
    TL0 = 0x00;
    TH0 = 0x4C;
    
    TR0 = 1;            // 启动定时器0
    ET0 = 1;            // 使能定时器0中断
    EA = 1;             // 打开总中断
}

/* ================== 主函数 ================== */
void main(void)
{
    init_hardware();
    init_game();
    
    while (1)
    {
        display_refresh();    // 刷新显示
        scan_keys();          // 扫描按键
        
        if (move_flag)        // 到了移动时间
        {
            move_flag = 0;
            if (game_over == 0)
            {
                update_game();
            }
        }
    }
}
复制代码

HC_SER = (col_high >> (7 - i)) & 0x01;

HC_SER = (col_low >> (7 - i)) & 0x01;
这两行被强行改成
HC_SER = (biat)(col_high >> (7 - i)) & 0x01;

HC_SER = (biat)(col_low >> (7 - i)) & 0x01;

显示就出问题了.

王***

天黑不*** 发表于 2026-9-8 17:17
HC_SER = (col_high >> (7 - i)) & 0x01;

HC_SER = (col_low >> (7 - i)) & 0x01;

看起来改的没啥问题？ 强制转bit和&0x01的效果是完全一样的，可能是存在其他的问题？

天黑不***

王*** 发表于 2026-9-8 17:20
看起来改的没啥问题？ 强制转bit和&0x01的效果是完全一样的，可能是存在其他的问题？ ...

问了STC AI给了这么一段

为什么加上 (bit) 后显示会出错？
根本原因：Keil C251 对 (bit) 转换的代码生成机制
在 STC32G（使用 Keil C251 编译）中，HC_SER 被定义为 sbit（可位寻址的位变量）。而 (bit) 是 Keil C251 的专用位类型。

当我们写：

HC_SER = (bit)(col_high >> (7 - i)) & 0x01;
📋
关键问题在于运算符优先级与 C251 的位变量处理方式：

根据 C 语言运算符优先级，(bit) 强制转换的优先级高于 &，所以实际的解析顺序是：

HC_SER = ((bit)(col_high >> (7 - i))) & 0x01;
📋
即先执行 (bit)(col_high >> (7 - i))，这会把右移的结果截断为一个 bit（0 或 1），然后再与 0x01 相与。

但问题不在这儿——因为 col_high >> (7-i) 的结果无论怎样，当 i 取 0~7 时，右移后提取的确实就是目标位，结果本来就是 0 或 1。

真正的问题在于 Keil C251 的编译器在生成 (bit) 转换代码时会使用"进位标志 C"作为中转：

C251 编译器对于 (bit) 类型转换，会生成类似这样的操作：先将表达式的值存入进位标志 C（通过进位标志传递），再从 C 取出给目标位变量。这个过程中如果 col_high 存放在 xdata（外部RAM）中，会涉及到：

从 xdata 读取 col_high（需要多时钟周期）
右移操作
将结果装载到进位标志
再从进位标志输出到 HC_SER
如果在第3步和第4步之间（进位标志装载/取出的过程中）恰好有其他中断或代码干扰了 PSW 的进位标志，或者编译器在优化时对位变量的处理不太理想，就可能导致输出数据错乱。

而原来的写法：

HC_SER = (col_high >> (7 - i)) & 0x01;
📋
编译器会把 & 0x01 的结果直接输出给 HC_SER，不经过额外的 (bit) 中间转换，生成的代码更直接、更高效，也更可靠。

验证一下：& 0x01 本身就足够产生 0/1 结果
col_high >> (7 - i) 右移后，我们只关心最低位，& 0x01 已经精确地提取出 0 或 1，这个结果赋给 sbit 类型是完美兼容的，完全不需要 (bit) 强制转换。

王***

天黑不*** 发表于 2026-9-8 19:39
问了STC AI给了这么一段

为什么加上 (bit) 后显示会出错？

STCIDE 目前并没有实现 bit 变量，只有 sbit 会被适配，就算是定义 bit 变量也会默认降级到 char 来实现，多余的运算会被优化掉
如果你这个程序不正常的话，可以打包一个工程上传上来，我来分析一下

sion***

现在使用aicube生成的程序使用串口发送字符时会出现异常（以前是可以正常收发的），单独使用实例程序测试能正常收发

王***

sion*** 发表于 2026-9-9 16:12
现在使用aicube生成的程序使用串口发送字符时会出现异常（以前是可以正常收发的），单独使用实例程序测试能 ...

可能某次改动引入了回归问题，我排查一下