16数字集

zzz19760225 · 发表于 2025-12-6 15:34:09

本帖最后由 zzz19760225 于 2026-1-26 08:46 编辑

1234567890a,;:.（小数点不在16数字集层面考虑，而是作为载体层面上，再次十进制表达十进制里表现。又或者增加小数点.和中文句号。）
全组合的内容。1名实相对关系里选择定义的制标准单元，2单元组合的排序排列全组合地图，3地图上的选择全组合，4选择全组合里的万物生物动物人类需求循环自转的各种规律选择集合。

zzz19760225 · 发表于 2025-12-6 15:42:15

本帖最后由 zzz19760225 于 2025-12-6 16:42 编辑

通义：linux mint22.2 C语言SDL2建立3X5点阵，二维数组代表，二维数组的15个值为单元全组合，依次显示每个组合内容的点阵效应。不用字符，每行中文注释。
修正一个SDL_CreateWindow 函数调用语法错误
直接使用 SDL_WINDOWPOS_CENTERED
文件dotmatrix.c

// 引入标准输入输出库
#include <stdio.h>
// 引入标准库（用于延时等）
#include <stdlib.h>
// 引入SDL2图形库
#include <SDL2/SDL.h>
// 定义点阵宽度（列数）
#define WIDTH 3
// 定义点阵高度（行数）
#define HEIGHT 5
// 定义每个点的像素大小（方便可视化）
#define DOT_SIZE 40
// 定义窗口宽度（含边距）
#define WINDOW_WIDTH (WIDTH * DOT_SIZE + 20)
// 定义窗口高度（含边距）
#define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 20)
// 定义每帧显示时间（毫秒）
#define FRAME_DELAY 100
// 主函数
int main(int argc, char* argv[])
{
// 初始化SDL系统
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("无法初始化SDL：%s\n", SDL_GetError());
return -1;
}
// 创建窗口
SDL_Window* window = SDL_CreateWindow(
"3x5点阵全组合演示", // 窗口标题
SDL_WINDOWPOS_CENTERED, // 横向居中
SDL_WINDOWPOS_CENTERED, // 纵向居中
WINDOW_WIDTH, // 窗口宽度
WINDOW_HEIGHT, // 窗口高度
SDL_WINDOW_SHOWN // 显示窗口
);
if (!window) {
printf("无法创建窗口：%s\n", SDL_GetError());
SDL_Quit();
return -1;
}
// 创建渲染器
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
printf("无法创建渲染器：%s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return -1;
}
// 定义点阵二维数组（初始为0）
int dot[HEIGHT][WIDTH] = {0};
// 总组合数：2的15次方
const int total = 1 << (WIDTH * HEIGHT); // 即32768
// 遍历所有组合（从0到32767）
for (int combo = 0; combo < total; combo++) {
// 清空屏幕为白色背景
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
// 将当前组合编号转换为点阵状态
int temp = combo;
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
dot[y][x] = temp & 1; // 取最低位作为该点状态（0或1）
temp >>= 1; // 右移一位处理下一点
}
}
// 绘制点阵
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
if (dot[y][x]) {
// 若该点为1，则绘制黑色实心矩形
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
} else {
// 若该点为0，则绘制浅灰色填充（可清晰看到灭点）
SDL_SetRenderDrawColor(renderer, 220, 220, 220, 255);
}
// 计算矩形位置（加边距10像素）
SDL_Rect rect = {
10 + x * DOT_SIZE,
10 + y * DOT_SIZE,
DOT_SIZE - 2, // 留1像素间隙
DOT_SIZE - 2
};
SDL_RenderFillRect(renderer, &rect);
}
}
// 更新屏幕显示
SDL_RenderPresent(renderer);
// 处理退出事件（如点击关闭按钮）
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
goto cleanup; // 跳出循环并清理资源
}
}
// 延迟一段时间以便观察
SDL_Delay(FRAME_DELAY);
}
cleanup:
// 释放渲染器资源
SDL_DestroyRenderer(renderer);
// 释放窗口资源
SDL_DestroyWindow(window);
// 关闭SDL系统
SDL_Quit();
// 程序正常结束
return 0;
}

复制代码

gcc -o dotmatrix dotmatrix.c -lSDL2
./dotmatrix
或鼠标双击dotmatrix
可以运行，产生一个页面黑色和灰色相对的快速组合递增，类似二进制有序堆积。
下面需要抽出这些组合，排序，在排序的序数序号中，提取使用4位01的16个点阵字符对应组合数组。（要不要过一百遍呢？）
所有 32768 种亮灭组合，只要其中的16种。余下的作为点阵牌使用，人怎么调用点阵牌呢。
通过指针，将3万组合里的16个提出来，怎么使用。
并行一个15点阵的线条，三个点阵为一线段，点阵需求的位置，可以相对二进制数量算出来。不需要自己算，让自动信息安排这个程序功能，点击点阵，就汇总出二进制数量。
需要手工点击点阵尝试点阵组合的各种样子，找个人认为不错的组合，然后获取对应显示的序数序号，在另一个输入框里输入，就可以调用。手工寻找，输入框再现点阵组合。

zzz19760225 · 发表于 2025-12-6 17:16:15

本帖最后由 zzz19760225 于 2025-12-6 17:39 编辑

通义：在上面的程序继续修改，鼠标左键点击点阵就变黑，再点击就变白，汇总显示黑色点阵所代表的数。

dotmatrix5.c

// 引入标准输入输出库
#include <stdio.h>
// 引入标准库（用于字符串等）
#include <stdlib.h>
// 引入SDL2图形库
#include <SDL2/SDL.h>
// 定义点阵宽度（列数）
#define WIDTH 3
// 定义点阵高度（行数）
#define HEIGHT 5
// 定义每个点的像素大小
#define DOT_SIZE 60
// 定义边距
#define MARGIN 20
// 定义窗口宽度
#define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
// 定义窗口高度
#define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
// 定义每帧刷新间隔（毫秒）
#define FRAME_DELAY 50
// 主函数
int main(int argc, char* argv[])
{
// 初始化SDL系统
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("无法初始化SDL：%s\n", SDL_GetError());
return -1;
}
// 创建窗口（初始标题）
SDL_Window* window = SDL_CreateWindow(
"数值: 0",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);
if (!window) {
printf("无法创建窗口：%s\n", SDL_GetError());
SDL_Quit();
return -1;
}
// 创建渲染器
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
printf("无法创建渲染器：%s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return -1;
}
// 点阵状态数组（0=灭，1=亮）
int dot[HEIGHT][WIDTH] = {0};
// 主循环标志
int running = 1;
// 事件结构体
SDL_Event event;
while (running) {
// 处理所有待处理事件
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = 0;
}
// 处理鼠标左键点击
else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
int mouse_x = event.button.x;
int mouse_y = event.button.y;
// 转换为点阵坐标（减去边距）
int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
// 检查是否在有效范围内
if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
// 切换该点状态
dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
}
}
}
// 计算当前点阵对应的整数值
unsigned int value = 0;
int bit_index = 0;
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
if (dot[y][x]) {
value |= (1U << bit_index); // 设置第 bit_index 位
}
bit_index++;
}
}
// 更新窗口标题（显示当前数值）
char title[64];
snprintf(title, sizeof(title), "数值: %u", value);
SDL_SetWindowTitle(window, title);
// 清屏（白色背景）
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
// 绘制点阵
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
if (dot[y][x]) {
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // 黑色（亮）
} else {
SDL_SetRenderDrawColor(renderer, 220, 220, 220, 255); // 浅灰（灭）
}
SDL_Rect rect = {
MARGIN + x * DOT_SIZE,
MARGIN + y * DOT_SIZE,
DOT_SIZE - 2,
DOT_SIZE - 2
};
SDL_RenderFillRect(renderer, &rect);
}
}
// 更新画面
SDL_RenderPresent(renderer);
// 控制刷新率
SDL_Delay(FRAME_DELAY);
}
// 清理资源
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}

复制代码

gcc -o dotmatrix5 dotmatrix5.c -lSDL2
./dotmatrix5
可以鼠标点击点阵，页面眉头显示对应十进制数字。

zzz19760225 · 发表于 2025-12-21 15:14:59

本帖最后由 zzz19760225 于 2025-12-25 10:59 编辑

以十进制为主，
是否应该修改为11个单元的排序全组合，另外一个信息间隔的逗号，一共12个单元的12元集合，12集。
0，1，2，3，4，5，6，7，8，9，
a(10)，
，(逗号专门的间隔单元)
8 4，0320 ×8
9 36，2880 ×9
10 362，8800 ×10
11 3991，6800 ×11
12 4，7900，1600 ×12
11位的排序全组合总数，可以覆盖24位颜色的1677万。
人耳可听的声波20赫兹～20000赫兹，2万的1，9980。

39916800-16777216-19980=2311，9604
空闲2311万可以自由发挥。

双逗号，，为一个信息条结束或更大层面的间隔。

类似16进制去表达二进制，用相对大的数量代表数字字符集，去表达太大的排序全组合空间，量化为文字和数字代表，对接八卦64卦等排序全组合。

zzz19760225 · 发表于 2025-12-25 10:55:21

9数字亿进制点阵1
可以显示两竖，每竖4个数字，八个点阵阿拉伯数字，但是没有适度的间隔开来。

#include <SDL2/SDL.h>
#include <stdio.h>
#include <stdbool.h> // 必须包含！
#define DOT_SIZE 20
#define PADDING 4 // 点与点之间，以及数字块之间的间隔
// 3x5 点阵数字图案：0~9（这里只用前8个）
const bool digits[10][5][3] = {
{{true, true, true}, {true, false, true}, {true, false, true}, {true, false, true}, {true, true, true}}, // 0
{{false, true, false}, {false, true, false}, {false, true, false}, {false, true, false}, {false, true, false}}, // 1
{{true, true, true}, {false, false, true}, {true, true, true}, {true, false, false}, {true, true, true}}, // 2
{{true, true, true}, {false, false, true}, {true, true, true}, {false, false, true}, {true, true, true}}, // 3
{{true, false, true}, {true, false, true}, {true, true, true}, {false, false, true}, {false, false, true}}, // 4
{{true, true, true}, {true, false, false}, {true, true, true}, {false, false, true}, {true, true, true}}, // 5
{{true, true, true}, {true, false, false}, {true, true, true}, {true, false, true}, {true, true, true}}, // 6
{{true, true, true}, {false, false, true}, {false, false, true}, {false, false, true}, {false, false, true}}, // 7
{{true, true, true}, {true, false, true}, {true, true, true}, {true, false, true}, {true, true, true}}, // 8
{{true, true, true}, {true, false, true}, {true, true, true}, {false, false, true}, {true, true, true}} // 9
};
int main(int argc, char* argv[]) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
return 1;
}
const int grid_cols = 2; // 横向 2 个数字
const int grid_rows = 4; // 竖向 4 个数字
const int num_digits = 8; // 显示 0~7
// 单个数字块的尺寸（含内部点阵间隙）
const int block_width = 3 * DOT_SIZE + 2 * PADDING;
const int block_height = 5 * DOT_SIZE + 4 * PADDING;
// 整体窗口尺寸：每个块之间再加 PADDING 作为块间距
int win_width = grid_cols * block_width + (grid_cols - 1) * PADDING;
int win_height = grid_rows * block_height + (grid_rows - 1) * PADDING;
SDL_Window* window = SDL_CreateWindow("2x4 3x5 Digit Matrix",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
win_width, win_height,
SDL_WINDOW_SHOWN);
if (!window) {
fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
bool quit = false;
SDL_Event e;
while (!quit) {
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
quit = true;
}
}
// 白色背景
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
// 绘制每个数字块
for (int idx = 0; idx < num_digits; ++idx) {
int row = idx / grid_cols; // 当前数字在网格中的行
int col = idx % grid_cols; // 当前数字在网格中的列
// 计算该数字块左上角坐标
int block_x = col * (block_width + PADDING);
int block_y = row * (block_height + PADDING);
// 绘制该数字的 3x5 点阵
for (int y = 0; y < 5; ++y) {
for (int x = 0; x < 3; ++x) {
if (digits[idx][y][x]) {
int px = block_x + x * (DOT_SIZE + PADDING);
int py = block_y + y * (DOT_SIZE + PADDING);
SDL_Rect r = {px, py, DOT_SIZE, DOT_SIZE};
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // 黑色点亮
SDL_RenderFillRect(renderer, &r);
}
}
}
}
SDL_RenderPresent(renderer);
SDL_Delay(16);
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}

复制代码

zzz19760225 · 发表于 2025-12-25 18:09:54

#include <SDL2/SDL.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h> // for usleep
#define GRID_SIZE 16
#define CELL_SIZE 20
#define WINDOW_WIDTH (GRID_SIZE * CELL_SIZE)
#define WINDOW_HEIGHT (GRID_SIZE * CELL_SIZE)
const char* filename = "16x16_1.txt";
int grid[GRID_SIZE][GRID_SIZE] = {0};
time_t last_mtime = 0;
// 创建默认文件（全0）
void create_default_file() {
FILE* fp = fopen(filename, "w");
if (!fp) {
fprintf(stderr, "Cannot create default file %s\n", filename);
return;
}
for (int y = 0; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
fputc('0', fp);
}
fputc('\n', fp);
}
fclose(fp);
printf("Created default %s (all zeros).\n", filename);
}
// 加载位图文件到 grid
int load_bitmap() {
FILE* fp = fopen(filename, "r");
if (!fp) {
printf("File %s not found.\n", filename);
create_default_file();
fp = fopen(filename, "r");
if (!fp) return -1;
}
char line[32];
int y = 0;
while (fgets(line, sizeof(line), fp) && y < GRID_SIZE) {
for (int x = 0; x < GRID_SIZE && line[x]; x++) {
grid[y][x] = (line[x] == '1') ? 1 : 0;
}
y++;
}
fclose(fp);
// 补全不足16行的情况（安全处理）
for (; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
grid[y][x] = 0;
}
}
// 获取当前修改时间
struct stat st;
if (stat(filename, &st) == 0) {
last_mtime = st.st_mtime;
}
return 0;
}
// 渲染点阵
void render(SDL_Renderer* renderer) {
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
for (int y = 0; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
SDL_Rect rect = { x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE };
SDL_SetRenderDrawColor(renderer,
grid[y][x] ? 0 : 255,
grid[y][x] ? 0 : 255,
grid[y][x] ? 0 : 255,
255
);
SDL_RenderFillRect(renderer, &rect);
}
}
// 可选：网格线
SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
for (int i = 0; i <= GRID_SIZE; i++) {
SDL_RenderDrawLine(renderer, i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_HEIGHT);
SDL_RenderDrawLine(renderer, 0, i * CELL_SIZE, WINDOW_WIDTH, i * CELL_SIZE);
}
SDL_RenderPresent(renderer);
}
// 检查文件是否被修改
int file_modified() {
struct stat st;
if (stat(filename, &st) != 0) {
// 文件被删除？当作已修改（下次加载会重建）
return 1;
}
return (st.st_mtime != last_mtime);
}
int main(int argc, char* argv[]) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
return 1;
}
SDL_Window* window = SDL_CreateWindow(
"16x16 Dot Matrix Auto-Refresh Viewer",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);
if (!window) {
fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
// 初次加载
if (load_bitmap() != 0) {
fprintf(stderr, "Failed to load bitmap.\n");
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
render(renderer);
int running = 1;
SDL_Event e;
const Uint32 CHECK_INTERVAL_MS = 500; // 每500毫秒检查一次
Uint32 last_check = SDL_GetTicks();
while (running) {
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
running = 0;
} else if (e.type == SDL_KEYDOWN) {
if (e.key.keysym.sym == SDLK_r) {
printf("Manual reload triggered.\n");
if (load_bitmap() == 0) render(renderer);
} else if (e.key.keysym.sym == SDLK_ESCAPE) {
running = 0;
}
}
}
// 自动检查文件是否被外部修改
Uint32 now = SDL_GetTicks();
if (now - last_check >= CHECK_INTERVAL_MS) {
last_check = now;
if (file_modified()) {
printf("Detected change in %s, reloading...\n", filename);
if (load_bitmap() == 0) {
render(renderer);
}
}
}
SDL_Delay(16); // ~60 FPS
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
//gcc -o 16x16点阵刷新1 16x16点阵刷新1.c -lSDL2

复制代码

编译后生成执行文件，运行执行文件会生成16x16_1.txt文本。
用nano修改16x16_1.txt，保存修改后，会对应点阵显示出变化。达到显存效应的需求

zzz19760225 · 发表于 2025-12-29 10:46:38

本帖最后由 zzz19760225 于 2025-12-29 11:32 编辑

16x16点阵全组合的鼠标点击自定义点阵选择，输出数值信息。

//gcc -o dotmatrix dotmatrix.c -lSDL2
#include <stdio.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
#define WIDTH 16
#define HEIGHT 16
#define DOT_SIZE 30
#define MARGIN 20
#define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
#define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
#define FRAME_DELAY 50
// 自定义16进制字符映射（0~15）
const char* hex_map[16] = {
"一", "二", "三", "四", "五", "六", "七", "八",
"九", "十", "壹", "贰", "叁", "肆", "伍", "陆"
};
// 将点阵写入 2.txt
void save_dot_to_file(int dot[HEIGHT][WIDTH]) {
FILE* fp = fopen("2.txt", "w");
if (!fp) {
fprintf(stderr, "无法创建文件 2.txt\n");
return;
}
// 设置UTF-8编码（可选，Linux/macOS默认UTF-8）
// Windows可能需要额外处理，但fopen默认ANSI；若需UTF-8可加BOM或用_setmode，此处简化
// 我们直接写UTF-8字符串
// 遍历256位，生成64个hex字符（从左上到右下，高位在前）
for (int i = 0; i < 64; i++) {
// 每个hex字符由4个bit组成
int nibble = 0;
for (int b = 0; b < 4; b++) {
int bit_index = i * 4 + b; // 0 ~ 255
int y = bit_index / WIDTH;
int x = bit_index % WIDTH;
if (y < HEIGHT && x < WIDTH && dot[y][x]) {
nibble |= (1 << (3 - b)); // 高位在前（bit0是最高位）
}
}
fputs(hex_map[nibble], fp);
}
fputc('\n', fp);
fclose(fp);
}
int main(int argc, char* argv[]) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("无法初始化SDL：%s\n", SDL_GetError());
return -1;
}
SDL_Window* window = SDL_CreateWindow(
"16x16 点阵编辑器（状态已保存至 2.txt）",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);
if (!window) {
printf("无法创建窗口：%s\n", SDL_GetError());
SDL_Quit();
return -1;
}
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
printf("无法创建渲染器：%s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return -1;
}
int dot[HEIGHT][WIDTH] = {0};
int running = 1;
SDL_Event event;
// 初始保存一次（全0）
save_dot_to_file(dot);
while (running) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = 0;
}
else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
int mouse_x = event.button.x;
int mouse_y = event.button.y;
int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
// 状态改变，立即保存
save_dot_to_file(dot);
}
}
}
// 清屏
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
// 绘制点阵
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
SDL_SetRenderDrawColor(renderer,
dot[y][x] ? 0 : 220,
dot[y][x] ? 0 : 220,
dot[y][x] ? 0 : 220,
255
);
SDL_Rect rect = {
MARGIN + x * DOT_SIZE,
MARGIN + y * DOT_SIZE,
DOT_SIZE - 2,
DOT_SIZE - 2
};
SDL_RenderFillRect(renderer, &rect);
}
}
SDL_RenderPresent(renderer);
SDL_Delay(FRAME_DELAY);
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}

复制代码

可以鼠标点击图形输出，可以使用中文代表为对应16进制输出为2.txt，用cat 2.txt，可以查看。

0=一，1=二，2=三，3=四，4=五，5=六，6=七，7=八，8=九，9=十，a=壹,b=贰,c=叁,d=肆,e=伍,f=陆,
一一一一一一一一一一一一一一一一一一一一一三一一一三九一一伍九一一贰九一一壹一一一四九一一三九一一伍九一一一一一一一一一一一一一

复制代码

zzz19760225 · 发表于 2025-12-29 16:42:39

两个程序，一个程序鼠标点击16x16点阵的自定义01字符16行，输出到2.txt，另一个程序读取2.txt，读取显示到16x16图形页面，是可以直接显示对接的。
鼠标点击的程序
16x16点阵点击输出二进制16行.c

//编译命令 gcc -o 16x16点阵点击输出二进制16行 16x16点阵点击输出二进制16行.c -lSDL2
#include <stdio.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
#define WIDTH 16
#define HEIGHT 16
#define DOT_SIZE 30
#define MARGIN 20
#define WINDOW_WIDTH (WIDTH * DOT_SIZE + 2 * MARGIN)
#define WINDOW_HEIGHT (HEIGHT * DOT_SIZE + 2 * MARGIN)
#define FRAME_DELAY 50
// 将点阵以分行二进制形式（每行16个0/1）写入 2.txt
void save_dot_to_file(int dot[HEIGHT][WIDTH]) {
FILE* fp = fopen("2.txt", "w");
if (!fp) {
fprintf(stderr, "无法创建文件 2.txt\n");
return;
}
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
fputc(dot[y][x] ? '1' : '0', fp);
}
fputc('\n', fp); // 每行结束后换行
}
fclose(fp);
}
int main(int argc, char* argv[]) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("无法初始化SDL：%s\n", SDL_GetError());
return -1;
}
SDL_Window* window = SDL_CreateWindow(
"16x16 点阵编辑器（二进制已保存至 2.txt，每行16位）",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);
if (!window) {
printf("无法创建窗口：%s\n", SDL_GetError());
SDL_Quit();
return -1;
}
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
printf("无法创建渲染器：%s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return -1;
}
int dot[HEIGHT][WIDTH] = {0}; // 初始化全灭
int running = 1;
SDL_Event event;
// 初始保存（全0）
save_dot_to_file(dot);
while (running) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = 0;
}
else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
int mouse_x = event.button.x;
int mouse_y = event.button.y;
int grid_x = (mouse_x - MARGIN) / DOT_SIZE;
int grid_y = (mouse_y - MARGIN) / DOT_SIZE;
if (grid_x >= 0 && grid_x < WIDTH && grid_y >= 0 && grid_y < HEIGHT) {
dot[grid_y][grid_x] = 1 - dot[grid_y][grid_x];
save_dot_to_file(dot); // 状态改变，立即保存
}
}
}
// 渲染画面
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); // 白色背景
SDL_RenderClear(renderer);
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
// 亮：黑色；灭：浅灰色
Uint8 color = dot[y][x] ? 0 : 220;
SDL_SetRenderDrawColor(renderer, color, color, color, 255);
SDL_Rect rect = {
MARGIN + x * DOT_SIZE,
MARGIN + y * DOT_SIZE,
DOT_SIZE - 2,
DOT_SIZE - 2
};
SDL_RenderFillRect(renderer, &rect);
}
}
SDL_RenderPresent(renderer);
SDL_Delay(FRAME_DELAY);
}
// 清理资源
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}

复制代码

zzz19760225 · 发表于 2025-12-29 16:45:08

第二个程序读取2.txt内容
16x16点阵点击输出二进制16行.c

#include <SDL2/SDL.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h> // for usleep
#define GRID_SIZE 16
#define CELL_SIZE 20
#define WINDOW_WIDTH (GRID_SIZE * CELL_SIZE)
#define WINDOW_HEIGHT (GRID_SIZE * CELL_SIZE)
const char* filename = "2.txt";
int grid[GRID_SIZE][GRID_SIZE] = {0};
time_t last_mtime = 0;
// 创建默认文件（全0）
void create_default_file() {
FILE* fp = fopen(filename, "w");
if (!fp) {
fprintf(stderr, "Cannot create default file %s\n", filename);
return;
}
for (int y = 0; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
fputc('0', fp);
}
fputc('\n', fp);
}
fclose(fp);
printf("Created default %s (all zeros).\n", filename);
}
// 加载位图文件到 grid
int load_bitmap() {
FILE* fp = fopen(filename, "r");
if (!fp) {
printf("File %s not found.\n", filename);
create_default_file();
fp = fopen(filename, "r");
if (!fp) return -1;
}
char line[32];
int y = 0;
while (fgets(line, sizeof(line), fp) && y < GRID_SIZE) {
for (int x = 0; x < GRID_SIZE && line[x]; x++) {
grid[y][x] = (line[x] == '1') ? 1 : 0;
}
y++;
}
fclose(fp);
// 补全不足16行的情况（安全处理）
for (; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
grid[y][x] = 0;
}
}
// 获取当前修改时间
struct stat st;
if (stat(filename, &st) == 0) {
last_mtime = st.st_mtime;
}
return 0;
}
// 渲染点阵
void render(SDL_Renderer* renderer) {
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderClear(renderer);
for (int y = 0; y < GRID_SIZE; y++) {
for (int x = 0; x < GRID_SIZE; x++) {
SDL_Rect rect = { x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE };
SDL_SetRenderDrawColor(renderer,
grid[y][x] ? 0 : 255,
grid[y][x] ? 0 : 255,
grid[y][x] ? 0 : 255,
255
);
SDL_RenderFillRect(renderer, &rect);
}
}
// 可选：网格线
SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
for (int i = 0; i <= GRID_SIZE; i++) {
SDL_RenderDrawLine(renderer, i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_HEIGHT);
SDL_RenderDrawLine(renderer, 0, i * CELL_SIZE, WINDOW_WIDTH, i * CELL_SIZE);
}
SDL_RenderPresent(renderer);
}
// 检查文件是否被修改
int file_modified() {
struct stat st;
if (stat(filename, &st) != 0) {
// 文件被删除？当作已修改（下次加载会重建）
return 1;
}
return (st.st_mtime != last_mtime);
}
int main(int argc, char* argv[]) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
return 1;
}
SDL_Window* window = SDL_CreateWindow(
"16x16 Dot Matrix Auto-Refresh Viewer",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);
if (!window) {
fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
// 初次加载
if (load_bitmap() != 0) {
fprintf(stderr, "Failed to load bitmap.\n");
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
render(renderer);
int running = 1;
SDL_Event e;
const Uint32 CHECK_INTERVAL_MS = 500; // 每500毫秒检查一次
Uint32 last_check = SDL_GetTicks();
while (running) {
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
running = 0;
} else if (e.type == SDL_KEYDOWN) {
if (e.key.keysym.sym == SDLK_r) {
printf("Manual reload triggered.\n");
if (load_bitmap() == 0) render(renderer);
} else if (e.key.keysym.sym == SDLK_ESCAPE) {
running = 0;
}
}
}
// 自动检查文件是否被外部修改
Uint32 now = SDL_GetTicks();
if (now - last_check >= CHECK_INTERVAL_MS) {
last_check = now;
if (file_modified()) {
printf("Detected change in %s, reloading...\n", filename);
if (load_bitmap() == 0) {
render(renderer);
}
}
}
SDL_Delay(16); // ~60 FPS
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
//gcc -o 16x16点阵刷新1 16x16点阵刷新1.c -lSDL2

复制代码

运行编译后的执行程序，就可以对应电器开关一样，这边点击，那边对应显示。（好像没有什么意义！）

zzz19760225 · 发表于 2026-1-6 09:35:15

本帖最后由 zzz19760225 于 2026-1-6 09:37 编辑

linux mint22.2下，nasm汇编+SDL2的C语言图形库，做点阵位图的数字集，八进制无文字颜色代表集=八卦排序全组合，满编全十进制，阿拉伯数字，汉字数字，麻将，苏州数字，天干地支十二进制挪用等多十进制，百进制，千字文的千进制，阿拉伯数字组成的万进制和亿进制可能。

zzz19760225 · 发表于 2026-1-24 11:26:20

寒夜孤星的6个bat批处理，通过AI自动信息通义千问，转为perl版。
6
第六种
han6.pl

#!/usr/bin/perl
use strict; # 启用严格模式，强制声明变量
use warnings; # 启用警告，帮助发现潜在错误
# 定义要排列的四个汉字
my @chars = ('寒', '夜', '孤', '星');
# 用于存储所有排列结果的数组
my @results;
# 递归函数：生成全排列
# 参数：
# $ prefix —— 当前已拼接的字符串（前缀）
# $ remaining —— 剩余可选字符的数组引用
sub permute {
my ( $prefix, $remaining) = @_;
# 如果剩余字符为空，说明已形成一个完整排列
if (@$remaining == 0) {
push @results, $prefix; # 将结果保存到数组
print " $prefix\n"; # 输出该排列（注意：原脚本前面有空格，这里已去除）
return;
}
# 遍历剩余字符中的每一个位置
for my $i (0 .. $#{ $remaining}) {
my @new_remaining = @$remaining; # 复制剩余字符列表
my $char = splice(@new_remaining, $i, 1); # 取出第 i 个字符
permute( $prefix . $char, \@new_remaining); # 递归：前缀加上该字符，剩余列表更新
}
}
# 从空前缀和完整字符列表开始递归
permute("", \@chars);
# 输出总共有多少种排列方式（4! = 24）
print scalar(@results) . "种组合方式\n";
# 暂停程序，等待用户按回车（类似 Windows 的 pause）
<>;

复制代码

第六种输出结果

寒夜孤星
寒夜星孤
寒孤夜星
寒孤星夜
寒星夜孤
寒星孤夜
夜寒孤星
夜寒星孤
夜孤寒星
夜孤星寒
夜星寒孤
夜星孤寒
孤寒夜星
孤寒星夜
孤夜寒星
孤夜星寒
孤星寒夜
孤星夜寒
星寒夜孤
星寒孤夜
星夜寒孤
星夜孤寒
星孤寒夜
星孤夜寒
24种组合方式

复制代码

zzz19760225 · 发表于 2026-4-3 15:58:04

本帖最后由 zzz19760225 于 2026-4-3 18:03 编辑

linux下自制字符，

制作永久生效的自制终端字体，核心是修改点阵字模，而不是简单地更换字体文件。这需要用到专门的编辑器 fontopia。

2. 修改终端字体，自制字形（永久生效）

Linux 终端通常用 PCF/PSF 字体，可以修改。

提取字体：cp /usr/share/consolefonts/Lat2-Terminus16.psf.gz . ; gunzip Lat2-Terminus16.psf.gz

转换格式：psf2raw Lat2-Terminus16.psf raw.bin (需 psfutils)

修改位图：用 16 进制编辑器修改 raw.bin（每个字符是 16 字节，每字节代表一行 8 像素）。需对照原字体映射表。

回转换：raw2psf raw.bin myfont.psf ; sudo cp myfont.psf /usr/share/consolefonts/

加载：setfont myfont.psf（立即生效，重启恢复）。永久修改需配置 /etc/vconsole.conf。

⚠️ 注意：现代图形终端（gnome-terminal, konsole）通常忽略控制台字体，需要使用 framebuffer 控制台（Ctrl+Alt+F2）才能看到效果。

你可以放心修改终端字体，它完全不影响你使用 Ctrl + Alt + F7 切换回图形界面。
原因很简单：

修改对象不同：你修改的 setfont 和 /etc/vconsole.conf 只作用于虚拟终端（也就是 tty1 到 tty6，通常按 Ctrl + Alt + F2 到 F6 进入）。而你日常使用的图形界面（GNOME、KDE、Deepin等）通常运行在 tty7 或 tty1（取决于发行版），Ctrl + Alt + F7 正是切换到它的快捷键。

互不干扰：虚拟终端和图形界面使用完全独立的字体系统和显示驱动。你在 tty2 里把字母 'A' 改成一只小乌龟，图形界面里的 Firefox、终端模拟器、文本编辑器丝毫不会受影响。同样，切换回图形界面的快捷键功能也完好无损。

总结：

在 tty2-tty6：看到的是你自制的字体。

按 Ctrl + Alt + F7 回到图形界面：一切如常，字体没变，快捷键正常工作。

再按 Ctrl + Alt + F2 回去：自制字体依然在。

所以放心大胆去修改吧，这就像你给自己书房换了个台灯，完全不影响客厅的照明和开关。

PSF 字体全称 PC Screen Font（PC 屏幕字体），是一种古老的等宽位图字体格式。

它最早在 1989 年左右为 DOS 系统设计，后被 Linux 内核采纳为控制台默认字体

手动绘制或微调单个字形，像用画图软件一样 gbdfed (图形化)

方案一：gbdfed —— 图形化界面，直观易用

如果你习惯使用鼠标，喜欢所见即所得的编辑方式，gbdfed 是最佳选择

。

核心优势：它是一个基于 GTK 的图形界面软件，可以像在画图软件里一样，用鼠标点像素来设计字形。它的最大亮点是原生支持导入和导出 PSF 格式，可以完美融入你的工作流。

工作流程：gbdfed 的逻辑是先将 PSF 字体导入，在内部转换成 BDF 格式进行编辑，然后再导出回 PSF2 格式

。这个过程对用户是透明的，你不必关心格式转换的细节。

编辑能力：可以自由绘制每个字符的点阵图，复制粘贴字形，修改字体属性（如大小、间距等），并且支持 Unicode 字符映射

。

安装方法：在 Linux Mint 的终端中运行以下命令即可安装：
bash

sudo apt update
sudo apt install gbdfed

用gbdfed，建立1234567890a,;:.字符，从10进制开始的数字集。

zzz19760225 · 发表于 2026-4-12 14:53:30

本帖最后由 zzz19760225 于 2026-4-12 15:34 编辑

Linux 6.14.5 版本
内核源码极为庞大，但目录结构非常清晰。理解每个顶级目录的职责，是深入源码的第一步：

arch/------硬件架构相关代码-------------x86/, arm64/, loongarch/ 等
block/-----块设备层（管理硬盘、SSD等）--blk-cgroup.c, bdev.c
crypto/----加密API的实现----------------crypto_null.c, ecdsa-p1363.c
Documentation/--内核文档（非常重要！）--admin-guide/, bpf/, trace/
drivers/---硬件驱动（占源码大半）-------gpu/, net/, usb/, ata/
fs/--------文件系统实现-----------------ext4/, btrfs/, overlayfs/
include/---内核头文件-------------------linux/, asm-generic/
init/------内核启动初始化---------------main.c (start_kernel 入口)
ipc/-------进程间通信-------------------msg.c, sem.c, shm.c
kernel/----核心子系统（调度、中断等）---sched/, irq/, printk/
lib/-------内核通用库函数---------------radix-tree.c, sort.c
mm/--------内存管理---------------------page_alloc.c, vmscan.c
net/-------网络协议栈-------------------ipv4/, ipv6/, socket.c
scripts/---构建和配置脚本---------------kconfig/, patch-kernel
security/--安全框架（如SELinux）--------apparmor/, keys/
sound/-----音频子系统-------------------pci/, usb/, core/
tools/-----与内核交互的用户态工具-------perf/, objtool/
usr/-------initramfs 生成相关-----------gen_init_cpio.c
顶级目录---核心功能---------------------关键子模块/文件举例

复制代码

按照字符数量排序18个集合

2
fs/--------文件系统实现-----------------ext4/, btrfs/, overlayfs/
mm/--------内存管理---------------------page_alloc.c, vmscan.c
3
usr/-------initramfs 生成相关-----------gen_init_cpio.c
lib/-------内核通用库函数---------------radix-tree.c, sort.c
ipc/-------进程间通信-------------------msg.c, sem.c, shm.c
net/-------网络协议栈-------------------ipv4/, ipv6/, socket.c
4
arch/------硬件架构相关代码-------------x86/, arm64/, loongarch/ 等
init/------内核启动初始化---------------main.c (start_kernel 入口)
5
block/-----块设备层（管理硬盘、SSD等）--blk-cgroup.c, bdev.c
sound/-----音频子系统-------------------pci/, usb/, core/
tools/-----与内核交互的用户态工具-------perf/, objtool/
6
kernel/----核心子系统（调度、中断等）---sched/, irq/, printk/
crypto/----加密API的实现----------------crypto_null.c, ecdsa-p1363.c
7
include/---内核头文件-------------------linux/, asm-generic/
scripts/---构建和配置脚本---------------kconfig/, patch-kernel
drivers/---硬件驱动（占源码大半）-------gpu/, net/, usb/, ata/
8
security/--安全框架（如SELinux）--------apparmor/, keys/
Documentation/--内核文档（非常重要！）--admin-guide/, bpf/, trace/

复制代码

zzz19760225 · 发表于 2026-4-13 16:12:24

本帖最后由 zzz19760225 于 2026-4-15 13:19 编辑

汉字笔画种类
4，横竖劈捺
5，横竖撇点折
6，横竖撇捺点提
8，横竖撇捺点提钩折，横竖撇捺点提钩弯，

31
32

36
37

50

a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

Bin(二进制)--Oct(八进制)--Dec(十进制)--Hex(十六进制)--缩写/字符解释
0000 0000----00-----------0------------0x00-----------NUL(null)空字符
0000 0001----01-----------1------------0x01-----------SOH(start of headline)标题开始
0000 0010----02-----------2------------0x02-----------STX (start of text)正文开始
0000 0011----03-----------3------------0x03-----------ETX (end of text)正文结束
0000 0100----04-----------4------------0x04-----------EOT (end of transmission)传输结束
0000 0101----05-----------5------------0x05-----------ENQ (enquiry)请求
0000 0110----06-----------6------------0x06-----------ACK (acknowledge)收到通知
0000 0111----07-----------7------------0x07-----------BEL (bell)响铃
0000 1000----010----------8------------0x08-----------BS (backspace)退格
0000 1001----011----------9------------0x09-----------HT (horizontal tab)水平制表符
0000 1010----012----------10-----------0x0A-----------LF (NL line feed, new line)换行键
0000 1011----013----------11-----------0x0B-----------VT (vertical tab)垂直制表符
0000 1100----014----------12-----------0x0C-----------FF (NP form feed, new page)换页键
0000 1101----015----------13-----------0x0D-----------CR (carriage return)回车键
0000 1110----016----------14-----------0x0E-----------SO (shift out)不用切换
0000 1111----017----------15-----------0x0F-----------SI (shift in)启用切换
0000 1110016140x0ESO (shift out)不用切换
0000 1111017150x0FSI (shift in)启用切换
0001 0000020160x10DLE (data link escape)数据链路转义
0001 0001021170x11DC1 (device control 1)设备控制1
0001 0010022180x12DC2 (device control 2)设备控制2
0001 0011023190x13DC3 (device control 3)设备控制3
0001 0100024200x14DC4 (device control 4)设备控制4
0001 0101025210x15NAK (negative acknowledge)拒绝接收
0001 0110026220x16SYN (synchronous idle)同步空闲
0001 0111027230x17ETB (end of trans. block)结束传输块
0001 1000030240x18CAN (cancel)取消
0001 1001031250x19EM (end of medium)媒介结束
0001 1010032260x1ASUB (substitute)代替
0001 1011033270x1BESC (escape)换码(溢出)
0001 1100034280x1CFS (file separator)文件分隔符
0001 1101035290x1DGS (group separator)分组符
0001 1110036300x1ERS (record separator)记录分隔符
0001 1111037310x1FUS (unit separator)单元分隔符
0010 0000040320x20(space)空格
0010 0001041330x21!叹号
0010 0010042340x22"双引号
0010 0011043350x23#井号
0010 0100044360x24$美元符
0010 0101045370x25%百分号
0010 0110046380x26&和号
0010 0111047390x27'单引号
0010 1000050400x28(开括号
0010 1001051410x29)闭括号
0010 1010052420x2A*星号
0010 1011
053
43
0x2B
+
加号
0010 1100
054
44
0x2C
,
逗号
0010 1101
055
45
0x2D
-
减号/破折号
0010 1110
056
46
0x2E
.
句号
0010 1111
057
47
0x2F
/
斜杠
0011 0000
060
48
0x30
0
字符0
0011 0001
061
49
0x31
1
字符1
0011 0010
062
50
0x32
2
字符2
0011 0011
063
51
0x33
3
字符3
0011 0100
064
52
0x34
4
字符4
0011 0101
065
53
0x35
5
字符5
0011 0110
066
54
0x36
6
字符6
0011 0111
067
55
0x37
7
字符7
0011 1000
070
56
0x38
8
字符8
0011 1001
071
57
0x39
9
字符9
0011 1010
072
58
0x3A
:
冒号
0011 1011
073
59
0x3B
;
分号
0011 1100
074
60
0x3C
<
小于
0011 1101
075
61
0x3D
=
等号
0011 1110
076
62
0x3E
>
大于
0011 1111
077
63
0x3F
?
问号
0100 0000
0100
64
0x40
@
电子邮件符号
0100 0001
0101
65
0x41
A
大写字母A
0100 0010
0102
66
0x42
B
大写字母B
0100 0011
0103
67
0x43
C
大写字母C
0100 0100
0104
68
0x44
D
大写字母D
0100 0101
0105
69
0x45
E
大写字母E
0100 0110
0106
70
0x46
F
大写字母F
0100 0111
0107
71
0x47
G
大写字母G
0100 1000
0110
72
0x48
H
大写字母H
0100 1001
0111
73
0x49
I
大写字母I
01001010
0112
74
0x4A
J
大写字母J
0100 1011
0113
75
0x4B
K
大写字母K
0100 1100
0114
76
0x4C
L
大写字母L
0100 1101
0115
77
0x4D
M
大写字母M
0100 1110
0116
78
0x4E
N
大写字母N
0100 1111
0117
79
0x4F
O
大写字母O
0101 0000
0120
80
0x50
P
大写字母P
0101 0001
0121
81
0x51
Q
大写字母Q
0101 0010
0122
82
0x52
R
大写字母R
0101 0011
0123
83
0x53
S
大写字母S
0101 0100
0124
84
0x54
T
大写字母T
0101 0101
0125
85
0x55
U
大写字母U
0101 0110
0126
86
0x56
V
大写字母V
0101 0111
0127
87
0x57
W
大写字母W
0101 1000
0130
88
0x58
X
大写字母X
0101 1001
0131
89
0x59
Y
大写字母Y
0101 1010
0132
90
0x5A
Z
大写字母Z
0101 10110133910x5B[开方括号
0101 11000134920x5C\反斜杠
0101 11010135930x5D]闭方括号
0101 11100136940x5E^脱字符
0101 11110137950x5F_下划线
0110 00000140960x60`开单引号
0110 00010141970x61a小写字母a
0110 00100142980x62b小写字母b
0110 00110143990x63c小写字母c
0110 010001441000x64d小写字母d
0110 010101451010x65e小写字母e
0110 011001461020x66f小写字母f
0110 011101471030x67g小写字母g
0110 100001501040x68h小写字母h
0110 100101511050x69i小写字母i
0110 101001521060x6Aj小写字母j
0110 101101531070x6Bk小写字母k
0110 110001541080x6Cl小写字母l
0110 110101551090x6Dm小写字母m
0110 111001561100x6En小写字母n
0110 111101571110x6Fo小写字母o
0111 000001601120x70p小写字母p
0111 000101611130x71q小写字母q
0111 001001621140x72r小写字母r
0111 001101631150x73s小写字母s
0111 010001641160x74t小写字母t
0111 010101651170x75u小写字母u
0111 011001661180x76v小写字母v
0111 011101671190x77w小写字母w
0111 100001701200x78x小写字母x
0111 100101711210x79y小写字母y
0111 101001721220x7Az小写字母z
0111 101101731230x7B{开花括号
0111 110001741240x7C|垂线
0111 110101751250x7D}闭花括号
0111 111001761260x7E波浪号
0111 1111 -- 0177 -- 127 -- 0x7F -- DEL (delete) -- 删除

复制代码

zzz19760225 · 发表于 2026-4-14 20:53:57

本帖最后由 zzz19760225 于 2026-4-19 18:38 编辑

simulide仿真
甲：需求本体有关的单元认识理解熟悉熟练，乙：环境测试实验内容集合，丙：实验历史记录和未来全排列的自动度（电器硬件概念层面的自动化自动信息）。
1电源，输入电流，亮一个电源灯，输出接地。[ 完成 ] 但是，需要闭环电源电流，当电池输入流入，接地为流出时，无法点亮。那么应该还不算完成。
用单向引出线的电源=Fixed Voltage-6，就可以接地点亮灯了。这个问题马马虎虎算过了吧。
2键盘逻辑单元阵列输入，输出逻辑单元阵列屏幕800x600。
模拟104键盘
模拟800x600屏幕
单开关到单屏幕点阵
单开关到多屏幕点阵
多开关到单屏幕点阵
多开关到多屏幕点阵
任意开关到任意屏幕点阵的规律和抽象概念

1环境测试电源电流电压，2电路板平台电路架构，3集成块74组织机器，4无限抽象逻辑符号组织机器。5电流公式和具体数量数字清单，组织机器图片的记录排序（基本原理的概念汉字DOS，应该在这个信息排序的选择中）。

		自动登录	找回密码
密码			注册

[新手上路]批处理新手入门导读	[视频教程]批处理基础视频教程	[视频教程]VBS基础视频教程	[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动	[批处理精品]CMD命令50条不能说的秘密	[在线下载]第三方命令行工具	[在线帮助]VBScript / JScript 在线参考

16数字集

DOS到LINUX使用的点阵PSF字体

面汉字笔画种类单元组合=对应字母线的点

浏览过的版块