-- Module Name: my_fifo - Behavioral
-- Description: A 32 x 9 FIFO using inferred storage

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity my_fifo is
Port ( clk : in STD_LOGIC;
wr : in STD_LOGIC;
din : in STD_LOGIC_VECTOR(8 downto 0);
empty : out STD_LOGIC;
full : out STD_LOGIC;
rd : in STD_LOGIC;
dout : out STD_LOGIC_VECTOR(8 downto 0));
end my_fifo;

architecture Behavioral of my_fifo is
signal i_full : std_logic;
signal i_empty : std_logic;

type mem_array is array(31 downto 0) of std_logic_vector(8 downto 0);
signal memory : mem_array;
signal wr_ptr : unsigned(4 downto 0) := (others => '0');
signal rd_ptr : unsigned(4 downto 0) := (others => '0');

begin
full <= i_full;
empty <= i_empty;

flag_proc: process(wr_ptr, rd_ptr)
begin
if wr_ptr = rd_ptr then
i_empty <= '1';
else
i_empty <= '0';
end if;

if wr_ptr+1 = rd_ptr then
i_full <= '1';
else
i_full <= '0';
end if;
end process;

clk_proc: process(clk)
begin
if rising_edge(clk) then
if rd = '1' then
if wr = '1' then
if i_empty = '0' then
dout <= memory(to_integer(rd_ptr));
rd_ptr <= rd_ptr + 1;
end if;

memory(to_integer(wr_ptr)) <= din;
wr_ptr <= wr_ptr + 1;

elsif i_empty = '0' then
dout <= memory(to_integer(rd_ptr));
rd_ptr <= rd_ptr + 1;
end if;
elsif wr = '1' then
if i_full = '0' then
memory(to_integer(wr_ptr)) <= din;
wr_ptr <= wr_ptr + 1;
end if;
end if;
end if;
end process;
end Behavioral;

module sram_control(
input clk_pld, //основной такт плис
input wd, //запись в sram, (высокий приоритет)
input request, //запрос данных
output reg ack, //подтверждение готовности данных
output empty, //sram пустая (читать нельзя)
output full, //sram полная (писать нельзя)
output [17:0] addr, //адрес sram
input [15:0] din, //вход данных для записи во внешнюю sram
output reg [15:0] dout, //выход данных для чтения из sram
inout [15:0] dinout //двунаправленный порт данных для подключения непосредственно к sram
);

reg rdy = 0;
reg [15:0] buff = 0; //буфер 3х состояний
reg [18:0] count_w = 0; //регистр счётчика записи
reg [18:0] count_r = 0; //регистр счётчика чтения

//счётчик адреса записи
always @(posedge clk)
begin
if(wd) count_w = count_w + 1;
end

//счётчик адреса чтения
always @(posedge clk)
begin
if(rdу) count_r = count_r + 1;
end

//процес управляющий логикой чтения данных
always @(posedge clk)
begin
if(request)
begin

//??????????????????????????????????
end
end


always @(posedge clk)
begin
if(wd) buff = din;
else
begin
buff = 16'bz;
if(rdу)
dout = dinout;
end
end

assign dinout = buff;
assign addr = (!wd && rdу)? count_r : count_w;

assign full = ((count_w[17:0] == count_r[17:0]) && (count_w[18] ^^ count_r[18]))? 1'b1 : 1'b0;
assign empty = ((count_w[17:0] == count_r[17:0]) && (!(count_w[18] ^^ count_r[18])))? 1'b1 : 1'b0;
endmodule

module translator(
input wire clk, //клок
input wire [7:0]sbyte, //вход 1байт
input wire rdy, //загрузка байта
output reg [15:0]word, //выход 2байта
output reg wr //данные готовы
);

reg cnt = 0;
reg [15:0]buff0 = 0;

always @(posedge rdy)
begin
if(!cnt)
begin
buff0[15:8] = sbyte[7:0];
end
else
begin
buff0[7:0] = sbyte[7:0];
word = buff0;
end
cnt = cnt + 1'b1;
end

always @(posedge clk)
begin
wr = ~cnt && rdy;
end

endmodule

module FIFO_SRAM(
input Reset,
input Wclk,
input Rclk,
input Rd,
input Wd,
output full,
output empty,
input [DATA-1:0] Din,
output reg [DATA-1:0] Dout,
output [ADDR-1:0] Addr_Sram,
inout [DATA-1:0] Data_Sram,
output nCS,
output nOE,
output nWE
);

parameter ADDR = 4; // Параметр разрядности Адреса SRAM
parameter DATA = 4; // Параметр разрядности Данных SRAM

//--- Счётчики адресов чтения и записи ------------------------------
assign Addr_Sram = (Wd) ? write_addr[ADDR-1 : 0] : read_addr[ADDR-1 : 0];
reg [ADDR:0] read_addr=0;
always @(posedge Rclk) //По такту чтения
begin
if(Reset)
begin
read_addr <= 0;
end
else
begin
if (Rd) read_addr <= read_addr + 1'b1;
else read_addr <= read_addr;
end
end
//---
reg [ADDR:0] write_addr=0;
always @(posedge Wclk) //По такту записи
begin
if(Reset)
begin
write_addr <= 0;
end
else
begin
if (Wd) write_addr <= write_addr + 1'b1;
else write_addr <= write_addr;
end
end
//--- Абработка флагов заполненности ФИФО ------------------------------
assign full = ((write_addr[ADDR-1:0] == read_addr[ADDR-1:0]) && (write_addr[ADDR] ^ read_addr[ADDR]))? 1'b1 : 1'b0; //Фифо полное
assign empty = ((write_addr[ADDR-1:0] == read_addr[ADDR-1:0]) && (!(write_addr[ADDR] ^ read_addr[ADDR])))? 1'b1 : 1'b0; //Фифо пустое

//--- Логика комутации данных ------------------------------
wire [DATA-1 : 0] bus_data_out;
always@(posedge Wd or posedge Rd)
begin
Dout <= bus_data_out; //При любом запросе пишим на выход
end

assign bus_data_out = (Wd & empty)? Din : 'bz ; //Если запись и фифо пустое то со входа пишем на прямую в выходной регистр
assign Data_Sram = (Wd & ~empty)? Din : 'bz ; //Если запись и в выходном регистре не пусто то заполняем SRAM
assign bus_data_out = (~Wd & Rd)? Data_Sram : 'bz ; //Если нет записи, но есть чтение то из SRAM в выходной регистр

assign nCS = ~(Wd | Rd); //Разрешение чипа SRAM
assign nOE = ~(Rd); //Чтение чипа SRAM
assign nWE = ~(Wd); //Запись чипа SRAM

endmodule

input addr1;
input addr2;
input we;
input data_in;
output data_out;
reg PortSel; //регистр для выбора порта
reg mem_data_in; //регистр для сохранения

always @(posedge clk)
begin
   if(PortSel == 0)
      begin
        mem_addr <= addr2; //готовимся читать со 2 адреса
        mem_we <= 1'b0; //снимаем сигнал записи, 2 адрес чтение
        data_out <= mem_data_out; //защелкиваем данные с памяти (с прошлого задания адреса)
        PortSel <= 1'b1;
      end
   else
      begin
        mem_addr <= addr1; //готовимся писать в 1 адрес если надо
        mem_we <= we; //ставим we если надо
        mem_data_in <= data_in; //защелкиваем данные для записи
        PortSel <= 1'b0;
      end
end

module ADDR_counter(
input res,
input clk,
input wr,
input rd,
output full,
output empty,
output [ADDR-1:0] Addr_Sram
);

parameter ADDR = 5; // Параметр разрядности Адреса SRAM

//--- Счётчики адресов чтения и записи ------------------------------
assign Addr_Sram = (wr) ? write_addr[ADDR-1 : 0] : read_addr[ADDR-1 : 0];
reg [ADDR:0] read_addr=0;
always @(posedge clk or posedge res) //По такту чтения
begin
if(res)
begin
read_addr <= 0;
end
else
begin
if (rd) read_addr <= read_addr + 1'b1;
else read_addr <= read_addr;
end
end
//---
reg [ADDR:0] write_addr=0;
always @(posedge clk or posedge res) //По такту записи
begin
if(res)
begin
write_addr <= 0;
end
else
begin
if (wr) write_addr <= write_addr + 1'b1;
else write_addr <= write_addr;
end
end
//--- Абработка флагов заполненности ФИФО ------------------------------
assign full = ((write_addr[ADDR-1:0] == read_addr[ADDR-1:0]) && (write_addr[ADDR] ^ read_addr[ADDR]))? 1'b1 : 1'b0; //Фифо полное
assign empty = ((write_addr[ADDR-1:0] == read_addr[ADDR-1:0]) && (!(write_addr[ADDR] ^ read_addr[ADDR])))? 1'b1 : 1'b0; //Фифо пустое

endmodule