Лисья Нора
09:23
Главная » Проекты » 8. Протокол PS/2: Верилог

Оглавление


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

В прошлой части я рассказал о том, как работает протокол 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; // Отсчет таймаута для "зависшего" приема данных в случае ошибки
Принцип работы модуля такой.
Разработав этот алгоритм, приступим к реализации:
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:
waveps2.png
Как видно, сначала идет старт-бит 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;
Это пример, как принимаются данные от модуля.