Raspberry Pi Pico + Neopixel panel 16x16 a programování v Zigu

;
; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
;
; SPDX-License-Identifier: BSD-3-Clause
;
.program ws2812                         ; (1)
.side_set 1                             ; (2)

.define public T1 2                     ; (3)
.define public T2 5
.define public T3 3

.wrap_target                            ; (4)
bitloop:
    out x, 1       side 0 [T3 - 1] ; Side-set still takes place when instruction stalls
    jmp !x do_zero side 1 [T1 - 1] ; Branch on the bit we shifted out. Positive pulse
do_one:
    jmp  bitloop   side 1 [T2 - 1] ; Continue driving high, for a long pulse
do_zero:
    nop            side 0 [T2 - 1] ; Or drive low, for a short pulse
.wrap

$ ffmpeg -i VID_20240816_202407.mp4 -vf "transpose=2" -acodec copy zig_neopixel.mp4
$ ffmpeg -i zig_neopixel.mp4 -vf "transpose=2" -acodec copy prace_zig_neopixel.mp4

const std = @import("std");
const microzig = @import("microzig");
const rp2040 = microzig.hal;
const gpio = rp2040.gpio;
const rand = rp2040.rand;
const Pio = rp2040.pio.Pio;
const StateMachine = rp2040.pio.StateMachine;
const radku = 16;
const sloupcu = 16;
const pocet_ledek = radku*sloupcu; // pocet zřetězených LED
const obracene = true;
var barvy: [pocet_ledek]u32 = undefined;

const ws2812_program = blk: {
    @setEvalBranchQuota(5000);
    break :blk rp2040.pio.assemble(
        \\;
        \\; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
        \\;
        \\; SPDX-License-Identifier: BSD-3-Clause
        \\;
        \\.program ws2812
        \\.side_set 1
        \\
        \\.define public T1 2
        \\.define public T2 5
        \\.define public T3 3
        \\
        \\.wrap_target
        \\bitloop:
        \\    out x, 1       side 0 [T3 - 1] ; Side-set still takes place when instruction stalls
        \\    jmp !x do_zero side 1 [T1 - 1] ; Branch on the bit we shifted out. Positive pulse
        \\do_one:
        \\    jmp  bitloop   side 1 [T2 - 1] ; Continue driving high, for a long pulse
        \\do_zero:
        \\    nop            side 0 [T2 - 1] ; Or drive low, for a short pulse
        \\.wrap
    , .{}).get_program_by_name("ws2812");
};

const pio: Pio = .pio0;
const sm: StateMachine = .sm0;
const led_pin = gpio.num(15);   // GP15 (pin 20 na Raspberry Pi Pico)

pub fn main() void {
    pio.gpio_init(led_pin);
    sm_set_consecutive_pindirs(pio, sm, @intFromEnum(led_pin), 1, true);

    const cycles_per_bit: comptime_int = ws2812_program.defines[0].value + //T1
        ws2812_program.defines[1].value + //T2
        ws2812_program.defines[2].value; //T3
    const div = @as(f32, @floatFromInt(rp2040.clock_config.sys.?.output_freq)) /
        (800_000 * cycles_per_bit);

    pio.sm_load_and_start_program(sm, ws2812_program, .{
        .clkdiv = rp2040.pio.ClkDivOptions.from_float(div),
        .pin_mappings = .{
            .side_set = .{
                .base = @intFromEnum(led_pin),
                .count = 1,
            },
        },
        .shift = .{
            .out_shiftdir = .left,
            .autopull = true,
            .pull_threshold = 24,
            .join_tx = true,
        },
    }) catch unreachable;
    pio.sm_set_enabled(sm, true);
    // random number init
    var ascon = rand.Ascon.init();
    var rng = ascon.random();
    var buffer: [14*3]u8 = undefined;
    clear();
    while (true) {
        // barvy na řádcích 12 a 13 se budou náhodně měnit
        rng.bytes(buffer[0..]);
        for(0..14) |i| {
            bod(i+1, 13, buffer[3*i+0],buffer[3*i+1],buffer[3*i+2]);
        }
        rng.bytes(buffer[0..]);
        for(0..14) |i| {
            bod(i+1, 12, buffer[3*i+0],buffer[3*i+1],buffer[3*i+2]);
        }

        for(0..16) |i| {
            bod(i,  0, 0x22, 0x00, 0x00);
            bod(i, 15, 0x00, 0x22, 0x00);
            bod(0,  i, 0x00, 0x00, 0x22);
            bod(15, i, 0x22, 0x22, 0x00);
        }
        bod(0,   0, 0x22, 0x22, 0x22);
        bod(0,  15, 0x22, 0x22, 0x22);
        bod(15,  0, 0x22, 0x22, 0x22);
        bod(15, 15, 0x22, 0x22, 0x22);
        write_display(pio,sm);
        rp2040.time.sleep_ms(2500);
        // nakreslím písmeno Z
        bod(2,8,0x00,0x00,0x44);
        bod(3,8,0x00,0x00,0x44);
        bod(4,8,0x00,0x00,0x44);
        bod(5,8,0x00,0x00,0x44);
        bod(6,8,0x00,0x00,0x44);
        bod(6,7,0x00,0x00,0x44);
        bod(5,6,0x00,0x00,0x44);
        bod(4,5,0x00,0x00,0x44);
        bod(3,4,0x00,0x00,0x44);
        bod(2,3,0x00,0x00,0x44);
        bod(2,2,0x00,0x00,0x44);
        bod(3,2,0x00,0x00,0x44);
        bod(4,2,0x00,0x00,0x44);
        bod(5,2,0x00,0x00,0x44);
        bod(6,2,0x00,0x00,0x44);
        // nakreslím písmeno I
        bod(8,2,0x00,0x00,0x44);
        bod(8,3,0x00,0x00,0x44);
        bod(8,4,0x00,0x00,0x44);
        bod(8,5,0x00,0x00,0x44);
        bod(8,6,0x00,0x00,0x44);
        bod(8,7,0x00,0x00,0x44);
        bod(8,8,0x00,0x00,0x44);
        // nakreslím písmeno G
        bod(0xd,8,0x00,0x00,0x44);
        bod(0xc,8,0x00,0x00,0x44);
        bod(0xb,8,0x00,0x00,0x44);
        bod(0xa,7,0x00,0x00,0x44);
        bod(0xa,6,0x00,0x00,0x44);
        bod(0xa,5,0x00,0x00,0x44);
        bod(0xa,4,0x00,0x00,0x44);
        bod(0xa,3,0x00,0x00,0x44);
        bod(0xb,2,0x00,0x00,0x44);
        bod(0xc,2,0x00,0x00,0x44);
        bod(0xd,2,0x00,0x00,0x44);
        bod(0xd,3,0x00,0x00,0x44);
        bod(0xd,4,0x00,0x00,0x44);
        bod(0xd,5,0x00,0x00,0x44);
        bod(0xc,5,0x00,0x00,0x44);

        write_display( pio, sm);
        rp2040.time.sleep_ms(2500);
        clear();
    }
}

fn sm_set_consecutive_pindirs(_pio: Pio, _sm: StateMachine, pin: u5, count: u3, is_out: bool) void {
    const sm_regs = _pio.get_sm_regs(_sm);
    const pinctrl_saved = sm_regs.pinctrl.raw;
    sm_regs.pinctrl.modify(.{
        .SET_BASE = pin,
        .SET_COUNT = count,
    });
    _pio.sm_exec(_sm, rp2040.pio.Instruction{
        .tag = .set,
        .delay_side_set = 0,
        .payload = .{
            .set = .{
                .data = @intFromBool(is_out),
                .destination = .pindirs,
            },
        },
    });
    sm_regs.pinctrl.raw = pinctrl_saved;
}

/// rozsvití celý řádek LED v dané barvě (red, green, blue)
/// pio.sm_blocking_write() je potřeba volat bez časových pauz
fn plny_radek(_pio: Pio, _sm: StateMachine, red: u32, green: u32, blue: u32) void {
    const color: u32 = ((red << 8) + (green << 16) + blue) << 8;
    for(0..pocet_ledek) |_| {
        _pio.sm_blocking_write(_sm, color);
    }
}

/// zapíše pole barvy na displej
fn write_display(_pio: Pio, _sm: StateMachine) void {
    for(0..pocet_ledek) |i| {
        _pio.sm_blocking_write(_sm, barvy[i] << 8);
    }
}

/// vynuluje pole barvy
fn clear() void {
    for(0..pocet_ledek) |i| {
        barvy[i]=0x000000;
    }
}

/// obarví bod o souřadnicích x,y barvou (R,G,B)
fn bod(x: u32, y: u32, red: u32, green: u32, blue: u32) void {
    if( x >= 0 and x < radku and y >= 0 and y < sloupcu ) {
        const color: u32 = (red << 8) + (green << 16) + blue;
        var linbod: u32 = 0;
        if(y % 2 == 0) { // sude radky
            linbod = y*radku + x;
        } else {
            linbod = y*radku + (sloupcu - x - 1);
        }
        if(linbod >= 0 and linbod < pocet_ledek) {
            barvy[linbod] = color;
        }
    }
}

// neopixel_cas.zig
// (c) Jirka Chráska <jirka@lixis.cz>
// SPDX-License-Identifier: BSD-3-Clause

const std = @import("std");
const microzig = @import("microzig");
const rp2040 = microzig.hal;
const gpio = rp2040.gpio;
const rand = rp2040.rand;
const Pio = rp2040.pio.Pio;
const StateMachine = rp2040.pio.StateMachine;
const radku = 16;
const sloupcu = 32;
const sloupcu_matice = 16;
const pocet_ledek = radku * sloupcu; // pocet zřetězených LED
const obracene = true;
var barvy: [pocet_ledek]u32 = undefined;
// debug uart
const led = gpio.num(25);
const uart = rp2040.uart.num(0);
const baud_rate = 115200;
const uart_tx_pin = gpio.num(0);
const uart_rx_pin = gpio.num(1);

pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
    std.log.err("panic: {s}", .{message});
    @breakpoint();
    while (true) {}
}

pub const microzig_options = .{
    .log_level = .debug,
    .logFn = rp2040.uart.log,
};

const ws2812_program = blk: {
    @setEvalBranchQuota(5000);
    break :blk rp2040.pio.assemble(
        \\;
        \\; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
        \\;
        \\; SPDX-License-Identifier: BSD-3-Clause
        \\;
        \\.program ws2812
        \\.side_set 1
        \\
        \\.define public T1 2
        \\.define public T2 5
        \\.define public T3 3
        \\
        \\.wrap_target
        \\bitloop:
        \\    out x, 1       side 0 [T3 - 1] ; Side-set still takes place when instruction stalls
        \\    jmp !x do_zero side 1 [T1 - 1] ; Branch on the bit we shifted out. Positive pulse
        \\do_one:
        \\    jmp  bitloop   side 1 [T2 - 1] ; Continue driving high, for a long pulse
        \\do_zero:
        \\    nop            side 0 [T2 - 1] ; Or drive low, for a short pulse
        \\.wrap
    , .{}).get_program_by_name("ws2812");
};

const pio: Pio = .pio0;
const sm: StateMachine = .sm0;
const led_pin = gpio.num(15); // GP15 (pin 20 na Raspberry Pi Pico) sem je připojen displej WS2812B

pub fn main() void {
    // uart logování
    led.set_function(.sio);
    led.set_direction(.out);
    led.put(1);

    uart.apply(.{
        .baud_rate = baud_rate,
        .tx_pin = uart_tx_pin,
        .rx_pin = uart_rx_pin,
        .clock_config = rp2040.clock_config,
    });

    rp2040.uart.init_logger(uart);
    // inicializace pinu pro WS2812B displej
    pio.gpio_init(led_pin);
    // nastavení pinu pro PIO program a side set pinů (jeden)
    sm_set_consecutive_pindirs(pio, sm, @intFromEnum(led_pin), 1, true);

    // cycles_per_bit určuje, kolik cyklů (tiků) hodin bude trvat přenos jednoho bitu
    // T1=2 + T2=5 + T3=3, což je 10 cyklů
    const cycles_per_bit: comptime_int = ws2812_program.defines[0].value + //T1
        ws2812_program.defines[1].value + //T2
        ws2812_program.defines[2].value; //T3
    const div = @as(f32, @floatFromInt(rp2040.clock_config.sys.?.output_freq)) / (800_000 * cycles_per_bit);

    // načtení a spuštění PIO programu
    pio.sm_load_and_start_program(sm, ws2812_program, .{
        .clkdiv = rp2040.pio.ClkDivOptions.from_float(div),
        .pin_mappings = .{
            .side_set = .{
                .base = @intFromEnum(led_pin),
                .count = 1,
            },
        },
        .shift = .{
            .out_shiftdir = .left,
            .autopull = true,
            .pull_threshold = 24,
            .join_tx = true,
        },
    }) catch unreachable;
    pio.sm_set_enabled(sm, true);
    // random number init (to je jenom pomůcka pro testování)
    var ascon = rand.Ascon.init();
    var rng = ascon.random();
    var cbuffer: [3]u8 = undefined;
    clear();
    const sec = [_]u8{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    const dsec = [_]u8{ '0', '1', '2', '3', '4', '5' };
    const min = [_]u8{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    const dmin = [_]u8{ '0', '1', '2', '3', '4', '5' };
    const hod = [_]u8{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    const dhod = [_]u8{ '0', '1', '2' };
    std.log.info("start", .{});
    while (true) {
        led.put(1);
        for (dhod) |dh| {
            std.log.info("Dhod {c}", .{dh});
            for (hod) |h| {
                std.log.info("hod {c}", .{h});
                if (h == '4' and dh == '2') {
                    break;
                }
                for (dmin) |dm| {
                    std.log.info("dmin {c}", .{dm});
                    for (min) |m| {
                        std.log.info("min {c}", .{m});
                        for (dsec) |ds| {
                            std.log.info("ds {c}", .{ds});
                            rng.bytes(cbuffer[0..]);
                            const r = cbuffer[0];
                            const g = cbuffer[1];
                            const b = cbuffer[2];

                            for (sec) |s| {
                                std.log.info("s {c}", .{s});
                                znak5(0, 8, dh, r, g, b);
                                znak5(5, 8, h, r, g, b);
                                bod(10, 10, 0xaa, 0x00, 0x00);
                                bod(10, 13, 0xaa, 0x00, 0x00);
                                znak5(11, 8, dm, r, g, b);
                                znak5(16, 8, m, r, g, b);
                                bod(21, 10, 0x00, 0xaa, 0x00);
                                bod(21, 13, 0x00, 0xaa, 0x00);
                                znak5(22, 8, ds, r, g, b);
                                znak5(27, 8, s, r, g, b);
                                write_display(pio, sm);
                                rp2040.time.sleep_ms(1000);
                                led.put(0);
                                clear();
                            }
                        }
                    }
                }
            }
        }
    }
}

fn sm_set_consecutive_pindirs(_pio: Pio, _sm: StateMachine, pin: u5, count: u3, is_out: bool) void {
    const sm_regs = _pio.get_sm_regs(_sm);
    const pinctrl_saved = sm_regs.pinctrl.raw;
    sm_regs.pinctrl.modify(.{
        .SET_BASE = pin,
        .SET_COUNT = count,
    });
    _pio.sm_exec(_sm, rp2040.pio.Instruction{
        .tag = .set,
        .delay_side_set = 0,
        .payload = .{
            .set = .{
                .data = @intFromBool(is_out),
                .destination = .pindirs,
            },
        },
    });
    sm_regs.pinctrl.raw = pinctrl_saved;
}

// zapíše pole barvy na diplej
fn write_display(_pio: Pio, _sm: StateMachine) void {
    for (0..pocet_ledek) |i| {
        _pio.sm_blocking_write(_sm, barvy[i] << 8);
    }
}

/// vynuluje pole barvy
fn clear() void {
    for (0..pocet_ledek) |i| {
        barvy[i] = 0x000000;
    }
}

/// obarví bod o souřadnicích x,y barvou (R,G,B)
fn bod(x: u32, y: u32, red: u32, green: u32, blue: u32) void {
    if (x >= 0 and x < sloupcu and y >= 0 and y < radku) {
        const color: u32 = (red << 8) + (green << 16) + blue;
        var linbod: u32 = 0;
        if (x % 2 == 0) { // sudé sloupce jdou shora dolů
            if (x < sloupcu_matice) {
                linbod = x * radku + (radku - 1 - y);
            } else {
                linbod = sloupcu_matice * radku + (x - sloupcu_matice) * radku + (radku - 1 - y);
            }
        } else { // liché sloupce jdou zdola nahoru
            if (x < sloupcu_matice) {
                linbod = x * radku + y;
            } else {
                linbod = sloupcu_matice * radku + (x - sloupcu_matice) * radku + y;
            }
        }
        // std.log.info("x {}, y {}, linbod {}", .{ x, y, linbod });
        if (linbod >= 0 and linbod < pocet_ledek) {
            barvy[linbod] = color;
        }
    }
}
/// Vykreslí znak 5x8 bodů do pole barvy
fn znak5(x: u8, y: u8, znak: u16, red: u8, green: u8, blue: u8) void {
    const z: [5]u8 = switch (znak) {
        '.' => [5]u8{ 0x60, 0x60, 0x00, 0x00, 0x00 },
        ',' => [5]u8{ 0x80, 0x60, 0x00, 0x00, 0x00 },
        ':' => [5]u8{ 0x6c, 0x6c, 0x00, 0x00, 0x00 },
        ';' => [5]u8{ 0x8c, 0x6c, 0x00, 0x00, 0x00 },
        '!' => [5]u8{ 0x00, 0x6f, 0x6f, 0x00, 0x00 },
        '?' => [5]u8{ 0x02, 0x59, 0x59, 0x06, 0x00 },
        '+' => [5]u8{ 0x10, 0x10, 0x7c, 0x10, 0x10 },
        '-' => [5]u8{ 0x10, 0x10, 0x10, 0x10, 0x00 },
        '/' => [5]u8{ 0x60, 0x30, 0x18, 0x0c, 0x06 },
        '*' => [5]u8{ 0x54, 0x38, 0x7c, 0x38, 0x54 },
        '[' => [5]u8{ 0x7f, 0x41, 0x41, 0x00, 0x00 },
        ']' => [5]u8{ 0x00, 0x41, 0x41, 0x7f, 0x00 },
        '(' => [5]u8{ 0x3c, 0x42, 0x81, 0x00, 0x00 },
        ')' => [5]u8{ 0x00, 0x00, 0x81, 0x42, 0x3c },
        '%' => [5]u8{ 0x63, 0x13, 0x08, 0x64, 0x63 },
        '#' => [5]u8{ 0x24, 0x7f, 0x24, 0x7f, 0x24 },
        '0' => [5]u8{ 0x3e, 0x41, 0x41, 0x3e, 0x00 },
        '1' => [5]u8{ 0x04, 0x42, 0x7f, 0x40, 0x00 },
        '2' => [5]u8{ 0x66, 0x51, 0x49, 0x46, 0x00 },
        '3' => [5]u8{ 0x22, 0x49, 0x49, 0x36, 0x00 },
        '4' => [5]u8{ 0x1c, 0x12, 0x79, 0x10, 0x00 },
        '5' => [5]u8{ 0x4f, 0x49, 0x49, 0x31, 0x00 },
        '6' => [5]u8{ 0x3e, 0x49, 0x49, 0x32, 0x00 },
        '7' => [5]u8{ 0x61, 0x11, 0x09, 0x07, 0x00 },
        '8' => [5]u8{ 0x36, 0x49, 0x49, 0x36, 0x00 },
        '9' => [5]u8{ 0x46, 0x49, 0x49, 0x3e, 0x00 },
        'a' => [5]u8{ 0x20, 0x54, 0x54, 0x54, 0x78 },
        'á' => [5]u8{ 0x20, 0x54, 0x56, 0x55, 0x78 },
        'A' => [5]u8{ 0x78, 0x14, 0x12, 0x14, 0x78 },
        'Á' => [5]u8{ 0x78, 0x14, 0x12, 0x15, 0x78 },
        'b' => [5]u8{ 0x7e, 0x48, 0x48, 0x30, 0x00 },
        'B' => [5]u8{ 0x7e, 0x4a, 0x4a, 0x34, 0x00 },
        'c' => [5]u8{ 0x30, 0x48, 0x48, 0x48, 0x00 },
        'C' => [5]u8{ 0x3c, 0x42, 0x42, 0x42, 0x00 },
        'Č' => [5]u8{ 0x3c, 0x43, 0x42, 0x43, 0x00 },
        'č' => [5]u8{ 0x30, 0x4a, 0x4c, 0x4a, 0x00 },
        'd' => [5]u8{ 0x30, 0x48, 0x48, 0x7e, 0x00 },
        'ď' => [5]u8{ 0x30, 0x49, 0x4a, 0x7d, 0x00 },
        'D' => [5]u8{ 0x7e, 0x42, 0x42, 0x3c, 0x00 },
        'Ď' => [5]u8{ 0x7e, 0x43, 0x42, 0x3d, 0x00 },
        'e' => [5]u8{ 0x38, 0x54, 0x54, 0x58, 0x00 },
        'é' => [5]u8{ 0x38, 0x54, 0x56, 0x59, 0x00 },
        'ě' => [5]u8{ 0x38, 0x55, 0x56, 0x59, 0x00 },
        'E' => [5]u8{ 0x7c, 0x54, 0x54, 0x54, 0x00 },
        'É' => [5]u8{ 0x7c, 0x54, 0x56, 0x55, 0x00 },
        'Ě' => [5]u8{ 0x7c, 0x55, 0x56, 0x55, 0x00 },
        'f' => [5]u8{ 0x40, 0x78, 0x54, 0x04, 0x00 },
        'F' => [5]u8{ 0x7e, 0x12, 0x12, 0x02, 0x00 },
        'g' => [5]u8{ 0x98, 0xa4, 0xa4, 0x78, 0x00 },
        'G' => [5]u8{ 0x3c, 0x42, 0x4a, 0x7a, 0x00 },
        'h' => [5]u8{ 0x7e, 0x08, 0x08, 0x70, 0x00 },
        'H' => [5]u8{ 0x7e, 0x08, 0x08, 0x7e, 0x00 },
        'i' => [5]u8{ 0x40, 0x7a, 0x40, 0x00, 0x00 },
        'í' => [5]u8{ 0x40, 0x78, 0x42, 0x01, 0x00 },
        'I' => [5]u8{ 0x42, 0x7e, 0x42, 0x00, 0x00 },
        'Í' => [5]u8{ 0x00, 0x44, 0x7e, 0x45, 0x00 },
        'j' => [5]u8{ 0x80, 0x80, 0x7a, 0x00, 0x00 },
        'J' => [5]u8{ 0x42, 0x42, 0x42, 0x3e, 0x00 },
        'k' => [5]u8{ 0x7e, 0x10, 0x28, 0x44, 0x00 },
        'K' => [5]u8{ 0x7e, 0x18, 0x24, 0x42, 0x00 },
        'l' => [5]u8{ 0x00, 0x00, 0x7e, 0x40, 0x00 },
        'L' => [5]u8{ 0x7e, 0x40, 0x40, 0x40, 0x00 },
        'm' => [5]u8{ 0x78, 0x08, 0x70, 0x08, 0x78 },
        'M' => [5]u8{ 0x7e, 0x04, 0x08, 0x04, 0x7e },
        'n' => [5]u8{ 0x78, 0x10, 0x08, 0x70, 0x00 },
        'ň' => [5]u8{ 0x78, 0x11, 0x0a, 0x71, 0x00 },
        'N' => [5]u8{ 0x7c, 0x08, 0x10, 0x20, 0x7c },
        'Ň' => [5]u8{ 0x7c, 0x09, 0x12, 0x21, 0x7c },
        'o' => [5]u8{ 0x30, 0x48, 0x48, 0x30, 0x00 },
        'ó' => [5]u8{ 0x30, 0x48, 0x4a, 0x31, 0x00 },
        'O' => [5]u8{ 0x3c, 0x42, 0x42, 0x42, 0x3c },
        'Ó' => [5]u8{ 0x3c, 0x42, 0x43, 0x42, 0x3c },
        'p' => [5]u8{ 0xf8, 0x28, 0x28, 0x10, 0x00 },
        'P' => [5]u8{ 0x7e, 0x12, 0x12, 0x0c, 0x00 },
        'q' => [5]u8{ 0x30, 0x48, 0x48, 0xb0, 0x00 },
        'Q' => [5]u8{ 0x3c, 0x42, 0x42, 0x42, 0xbc },
        'r' => [5]u8{ 0x78, 0x10, 0x08, 0x10, 0x00 },
        'ř' => [5]u8{ 0x78, 0x11, 0x0a, 0x11, 0x00 },
        'R' => [5]u8{ 0x7e, 0x12, 0x32, 0x4c, 0x00 },
        'Ř' => [5]u8{ 0x7e, 0x13, 0x32, 0x4d, 0x00 },
        's' => [5]u8{ 0x48, 0x54, 0x54, 0x24, 0x00 },
        'š' => [5]u8{ 0x48, 0x55, 0x56, 0x25, 0x00 },
        'S' => [5]u8{ 0x4c, 0x52, 0x52, 0x52, 0x22 },
        'Š' => [5]u8{ 0x4c, 0x53, 0x52, 0x53, 0x22 },
        't' => [5]u8{ 0x00, 0x10, 0x7c, 0x50, 0x00 },
        'ť' => [5]u8{ 0x00, 0x11, 0x7a, 0x51, 0x00 },
        'T' => [5]u8{ 0x02, 0x02, 0x7e, 0x02, 0x02 },
        'Ť' => [5]u8{ 0x02, 0x03, 0x7e, 0x03, 0x02 },
        'u' => [5]u8{ 0x38, 0x40, 0x40, 0x78, 0x00 },
        'ú' => [5]u8{ 0x38, 0x40, 0x42, 0x79, 0x00 },
        'ů' => [5]u8{ 0x38, 0x40, 0x42, 0x79, 0x00 },
        'U' => [5]u8{ 0x3e, 0x40, 0x40, 0x40, 0x3e },
        'Ů' => [5]u8{ 0x3c, 0x42, 0x45, 0x42, 0x3c },
        'Ú' => [5]u8{ 0x3e, 0x40, 0x42, 0x41, 0x3e },
        'v' => [5]u8{ 0x18, 0x20, 0x40, 0x20, 0x18 },
        'V' => [5]u8{ 0x1e, 0x20, 0x60, 0x20, 0x1e },
        'w' => [5]u8{ 0x78, 0x20, 0x10, 0x20, 0x78 },
        'W' => [5]u8{ 0x7e, 0x20, 0x10, 0x20, 0x7e },
        'x' => [5]u8{ 0x48, 0x30, 0x30, 0x48, 0x00 },
        'X' => [5]u8{ 0x62, 0x14, 0x08, 0x14, 0x62 },
        'y' => [5]u8{ 0x98, 0xa0, 0x60, 0x38, 0x00 },
        'ý' => [5]u8{ 0x98, 0xa0, 0x62, 0x39, 0x00 },
        'Y' => [5]u8{ 0x06, 0x08, 0x70, 0x08, 0x06 },
        'Ý' => [5]u8{ 0x06, 0x08, 0x72, 0x09, 0x06 },
        'z' => [5]u8{ 0x48, 0x68, 0x58, 0x48, 0x00 },
        'ž' => [5]u8{ 0x48, 0x69, 0x5a, 0x49, 0x00 },
        'Z' => [5]u8{ 0x42, 0x62, 0x52, 0x4a, 0x46 },
        'Ž' => [5]u8{ 0x42, 0x63, 0x52, 0x4b, 0x46 },
        else => [5]u8{ 0x00, 0x00, 0x00, 0x00, 0x00 },
    };

    for (0..5) |i| {
        if (z[i] & 0b0000_0001 == 1) {
            bod(x + i, y + 7, red, green, blue);
        }
        if (z[i] & 0b0000_0010 == 2) {
            bod(x + i, y + 6, red, green, blue);
        }
        if (z[i] & 0b0000_0100 == 4) {
            bod(x + i, y + 5, red, green, blue);
        }
        if (z[i] & 0b0000_1000 == 8) {
            bod(x + i, y + 4, red, green, blue);
        }
        if (z[i] & 0b0001_0000 == 16) {
            bod(x + i, y + 3, red, green, blue);
        }
        if (z[i] & 0b0010_0000 == 32) {
            bod(x + i, y + 2, red, green, blue);
        }
        if (z[i] & 0b0100_0000 == 64) {
            bod(x + i, y + 1, red, green, blue);
        }
        if (z[i] & 0b1000_0000 == 128) {
            bod(x + i, y + 0, red, green, blue);
        }
    }
}