Создаем I2C Master Controller на Verilog. Burst-транзакции и дисплей SSD1306

• Инициализирует OLED-дисплей SSD1306 (128x64, I2C, адрес 0x3C);
  
• Формирует кадр в собственном фреймбуфере в железе без MCU, без softcore-процессора, без HLS-компилятора:
  • Статический текст “SSD1306” в верхней строке;
    
  • Каркасный псевдотрехмерный куб в центре, который вращается вокруг вертикальной оси по кнопке “Анимация”;
    
  • Подпись “STATIC” или “ANIM” в нижней строке.
• Передает 1024 пикселя + 1 control-байт в одной I2C-транзакции и обновляет картинку “в режиме реального времени” с частотой около 10 FPS.

• Инженерная. Это продолжение стендовой верификации ядра i2c_master_core: мы гоняем по шине непрерывный поток ~95 мс длиной и убеждаемся, что ядро удерживает связь без сбоев ACK и потерь арбитража.
  
• Учебная. Мы проходим путь от ядра I2C-уровня “один байт за команду” до полноценной графической подсистемы с растеризатором, LUT sin/cos, пайплайном вершин и dual-port BRAM.  Без процессора.  Всё  - явные автоматы и детерминированные операции.

• burst-writer, автоматически формирующий последовательность START → WRITE(addr) → WRITE(data[0]) … WRITE(data[N-1]) → STOP;
  
• рендер-модуль, который готовит содержимое фреймбуфера без вмешательства CPU.

• Тема проекта - именно I2C (это лабораторный пример для I2C-мастера);
  
• Нам достаточно ~8 fps, чтобы анимация воспринималась плавно.
  
• I2C проще физически: 2 провода вместо 4+, не требует CS.

• Адресный джампер SA0 - перемычка или 0-Ω резистор, которая подтягивает SA0 либо к GND (адрес 0x3C), либо к VCC (0x3D). Пользуйтесь мультиметром, чтобы убедиться, куда он спаян на вашем конкретном модуле.
  
• Пин RES (reset) - опциональный, на большинстве плат подтянут к VCC через RC-цепочку.  Если его нет на колодке - модуль сбрасывается автоматически при подаче питания.

set_location_assignment PIN_E8 -to i2c_scl
set_location_assignment PIN_E9 -to i2c_sda
set_instance_assignment -name IO_STANDARD "3.3-V LVCMOS" -to i2c_scl
set_instance_assignment -name IO_STANDARD "3.3-V LVCMOS" -to i2c_sda

• Multi-master / multi-slave - несколько устройств могут одновременно владеть шиной, и если они одновременно “хотят” в 1, конфликта не возникнет; а если один тянет в 0 - он “побеждает”  (wired-AND).  Это же свойство используется для арбитража в multi-master-системах.
  
• Clock stretching - slave-устройство (например, медленный EEPROM) может “прижать” SCL к GND, пока оно не готово, и мастер обязан подождать.

assign i2c_sda = sda_oen ? 1'bz : 1'b0;
assign i2c_scl = scl_oen ? 1'bz : 1'b0;

assign sda_in = i2c_sda;   // считываем уровень после pull-up / wired-AND
assign scl_in = i2c_scl;

• уметь различать “я передаю команду настройки” и “я передаю пиксели”;
  
• корректно строить короткие init-транзакции и длинные data-burst’ы;
  
• отличать ошибки физического уровня (NACK на адрес) от ошибок контроллера (неправильный control-byte → мусор в GDDRAM).

// quartus_ssd1306/src/ssd1306_ctrl.v
localparam [6:0] SSD_ADDR = 7'h3C;
...
bw_slave_addr <= SSD_ADDR;

// rtl/i2c_burst_writer.v
wire [7:0] addr_byte = {slave_addr_i, 1'b0};   // W=0 — только запись

// псевдокод
bw_byte_count <= 16'd0;   // 0 data-байт
bw_start      <= 1'b1;
// ждём done_o:
if (bw_error) begin
    // нет SSD1306 на шине: не переходим в PH_INIT,
    // зажигаем LED ошибки
end

• D/C# (Data / Command) - 0 → дальнейший поток интерпретируется как команды; 1 → как данные для GDDRAM.
  
• Co (Continuation) - 0 → режим «до конца транзакции»; 1 →  режим “один следующий байт, потом снова control-byte”.

• Режимы с Co=0 быстрые, но монотонные: в рамках одной транзакции передаем либо только команды, либо только данные. Смена режима требует STOP + новый START.
  
• Режимы с Co=1 гибкие, но с накладными расходами: в одной транзакции можно чередовать команды и данные, но перед каждым таким байтом летит “служебный” control-байт - +9 бит I2C (8 data + 1 ACK), т. е. ~10% накладных расходов даже в лучшем случае.

• 0x20, 0x00 - Horizontal Addressing (мы используем именно его): курсор (col, page) наращивается по столбцам, в конце столбца  (col=127) переходит на следующую страницу, в конце страницы (page=7) оборачивается обратно в (0, 0).  Идеально для  “отправил 1024 байта - и весь экран обновился”.
  
• 0x20, 0x01- Vertical Addressing: (col, page) идёт сначала по страницам, потом переключается на следующий столбец.
  
• 0x20, 0x02- Page Addressing: курсор перекатывается только  по столбцам; переход на следующую страницу не автоматический.

0x20, 0x00,             // horizontal addressing
0x21, 0x00, 0x7F,       // set column range [0, 127]
0x22, 0x00, 0x07,       // set page range [0, 7]

• Задаётslave_addr_i = 0x3C;
  
• Задаёт byte_count_i = INIT_LEN или 1025;
  
• В качестве источника данных выдаёт либо ROM (init-поток), либо {0x40, fb[0..1023]} (frame-поток).

byte = 8'b b7 b6 b5 b4 b3 b2 b1 b0
                │  │  │  │  │  │  │  │
                │  │  │  │  │  │  │  └── top    (row = page*8 + 0)
                │  │  │  │  │  │  └───── row 1  (row = page*8 + 1)
                │  │  │  │  │  └──────── row 2  (row = page*8 + 2)
                │  │  │  │  └─────────── row 3
                │  │  │  └────────────── row 4
                │  │  └───────────────── row 5
                │  └──────────────────── row 6
                └─────────────────────── bottom (row = page*8 + 7)
    bit = 0  ⇒  пиксель не горит (чёрный)
    bit = 1  ⇒  пиксель светится

• строка 30 = page 3, sub-row 6 (3 x 8 + 6 = 30);
  
• значит нужно записать bit 6 = 1, все остальные биты = 0 ⇒ байт 0x40;
  
• в 128 колонках страницы 3 подряд кладём 0x40 × 128.

Дано:      x ∈ [0..127] — номер столбца (col)
           y ∈ [0..63]  — номер строки (row)
           fb_addr — линейный адрес байта в буфере 0..1023
Прямое преобразование (pixel → byte + bit):
           col     = x
           page    = y >> 3              // y / 8
           sub_row = y & 3'b111          // y % 8
           fb_addr = (page << 7) | col   // page * 128 + col
           bit_mask = 1 << sub_row
Обратное (byte+bit → pixel):
           col  = fb_addr[6:0]
           page = fb_addr[9:7]
           y    = (page << 3) | sub_row
           x    = col

// Псевдокод
uint8_t b = fb[fb_addr];             // read
b |= (1 << sub_row);                 // set target pixel
// b &= ~(1 << sub_row);             // или clear, если "стираем"
fb[fb_addr] = b;                     // write

• RD: поставить raddr = fb_addr, защёлкнуть q через такт.
  
• MOD: скомбинировать q | bit_mask (или с AND).
  
• WR: записать fb[waddr] = modified.

reg [7:0] fb [0:1023];
// Порт записи (из рендера)
always @(posedge clk_i) begin
    if (fb_we)
        fb[fb_waddr] <= fb_wdata;
    // Порт чтения для I2C-потока:
    rdata_o      <= fb[raddr_i];
    // Порт чтения для RMW внутри рендера:
    fb_rdata_rmw <= fb[fb_raddr_rmw];
end

// В ssd1306_ctrl.v, вход data-источника burst-writer’а:
wire [9:0]  pix_idx  = src_idx[9:0];         // idx ∈ 0..1023
scene_rdata <= fb[pix_idx];                  // ровно то, что нужно послать

• Весь экран горит? → Все 1024 байта = 0xFF;
  
• Чёрный экран? → Все 1024 байта = 0x00;
  
• Один пиксель (0, 0) горит? → fb[0] = 0x01, всё остальное 0;
  
• Один пиксель (0, 63) горит? → fb[128 * 7 + 0] = 0x80, остальное 0. Это и есть левый-нижний угол.
  
• Один пиксель (127, 63) горит? → fb[128 * 7 + 127] = 0x80, т. е. fb[1023] = 0x80;
  
• Горизонтальная линия y=0? → fb[0..127] = 0x01, остальные 896 байт = 0x00;
  
• Вертикальная линия x=0? → fb[0], fb[128], fb[256], ..., fb[896] = 0xFF; остальные = 0x00 (8 байтов, по одному на каждую страницу).

• col_ptr ∈ [0..127] - номер столбца;
  
• page_ptr ∈ [0..7] - номер страницы.

• column range: [col_start, col_end], задаётся командой 0x21, col_start, col_end;
  
• page range: [page_start, page_end], задаётся командой 0x22,page_start, page_end.

Command sequence:   0x20  0xMM
                   ─────  ────
                   code   mode: 00 = Horizontal
                                01 = Vertical
                                02 = Page (default после POR)
                                03 = invalid (игнорируется)

Поведение:  col_ptr++ каждый байт
            col_ptr > col_end  →  col_ptr = col_start  (остаётся та же page)
            page_ptr не меняется автоматически

Поведение:  col_ptr++ каждый байт
            col_ptr > col_end    →  col_ptr = col_start, page_ptr++
            page_ptr > page_end  →  page_ptr = page_start (wrap через весь окно)

Поведение:  page_ptr++ каждый байт
            page_ptr > page_end  →  page_ptr = page_start, col_ptr++
            col_ptr > col_end    →  col_ptr = col_start

fb_idx ∈ [0..1023]          — линейный индекс в BRAM
page    = fb_idx[9:7]       — старшие 3 бита = номер страницы
col     = fb_idx[6:0]       — младшие 7 бит = номер столбца
fb_idx ≡ page * 128 + col
       = тот же порядок, в котором SSD1306 запишет байты в GDDRAM
         в horizontal-mode

// В ssd1306_ctrl.v
wire [9:0] pix_idx  = src_idx[9:0];            // 0..1023
scene_rdata <= fb[pix_idx];                    // читаем из BRAM
// burst-writer отправляет scene_rdata как очередной data-байт

• хранить фреймбуфер в “извращённой” раскладке (с точки зрения рендера) - это усложнит логику scene_renderer;
  
• делать сложный обход при отправке - усложнит ctrl и burst-writer.

; Set column range [0..127]
0x21
0x00     ; col_start
0x7F     ; col_end   (127)
; Set page range [0..7]
0x22
0x00     ; page_start
0x07     ; page_end

0x20, 0x00,        // horizontal addressing mode
0x21, 0x00, 0x7F,  // column start/end: 0..127
0x22, 0x00, 0x07,  // page   start/end: 0..7

... (рендер следующего кадра в BRAM) ...
START → 0x78 → 0x40 → pixel[0] → ... → pixel[1023] → STOP

• Многие регистры при изменении “на лету” вызывают визуальные артефакты: моргания, полосы, скачки яркости.  Если экран  выключен - артефакты никому не видны.
  
• Команды “MUX Ratio”, “COM Pins”, “Display Clock” при ошибочных аргументах при включенной панели могут ввести контроллер строк в состояние, когда ток через отдельные OLED-ячейки превышает безопасный, и пиксели могут «выгорать».  Это редкий, но задокументированный в даташите риск.

START → 0x78 → init_rom[0..31] → STOP
 (S)    ADDR      │        │
                  │        └── init_rom[1..31]: 0xAE, 0xD5, ..., 0xAF
                  └── init_rom[0] = 0x00 (control-byte)

// Фаза PH_INIT:
bw_slave_addr <= SSD_ADDR;                  // 0x3C
bw_byte_count <= {10'd0, INIT_LEN};          // 32
bw_start      <= 1'b1;
phase         <= PH_INITW;

wire [7:0] init_byte = init_rom(src_idx[5:0]);
wire [7:0] bw_data   = (phase == PH_INITW) ? init_byte : data_byte;

• формирование SCL-клока с настраиваемой частотой (через ena_i - импульс “каждую четверть периода SCL”, генерируемый внешним prescaler’ом);
  
• формирование START/STOP/RESTART-условий с правильными setup/hold временами;
  
• подача и прием бит из сдвигового регистра tx_shift_r /  rx_shift_r;
  
• детекция ACK/NACK от slave’а (сэмпл SDA на 9-м бит-слоте);
  
• детекция clock stretching (ядро ждёт, пока SCL физически не отпустится в high, даже если внутренний prescaler уже хочет продолжать);
  
• детекция arbitration lost (сравнение “что мы выставили на SDA” с “что реально на шине” в момент, когда мы ожидали 1);
  
• tri-state управление SDA/SCL (sda_oen_o, scl_oen_o в open-drain-семантике);
  
• индикация busy_o (шина занята - был START без ещё STOP).

• последовательности из нескольких байт - каждый байт запрашивается отдельной командой CMD_WRITE;
  
• как соотносятся адрес и данные - для ядра оба просто “байты”;
  
• про control-byte, про GDDRAM, про “burst” - эти понятия живут на более высоком уровне;
  
• про retries при NACK, про таймауты при clock-stretching - решения принимает верхний уровень.

// Clock & reset
input  wire        clk_i;
input  wire        rstn_i;
input  wire        ena_i;            // 1-такт импульс, каждую четверть SCL
// Command interface
input  wire        cmd_valid_i;      // level, поднят пока команда не принята
input  wire [2:0]  cmd_i;            // код команды (см. ниже)
input  wire [7:0]  din_i;            // TX data при WRITE
output reg  [7:0]  dout_o;           // RX data после READ
output reg         rx_ack_o;         // ACK от slave (0=ACK, 1=NACK)
output reg         ready_o;          // 1 — ядро готово принять команду
// Status
output reg         arb_lost_o;       // sticky: потеря арбитража
input  wire        arb_lost_clear_i; // импульс сброса arb_lost
output reg         busy_o;           // шина занята (START без STOP)
// Пины шины I2C (open-drain)
input  wire        scl_i;
output reg         scl_oen_o;
input  wire        sda_i;
output reg         sda_oen_o;

• ena_i + prescaler - задаёт частоту SCL. На верхнем уровне (ssd1306_test_top.v) стоит простой счётчик-делитель, который  каждую четверть периода SCL выдаёт 1-тактовый импульс.  Ядро не использует никакого собственного clock-enable, поэтому его можно  тактировать и 50 МГц, и 500 кГц - реальная частота SCL определяется ena_i.  Для нашего проекта период ena_i = 1/800 кГц = 1.25 мкс → частота SCL = 800/4 = 200 кГц.
  
• Command interface (cmd_valid_i/cmd_i/din_i + ready_o/rx_ack_o/dout_o) - то, через что мы дёргаем ядро снаружи.  Ровно эти сигналы и проходят через i2c_burst_writer как прокси.
  
• Status + pads - наружу: индикаторы и физические пины. arb_lost_o/busy_o используются и top-level’ом (для индикации), и burst-writer’ом (для реакции на ошибки); sda_oen_o/scl_oen_o идут прямо на tri-state-буферы FPGA.

Ядро: ─── ready=1 ────────── ready=0 ──────── ready=1 ──────
              ↑                                 ↑
Ктл.: ────── cmd_valid=1 ──── cmd_valid=0 ────────────────
               ↑
            ядро принимает команду
            (в этот такт cmd_i, din_i должны быть валидны)

• Когда ядро свободно, оно держит ready_o = 1. 
  
• Внешний контроллер (burst-writer) поднимает cmd_valid_i = 1 только если видит ready_o = 1.  Одновременно выставляет cmd_i и (если команда - WRITE) din_i.
  
• Ядро защёлкивает команду, опускает ready_o = 0, начинает выполнение.  Процесс длится от десятков до сотен системных тактов в зависимости от команды и clock-stretching’а.
  
• По завершении ядро снова поднимает ready_o = 1.  В этом же такте rx_ack_o / dout_o валидны (для WRITE/READ соответственно).
  
• Внешний контроллер может либо сразу подать следующую команду (удерживая cmd_valid_i = 1 без опускания), либо снять cmd_valid_i и подождать.

• CMD_START: ~2 фазы SCL = ~2 × 1.25 мкс = 2.5 мкс ≈ 125 системных тактов @ 50 МГц;
  
• CMD_WRITE / CMD_READ: 9 бит-слотов × 4 фазы = ~36 фаз ≈ 45 мкс ≈ 2250 тактов;
  
• CMD_STOP: ~2 фазы ≈ 125 тактов.

• Переиспользуемость. Не все устройства хотят burst: у EEPROM Page Write - строго 32 байта на page (далее нужен новый ADDR-фрейм).  BME280 - write 1 регистр, read 6 байт (smart retry).  Если вложить “burst на N байт” внутрь ядра, под разные устройства придётся параметризовать, добавлять режимы и т. д. - сложность лавинообразно растёт.
  
• Тестируемость. С ядром как "1 команда = 1 atom" можно гонять микро-тесты по одной команде и покрывать всю матрицу ACK/NACK/arb-lost. С burst-ядром тест-векторы исчисляются миллионами комбинаций.
  
• Сложность FSM. Разделение “bit/byte-FSM” и “burst-FSM” даёт два маленьких автомата (~100 LE каждый) вместо одного большого (~500 LE) с большим радиусом разработки. Это прямо влияет на timing closure на Cyclone IV.

PH_INIT: begin
    bw_start      <= 1'b1;          // assert на 1 такт
    bw_byte_count <= {10'd0, INIT_LEN};
    phase         <= PH_INITW;
end
// ... в следующем такте ssd1306_ctrl уже в PH_INITW,
// а bw_start автоматически сброшен:
//   bw_start <= 1'b0;  в начале always-блока

• byte_count_i = 0- транзакция START + ADDR + STOP. Полезно  для “прощупывания” адреса (I2C device discovery): если адрес отвечает ACK, “error_o = 0”, иначе “error_o = 1”.
  
• byte_count_i = INIT_LEN = 32 - init SSD1306.
  
• byte_count_i = DATA_LEN = 1025 - передача фреймбуфера (1 control-байт + 1024 пикселя).

• не ассертить start_i повторно, пока предыдущая транзакция идёт; 
  
• зажечь “busy-LED” (в нашем проекте - LED[0]);
  
• проверки “можно ли отпустить шину” при реакции на внешние события.

PH_INITW: begin
    if (bw_done) begin          // захватит импульс в любом случае,
        ...                     // т. к. проверяется каждый такт
    end
end

• slave ответил NACK на байт адреса (rx_ack_i = 1 после ADDR_WAIT);
  
• slave ответил NACK на любой data-байт;
  
• произошла потеря арбитража (arb_lost_i = 1) в момент активной транзакции.

• case-функция (ROM) - как наш init_rom в ssd1306_ctrl;
  
• dual-port BRAM - как scene_renderer для пиксельных данных;
  
• FIFO, заполняемый с UART/SPI;
  
• потоковый генератор (counter, PRBS);
  
• даже внешний AXI-stream - через небольшой адаптер.

• поднимается ровно в тот момент, когда FSM входит в S_DATA_REQ;
  
• держится в 1, пока не придёт data_valid_i = 1;
  
• в том же такте, когда data_valid_i = 1, FSM переходит в S_DATA_CMD, и data_req_o автоматически падает.

• burst-writer поднимает cmd_valid_o = 1, когда ready_i = 1 (ядро готово);
  
• держит в 1 до детекции ready_i = 0 (ядро приняло команду);
  
• в том же такте сбрасывает cmd_valid_o и уходит в WAIT-состояние.

• S_ADDR_CMD → {slave_addr_i, 1'b0} (сохранено в addr_byte);
  
• S_DATA_CMD → data_i (защёлкнуто в din_o при рукопожатии с источником).

• ready_i = 1 в S_IDLE ядра - ждёт новую команду;
  
• ready_i = 0 - ядро занято (идёт START, передача бита, clock-stretching от slave’а, и т. д.);
  
• ready_i снова поднимается в 1 на такте, следующем после завершения команды - в этот момент можно одновременно читать rx_ack_o / dout_o и ассертить следующую команду.

• _CMD-состояния: условие для ассерта cmd_valid_o - “ждать, пока ready_i = 1”;
  
• _WAIT-состояния: ждать, пока ready_i снова не станет 1 (значит команда выполнена).

• rx_ack_i = 0 - ACK, всё хорошо, можно передавать следующий байт.
  
• rx_ack_i = 1 - NACK, slave не подтвердил приём. Burst-writer интерпретирует это как ошибку: ставит nack_flag, прерывает передачу и отправляет STOP, чтобы корректно освободить шину.

if (arb_lost_i && busy_o) begin
    cmd_valid_o <= 1'b0;     // перестать подавать команды ядру
    nack_flag   <= 1'b1;     // выставить error_o в S_DONE
    state       <= S_DONE;   // аварийный выход
end

START  →  WRITE(addr)  →  WRITE(data0)  →  …  →  WRITE(data_{N-1})  →  STOP

module i2c_burst_writer #(
    parameter CNT_W = 16
)(
    input  wire              clk_i,
    input  wire              rstn_i,
    // Control
    input  wire              start_i,
    input  wire [6:0]        slave_addr_i,
    input  wire [CNT_W-1:0]  byte_count_i,
    output wire              busy_o,
    output reg               done_o,
    output reg               error_o,
    // Data source
    output wire              data_req_o,
    input  wire [7:0]        data_i,
    input  wire              data_valid_i,
    // i2c_master_core command interface
    output reg               cmd_valid_o,
    output reg  [2:0]        cmd_o,
    output reg  [7:0]        din_o,
    input  wire              ready_i,
    input  wire              rx_ack_i,
    input  wire              arb_lost_i
);

localparam [2:0] CMD_START = 3'd1,
                 CMD_WRITE = 3'd2,
                 CMD_STOP  = 3'd4;
localparam [3:0] S_IDLE        = 4'd0,
                 S_START_CMD   = 4'd1,
                 S_START_WAIT  = 4'd2,
                 S_ADDR_CMD    = 4'd3,
                 S_ADDR_WAIT   = 4'd4,
                 S_DATA_REQ    = 4'd5,
                 S_DATA_CMD    = 4'd6,
                 S_DATA_WAIT   = 4'd7,
                 S_STOP_CMD    = 4'd8,
                 S_STOP_WAIT   = 4'd9,
                 S_DONE        = 4'd10;
reg [3:0]        state;
reg [CNT_W-1:0]  cnt;
reg [7:0]        addr_byte;
reg              nack_flag;

• CMD_START/WRITE/STOP - мы используем только три команды ядра  из шести существующих.  CMD_READ/CMD_RESTART/CMD_NOP не нужны для WRITE-burst’а - поэтому в модуле их мнемоник даже не объявляем.
  
• S_* - 11 состояний FSM.  4 бит ([3:0]) достаточно для 16 значений, с запасом. Каждое состояние - логическая единица  транзакции: CMD = “ассертить команду ядру”, WAIT = “ждать завершения”, _REQ = “запросить байт у источника”, и т. д.
  
• state - сам регистр FSM.
  
• cnt - счётчик оставшихся data-байт (без байта адреса). Защёлкивается из byte_count_i при start_i и декрементируется после каждого успешно переданного data-байта.
  
• addr_byte - полный 8-битный ADDR-байт, собранный из 7-битного slave_addr_i и младшего W=0.  Защёлкивается при start_i, чтобы оставаться стабильным на весь срок транзакции, даже если наверху slave_addr_i изменится.
  
• nack_flag - липкий однобитный флаг «в ходе транзакции был NACK или arb-lost». Выставляется в 1 при ошибке, переносится в error_o в S_DONE.

assign busy_o     = (state != S_IDLE);
assign data_req_o = (state == S_DATA_REQ);

• busy_o - видно наружу мгновенно в тот же такт, когда FSM переходит в не-S_IDLE. Это позволяет верхнему уровню точно синхронизировать start_i с ним (“ждём busy_o = 0, потом поднимаем start_i на 1 такт”).
  
• data_req_o - также мгновенно поднимается при входе в S_DATA_REQ и падает при выходе. Для комбинаторного источника данных (ROM/мукс) это означает “сейчас же защёлкнуть байт”.

always @(posedge clk_i or negedge rstn_i) begin
    if (!rstn_i) begin
        state       <= S_IDLE;
        cnt         <= {CNT_W{1'b0}};
        addr_byte   <= 8'd0;
        nack_flag   <= 1'b0;
        cmd_valid_o <= 1'b0;
        cmd_o       <= 3'd0;
        din_o       <= 8'd0;
        done_o      <= 1'b0;
        error_o     <= 1'b0;
    end else begin
        done_o <= 1'b0;
        …

if (arb_lost_i && busy_o) begin
    cmd_valid_o <= 1'b0;
    nack_flag   <= 1'b1;
    state       <= S_DONE;
end else begin
    case (state)
    …

• arb_lost_i валиден только когда ядро обнаружило физический конфликт на SDA с другим мастером.  Стоит sticky-уровень до arb_lost_clear_i ядра.
  
• Проверка && busy_o гарантирует, что мы не реагируем, если arb-lost пришёл в S_IDLE (тогда мы не являемся источником конфликта, это чужая проблема).
  
• Действие: опустить cmd_valid_o (чтобы ядро не принимало новых команд), поднять nack_flag (для error_o) и уйти в S_DONE.
  
• STOP не отправляется - нельзя: шину физически удерживает другой мастер, любая наша попытка записи превратится в повторный конфликт. Ядро само отпускает SDA/SCL при детекции al_event.

S_IDLE: begin
    if (start_i) begin
        addr_byte <= {slave_addr_i, 1'b0};
        cnt       <= byte_count_i;
        nack_flag <= 1'b0;
        error_o   <= 1'b0;
        state     <= S_START_CMD;
    end
end

• Защёлкивает 8-битный addr_byte: 7-битный адрес сдвигается  на 1 влево, младший бит = 0 (W - write).
  
• Защёлкивает cnt из byte_count_i. С этого момента значение внутри модуля стабильно, даже если верхний уровень изменит byte_count_i.
  
• Сбрасывает nack_flag и error_o - предыдущая ошибка забывается, новая транзакция начинается с “чистого листа”.
  
• Переходит в S_START_CMD.

S_START_CMD: begin
    cmd_o <= CMD_START;
    if (ready_i)
        cmd_valid_o <= 1'b1;
    if (cmd_valid_o && !ready_i) begin
        cmd_valid_o <= 1'b0;
        state       <= S_START_WAIT;
    end
end
S_START_WAIT: begin
    if (ready_i)
        state <= S_ADDR_CMD;
end

такт  state         cmd_o    cmd_valid_o  ready_i
  1   S_START_CMD   START       0            1      ← видим ready=1 → готовимся
  2   S_START_CMD   START       1            1      ← выставили valid=1,ядро ещё готово
  3   S_START_CMD   START       1            0      ← ядро приняло, опустило ready
  4   S_START_CMD   START       0            0      ← мы увидели (!ready & valid),
                                                       опустили valid, уходим в WAIT
  5   S_START_WAIT  —           0            0      ← ядро работает
  ... (много тактов, генерация START на шине) ...
  N   S_START_WAIT  —           0            1      ← ready снова 1 → команда выполнена
 N+1  S_ADDR_CMD    —           0            1      ← переходим к следующей команде

S_ADDR_CMD: begin
    cmd_o <= CMD_WRITE;
    din_o <= addr_byte;
    if (ready_i)
        cmd_valid_o <= 1'b1;
    if (cmd_valid_o && !ready_i) begin
        cmd_valid_o <= 1'b0;
        state       <= S_ADDR_WAIT;
    end
end
S_ADDR_WAIT: begin
    if (ready_i) begin
        if (rx_ack_i) begin
            nack_flag <= 1'b1;
            state     <= S_STOP_CMD;
        end else if (cnt == {CNT_W{1'b0}})
            state <= S_STOP_CMD;
        else
            state <= S_DATA_REQ;
    end
end

• rx_ack_i == 1 (NACK от slave’а) — slave не ответил на адрес. Ставим nack_flag = 1, уходим в S_STOP_CMD — даже при ошибке нужно корректно отпустить шину.
  
• cnt == 0 — случай «пробы адреса»: byte_count_i был равен 0, data-байтов нет.  Идём сразу в S_STOP_CMD, без ошибки.  Это тот самый I2C probe.
  
• иначе — нормальный путь: переходим в S_DATA_REQ для первого data-байта.

S_DATA_REQ: begin
    if (data_valid_i) begin
        din_o <= data_i;
        state <= S_DATA_CMD;
    end
end
S_DATA_CMD: begin
    cmd_o <= CMD_WRITE;
    if (ready_i)
        cmd_valid_o <= 1'b1;
    if (cmd_valid_o && !ready_i) begin
        cmd_valid_o <= 1'b0;
        state       <= S_DATA_WAIT;
    end
end
S_DATA_WAIT: begin
    if (ready_i) begin
        cnt <= cnt - {{(CNT_W-1){1'b0}}, 1'b1};
        if (rx_ack_i) begin
            nack_flag <= 1'b1;
            state     <= S_STOP_CMD;
        end else if (cnt == {{(CNT_W-1){1'b0}}, 1'b1})
            state <= S_STOP_CMD;
        else
            state <= S_DATA_REQ;
    end
end

• S_DATA_REQ: выставлен data_req_o = 1.  Ждём, пока  источник поднимет data_valid_i = 1.  В момент, когда оба  сигнала совпадают (data_req_o = 1 и data_valid_i = 1) - защёлкиваем din_o <= data_i и переходим в S_DATA_CMD.  В том же такте data_req_o автоматически становится 0 (потому что state != S_DATA_REQ).
  
• S_DATA_CMD: тот же шаблон «cmd+valid», что и для START/ADDR.  cmd_o = MD_WRITE, din_o уже загружен.  Когда ядро приняло - переходим в S_DATA_WAIT.
  
• S_DATA_WAIT: ядро работает, физически сдвигает байт на SDA. Когда закончит ready_i = 1 снова):
  - декремент cnt - без -= (Verilog не знает), явным сложением с -1. Выражение {{(CNT_W-1){1'b0}}, 1'b1} - это 1 в ширине CNT_W бит (для 16-бит это 16'h0001).
  - проверка rx_ack_i: NACK → nack_flag = 1, S_STOP_CMD;
  - если после декремента cnt стал 0 (т. е. только что отправлен последний data-байт) - S_STOP_CMD;
  - иначе - возврат в S_DATA_REQ за следующим байтом.

• 1 такт на S_DATA_REQ (если источник мгновенно валиден);
  
• ~2 такта на S_DATA_CMD (peak ready, опустить valid);
  
• ~2250 тактов на S_DATA_WAIT (ядро гонит 9 бит по SCL = 1125 мкс ≈ 45 мкс).

S_STOP_CMD: begin
    cmd_o <= CMD_STOP;
    if (ready_i)
        cmd_valid_o <= 1'b1;
    if (cmd_valid_o && !ready_i) begin
        cmd_valid_o <= 1'b0;
        state       <= S_STOP_WAIT;
    end
end
S_STOP_WAIT: begin
    if (ready_i)
        state <= S_DONE;
end

S_DONE: begin
    done_o  <= 1'b1;
    error_o <= nack_flag;
    state   <= S_IDLE;
end
default: state <= S_IDLE;

• Поднимает done_o = 1.  В следующем же такте pre-assign (done_o <= 1'b0 в начале always-блока) вернёт его в 0.  Так получается одноцикловый импульс.
  
• Переносит nack_flag в error_o.  error_o - level-флаг, удерживается до следующего start_i (где он очистится в S_IDLE).
  
• Возвращается в S_IDLE. default: state <= S_IDLE; - страховка от попадания в непредусмотренное значение регистра state (глитч при загрузке FPGA, однобитная SEU-ошибка в BRAM-регистре, и пр.).  Возврат вS_IDLE - безопасный recovery.

// из quartus_ssd1306/src/ssd1306_ctrl.v
wire [7:0] init_byte = init_rom(src_idx[5:0]);
wire [7:0] data_byte = (src_idx == 11'd0) ? 8'h40 : scene_rdata;
wire [7:0] bw_data   = (phase == PH_INITW) ? init_byte : data_byte;
assign bw_data_valid = bw_data_req;  // комбинаторное равенство

i2c_burst_writer #(.CNT_W(16)) u_burst (…);

// ---------------------------------------------------------------------------
// I2C Burst Writer — auto-sequences multi-byte I2C write transactions.
// ---------------------------------------------------------------------------
module i2c_burst_writer #(
    parameter CNT_W = 16              // [4.2] ширина счётчика, 16 бит по умолчанию
)(
    input  wire              clk_i,
    input  wire              rstn_i,
    // Control — см. 3.3.2
    input  wire              start_i,
    input  wire [6:0]        slave_addr_i,
    input  wire [CNT_W-1:0]  byte_count_i,
    output wire              busy_o,
    output reg               done_o,
    output reg               error_o,
    // Data source — см. 3.3.3 и 4.14
    output wire              data_req_o,
    input  wire [7:0]        data_i,
    input  wire              data_valid_i,
    // i2c_master_core command interface — см. 3.1 и 4.13
    output reg               cmd_valid_o,
    output reg  [2:0]        cmd_o,
    output reg  [7:0]        din_o,
    input  wire              ready_i,
    input  wire              rx_ack_i,
    input  wire              arb_lost_i
);
    // ----- Мнемоники команд ядра (см. 3.1.3) -----
    localparam [2:0] CMD_START = 3'd1,
                     CMD_WRITE = 3'd2,
                     CMD_STOP  = 3'd4;
    // ----- Состояния FSM (см. 4.3 и диаграмму в 4.18) -----
    localparam [3:0] S_IDLE        = 4'd0,
                     S_START_CMD   = 4'd1,
                     S_START_WAIT  = 4'd2,
                     S_ADDR_CMD    = 4'd3,
                     S_ADDR_WAIT   = 4'd4,
                     S_DATA_REQ    = 4'd5,
                     S_DATA_CMD    = 4'd6,
                     S_DATA_WAIT   = 4'd7,
                     S_STOP_CMD    = 4'd8,
                     S_STOP_WAIT   = 4'd9,
                     S_DONE        = 4'd10;
    reg [3:0]        state;
    reg [CNT_W-1:0]  cnt;
    reg [7:0]        addr_byte;
    reg              nack_flag;
    // ----- Комбинаторные выходы (см. 4.4) -----
    assign busy_o     = (state != S_IDLE);
    assign data_req_o = (state == S_DATA_REQ);
    always @(posedge clk_i or negedge rstn_i) begin
        if (!rstn_i) begin
            // ----- Асинхронный reset (см. 4.5) -----
            state       <= S_IDLE;
            cnt         <= {CNT_W{1'b0}};
            addr_byte   <= 8'd0;
            nack_flag   <= 1'b0;
            cmd_valid_o <= 1'b0;
            cmd_o       <= 3'd0;
            din_o       <= 8'd0;
            done_o      <= 1'b0;
            error_o     <= 1'b0;
        end else begin
            // ----- done_o — одноцикловый импульс (см. 4.5, 4.12) -----
            done_o <= 1'b0;
            // ----- Страж arb-lost, высший приоритет (см. 4.6) -----
            if (arb_lost_i && busy_o) begin
                cmd_valid_o <= 1'b0;
                nack_flag   <= 1'b1;
                state       <= S_DONE;
            end else begin
            case (state)
            // ============ S_IDLE (см. 4.7) ============
            S_IDLE: begin
                if (start_i) begin
                    addr_byte <= {slave_addr_i, 1'b0};
                    cnt       <= byte_count_i;
                    nack_flag <= 1'b0;
                    error_o   <= 1'b0;
                    state     <= S_START_CMD;
                end
            end
            // ============ START (см. 4.8) ============
            S_START_CMD: begin
                cmd_o <= CMD_START;
                if (ready_i)                            cmd_valid_o <= 1'b1;
                if (cmd_valid_o && !ready_i) begin
                    cmd_valid_o <= 1'b0;
                    state       <= S_START_WAIT;
                end
            end
            S_START_WAIT: begin
                if (ready_i) state <= S_ADDR_CMD;
            end
            // ============ WRITE(addr) (см. 4.9) ============
            S_ADDR_CMD: begin
                cmd_o <= CMD_WRITE;
                din_o <= addr_byte;
                if (ready_i)                            cmd_valid_o <= 1'b1;
                if (cmd_valid_o && !ready_i) begin
                    cmd_valid_o <= 1'b0;
                    state       <= S_ADDR_WAIT;
                end
            end
            S_ADDR_WAIT: begin
                if (ready_i) begin
                    if (rx_ack_i) begin
                        nack_flag <= 1'b1;
                        state     <= S_STOP_CMD;        // NACK на адресе → STOP с ошибкой
                    end else if (cnt == {CNT_W{1'b0}})
                        state <= S_STOP_CMD;            // probe (byte_count=0) → STOP без ошибки
                    else
                        state <= S_DATA_REQ;            // норма → к data-потоку
                end
            end
            // ============ Data-loop (см. 4.10) ============
            S_DATA_REQ: begin
                if (data_valid_i) begin
                    din_o <= data_i;                    // защёлкиваем байт от источника
                    state <= S_DATA_CMD;
                end
            end
            S_DATA_CMD: begin
                cmd_o <= CMD_WRITE;
                if (ready_i)                            cmd_valid_o <= 1'b1;
                if (cmd_valid_o && !ready_i) begin
                    cmd_valid_o <= 1'b0;
                    state       <= S_DATA_WAIT;
                end
            end
            S_DATA_WAIT: begin
                if (ready_i) begin
                    cnt <= cnt - {{(CNT_W-1){1'b0}}, 1'b1};   // cnt--
                    if (rx_ack_i) begin
                        nack_flag <= 1'b1;
                        state     <= S_STOP_CMD;         // NACK → STOP с ошибкой
                    end else if (cnt == {{(CNT_W-1){1'b0}}, 1'b1})
                        state <= S_STOP_CMD;             // последний байт — к STOP
                    else
                        state <= S_DATA_REQ;             // ещё байт
                end
            end
            // ============ STOP (см. 4.11) ============
            S_STOP_CMD: begin
                cmd_o <= CMD_STOP;
                if (ready_i)                            cmd_valid_o <= 1'b1;
                if (cmd_valid_o && !ready_i) begin
                    cmd_valid_o <= 1'b0;
                    state       <= S_STOP_WAIT;
                end
            end
            S_STOP_WAIT: begin
                if (ready_i) state <= S_DONE;
            end
            // ============ DONE (см. 4.12) ============
            S_DONE: begin
                done_o  <= 1'b1;                     // 1-такт импульс
                error_o <= nack_flag;                // level-флаг до следующего start
                state   <= S_IDLE;
            end
            default: state <= S_IDLE;                  // safety recovery
            endcase
            end // arb_lost guard
        end
    end
endmodule

• soft-core CPU в виде HDL-ядра - ни Nios II/e (Altera), ни PicoRV32, ни SERV, ни Cortex-M0 DesignStart;
  
• HLS-инструменты - Intel HLS, Vivado HLS, Bluespec и т. п. (они, строго говоря, и не являются “процессорами”, но скрывают процессорное мышление за высокоуровневым C-кодом);
  
• LUT-based softcore-симуляторы - “миниатюрные” CPU-подобные конструкции на ~500 LE, которые встречают иногда в учебных проектах.

• Практика. На платах класса AX301 (EP4CE10F17, ~10 кLE, без жёсткого CPU и без ARM-стека) soft-core съест 600-1000 LE и даст не более 25 MIPS. Это мало. Рендер 3D-куба на 25 MIPS без DSP и без FP - ~100 мс/кадр, что ставит крест на 10+ fps.  Прямой аппаратный рендер на том же кристалле занимает ~40 мкс - в 2500 раз быстрее.
  
• Образование. Без CPU заставляет разработчика вручную разложить задачу на микро-пайплайн из сложения, умножения, сдвига, case-lookup, BRAM-доступа и FSM - и увидеть, как именно работают эти примитивы. Это основа FPGA-культуры.

• Fixed-function pipeline. Набор стадий рендера определён на этапе синтеза и не может быть переставлен «в runtime». Это значит, что, например, нельзя «в одном кадре сначала нарисовать куб, потом текст; а в другом — сначала текст, потом куб». Порядок жёстко зашит в FSM.
  
• Всё известно заранее. Количество вершин (8), количество рёбер (12), количество букв в верхней строке (7), длина sin-таблицы (17 значений на четверть) — все это параметры времени синтеза. Никаких «дайте мне массив длины N, где N будет известно в runtime».
  
• Детерминизм. Время от start_i до ready_o = 1 одинаково для каждого кадра (с точностью до параметров, влияющих на Брезенхэма — длины рёбер зависят от угла). Нет кэш-промахов, сваливаний в обработчик прерываний и пр. Фактический разброс рендера — ±50 тактов на 50 МГц ≈ ±1 мкс.
  
• Прямая наблюдаемость. Любой промежуточный сигнал (вершина после поворота, счётчик пиксельной стороны, индекс буквы) — это физический провод в схеме, который можно вывести на test-probe или в SignalTap. Никакой «виртуальной памяти».

function [7:0] gen_pattern;
    input [6:0] col;
    input [2:0] page;
    input [5:0] t;
    begin
        gen_pattern = /* какое-то выражение от col, page, t */;
    end
endfunction

• Ноль BRAM. Картинка не хранится нигде — она вычисляется в момент запроса. На скромных FPGA (5K LE) это может быть критично.
  
• Мгновенная реакция на параметры. Меняется t — на следующем же такте это отражается в выдаваемых байтах.
  
• Простота. Один case на 10 строк может дать узор «шахматная доска», «горизонтальные полосы», «градиент» и т. п.

• Привязка к функциональной разделимости. f(col, page, t) должна быть чистой функцией — зависеть только от своих аргументов. Это жёсткое ограничение: например, для рисования линии (x0, y0) → (x1, y1) нужна сквозная пошаговая эволюция x/y, которая не представима как f(col, page).
  
• Взрыв сложности для композиции. Если на экране должны быть и текст, и куб одновременно — формула выглядит как f_cube(c, p, t) OR f_text(c, p), и внутри f_cube ещё разворачивается проверка «лежит ли пиксель на одной из 12 линий, тангенциальных к куба после поворота». Для каждого пикселя (128×64 = 8192 раз за кадр) эта проверка запускается заново. Комбинаторно это очень «жирно» на LUT.
  
• Невозможность произвольных алгоритмов. Брезенхэм — итеративен по природе. Заставить его работать «на лету» без BRAM невозможно.

reg [7:0] fb [0:1023];
// Write port (рендерер)
always @(posedge clk) if (we) fb[waddr] <= wdata;
// Read port (burst-writer)
always @(posedge clk) rdata <= fb[raddr];

• Произвольные алгоритмы. Рендерер может использовать любой итеративный алгоритм (Брезенхэм, flood-fill, Z-buffer, stencil), так как результат аккумулируется в BRAM по мере вычисления.
  
• Композиция. Текст и куб рисуются независимо: сначала один проход «очистить FB», потом проход «нарисовать 12 линий», потом проход «нарисовать текст». Каждый проход не знает о других и не пересекается по коду.
  
• Хорошо ложится на Cyclone IV. Один M9K-блок = 9 216 бит > 8 192 бит (наш fb). Синтез выводит буфер именно в M9K, не расходуя LUT.
  
• Dual-port позволяет рендеру и burst-writer’у работать параллельно.

• Стоит 1 M9K. У EP4CE10 их 30, у EP4CE6 — 15 — всё равно огромный запас. Для крошечных FPGA (EP4CE6 в dev-плате без M9K) было бы критично, у нас — нет.
  
• Задержка рендера. Рендер занимает ~38 мкс (см. 5.4). Это не влияет на нас при fps < 25, но в теории могло бы (см. 5.5).

• Нам нужен Брезенхэм для рёбер куба — других эффективных способов нет. Значит, процедурный подход не годится в принципе.
  
• У нас есть M9K-блоки с избытком — архитектурный «бесплатный обед».
  
• Композиция текст+куб+анимация в одном кадре тривиально представима как последовательность проходов.

// quartus_ssd1306/src/scene_renderer.v
reg  [7:0] fb [0:1023];
always @(posedge clk_i) begin
    if (fb_we)
        fb[fb_waddr] <= fb_wdata;
    rdata_o      <= fb[raddr_i];        // порт B: для I2C
    fb_rdata_rmw <= fb[fb_raddr_rmw];   // порт RMW для рендера (см. ниже)
end

• Write-порт — один, общий для всех фаз рендера.
  
• Read-порты — нужно два независимых:
  • один для RMW-чтения (fb_rdata_rmw) во время рендера,
    
  • второй для I2C-стрима (rdata_o) со стороны ssd1306_ctrl.

reg [7:0] fb [0:1023];
reg  [9:0] fb_waddr;
reg  [7:0] fb_wdata;
reg        fb_we;
reg  [9:0] fb_raddr_rmw;
reg  [7:0] fb_rdata_rmw;
always @(posedge clk_i) begin
    if (fb_we)
        fb[fb_waddr] <= fb_wdata;       // write port
    rdata_o      <= fb[raddr_i];         // read port 1 (I2C)
    fb_rdata_rmw <= fb[fb_raddr_rmw];    // read port 2 (RMW)
end

• одну запись if (fb_we) fb[…] <= fb_wdata; → соответствует одному write-порту;
  
• два независимых <= fb[addr] без if → два read-порта.

такт       1          2            3                4
raddr   :  X       FB_ADDR         Y                Y
rdata   :  ?          ?       fb[FB_ADDR]         fb[Y]
                              ↑ данные готовы

• S_EDGE_RD — выставить fb_raddr_rmw;
  
• (следующий такт) — ждать, данные появляются в fb_rdata_rmw;
  
• S_EDGE_WR — прочитать fb_rdata_rmw, вычислить модификацию, выставить fb_waddr/fb_wdata/fb_we.

• нет конфликтов RMW: запись текста не перекрывает байты куба и наоборот;
  
• текст не требует RMW: каждая буква высотой 8 пикселей и выровнена ровно по странице, поэтому один write-запрос перезаписывает весь столбец буквы целиком (0x00 → 0x___). Быстрее и проще чем RMW рёбер куба;
  
• чистая последовательность фаз: сначала стираем весь FB, потом рисуем каждый слой в любом порядке — результат одинаков.

• S_EDGE_*: длительность зависит от проекций рёбер. Чем более «по диагонали» спроецировано ребро, тем больше пикселей Брезенхэм отрисует. Максимальная длина ребра на 128×64 — около 45 пикселей (диагональ всего экрана); минимальная — когда ребро сморщено в точку (≈ 1 пиксель). На типовой конфигурации (куб заполняет ~40 пикселей по каждой оси) разброс 12 рёбер суммарно — от ~550 до ~750 тактов.
  
• S_TEXT_*: зависит от строки (ANIM короче, чем STATIC). Разница — ~20 тактов между двумя вариантами.

• Нет пользы. Даже без pipelining мы получаем ~21 fps (46 мс передачи + 38 мкс рендера). Для человеческого глаза разница между 21.0 fps и 21.1 fps отсутствует.
  
• Pipelining стоит +1 M9K. Второй буфер 1 КиБ + логика переключения front/back потребует ~150 LE и 1 M9K. Не катастрофично, но и не оправдано при нулевом видимом эффекте.
  
• Усложнение синхронизации. При pipelining нужно аккуратно отслеживать «какой буфер сейчас передаётся» и «в какой пишет рендерер», чтобы избежать race conditions. Это дополнительные состояния в FSM ssd1306_ctrl.
  
• Меньше ошибок. Сериализованный pipeline проще отлаживать: в любой момент точно один кадр либо рендерится, либо передаётся — не оба сразу.

• «Без CPU» — архитектурный принцип, а не ограничение. Он заставляет нас разложить задачу на аппаратные примитивы и даёт взамен детерминизм + скорость.
  
• BRAM-фреймбуфер — единственный разумный способ для композиции сложных сцен; процедурный подход не масштабируется до 12 линий + текста.
  
• Dual-port M9K позволяет I2C-стриму и рендеру работать параллельно на уровне BRAM, даже при логической сериализации их FSM.
  
• Sequential pipeline render→TX даёт ~21 fps при минимальной сложности. Double buffering не нужен.
  
• Тайминг-бюджет 1900 тактов рендера на 2.3M тактов передачи — огромный запас, позволяющий свободно добавлять сцены (ещё текст, ещё объекты, flood-fill, и т. п.), пока не превысим ~1M тактов (что маловероятно).

module scene_renderer (
    input  wire        clk_i,
    input  wire        rstn_i,
    input  wire        start_i,   // 1-такт импульс запуска рендера
    input  wire        mode_i,    // 0 = static  (нижняя строка "STATIC")
                                  // 1 = animation (нижняя строка "ANIM",
                                  //                и угол берётся из angle_i)
    input  wire [5:0]  angle_i,   // 0..63 ≡ 0..2π, угол поворота куба по Y
    output reg         ready_o,   // 1 ↔ кадр готов, можно начинать I2C TX
    input  wire [9:0]  raddr_i,   // порт чтения из FB для I2C-стрима
    output reg  [7:0]  rdata_o
);

• clk_i / rstn_i — стандартные clock/reset. Синхронно с ядром шины (50 МГц).
  
• start_i — импульс «начать рендер кадра». FSM из S_IDLE переходит в S_CLEAR, параметры mode_i/angle_i защёлкиваются одновременно.
  
• mode_i — статический vs анимационный режим. Влияет на нижний текст (STATIC / ANIM). В static-режиме angle_i также учитывается — просто верхний уровень держит его постоянным.
  
• angle_i — 6-битный угол, 64 шага по окружности (один шаг ≈ 5.625°). Детализация умышленно грубая: рендер 1 + 46 ≈ 46 мс на кадр, а 64 шага дадут ~2.8 s на полный оборот — вполне плавно воспринимается глазом.
  
• ready_o — level-флаг «кадр готов». Устанавливается в 1 в S_DONE, сбрасывается при следующем start_i.
  
• raddr_i / rdata_o — независимый read-порт BRAM для I2C-передачи. Адрес — линейный 10-бит индекс 0..1023 (см. 2.3.3 про zero-copy mapping). Данные появляются с задержкой 1 такт (sync BRAM).

localparam signed [7:0] S            = 8'sd12;
localparam [3:0]        NUM_EDGES    = 4'd12;
localparam [6:0]        TOP_COL0     = 7'd43;
localparam [6:0]        BOT_STA_COL0 = 7'd46;
localparam [6:0]        BOT_ANI_COL0 = 7'd52;
localparam [2:0]        TOP_PAGE     = 3'd0;
localparam [2:0]        BOT_PAGE     = 3'd7;
localparam [2:0]        TOP_LEN_M1   = 3'd6;   // 7 chars − 1
localparam [2:0]        STA_LEN_M1   = 3'd5;   // 6 chars − 1
localparam [2:0]        ANI_LEN_M1   = 3'd3;   // 4 chars − 1

reg  [7:0] fb [0:1023];
reg  [9:0] fb_waddr;
reg  [7:0] fb_wdata;
reg        fb_we;
reg  [9:0] fb_raddr_rmw;
reg  [7:0] fb_rdata_rmw;
always @(posedge clk_i) begin
    if (fb_we)
        fb[fb_waddr] <= fb_wdata;
    rdata_o      <= fb[raddr_i];
    fb_rdata_rmw <= fb[fb_raddr_rmw];
end

• fb — массив 1024×8 бит. Quartus infers его как один M9K-блок (9 216 бит; мы используем 8 192).
  
• Один write-порт: fb_we/fb_waddr/fb_wdata — управляется FSM рендера.
  
• Два read-порта:
  • rdata_o ← fb[raddr_i] — для внешнего чтения (I2C TX).
    
  • fb_rdata_rmw ← fb[fb_raddr_rmw] — для внутреннего RMW-чтения (см. стадию S_EDGE_*).
• Read-latency у обоих read-портов — 1 такт: на такте N выставлен адрес, на такте N+1 данные — в регистре.

function signed [8:0] sin_q;
    input [4:0] q;       // q ∈ 0..16
    case (q)
        5'd0 : sin_q = 9'sd0;    5'd1 : sin_q = 9'sd12;
        5'd2 : sin_q = 9'sd25;   5'd3 : sin_q = 9'sd37;
        5'd4 : sin_q = 9'sd49;   5'd5 : sin_q = 9'sd60;
        5'd6 : sin_q = 9'sd71;   5'd7 : sin_q = 9'sd81;
        5'd8 : sin_q = 9'sd90;   5'd9 : sin_q = 9'sd98;
        5'd10: sin_q = 9'sd106;  5'd11: sin_q = 9'sd112;
        5'd12: sin_q = 9'sd117;  5'd13: sin_q = 9'sd122;
        5'd14: sin_q = 9'sd125;  5'd15: sin_q = 9'sd126;
        5'd16: sin_q = 9'sd127;  default: sin_q = 9'sd0;
    endcase
endfunction

• Относительно π/2: sin(π/2 + x) = sin(π/2 − x) (в рамках одной четверти это «зеркалит» вторую половину первой четверти к первой).
  
• Относительно π: sin(π + x) = −sin(x) (третья и четвёртая четверти — просто минус первой и второй).

function signed [8:0] sin6;
    input [5:0] theta;
    reg   [4:0] qi;
    reg signed [8:0] mag;
    begin
        qi  = theta[4] ? (5'd16 - {1'b0, theta[3:0]})
                       :          {1'b0, theta[3:0]};
        mag = sin_q(qi);
        sin6 = theta[5] ? -mag : mag;
    end
endfunction

• theta[5] — старший бит: он переключает знак (третья/четвёртая четверти → −mag).
  
• theta[4] — средний бит: мы в первой или второй «половине» полупериода. theta[4]=0 — прямой обход (0..15 → qi=0..15); theta[4]=1 — зеркальный (16..31 → qi=16..1).
  
• theta[3:0] — младшие 4 бита: индекс внутри четверти 0..15.
  
• qi — нормализованный индекс для sin_q, значение 0..16.

function signed [8:0] cos6;
    input [5:0] theta;
    cos6 = sin6(theta + 6'd16);   // cos(θ) = sin(θ + π/2)
endfunction

function signed [7:0] vx_rom;
    input [2:0] i;
    case (i)
        3'd0: vx_rom = -S;  3'd1: vx_rom =  S;
        3'd2: vx_rom =  S;  3'd3: vx_rom = -S;
        3'd4: vx_rom = -S;  3'd5: vx_rom =  S;
        3'd6: vx_rom =  S;  3'd7: vx_rom = -S;
    endcase
endfunction
// vy_rom, vz_rom аналогично

function [2:0] edge_v0;
    input [3:0] e;
    case (e)
        4'd0:  edge_v0 = 3'd0;  4'd1:  edge_v0 = 3'd1;
        ... // всего 12 записей
    endcase
endfunction
// edge_v1 аналогично, с парными номерами

0:'S'  
1:'D'  
2:'1'  
3:'3'  
4:'0'  
5:'6'  
6:' '  
7:'C'
8:'U'  
9:'B'  
10:'E'
11:'A'
12:'I'
13:'T'
14:'N'  15:'M'

function [7:0] font_byte;
    input [6:0] addr;
    case (addr)
        // 'S' — код символа 0
        7'd0:  font_byte = 8'h26; 7'd1:  font_byte = 8'h49;
        7'd2:  font_byte = 8'h49; 7'd3:  font_byte = 8'h49;
        7'd4:  font_byte = 8'h32;
        // 'D' — код символа 1
        7'd8:  font_byte = 8'h7F; 7'd9:  font_byte = 8'h41;
        7'd10: font_byte = 8'h41; 7'd11: font_byte = 8'h41;
        7'd12: font_byte = 8'h3E;
        ...
    endcase
endfunction

function [3:0] top_char;        // "SSD1306"
    input [2:0] i;
    case (i)
        3'd0: top_char = 4'd0;   // S
        3'd1: top_char = 4'd0;   // S
        3'd2: top_char = 4'd1;   // D
        3'd3: top_char = 4'd2;   // 1
        3'd4: top_char = 4'd3;   // 3
        3'd5: top_char = 4'd4;   // 0
        3'd6: top_char = 4'd5;   // 6
    endcase
endfunction
function [3:0] bot_sta_char;    // "STATIC"
    case (i)
        3'd0: bot_sta_char = 4'd0;   // S
        3'd1: bot_sta_char = 4'd13;  // T
        3'd2: bot_sta_char = 4'd11;  // A
        3'd3: bot_sta_char = 4'd13;  // T
        3'd4: bot_sta_char = 4'd12;  // I
        3'd5: bot_sta_char = 4'd7;   // C
    endcase
endfunction
function [3:0] bot_ani_char;    // "ANIM"
    case (i)
        3'd0: bot_ani_char = 4'd11;  // A
        3'd1: bot_ani_char = 4'd14;  // N
        3'd2: bot_ani_char = 4'd12;  // I
        3'd3: bot_ani_char = 4'd15;  // M
    endcase
endfunction

reg signed [8:0] vtx_px [0:7];   // 8 вершин после поворота — X
reg signed [8:0] vtx_py [0:7];   //                           Y
reg [4:0]  state;                 // 15 состояний FSM (5 бит с запасом)
reg        mode_r;                // защёлкнутый mode_i
reg [5:0]  angle_r;               // защёлкнутый angle_i
// S_CLEAR
reg [10:0] clr_idx;               // 0..1023, потому 11 бит чтобы не обернуться
// S_ROT_*
reg signed [8:0]  sin_th, cos_th; // sin/cos угла текущего кадра
reg        [2:0]  vtx_idx;        // 0..7
reg signed [7:0]  cur_vx, cur_vy, cur_vz;
reg signed [17:0] prod_xc, prod_zs, prod_xs, prod_zc;  // 4 умножения
// S_EDGE_* (Брезенхэм)
reg [3:0]         edge_idx;       // 0..11
reg signed [8:0]  bx, by;         // текущий пиксель
reg signed [8:0]  bx_end, by_end; // конечный пиксель ребра
reg signed [8:0]  bdx;            // +|dx|
reg signed [8:0]  bdy;            // −|dy|
reg signed [1:0]  bsx, bsy;       // ±1 для каждой оси
reg signed [10:0] berr;           // аккумулятор Брезенхэма
reg [7:0]         pix_mask;       // 1 << by[2:0]
// S_TEXT_*
reg [2:0]  txt_char_idx;          // 0..7 (до TOP_LEN_M1)
reg [2:0]  txt_col_idx;           // 0..4 — текущий столбец буквы
reg        txt_phase;             // 0=top, 1=bottom

wire signed [17:0] rot_xp_full = prod_xc - prod_zs;   // vx·cos − vz·sin
wire signed [17:0] rot_zp_full = prod_xs + prod_zc;   // vx·sin + vz·cos
wire signed [10:0] rot_xp      = rot_xp_full[17:7];   // /128
wire signed [10:0] rot_zp      = rot_zp_full[17:7];   // /128
wire signed [10:0] rot_px      = rot_xp + 11'sd64;    // +64: центр по X
wire signed [10:0] cur_vy_ext  = {{3{cur_vy[7]}}, cur_vy};
wire signed [10:0] rot_py      = cur_vy_ext + (rot_zp >>> 2) + 11'sd32;

• x' = (vx·cos − vz·sin) / 128 + 64 — поворот вокруг Y + центровка (экран 128 пикселей по X, центр = 64).
  
• z' = (vx·sin + vz·cos) / 128 — глубина после поворота.
  
• y' = vy + z' / 4 + 32 — псевдо-3D проекция: вместо полного перспективного деления добавляем четверть z' к y. Это даёт эффект «передний план опущен вниз, задний — вверх». +32 — центр по Y (экран 64 пикселя, центр = 32).

wire [2:0]         e0         = edge_v0(edge_idx);
wire [2:0]         e1         = edge_v1(edge_idx);
wire signed [8:0]  p0x        = vtx_px[e0];
wire signed [8:0]  p0y        = vtx_py[e0];
wire signed [8:0]  p1x        = vtx_px[e1];
wire signed [8:0]  p1y        = vtx_py[e1];
wire signed [8:0]  init_dx    = (p1x >= p0x) ? (p1x - p0x) : (p0x - p1x);
wire signed [8:0]  init_dy_n  = (p1y >= p0y) ? (p0y - p1y) : (p1y - p0y);  // ≤ 0
wire signed [1:0]  init_sx    = (p0x < p1x) ?  2'sd1 : -2'sd1;
wire signed [1:0]  init_sy    = (p0y < p1y) ?  2'sd1 : -2'sd1;
wire signed [10:0] init_err   = {{2{init_dx[8]}},   init_dx}
                              + {{2{init_dy_n[8]}}, init_dy_n};

wire signed [10:0] bdx_ext = {{2{bdx[8]}}, bdx};
wire signed [10:0] bdy_ext = {{2{bdy[8]}}, bdy};
wire signed [10:0] b_e2    = berr <<< 1;
wire               step_x  = (b_e2 >= bdy_ext);
wire               step_y  = (b_e2 <= bdx_ext);
wire signed [8:0]  bsx_ext = {{7{bsx[1]}}, bsx};
wire signed [8:0]  bsy_ext = {{7{bsy[1]}}, bsy};
wire signed [10:0] berr_nx = berr + (step_x ? bdy_ext : 11'sd0)
                                  + (step_y ? bdx_ext : 11'sd0);

• e2 = 2·err;
  
• если e2 ≥ dy_n (т. е. err положителен) — сделать шаг по X;
  
• если e2 ≤ dx — сделать шаг по Y;
  
• обновить err добавлением dy_n и/или dx в зависимости от того, какие шаги были сделаны.

wire in_screen = (bx >= 9'sd0) && (bx <= 9'sd127)
              && (by >= 9'sd0) && (by <= 9'sd63);
wire [9:0] pix_addr  = {by[5:3], bx[6:0]};  // page*128 + col
wire [7:0] new_mask  = 8'd1 << by[2:0];     // бит внутри столбца

• page = by[5:3] — деление y/8;
  
• col = bx[6:0] — просто x;
  
• fb_addr = {page, col} — конкатенация, эквивалентно page*128+col;
  
• bit_mask = 1 << by[2:0] — y mod 8 как позиция бита.

wire [3:0] cur_char = (!txt_phase) ? top_char(txt_char_idx)
                                   : (mode_r ? bot_ani_char(txt_char_idx)
                                             : bot_sta_char(txt_char_idx));
wire [2:0] cur_page = (!txt_phase) ? TOP_PAGE : BOT_PAGE;
wire [6:0] cur_col0 = (!txt_phase) ? TOP_COL0
                                   : (mode_r ? BOT_ANI_COL0 : BOT_STA_COL0);
wire [2:0] cur_last = (!txt_phase) ? TOP_LEN_M1
                                   : (mode_r ? ANI_LEN_M1 : STA_LEN_M1);
wire [5:0] txt_char_mul6 = {txt_char_idx, 2'b00} + {1'b0, txt_char_idx, 1'b0};
wire [6:0] txt_base_col  = cur_col0 + {1'b0, txt_char_mul6};
wire [6:0] txt_col       = txt_base_col + {4'd0, txt_col_idx};
wire [9:0] txt_addr      = {cur_page, txt_col};

// pre-assign в начале else-ветки: fb_we по умолчанию = 0
fb_we <= 1'b0;
case (state)
    ...
endcase
// post-assign: сбрасывает ready при повторном старте
if (start_i && state != S_IDLE) ready_o <= 1'b0;

• fb_we <= 1'b0 — pre-assign, аналогичный тому, что делает done_o <= 0 в i2c_burst_writer: write-enable по умолчанию снят, и любое состояние, которое хочет записать, должно явно поставить fb_we <= 1'b1. Это защищает от случайной «утечки» write’а в неожиданных состояниях.
  
• post-assign if (start_i && state != IDLE) — нужен, чтобы при «повторном» запуске (например, если верхний уровень решил перезапустить рендер до того, как текущий закончился) флаг ready_o сбрасывался. В норме это не происходит.

S_IDLE: begin
    if (start_i) begin
        mode_r  <= mode_i;
        angle_r <= angle_i;
        ready_o <= 1'b0;
        clr_idx <= 11'd0;
        state   <= S_CLEAR;
    end
end

S_CLEAR: begin
    fb_we    <= 1'b1;
    fb_waddr <= clr_idx[9:0];
    fb_wdata <= 8'h00;
    if (clr_idx == 11'd1023) begin
        clr_idx <= 11'd0;
        state   <= S_ROT_SETUP;
    end else
        clr_idx <= clr_idx + 11'd1;
end

• это изменит layout BRAM’а и усложнит read-порты;
  
• 20.5 мкс на clear при 46 мс кадра — 0.04%, экономить не на чем.

• 1 = 11'd1024, а если использовать 10-битный счётчик,10'd1023
  
• 1 = 10'd0— но мы проверяем== 1023` до инкремента, так что в принципе хватило бы и 10 бит. 11-битный — перестраховка на случай, если кто-то в будущем захочет увеличить FB.

S_ROT_SETUP: begin
    sin_th  <= sin6(angle_r);
    cos_th  <= cos6(angle_r);
    vtx_idx <= 3'd0;
    state   <= S_ROT_LOAD;
end

S_ROT_LOAD: begin
    cur_vx <= vx_rom(vtx_idx);
    cur_vy <= vy_rom(vtx_idx);
    cur_vz <= vz_rom(vtx_idx);
    state  <= S_ROT_MUL;
end

S_ROT_MUL: begin
    prod_xc <= cur_vx * cos_th;
    prod_zs <= cur_vz * sin_th;
    prod_xs <= cur_vx * sin_th;
    prod_zc <= cur_vz * cos_th;
    state   <= S_ROT_STORE;
end

S_ROT_STORE: begin
    vtx_px[vtx_idx] <= rot_px[8:0];
    vtx_py[vtx_idx] <= rot_py[8:0];
    if (vtx_idx == 3'd7) begin
        edge_idx <= 4'd0;
        state    <= S_EDGE_INIT;
    end else begin
        vtx_idx <= vtx_idx + 3'd1;
        state   <= S_ROT_LOAD;
    end
end

S_EDGE_INIT: begin
    bx     <= p0x;
    by     <= p0y;
    bx_end <= p1x;
    by_end <= p1y;
    bdx    <= init_dx;
    bdy    <= init_dy_n;
    bsx    <= init_sx;
    bsy    <= init_sy;
    berr   <= init_err;
    state  <= S_EDGE_SETUP;
end

S_EDGE_SETUP: begin
    if (in_screen) begin
        fb_raddr_rmw <= pix_addr;
        pix_mask     <= new_mask;
        state        <= S_EDGE_RD;
    end else begin
        state <= S_EDGE_STEP;        // skip clip
    end
end

• В экране: запрашиваем чтение fb[pix_addr] (выставляем fb_raddr_rmw), защёлкиваем pix_mask, идём в S_EDGE_RD (ждать ответ BRAM).
  
• Вне экрана: пропускаем RD/WR, сразу в S_EDGE_STEP (сделать шаг Брезенхэма без записи).

S_EDGE_RD: begin
    state <= S_EDGE_WR;
end

S_EDGE_WR: begin
    fb_we    <= 1'b1;
    fb_waddr <= fb_raddr_rmw;
    fb_wdata <= fb_rdata_rmw | pix_mask;
    state    <= S_EDGE_STEP;
end

S_EDGE_STEP: begin
    if (bx == bx_end && by == by_end) begin
        if (edge_idx == (NUM_EDGES - 4'd1)) begin
            txt_phase    <= 1'b0;
            txt_char_idx <= 3'd0;
            txt_col_idx  <= 3'd0;
            state        <= S_TEXT_INIT;
        end else begin
            edge_idx <= edge_idx + 4'd1;
            state    <= S_EDGE_INIT;
        end
    end else begin
        berr <= berr_nx;
        if (step_x) bx <= bx + bsx_ext;
        if (step_y) by <= by + bsy_ext;
        state <= S_EDGE_SETUP;
    end
end

• Достигли конца ребра (bx == bx_end && by == by_end):
  • если это последнее ребро (edge_idx == 11) — переходим к рендерингу текста (S_TEXT_INIT);
    
  • иначе — инкремент edge_idx, обратно в S_EDGE_INIT для следующего ребра.
• Не конец — классический шаг Брезенхэма:
  • berr обновляется суммой bdy_ext/bdx_ext согласно флагам step_x/step_y (комб-выражения из 6.8.3);
    
  • bx/by инкрементируются на ±1 соответственно;
    
  • возврат в S_EDGE_SETUP для рисования следующего пикселя.

S_TEXT_INIT: begin
    state <= S_TEXT_WR;
end

S_TEXT_WR: begin
    fb_we    <= 1'b1;
    fb_waddr <= txt_addr;
    fb_wdata <= font_byte({cur_char, txt_col_idx});
    state    <= S_TEXT_NEXT;
end

• верхний текст в page 0, нижний — в page 7;
  
• куб в pages 2..5;
  
• страницы не пересекаются → текст не затирает пиксели куба.

S_TEXT_NEXT: begin
    if (txt_col_idx == 3'd4) begin
        txt_col_idx <= 3'd0;
        if (txt_char_idx == cur_last) begin
            if (!txt_phase) begin
                txt_phase    <= 1'b1;
                txt_char_idx <= 3'd0;
                state        <= S_TEXT_WR;
            end else begin
                state <= S_DONE;
            end
        end else begin
            txt_char_idx <= txt_char_idx + 3'd1;
            state        <= S_TEXT_WR;
        end
    end else begin
        txt_col_idx <= txt_col_idx + 3'd1;
        state       <= S_TEXT_WR;
    end
end

• Если txt_col_idx < 4 — просто инкрементим столбец, возвращаемся в S_TEXT_WR.
  
• Если столбец = 4 (последний в букве) — сбрасываем столбец в 0:
  • если буква не последняя — инкрементим txt_char_idx, следующая буква;
    
  • если буква последняя в строке — переключаем txt_phase на нижнюю строку (либо уходим в S_DONE, если нижняя уже отрисована).

S_DONE: begin
    ready_o <= 1'b1;
    state   <= S_IDLE;
end

• ещё одну строку текста (больше txt_phase → 2 бита, новый лексикон);
  
• 2D-примитивы: прямоугольник (fill page-aligned rows), круг (Bresenham variant);
  
• простую анимацию иконок (bitmap в ROM, blit как текст);
  
• поворот куба по двум осям (+sin_phi/cos_phi, +2 умножения).

• фиксированные перспективные проекции (деление замещается умножением на 1/z из LUT);
  
• несколько объектов (нужен список объектов в ROM);
  
• «flood fill» замкнутой области (сканлайн-fill по страницам).

• полноценный 3D-рендер с Z-buffer’ом (нужно + 1 M9K под Z-буфер,
  • умножения для интерполяции);
• сглаживание (anti-aliasing) — требует 2-битного или даже 4-битного канала прозрачности, что несовместимо с 1bpp OLED;
  
• текстурированные полигоны — смотри полноценный GPU.

• что у SSD1306 I2C-адрес 0x3C, что control-byte для frame — 0x40, что init-последовательность — 32 байта;
  
• что перед первой командой после POR нужно ждать 100 мс;
  
• что анимация идёт через инкремент angle между кадрами;
  
• что при NACK нужно сбросить inited и при повторном нажатии пройти полный init-цикл заново.

module ssd1306_ctrl #(
    parameter CLK_FREQ = 50_000_000,
    parameter I2C_ADDR = 7'h3C,
    parameter DELAY_MS = 100
)(
    input  wire        clk_i,
    input  wire        rstn_i,
    input  wire        start_i,           // KEY2 — статический кадр
    input  wire        anim_i,            // KEY3 — анимация / стоп
    output wire        busy_o,
    output reg         done_o,
    output reg         err_o,
    output reg  [10:0] progress_o,        // текущий src_idx (для 7-seg)
    output wire        animating_o,
    // i2c_master_core command interface — прокси через burst_writer
    output wire        cmd_valid_o,
    output wire [2:0]  cmd_o,
    output wire [7:0]  din_o,
    input  wire        ready_i,
    input  wire        rx_ack_i,
    input  wire        arb_lost_i,
    output wire        arb_lost_clear_o
);

localparam [5:0] INIT_LEN = 6'd32;
function [7:0] init_rom;
    input [5:0] idx;
    case (idx)
        6'd0:  init_rom = 8'h00;   // Control byte: command stream
        6'd1:  init_rom = 8'hAE;   // Display OFF
        6'd2:  init_rom = 8'hD5;   // Set display clock divide
        6'd3:  init_rom = 8'h80;
        6'd4:  init_rom = 8'hA8;   // Set multiplex ratio
        ...
        6'd31: init_rom = 8'hAF;   // Display ON
        default: init_rom = 8'h00;
    endcase
endfunction

• control-byte 0x00 идёт как idx=0 — это не отдельный сигнал, а просто первый байт ROM’а. Благодаря этому в data-source mux (см. 7.6) не нужен дополнительный условный мультиплексор для init — просто bw_data = init_rom(src_idx).
  
• Длина ровно 32 = INIT_LEN, передаётся в bw_byte_count при старте init-транзакции.
  
• default: init_rom = 8'h00 — страховка от случайного идущего дальше индекса (теоретически не достижимо, т. к. byte_count = 32 → burst-writer остановится на idx=31).

localparam [10:0] DATA_LEN = 11'd1025;   // 1 control-byte + 1024 пикселя
localparam [3:0] PH_IDLE   = 4'd0,
                 PH_DELAY  = 4'd1,
                 PH_INIT   = 4'd2,
                 PH_INITW  = 4'd3,
                 PH_RENDER = 4'd4,
                 PH_RENDW  = 4'd5,
                 PH_FRAME  = 4'd6,
                 PH_FRAMEW = 4'd7,
                 PH_ANEXT  = 4'd8,
                 PH_OK     = 4'd9,
                 PH_ERR    = 4'd10;
reg  [3:0]  phase;
reg  [22:0] delay_cnt;
reg  [10:0] src_idx;
reg         inited;
reg         mode;
reg         anim_run;
reg  [5:0]  angle;
localparam [22:0] DELAY_CYCLES = (CLK_FREQ / 1000) * DELAY_MS;

reg         scene_start;
wire        scene_ready;
wire [7:0]  scene_rdata;
wire [9:0]  scene_raddr = (src_idx == 11'd0) ? 10'd0 : (src_idx[9:0] - 10'd1);
scene_renderer u_scene (
    .clk_i   (clk_i),
    .rstn_i  (rstn_i),
    .start_i (scene_start),
    .mode_i  (mode),
    .angle_i (angle),
    .ready_o (scene_ready),
    .raddr_i (scene_raddr),
    .rdata_o (scene_rdata)
);

scene_raddr = (src_idx == 0) ? 0 : (src_idx - 1);

• src_idx = 0 соответствует байту control-byte 0x40, а не первому пикселю. Его читать не из BRAM — его подмешивает контроллер (см. 7.6).
  
• src_idx = 1..1024 соответствует пикселям fb[0..1023].

wire [7:0]  init_byte  = init_rom(src_idx[5:0]);
wire [7:0]  data_byte  = (src_idx == 11'd0) ? 8'h40 : scene_rdata;
wire [7:0]  bw_data    = (phase == PH_INITW) ? init_byte : data_byte;

• init_byte — первая ветка, в init-режиме. Просто читает init_rom(src_idx[5:0]). Тут нет ни BRAM’а, ни control-byte’а (он уже зашит в init_rom[0] = 0x00).
  
• data_byte — ветка в frame-режиме. Два случая:
  • src_idx == 0 → выдаём 0x40 (frame control-byte);
    
  • src_idx >= 1 → выдаём scene_rdata (читаем из BRAM через scene_raddr = src_idx - 1).
• bw_data — общий выбор между init и frame по текущей фазе.

always @(posedge clk_i or negedge rstn_i) begin
    if (!rstn_i)
        src_idx <= 11'd0;
    else if (phase == PH_INIT || phase == PH_FRAME)
        src_idx <= 11'd0;                // новый burst → начать с 0
    else if (bw_data_req)
        src_idx <= src_idx + 11'd1;      // инкремент на каждом запросе
end

• При сбросе — src_idx = 0.
  
• При входе в PH_INIT/PH_FRAME — src_idx = 0 (начало новой транзакции). Заметьте, что это однократный тик: эти фазы сразу же переходят в PH_INITW/PH_FRAMEW на следующем такте.
  
• Во всех остальных фазах — инкремент на каждый bw_data_req = 1 (запрос следующего байта от burst-writer’а).

• ~9 I2C-бит × 4 ena-тика × 125 такт/ena ≈ 4500 тактов на передачу одного байта по I2C;
  
• 1–2 такта на CMD/WAIT-переходы;
  
• задержка BRAM = 1 такт.

такт N:       src_idx = K;  scene_raddr = K-1;
такт N+1:     (BRAM обновился)  scene_rdata = fb[K-1];
такт N+2:     bw_data_req pulse → byte latched as data_i = fb[K-1]  ✓
... 4500 тактов I2C ...
такт N+4502:  src_idx = K+1;  scene_raddr = K;
такт N+4503:  scene_rdata = fb[K];
такт N+4504:  next data_req → byte fb[K]  ✓

assign busy_o      = (phase != PH_IDLE && phase != PH_OK && phase != PH_ERR);
assign animating_o = anim_run;
wire trigger = start_i || anim_i;
assign arb_lost_clear_o = trigger && (phase == PH_IDLE ||
                                      phase == PH_OK   ||
                                      phase == PH_ERR);

reg anim_stop_req;
always @(posedge clk_i or negedge rstn_i) begin
    if (!rstn_i)
        anim_stop_req <= 1'b0;
    else if (anim_i && anim_run)
        anim_stop_req <= 1'b1;
    else if (phase == PH_OK || phase == PH_IDLE)
        anim_stop_req <= 1'b0;
end

• Если пользователь нажимает KEY3 во время активной анимации (anim_i && anim_run) → запоминаем запрос на остановку (anim_stop_req = 1).
  
• Остановка срабатывает в PH_FRAMEW: если anim_run && !anim_stop_req → уходим в PH_ANEXT (продолжаем анимацию); иначе → PH_OK (стоп).
  
• Очистка флага — в PH_OK или PH_IDLE (когда анимация уже остановлена).

always @(posedge clk_i or negedge rstn_i) begin
    if (!rstn_i) begin
        phase         <= PH_IDLE;
        delay_cnt     <= 23'd0;
        bw_start      <= 1'b0;
        bw_byte_count <= 16'd0;
        scene_start   <= 1'b0;
        done_o        <= 1'b0;
        err_o         <= 1'b0;
        progress_o    <= 11'd0;
        inited        <= 1'b0;
        mode          <= 1'b0;
        anim_run      <= 1'b0;
        angle         <= 6'd0;
    end else begin
        bw_start    <= 1'b0;     // pre-assign — одноцикловые импульсы
        scene_start <= 1'b0;
        done_o      <= 1'b0;
        ...

PH_IDLE: begin
    if (start_i) begin
        mode     <= 1'b0;
        anim_run <= 1'b0;
        angle    <= 6'd0;
        err_o    <= 1'b0;
        if (inited)
            phase <= PH_RENDER;
        else begin
            delay_cnt <= DELAY_CYCLES;
            phase     <= PH_DELAY;
        end
    end else if (anim_i) begin
        mode     <= 1'b1;
        anim_run <= 1'b1;
        angle    <= 6'd0;
        err_o    <= 1'b0;
        if (inited)
            phase <= PH_RENDER;
        else begin
            delay_cnt <= DELAY_CYCLES;
            phase     <= PH_DELAY;
        end
    end
end

• KEY2 (start_i): mode=0, anim_run=0 → один статический кадр.
  
• KEY3 (anim_i): mode=1, anim_run=1 → циклическая анимация.

PH_DELAY: begin
    if (delay_cnt == 23'd0)
        phase <= PH_INIT;
    else
        delay_cnt <= delay_cnt - 23'd1;
end

PH_INIT: begin
    bw_start      <= 1'b1;
    bw_byte_count <= {10'd0, INIT_LEN};
    phase         <= PH_INITW;
end
PH_INITW: begin
    progress_o <= src_idx;
    if (bw_done) begin
        if (bw_error) begin
            err_o  <= 1'b1;
            inited <= 1'b0;
            phase  <= PH_ERR;
        end else begin
            inited <= 1'b1;
            phase  <= PH_RENDER;
        end
    end
end

• каждый такт обновляет progress_o текущим src_idx (для визуализации на 7-сегменте);
  
• по bw_done:
  • если ошибка (NACK / arb-lost) → PH_ERR, inited = 0;
    
  • иначе → PH_RENDER, inited = 1.

PH_RENDER: begin
    scene_start <= 1'b1;
    phase       <= PH_RENDW;
end
PH_RENDW: begin
    if (scene_ready)
        phase <= PH_FRAME;
end

PH_FRAME: begin
    bw_start      <= 1'b1;
    bw_byte_count <= {5'd0, DATA_LEN};       // 16-bit = 0x0401 = 1025
    phase         <= PH_FRAMEW;
end
PH_FRAMEW: begin
    progress_o <= src_idx;
    if (bw_done) begin
        if (bw_error) begin
            err_o    <= 1'b1;
            anim_run <= 1'b0;
            phase    <= PH_ERR;
        end else if (anim_run && !anim_stop_req)
            phase <= PH_ANEXT;
        else begin
            done_o   <= 1'b1;
            anim_run <= 1'b0;
            phase    <= PH_OK;
        end
    end
end

• Ошибка (bw_error) — PH_ERR, anim_run=0. Если у нас был цикл анимации, он тоже прерывается.
  
• Нормально + анимация + не-стоп — PH_ANEXT (инкремент угла, новый кадр).
  
• Нормально + не-анимация или стоп-запрос — PH_OK с pulse’ом done_o.

PH_ANEXT: begin
    angle <= angle + 6'd1;
    phase <= PH_RENDER;
end

PH_OK: begin
    if (start_i) begin
        mode     <= 1'b0;
        anim_run <= 1'b0;
        angle    <= 6'd0;
        err_o    <= 1'b0;
        phase    <= inited ? PH_RENDER : PH_DELAY;
        if (!inited) delay_cnt <= DELAY_CYCLES;
    end else if (anim_i) begin
        mode     <= 1'b1;
        anim_run <= 1'b1;
        angle    <= 6'd0;
        err_o    <= 1'b0;
        phase    <= inited ? PH_RENDER : PH_DELAY;
        if (!inited) delay_cnt <= DELAY_CYCLES;
    end
end

• Если inited = 1 (чип уже инициализирован) — сразу идём в PH_RENDER, экономя 100 мс + 32 байта I2C (~1.5 мс) = ~101.5 мс per повторный запуск.
  
• Если inited = 0 (ещё не init или после PH_ERR) — полный цикл через PH_DELAY → PH_INIT.

PH_ERR: begin
    if (start_i || anim_i) begin
        inited    <= 1'b0;
        mode      <= anim_i ? 1'b1 : 1'b0;
        anim_run  <= anim_i;
        angle     <= 6'd0;
        err_o     <= 1'b0;
        delay_cnt <= DELAY_CYCLES;
        phase     <= PH_DELAY;
    end
end

• всегда сбрасывает inited = 0 и идёт через PH_DELAY → PH_INIT — полный цикл инициализации (предположение: дисплей мог быть физически отключён / сбросился / сбоил, нужна перенастройка);
  
• выбирает режим: static или anim в зависимости от нажатой кнопки.

i2c_burst_writer #(
    .CNT_W (16)
) u_burst (
    .clk_i        (clk_i),
    .rstn_i       (rstn_i),
    .start_i      (bw_start),
    .slave_addr_i (I2C_ADDR),
    .byte_count_i (bw_byte_count),
    .busy_o       (bw_busy),
    .done_o       (bw_done),
    .error_o      (bw_error),
    .data_req_o   (bw_data_req),
    .data_i       (bw_data),
    .data_valid_i (bw_data_req),      // комбинаторная связка (см. 4.14)
    .cmd_valid_o  (cmd_valid_o),
    .cmd_o        (cmd_o),
    .din_o        (din_o),
    .ready_i      (ready_i),
    .rx_ack_i     (rx_ack_i),
    .arb_lost_i   (arb_lost_i)
);

• CNT_W = 16 — с запасом на 65 535 байт. Достаточно и для init (32), и для frame (1025), и для любых будущих расширений.
  
• data_valid_i = bw_data_req — комбинаторное равенство. Источник всегда валиден мгновенно (init-ROM — комб-функция; scene_rdata — BRAM с latency=1, но интервалы между запросами в 4500 раз больше).
  
• cmd_valid_o/cmd_o/din_o — выходы burst-writer’а пробрасываются прозрачно наверх, через ssd1306_ctrl на внешний i2c_master_core. Никаких дополнительных мультиплексоров.
  
• arb_lost_i — проксируется от ядра к burst-writer’у; а arb_lost_clear_o обратно, из ssd1306_ctrl к ядру.

• Dual-buffer анимация. Добавить второй BRAM + ping-pong флаг: пока кадр N передаётся, рендерим N+1 в другой буфер. Даст fps, ограниченный только передачей (~21 fps). Стоимость — +1 M9K, +20 LE.
  
• Retry при NACK. Сейчас по bw_error мы сразу уходим в PH_ERR. Можно добавить счётчик retries (до 3) с возвратом в PH_DELAY → PH_INIT. Полезно для шумной шины / вибрации.
  
• Watchdog по времени кадра. Если PH_FRAMEW длится больше 100 мс — что-то зависло (clock stretching slave’а, физическая проблема). Таймаут + принудительный STOP + PH_ERR.
  
• Несколько сцен. Добавить вход scene_sel_i и передавать в scene_renderer, чтобы показать разные сцены по разным кнопкам. Ctrl-логика не меняется.
  
• I2C probe перед init. См. 2.2.2 — можно отправить transaction с byte_count=0 перед PH_INIT, чтобы проверить наличие дисплея; если NACK → сразу PH_ERR без 100 мс ожидания.

• Генерирует core_ena из clk_50m — прескалер для работы I2C-ядра на 100 кГц.
  
• Подключает двунаправленные пины i2c_sda/i2c_scl через tri-state + синхронизаторы.
  
• Антидребезжит две кнопки KEY2/KEY3.
  
• Собирает статус (busy, done, err, animating) на 4 LED.
  
• Разворачивает 11-битный progress_o на 3 HEX-цифры 7-сегментного дисплея + 1 статус-цифра.
  
• Инстанциирует три главных модуля: i2c_master_core, ssd1306_ctrl, seg_scan, ax_debounce (×2).

module ssd1306_test_top (
    input  wire       clk_50m,
    input  wire       rst_n,
    input  wire       key_start,      // KEY2 — active-low, статика
    input  wire       key_anim,       // KEY3 — active-low, анимация
    inout  wire       i2c_sda,        // двунаправленные I2C
    inout  wire       i2c_scl,
    output wire [3:0] led,            // 4 LED, active-high
    output wire [5:0] seg_sel,        // 6 цифр, active-low select
    output wire [7:0] seg_data        // 8 сегментов, active-low
);

SCL_freq  = clk_sys / (4 · (PRE_TOP + 1))
100 кГц   = 50 МГц  / (4 · 125)
PRE_TOP   = 124

localparam [6:0] PRE_TOP = 7'd124;
reg [6:0] pre_cnt;
reg       core_ena;
always @(posedge clk_50m or negedge rst_n) begin
    if (!rst_n) begin
        pre_cnt  <= 7'd0;
        core_ena <= 1'b0;
    end else begin
        if (pre_cnt == PRE_TOP) begin
            pre_cnt  <= 7'd0;
            core_ena <= 1'b1;        // 1 такт из каждых 125
        end else begin
            pre_cnt  <= pre_cnt + 7'd1;
            core_ena <= 1'b0;
        end
    end
end

• 7-битный счётчик pre_cnt (0..127, достаточно для 124).
  
• 1 такт core_ena из каждых 125 тактов. I2C-ядро использует его как «разрешение сдвига» своего бит-FSM.
  
• Скважность 1/125 — это ena-стробы, они не являются клоком. В синтезе будет один клок-домен clk_50m, а core_ena просто включает/выключает последовательную логику в ядре — это хорошая практика CDC-free дизайна.

• Двунаправленные пины i2c_sda/i2c_scl — open-drain, FPGA их «отпускает» для чтения, «притягивает к земле» для передачи 0.
  
• Входные сигналы SDA/SCL приходят из другого клок-домена (или вовсе асинхронны) — их нужно синхронизировать.

wire sda_pad_in, scl_pad_in;
wire sda_oen, scl_oen;
assign i2c_sda   = sda_oen ? 1'bz : 1'b0;
assign i2c_scl   = scl_oen ? 1'bz : 1'b0;
assign sda_pad_in = i2c_sda;
assign scl_pad_in = i2c_scl;

• sda_oen = 1 — FPGA отпускает пин, линию удерживает внешний pull-up (4.7 кОм, см. 2.1.5), или её тянет slave.
  
• sda_oen = 0 — FPGA выдаёт 0, притягивая линию к GND. Никогда не выдаём 1 напрямую (это нарушило бы open-drain и вызвало КЗ, если slave одновременно тянет 0).
  
• assign ... = i2c_sda — простое чтение того же пина (верификация реального состояния, с учётом slave и pull-up).

reg [1:0] sda_sync, scl_sync;
always @(posedge clk_50m or negedge rst_n) begin
    if (!rst_n) begin
        sda_sync <= 2'b11;
        scl_sync <= 2'b11;
    end else begin
        sda_sync <= {sda_sync[0], sda_pad_in};
        scl_sync <= {scl_sync[0], scl_pad_in};
    end
end
wire sda_s = sda_sync[1];
wire scl_s = scl_sync[1];

• Два последовательных FF на каждую линию: sda_pad_in → sda_sync[0] → sda_sync[1].
  
• Задержка — 2 такта clk_50m = 40 нс. При 100 кГц SCL (10 мкс на бит) это пренебрежимо.
  
• Сброс в 2'b11 — правильное состояние для idle шины (линии отпущены). Это критически важно: после сброса мы должны «видеть» шину как свободную, иначе FSM ядра может посчитать её занятой.

Ступеней	MTBF (мин. оценка Altera)
1	~1 секунда
2	~ секунд ≈ 31 год
3	~ секунд

wire key_start_pulse, key_anim_pulse;
ax_debounce #(.CLK_FREQ(50_000_000), .DEBOUNCE_MS(20)) u_deb_start (
    .clk_i(clk_50m), .rstn_i(rst_n),
    .key_i(key_start), .key_pulse_o(key_start_pulse)
);
ax_debounce #(.CLK_FREQ(50_000_000), .DEBOUNCE_MS(20)) u_deb_anim (
    .clk_i(clk_50m), .rstn_i(rst_n),
    .key_i(key_anim), .key_pulse_o(key_anim_pulse)
);

module ax_debounce #(
    parameter CLK_FREQ    = 50_000_000,
    parameter DEBOUNCE_MS = 20
)(
    input  wire clk_i,
    input  wire rstn_i,
    input  wire key_i,
    output reg  key_pulse_o
);
    localparam CNT_MAX = (CLK_FREQ / 1000) * DEBOUNCE_MS;
    reg [19:0] cnt;
    reg        key_d;
    reg        key_stable;
    always @(posedge clk_i or negedge rstn_i) begin
        if (!rstn_i) begin
            cnt         <= 20'd0;
            key_d       <= 1'b1;
            key_stable  <= 1'b1;
            key_pulse_o <= 1'b0;
        end else begin
            key_pulse_o <= 1'b0;             // pre-assign: импульс 1 такт
            key_d       <= key_i;            // однократная выборка
            if (key_d != key_stable) begin   // есть рассогласование
                if (cnt >= CNT_MAX[19:0] - 20'd1) begin
                    cnt        <= 20'd0;
                    key_stable <= key_d;     // принять новое состояние
                    if (!key_d)
                        key_pulse_o <= 1'b1; // фронт 1→0 = нажатие
                end else
                    cnt <= cnt + 20'd1;
            end else
                cnt <= 20'd0;                // сброс — состояние стабильно
        end
    end
endmodule

• key_d — входной сэмпл прошлого такта; key_stable — текущее «признанное» состояние.
  
• Если совпадают — сигнал стабилен, счётчик сброшен.
  
• Если не совпадают — наращиваем счётчик. Как только он достигает CNT_MAX - 1 = 20 мс × 50 МГц / 1000 = 1 000 000 — признаём новое состояние стабильным.
  
• Только на фронте 1 → 0 (нажатие, т. к. активность-low) генерируем одноцикловый key_pulse_o. На отпускании — нет.

• Одно нажатие даёт ровно один key_pulse_o — идеально для FSM ssd1306_ctrl.
  
• Любые дребезги короче 20 мс игнорируются.
  
• Нажатия короче 20 мс тоже игнорируются — это защищает от помех. Пользователь так быстро нажать физически не может.
  
• Задержка распознавания — 20 мс. Нечувствительно для человека.

wire       cmd_valid, ready, rx_ack, arb_lost, busy;
wire       arb_lost_clear;
wire [2:0] cmd;
wire [7:0] din;
i2c_master_core u_core (
    .clk_i            (clk_50m),
    .rstn_i           (rst_n),
    .ena_i            (core_ena),          // от прескалера, 100 кГц × 4
    .cmd_valid_i      (cmd_valid),         // от burst_writer
    .cmd_i            (cmd),
    .din_i            (din),
    .dout_o           (),                  // не используется (read mode off)
    .rx_ack_o         (rx_ack),
    .ready_o          (ready),
    .arb_lost_o       (arb_lost),
    .arb_lost_clear_i (arb_lost_clear),
    .busy_o           (busy),
    .scl_i            (scl_s),             // синхронизированный вход
    .scl_oen_o        (scl_oen),
    .sda_i            (sda_s),
    .sda_oen_o        (sda_oen)
);

• ena_i = core_ena — строба для квартала SCL-периода (см. 8.3);
  
• cmd_valid_i/cmd_i/din_i — от u_ssd → u_burst, командный интерфейс;
  
• scl_i/sda_i — синхронизированные входы (scl_s/sda_s), не сырые пиновые;
  
• scl_oen_o/sda_oen_o — управление tri-state буферами (см. 8.4);
  
• busy_o не подключен к LED — есть более информативный ssd_busy от верхнего уровня.
  
• dout_o не используется — мы только пишем на SSD1306, никогда не читаем.

wire        ssd_busy, ssd_done, ssd_err, ssd_animating;
wire [10:0] ssd_progress;
ssd1306_ctrl #(
    .CLK_FREQ (50_000_000),
    .I2C_ADDR (7'h3C),
    .DELAY_MS (100)
) u_ssd (
    .clk_i            (clk_50m),
    .rstn_i           (rst_n),
    .start_i          (key_start_pulse),   // KEY2 после дебаунса
    .anim_i           (key_anim_pulse),    // KEY3 после дебаунса
    .busy_o           (ssd_busy),
    .done_o           (ssd_done),
    .err_o            (ssd_err),
    .progress_o       (ssd_progress),
    .animating_o      (ssd_animating),
    .cmd_valid_o      (cmd_valid),         // → u_core
    .cmd_o            (cmd),
    .din_o            (din),
    .ready_i          (ready),             // ← u_core
    .rx_ack_i         (rx_ack),
    .arb_lost_i       (arb_lost),
    .arb_lost_clear_o (arb_lost_clear)
);

reg ssd_done_latch;
always @(posedge clk_50m or negedge rst_n) begin
    if (!rst_n)
        ssd_done_latch <= 1'b0;
    else if (ssd_done)
        ssd_done_latch <= 1'b1;
    else if (key_start_pulse || key_anim_pulse)
        ssd_done_latch <= 1'b0;
end
assign led[0] = ssd_busy;           // занят
assign led[1] = ssd_done_latch;     // успех (latch!)
assign led[2] = ssd_err;            // ошибка
assign led[3] = ssd_animating;      // анимация

• Set по ssd_done (одноцикловый impulse из ssd1306_ctrl). Если бы подключили его напрямую к LED, пользователь бы увидел всего 20 нс вспышки = незаметно.
  
• Reset на новое нажатие кнопки — чтобы «погасить» успех предыдущего кадра и показать «идёт новый».

• Включение платы: все LED выключены, идёт POR-reset.
  
• Нажатие KEY2: LED0 загорается на ~46 мс, затем LED1.
  
• Нажатие KEY3: LED0 + LED3 горят постоянно (цикл); повторное KEY3 → LED0 гаснет, LED1 загорается (последний кадр завершён).
  
• Если дисплей отключён: LED0 мигает, через ~1 мс LED2 загорается, LED0 гаснет.

function [7:0] seg_hex;
    input [3:0] val;
    begin
        case (val)
            4'h0: seg_hex = 8'hC0;   // 1100 0000
            4'h1: seg_hex = 8'hF9;   // 1111 1001
            4'h2: seg_hex = 8'hA4;
            4'h3: seg_hex = 8'hB0;
            4'h4: seg_hex = 8'h99;
            4'h5: seg_hex = 8'h92;
            4'h6: seg_hex = 8'h82;
            4'h7: seg_hex = 8'hF8;
            4'h8: seg_hex = 8'h80;
            4'h9: seg_hex = 8'h90;
            4'hA: seg_hex = 8'h88;
            4'hB: seg_hex = 8'h83;
            4'hC: seg_hex = 8'hC6;
            4'hD: seg_hex = 8'hA1;
            4'hE: seg_hex = 8'h86;
            4'hF: seg_hex = 8'h8E;
            default: seg_hex = 8'hFF;  // всё выключено
        endcase
    end
endfunction

a
    ───
  f│   │b
   │ g │
    ───
  e│   │c
   │   │
    ───   ·dp
     d

localparam [7:0] SEG_BLANK = 8'hFF;    // все выключены
localparam [7:0] SEG_DASH  = 8'hBF;    // только g (средний)
localparam [7:0] SEG_A     = 8'h88;    // то же, что 'A'

• 8'h86 = 'E' (a, d, e, f, g) — отображение ошибки.

wire [7:0] seg_d0 = ssd_err        ? 8'h86 :            // 'E'
                    ssd_animating  ? SEG_A  :            // 'A'
                    ssd_done_latch ? seg_hex(4'h0)       // '0'
                                   : SEG_DASH;           // '-'
wire [7:0] seg_d1 = seg_hex(ssd_progress[3:0]);
wire [7:0] seg_d2 = seg_hex(ssd_progress[7:4]);
wire [7:0] seg_d3 = seg_hex({1'b0, ssd_progress[10:8]});
wire [7:0] seg_d4 = SEG_BLANK;
wire [7:0] seg_d5 = SEG_BLANK;
seg_scan #(.SCAN_BITS(16)) u_seg (
    .clk_i     (clk_50m),
    .rstn_i    (rst_n),
    .seg_data_0(seg_d0),
    .seg_data_1(seg_d1),
    .seg_data_2(seg_d2),
    .seg_data_3(seg_d3),
    .seg_data_4(seg_d4),
    .seg_data_5(seg_d5),
    .seg_sel   (seg_sel),
    .seg_data  (seg_data)
);

[seg_d5] [seg_d4]  [seg_d3]      [seg_d2]     [seg_d1]    [seg_d0]
  ( · )    ( · )   (prog[10:8])   (prog[7:4])  (prog[3:0]) (status)
  BLANK    BLANK     hex top       hex mid     hex low     -/0/E/A

• seg_d5, seg_d4 — пустые, ничего не отображают.
  
• seg_d3 — старшие 3 бита progress_o (0..7), дополнены нулём до 4 бит.
  
• seg_d2 — средние 4 бита.
  
• seg_d1 — младшие 4 бита.
  
• seg_d0 — статус-цифра по приоритету:
  • ssd_err → 'E' (горит всё время ошибки);
    
  • ssd_animating → 'A' (анимация активна);
    
  • ssd_done_latch → '0' (успех, защёлка);
    
  • иначе → '-' (idle или busy без завершения).

module seg_scan #(
    parameter SCAN_BITS = 16
)(
    input  wire       clk_i,
    input  wire       rstn_i,
    input  wire [7:0] seg_data_0,
    ...
    input  wire [7:0] seg_data_5,
    output reg  [5:0] seg_sel,
    output reg  [7:0] seg_data
);
    reg [SCAN_BITS-1:0] scan_cnt;
    wire [2:0] scan_idx = scan_cnt[SCAN_BITS-1 : SCAN_BITS-3];
    always @(posedge clk_i or negedge rstn_i) begin
        if (!rstn_i)
            scan_cnt <= {SCAN_BITS{1'b0}};
        else
            scan_cnt <= scan_cnt + 1'b1;
    end
    always @(*) begin
        case (scan_idx)
            3'd0: begin seg_sel = 6'b111110; seg_data = seg_data_0; end
            3'd1: begin seg_sel = 6'b111101; seg_data = seg_data_1; end
            3'd2: begin seg_sel = 6'b111011; seg_data = seg_data_2; end
            3'd3: begin seg_sel = 6'b110111; seg_data = seg_data_3; end
            3'd4: begin seg_sel = 6'b101111; seg_data = seg_data_4; end
            3'd5: begin seg_sel = 6'b011111; seg_data = seg_data_5; end
            default: begin seg_sel = 6'b111111; seg_data = 8'hFF; end
        endcase
    end
endmodule

• 16-битный счётчик scan_cnt считает от 0 до 65535 и перекатывается. Частота — clk_50m / 2^16 = ~763 Гц.
  
• Старшие 3 бита scan_cnt[15:13] = scan_idx задают текущую активную цифру (0..7, из них реально используются 0..5).
  
• Частота обновления одной цифры = 763 / 8 ≈ 95 Гц. Выше порога мерцания (~60 Гц) — человеческий глаз видит стабильное изображение.
  
• Скважность — 1/8 на цифру, т. к. 2 пустых слота (6, 7) + активна только одна из шести. Реальная яркость ≈ 12.5% от «все цифры всегда горят». Это стандарт для мультиплексированных индикаторов.
  
• seg_sel — one-hot active-low (6'b111110 — активна цифра 0, остальные off). Так индикатор работает на AX301.

FAMILY            = "Cyclone IV E"
DEVICE            = EP4CE6F17C8
TOP_LEVEL_ENTITY  = ssd1306_test_top
PROJECT_OUTPUT_DIRECTORY = output_files
MIN_CORE_JUNCTION_TEMP = 0
MAX_CORE_JUNCTION_TEMP = 85
NOMINAL_CORE_SUPPLY_VOLTAGE = 1.2V
LAST_QUARTUS_VERSION = "25.1std.0 Standard Edition"

src/ssd1306_test_top.v
src/ssd1306_ctrl.v
src/scene_renderer.v
src/seg_scan.v
src/ax_debounce.v
../rtl/i2c_master_core.v
../rtl/i2c_burst_writer.v
ssd1306_test_top.sdc

PIN_C1  → ~ALTERA_ASDO_DATA1~
PIN_D2  → ~ALTERA_FLASH_nCE_nCSO~
PIN_H1  → ~ALTERA_DCLK~
PIN_H2  → ~ALTERA_DATA0~
PIN_F16 → ~ALTERA_nCEO~

SDC_FILE ssd1306_test_top.sdc

create_clock -name clk_50m -period 20.000 [get_ports clk_50m]
derive_pll_clocks
derive_clock_uncertainty
# I2C пины — псевдо-статические (100 кГц), ослабляем ограничения
set_false_path -from [get_ports {i2c_sda i2c_scl rst_n key_start key_anim}] -to [all_registers]
set_false_path -from [all_registers] -to [get_ports {i2c_sda i2c_scl led