§ Адаптер на верилоге

В прошлой части я рассказал о том, как работает протокол PS/2 и написал его симуляцию на языке С. Сегодня я разберу адаптер для верилога, который будет просимулирован как с помощью верилятора, так и в реальной схеме (синтезирован для ПЛИС).
Начнем с описания портов (файл ps2.v):
module ps2
(
    input   clock,           // Тактовая частота 25 Мгц
    input   ps_clock,        // Пин, подключенный к проводу CLOCK с PS/2
    input   ps_data,         // Пин DATA

    output reg       done,   // Устанавливается =1, если данные доступны
    output reg [7:0] data    // Принятый байт с PS/2
);
...
endmodule
На выходе я установил регистры, а значит, их надо инициализировать в 0:
initial begin data = 8'h00; done = 1'b0; end
Теперь же, рассмотрим, какие регистры будут использоваться в модуле
reg         kbusy   = 1'b0;   // =1 Если идет прием данных с пина (шины) DATA
reg         kdone   = 1'b0;   // =1 Прием сигнала завершен, "фантомный" регистр к `done`
reg [1:0]   klatch  = 2'b00;  // Сдвиговый регистр для отслеживания позитивного и негативного фронта CLOCK
reg [3:0]   kcount  = 1'b0;   // Номер такта CLOCK
reg [9:0]   kin     = 1'b0;   // Сдвиговый регистр для приема данных с DATA
reg [19:0]  kout    = 1'b0;   // Отсчет таймаута для "зависшего" приема данных в случае ошибки
Принцип работы модуля такой.
  • Если текущее состояние модуля kbusy = 0, то тогда ничего не делать, ждать того момента, когда CLOCK перейдет из состояния 1 в состояние 0. Если это произошло, то установить kbusy = 1
  • В состоянии приема сигналов ожидать позитивного фронта CLOCK. Как только он будет получен, в сдвиговый регистр kin засылать новый бит с DATA, а также увеличить счетчик kcount + 1
  • Если счетчик будет равен kcount=10, то это значит, все необходимые биты приняты (старт-бит + 8 бит информации + бит четности), и потому на этом такте ставится done=1, но на следующем такте done становится равным 0, и также записывается в data принятое значение
  • В случае, если произошла ошибка, то есть, бит четности не совпадает с принятыми данными, done не ставить 1
  • Также, если прошло очень много времени во время приема сигнала, и CLOCK стабильно 1, то тогда сбросить состояние в kbusy=0. Вероятно, на линии произошла ошибка.
Разработав этот алгоритм, приступим к реализации:
always @(posedge clock) begin

    kdone <= 1'b0;

    // Процесс приема сигнала
    if (kbusy) begin

        ...

    end else begin

        // Обнаружен негативный фронт \__
        if (klatch == 2'b10) begin

            kbusy   <= 1'b1; // Активировать прием данных
            kcount  <= 1'b0; // Сброс двух счетчиков в 0
            kout    <= 1'b0;

        end

    end

    klatch <= {klatch[0], ps_clock};

end
При каждом такте (25 мгц), значение kdone сбрасывается в 0, кроме того случая, когда сигнал был только что принят. В коде реализован сдвиговый регистр klatch, который вдвигает биты CLOCK справа налево. Этот регистр необходим для отслеживания позитивного фронта (klatch=2'b01) или негативного фронта (klatch=2'b10).
Если kbusy=0, то при появлении негативного фронта обнуляются все счетчики и на следующем такте (25 мгц), уже переходит к ожиданию сигнала CLOCK:
// Позитивный фронт
if (klatch == 2'b01) begin

    // Завершающий такт
    if (kcount == 4'hA) begin

        data    <= kin[8:1];
        kbusy   <= 1'b0;
        kdone   <= ^kin[9:1]; // =1 Если четность совпадает

    end

    kcount  <= kcount + 1'b1;
    kin     <= {ps_data, kin[9:1]};

end

// Считать "зависший процесс"
kout <= ps_clock ? kout + 1 : 1'b0;

// И если прошло более 20 мс, то перевести в состояние ожидания
if (kout > 25000*20) kbusy <= 1'b0;
Поясню, что при 10-м такте от PS/2, необходимые данные будут находится в сдвиговом регистре kin[8:1], потому что в бите kin[0] находится старт-бит (всегда 0), а в бите kin[9] будет находится бит четности.
В kdone записывается побитовое XOR над всеми битами, включая бит четности. В случае совпадения четности, в kdone окажется 1. Это происходит по причине того, что бит четности вычисляется как ~^data[7:0], то есть, происходит инверсия, которая и оказывает хорошую услугу при вычислении корректности входящих данных.
Сдвиговый регистр kin работает слева направо, то есть, вдвигается сначала старший бит (MSB), а не младший, как в klatch. Таким образом, первый пришедший бит окажется в младших битах kin. Последний бит (четности), окажется в старшем бите kin (в бите 9).
Далее, вне зависимости от клока, будет считаться kout. Он увеличивается на +1 если CLOCK=1. И если такое состояние ожидания очень долго находится (25000*20, что равно 20 мс), то kbusy сбрасывается в режим ожидания.
И последний штрих:
always @(negedge clock) done <= kdone;
Этот код нужен для того, чтобы переписывать kdone в done на негативном фронте. Это нужно для того, чтобы data успел сформироваться, и чтобы done пришел вовремя без гонки состоянии. То есть, done будет готов на негативном фронте clock, через некоторое время, на следующем позитивном фронте процессор например, сможет принять данные и обработать их без ошибок и без конфликтов времени.

§ Тестбенч

Для того, чтобы проверить работоспособность модуля и выполнить его отладку, я написал тестбенч для icarus verilog.
`timescale 10ns / 1ns
module tb;

reg           clock;
always  #0.5  clock = ~clock;
initial begin clock = 0; #2000 $finish; end
initial begin $dumpfile("tb.vcd"); $dumpvars(0, tb); end

// ----------------
reg ps_clock = 1'b1;
reg ps_data  = 1'b1;

wire [7:0] keytest = 8'hF0;

initial begin

    // Старт-бит
    #8 ps_clock = 1'b0; ps_data = 1'b0;
    #3 ps_clock = 1'b1;
    // Биты данных
    #3 ps_clock = 1'b0; ps_data = keytest[0]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[1]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[2]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[3]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[4]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[5]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[6]; #3 ps_clock = 1'b1;
    #3 ps_clock = 1'b0; ps_data = keytest[7]; #3 ps_clock = 1'b1;
    // Бит четности
    #3 ps_clock = 1'b0; ps_data = ~^keytest; #3 ps_clock = 1'b1;
    // Стоп-бит
    #3 ps_clock = 1'b0; ps_data = 1'b1; #3 ps_clock = 1'b1;

end
// ----------------

ps2 Keyb
(
    .clock      (clock),
    .ps_clock   (ps_clock),
    .ps_data    (ps_data)
);

endmodule
Вначале, тестовые входящие регистры ps_clock и ps_data устанавливаются в 1, а потом, следуя логике в блоке initial, им ставятся разные значения.
#8 ps_clock = 1'b0; ps_data = 1'b0; Этот блок значит, что спустя 8x10 нс после начала, установить ps_clock и ps_data в 0
#3 ps_clock = 1'b1; спустя 30 нс, установить в ps_clock в 1
И так далее. В качестве входящих данных используется значение регистра keytest. В тестбенче также считается бит четности ps_data = ~^keytest; и выставляется стоп-бит.
Так этот процесс выглядит в программе просмотра временных диаграмм gtkwave:

Как видно, сначала идет старт-бит 0, потом четыре 0, далее четыре 1, бит четности (1 — количество единиц четно), и стоп-бит 1, всего 11 тактов.

§ Встраивание модуля верилятора

Теперь стоит проверить, как работает модуль, используя верилятор.
WARN=-Wall -Wno-unused -Wno-width -Wno-caseincomplete
tbc: verilate
	g++ -o tb -I$(VINC) tb.cc $(VINC)/verilated.cpp obj_dir/Vvga__ALL.a obj_dir/Vps2__ALL.a -lSDL2
	./tb
verilate:
	verilator $(WARN) -cc vga.v
	verilator $(WARN) -cc ps2.v
	cd obj_dir && make -f Vvga.mk
	cd obj_dir && make -f Vps2.mk
Это часть команд из makefile. Вместо одного модуля, теперь компилируется два. Я вынес в $(WARN) опции по удалению warnings, которые генерирует верилятор из-за слегка неаккуратного кода на верилоге.
В опциях к g++ добавляется только строка obj_dir/Vps2__ALL.a
Теперь же встроим код в tb.cc:
#include "obj_dir/Vps2.h"
...

Vvga* top = new Vvga;
Vps2* ps2 = new Vps2;

while (app->main()) {
    ...
    app->kbd_pop(ps_clock, ps_data);

    ps2->ps_clock = ps_clock;
    ps2->ps_data  = ps_data;
    ...
    ps2->clock = 0; ps2->eval();
    ps2->clock = 1; ps2->eval();
    ...
    if (ps2->done) printf("%02x ", ps2->data);
    ...
}
По идее, и все, что надо сделать. Получается, что добавился новый include, был создан новый объект класс Vps2, и через eval() запущен в работу, обеспечивая ту же самую частоту 25 мгц, что и видеоадаптеру.
Сразу же после kbd_pop, значение ps_clock и ps_data присваиваются входам модуля ps2.
Также, добавлена строка, при которой при появлении done на выходе ps2, будет в консоль выведена отладочная информация о принятом скан-коде от виртуальной клавиатуры.
Пожалуй, на этом можно и завершить эту тему. Единственное, что могу добавить, это то, как принимать данные от модуля:
reg [7:0] data;
always @(posedge clock_25)
    if (ps_done)
        data <= ps_data;
Это пример, как принимаются данные от модуля.
Как и обычно, скачать файлы можно здесь.

23 апр, 2022
© 2007-2022 Все мелочи ништяково распакованы