модуль энкодеров на верилоге Опции

[sergey sva]

Модуль энкодеров делаю для этой платы. Набросал заготовку, только заготовку.
Какие замечания, что бы сразу переделать? Может кто помочь захочет. )

CODE

//*************************************************************************//
// |------|
// ____| |____ A
//
// |------|
// _____| |____ B
//
// R ноль метка
//************************************************************************//
module ENCODERS(
ENCOD1_A,ENCOD1_B,ENCOD1_R, //
ENCOD2_A,ENCOD2_B,ENCOD2_R, //
ENCOD3_A,ENCOD3_B,ENCOD3_R, //Сигналы от энкодеров
SEL_MOD_E,ADRES_MOD,CLCK, //Сигнал от модуля clck_manage. Сигнал ADRES_MOD выдает адреса всех модулей.
//после трансляции адреса через 5 тактов устанавливается сигнал разрешения SEL_MOD_E
//Если адрес совпадает с адресом этого модуля thisadresmod, то можно записывть данные в
//двух портовую память.
WRITE_EN_MEMORI, //Разрешение записи 1 = запись; 0 = чтение.
RST_MEMORY, //сброс выхода памяти.
DATA_TO_MEMORY, //данные для записи.
DATA_FROM_MEMORY, //данные для чтения.
MEMORY_ADRES //Адрес чтение / записи.

);

input ENCOD1_A,ENCOD1_B,ENCOD1_R,ENCOD2_A,ENCOD2_B,ENCOD2_R,ENCOD3_A,ENCOD3_B,ENCOD3_R
, SEL_MOD_E, CLCK;
input[3:0] ADRES_MOD;
output WRITE_EN_MEMORI, RST_MEMORY;
output[31:0] DATA_TO_MEMORY;
input[31:0] DATA_FROM_MEMORY;
output[9:0] MEMORY_ADRES;
// Адрес этого модуля
parameter [3:0] thisadresmod = 4'h1;

//-----------------------------------------------------------------//
// Выбор модуля. Если модуль выбран можно читать писать в память. >>
reg select_module_ok;
reg wrmem,rstmem;
reg[31:0] dat_to_mem;
reg[9:0] adrmem;

always @( SEL_MOD_E )
begin

if(SEL_MOD_E == 1)
begin
if(ADRES_MOD[3:0] == thisadresmod[3:0] )
begin
select_module_ok <= 1;
end
else begin
select_module_ok <= 0;

end
end
else begin
select_module_ok <= 0;
end
end

assign WRITE_EN_MEMORI = select_module_ok ? wrmem : 1'bZ;
assign RST_MEMORY = select_module_ok ? rstmem : 1'bZ;
assign DATA_TO_MEMORY = select_module_ok ? dat_to_mem : 32'bZ;
assign MEMORY_ADRES = select_module_ok ? adrmem : 10'bZ;
// Выбор модуля. Если модуль выбран можно читать писать в память. <<
//------------------------------------------------------------------//

//------------------------------------------------------------------//
// Главный процесс модуля энкодеров >>
reg[31:0] encode1_value;
reg[31:0] encode2_value;
reg[31:0] encode3_value;
always @(posedge CLCK)
begin

//----------------------------//
if(select_module_ok == 1)
begin

// Здесь моно читать писать в память.
// Сигналы (wrmem, rstmem; dat_to_mem[31:0], DATA_FROM_MEMORY[31:0]; adrmem[9:0]

// мапинг памяти
// энкодер 1 смещение в памяти 0x0
// адрес 0 "множитель" формат флоат 32 бита (для чтения,записывается с компьютера)
// адрес 4 "позиция" формат флоат, получается из encode1_value * "множитель".

// энкодер 2 смещение в памяти 0x30
// адрес 30 "множитель" формат флоат 32 бита (для чтения,записывается с компьютера)
// адрес 34 "позиция" формат флоат, получается из encode2_value * "множитель".

// энкодер 3 смещение в памяти 0x60
// адрес 60 "множитель" формат флоат 32 бита (для чтения,записывается с компьютера)
// адрес 64 "позиция" формат флоат, получается из encode3_value * "множитель".




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


//сигналы от энкодеров
//(ENCOD1_A || ENCOD1_B || ENCOD1_R || ENCOD2_A || ENCOD2_B || ENCOD2_R || ENCOD3_A || ENCOD3_B || ENCOD3_R)

//переменные для результат подсчета
// encode1_value[31:0]; encode2_value[31:0]; encode3_value[31:0];



end

// Главный процесс модуля энкодеров <<
//---------------------------------------------------------------------//




endmodule

[Maverick]

я не вижу саму обработку енкодеров
могу привести описание обработки енкодера, правда на VHDL

CODE

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity QuadratureDecoder is
Port ( QuadA : in STD_LOGIC;
QuadB : in STD_LOGIC;
Clk : in STD_LOGIC;
Position : out STD_LOGIC_VECTOR (7 downto 0));
end QuadratureDecoder;

architecture Behavioral of QuadratureDecoder is

signal QuadA_Delayed: STD_LOGIC_VECTOR (2 downto 0);
signal QuadB_Delayed: STD_LOGIC_VECTOR (2 downto 0);

signal Count_Enable: STD_LOGIC;
signal Count_Direction: STD_LOGIC;

signal Count: STD_LOGIC_VECTOR(7 downto 0);

begin

process (Clk)
begin
if Clk='1' and Clk'event then
QuadA_Delayed <= (QuadA_Delayed(1), QuadA_Delayed(0), QuadA);
QuadB_Delayed <= (QuadB_Delayed(1), QuadB_Delayed(0), QuadB);
if Count_Enable='1' then
if Count_Direction='1' then
Count <= Count + 1;
Position <= Count;
else
Count <= Count - 1;
Position <= Count;
end if;
end if;
end if;
end process;

Count_Enable <= QuadA_Delayed(1) xor QuadA_Delayed(2) xor QuadB_Delayed(1) xor QuadB_Delayed(2);
Count_Direction <= QuadA_Delayed(1) xor QuadB_Delayed(2);

end Behavioral;

PS если потребуется могу дать тестбенч...