//-----------------------------------------------------
// Имя модуля : uart
// Имя файла : uart.v
// Функц. назначение : Простой UART
// Программист : portal-ed.ru/
//-----------------------------------------------------
module uart (
reset ,
txclk ,
ld_tx_data ,
tx_data ,
tx_enable ,
tx_out ,
tx_empty ,
rxclk ,
uld_rx_data ,
rx_data ,
rx_enable ,
rx_in ,
rx_empty
);
// Объявление портов
input reset ;
input txclk ;
input ld_tx_data ;
input [7:0] tx_data ;
input tx_enable ;
output tx_out ;
output tx_empty ;
input rxclk ;
input uld_rx_data ;
output [7:0] rx_data ;
input rx_enable ;
input rx_in ;
output rx_empty ;
// Внутренние переменные
reg [7:0] tx_reg ;
reg tx_empty ;
reg tx_over_run ;
reg [3:0] tx_cnt ;
reg tx_out ;
reg [7:0] rx_reg ;
reg [7:0] rx_data ;
reg [3:0] rx_sample_cnt ;
reg [3:0] rx_cnt ;
reg rx_frame_err ;
reg rx_over_run ;
reg rx_empty ;
reg rx_d1 ;
reg rx_d2 ;
reg rx_busy ;
// Логика UART приема
always @ (posedge rxclk or posedge reset)
if (reset) begin
rx_reg <= 0;
rx_data <= 0;
rx_sample_cnt <= 0;
rx_cnt <= 0;
rx_frame_err <= 0;
rx_over_run <= 0;
rx_empty <= 1;
rx_d1 <= 1;
rx_d2 <= 1;
rx_busy <= 0;
end else begin
// Синхронный и асинхронный сигнал
rx_d1 <= rx_in;
rx_d2 <= rx_d1;
// Загрузка принятых данных
if (uld_rx_data) begin
rx_data <= rx_reg;
rx_empty <= 1;
end
// Приём данных только тогда, когда разрешен приём
if (rx_enable) begin
// Проверка того, что получено начало кадра
if (!rx_busy && !rx_d2) begin
                                 rx_busy <= 1;
                                 rx_sample_cnt <= 1;
                                 rx_cnt <= 0;
                                 end
// Начало кадра обнаружено, переходим к остальным данным
if (rx_busy) begin
                rx_sample_cnt <= rx_sample_cnt + 1;
                if (rx_sample_cnt == 7) begin
                                                   if ((rx_d2 == 1) && (rx_cnt == 0)) begin
                                                                                                      rx_busy <= 0;
                                                                                                      end else begin
                                                                                                                     rx_cnt <= rx_cnt + 1;
// Начало сохранения данных приёма
if (rx_cnt > 0 && rx_cnt < 9) begin
                                          rx_reg[rx_cnt - 1] <= rx_d2;
                                          end
if (rx_cnt == 9) begin
                       rx_busy <= 0;
// Проверка конца кадра, т.е. кадр принят корректно
if (rx_d2 == 0) begin
                       rx_frame_err <= 1;
                      end else begin
                                    rx_empty <= 0;
                                    rx_frame_err <= 0;
                                    rx_over_run <= (rx_empty) ? 0 : 1;
                                    end
end
end
end
end
end
if (!rx_enable) begin
                     rx_busy <= 0;
                     end
end
// UART передатчик
always @ (posedge txclk or posedge reset)
if (reset) begin
              tx_reg <= 0;
             tx_empty <= 1;
             tx_over_run <= 0;
             tx_out <= 1;
             tx_cnt <= 0;
             end else begin
                           if (ld_tx_data) begin
                                                if (!tx_empty) begin
                                                                     tx_over_run <= 0;
                                                                     end else begin
                                                                                   tx_reg <= tx_data;
                                                                                   tx_empty <= 0;
                                                                                   end
end
if (tx_enable && !tx_empty) begin
                                        tx_cnt <= tx_cnt + 1;
                                        if (tx_cnt == 0) begin
                                                                tx_out <= 0;
end
if (tx_cnt > 0 && tx_cnt < 9) begin
                                           tx_out <= tx_reg[tx_cnt -1];
                                           end
if (tx_cnt == 9) begin
                        tx_out <= 1;
                        tx_cnt <= 0;
                        tx_empty <= 1;
                        end
end
if (!tx_enable) begin
                     tx_cnt <= 0;
                     end
end
endmodule

{phocadownload view=file|id=5|text=СКАЧАТЬ ПРИМЕР|target=s}

//-----------------------------------------------------
// Имя модуля : full_adder_gates
// Имя файла : full_adder_gates.v
// Функц. назначение : Полный сумматор, используя приметивы
// Программист : portal-ed.ru/
//-----------------------------------------------------
module full_adder_gates(x,y,z,sum,carry);
input x,y,z;
output sum,carry;
wire and1,and2,and3,sum1;
and U_and1 (and1,x,y),
U_and2 (and2,x,z),
U_and3 (and3,y,z);
or U_or (carry,and1,and2,and3);
xor U_sum (sum,x,y,z);
endmodule

 {phocadownload view=file|id=19|text=СКАЧАТЬ ПРИМЕР|target=s}

//-----------------------------------------------------
// Имя модуля : half_adder_gates
// Имя файла : half_adder_gates.v
// Функц. назначение : Последовательное CRC CCITT
// Программист : portal-ed.ru/
//-----------------------------------------------------
module half_adder_gates(x,y,sum,carry);
input x,y;
output sum,carry;
and U_carry (carry,x,y);
xor U_sum (sum,x,y);
endmodule

{phocadownload view=file|id=21|text=СКАЧАТЬ ПРИМЕР|target=s}

//-----------------------------------------------------
// Имя модуля : aFifo
// Имя файла : aFifo.v
// Функц. назначение : Асинхронный (однотактовый) FIFO
// Программист : portal-ed.ru/
//-----------------------------------------------------
module aFifo
#(parameter DATA_WIDTH = 8,
ADDRESS_WIDTH = 4,
FIFO_DEPTH = (1 << ADDRESS_WIDTH))
//Чтение порта
(output reg [DATA_WIDTH-1:0] Data_out,
output reg Empty_out,
input wire ReadEn_in,
input wire RClk,
//Запись в порт
input wire [DATA_WIDTH-1:0] Data_in,
output reg Full_out,
input wire WriteEn_in,
input wire WClk,
input wire Clear_in);
/////Внутренние связи и переменные//////
reg [DATA_WIDTH-1:0] Mem [FIFO_DEPTH-1:0];
wire [ADDRESS_WIDTH-1:0] pNextWordToWrite, pNextWordToRead;
wire EqualAddresses;
wire NextWriteAddressEn, NextReadAddressEn;
wire Set_Status, Rst_Status;
reg Status;
wire PresetFull, PresetEmpty;
//////////////Начало кода///////////////
//Логические порты данных:
//(Использование двойной RAM).
//'Data_out:
always @ (posedge RClk)
   if (ReadEn_in & !Empty_out)
   Data_out <= Mem[pNextWordToRead];
//'Data_in’:
always @ (posedge WClk)
   if (WriteEn_in & !Full_out)
      Mem[pNextWordToWrite] <= Data_in;
//Логическая поддержка Fifo:
//'Next Addresses' логическое разрешение:
assign NextWriteAddressEn = WriteEn_in & ~Full_out;
assign NextReadAddressEn = ReadEn_in & ~Empty_out;
//Addreses (Счетчик Грэя):
GrayCounter GrayCounter_pWr
(.GrayCount_out(pNextWordToWrite),
.Enable_in(NextWriteAddressEn),
.Clear_in(Clear_in),
.Clk(WClk)
);
GrayCounter GrayCounter_pRd
(.GrayCount_out(pNextWordToRead),
.Enable_in(NextReadAddressEn),
.Clear_in(Clear_in),
.Clk(RClk)
);
//'EqualAddresses':
assign EqualAddresses = (pNextWordToWrite == pNextWordToRead);
//'Quadrant selectors’:
assign Set_Status = (pNextWordToWrite[ADDRESS_WIDTH-2] ~^ pNextWordToRead[ADDRESS_WIDTH-1]) &
(pNextWordToWrite[ADDRESS_WIDTH-1] ^ pNextWordToRead[ADDRESS_WIDTH-2]);
assign Rst_Status = (pNextWordToWrite[ADDRESS_WIDTH-2] ^ pNextWordToRead[ADDRESS_WIDTH-1]) &
(pNextWordToWrite[ADDRESS_WIDTH-1] ~^ pNextWordToRead[ADDRESS_WIDTH-2]);
//'Status' защелка:
always @ (Set_Status, Rst_Status, Clear_in) //D Latch w/ Asynchronous Clear & Preset.
   if (Rst_Status | Clear_in)
      Status = 0; //Going 'Empty'.
      else if (Set_Status)
      Status = 1; //Going 'Full'.
//'Full_out' запись в порт:
assign PresetFull = Status & EqualAddresses; //'Полный' Fifo.
always @ (posedge WClk, posedge PresetFull) //D-триггер с
// асинхронной предустановкой
if (PresetFull)
    Full_out <= 1;
    else
    Full_out <= 0;
//'Empty_out' чтение из порта:
assign PresetEmpty = ~Status & EqualAddresses; //'Пустой' Fifo.
always @ (posedge RClk, posedge PresetEmpty) // D-триггер с
// асинхронной предустановкой
if (PresetEmpty)
    Empty_out <= 1;
    else
         Empty_out <= 0;
endmodule

{phocadownload view=file|id=6|text=СКАЧАТЬ ПРИМЕР|target=s}

//-----------------------------------------------------
// Имя модуля : syn_fifo
// Имя файла : syn_fifo.v
// Функц. назначение : Синхронный (однотактовый) FIFO
// Программист : portal-ed.ru/
//-----------------------------------------------------
module syn_fifo (
clk , // Тактовый вход
rst , // Высокий уровень - сброс
wr_cs , // Запись, выбор блока
rd_cs , // Чтение, выбор блока
data_in , // Входные данные
rd_en , // Разрешение чтения
wr_en , // Разрешение записи
data_out , // Выходные данные
empty , // FIFO пустой
full // FIFO полный
);
// Константы FIFO
parameter DATA_WIDTH = 8;
parameter ADDR_WIDTH = 8;
parameter RAM_DEPTH = (1 << ADDR_WIDTH);
// Объявление портов
input clk ;
input rst ;
input wr_cs ;
input rd_cs ;
input rd_en ;
input wr_en ;
input [DATA_WIDTH-1:0] data_in ;
output full ;
output empty ;
output[DATA_WIDTH-1:0] data_out ;
//-----------Внутренние переменные-------------------
reg [ADDR_WIDTH-1:0] wr_pointer;
reg [ADDR_WIDTH-1:0] rd_pointer;
reg [ADDR_WIDTH :0] status_cnt;
reg [DATA_WIDTH-1:0] data_out ;
wire [DATA_WIDTH-1:0] data_ram ;
//-----------Заданные переменные---------------
assign full = (status_cnt == (RAM_DEPTH-1));
assign empty = (status_cnt == 0);
//-----------Начало кода---------------------------
always @ (posedge clk or posedge rst)
begin : WRITE_POINTER
          if (rst) begin
                    wr_pointer <= 0;
                    end else if (wr_cs && wr_en ) begin
                                                                wr_pointer <= wr_pointer + 1;
                                                                end
end
always @ (posedge clk or posedge rst)
begin : READ_POINTER
          if (rst) begin
                    rd_pointer <= 0;
                    end else if (rd_cs && rd_en ) begin
                                                              rd_pointer <= rd_pointer + 1;
                                                              end
end
always @ (posedge clk or posedge rst)
begin : READ_DATA
          if (rst) begin
                    data_out <= 0;
                    end else if (rd_cs && rd_en ) begin
                                                              data_out <= data_ram;
                                                               end
end
always @ (posedge clk or posedge rst)
begin : STATUS_COUNTER
          if (rst) begin
                    status_cnt <= 0;
                    // Чтение, но не запись
                    end else if ((rd_cs && rd_en) && !(wr_cs && wr_en)
                                     && (status_cnt != 0)) begin
                                                                    status_cnt <= status_cnt - 1;
                                                                     // Запись, но не чтение
                                                                     end else if ((wr_cs && wr_en) && !(rd_cs && rd_en)
                                                                                      && (status_cnt != RAM_DEPTH)) begin
                                                                                                                                     status_cnt <= status_cnt + 1;
                                                                                                                                     end
end
ram_dp_ar_aw #(DATA_WIDTH,ADDR_WIDTH)DP_RAM (
.address_0 (wr_pointer) , // Вход address_0
.data_0 (data_in) , // Двунаправленный порт data_0
.cs_0 (wr_cs) , // Выбор блока
.we_0 (wr_en) , // Разрешение записи
.oe_0 (1'b0) , // Разрешение выхода
.address_1 (rd_pointer) , // Вход address_q
.data_1 (data_ram) , // Двунаправленный порт data_1
.cs_1 (rd_cs) , // Выбор блока
.we_1 (1'b0) , // Разрешение чтения
.oe_1 (rd_en) // Разрешение выхода
);
endmodule

{phocadownload view=file|id=37|text=СКАЧАТЬ ПРИМЕР|target=s}

//-----------------------------------------------------
// Имя модуля : rom_using_case
// Имя файла : rom_using_case.v
// Функц. назначение : Инициализация ROM используя case
// Программист : portal-ed.ru/
//-----------------------------------------------------
module rom_using_case (
address , // Вход адреса
data , // Выход данных
read_en , // Разрешение чтения
ce // Выбор блока
);
input [3:0] address;
output [7:0] data;
input read_en;
input ce;
reg [7:0] data ;
always @ (ce or read_en or address)
begin
case (address)
0 : data = 10;
1 : data = 55;
2 : data = 244;
3 : data = 0;
4 : data = 1;
5 : data = 8'hff;
6 : data = 8'h11;
7 : data = 8'h1;
8 : data = 8'h10;
9 : data = 8'h0;
10 : data = 8'h10;
11 : data = 8'h15;
12 : data = 8'h60;
13 : data = 8'h90;
14 : data = 8'h70;
15 : data = 8'h90;
endcase
end
endmodule

{phocadownload view=file|id=35|text=СКАЧАТЬ ПРИМЕР|target=s}

ВСПОМНИТЬ КАК РАБОТАЕТ>>>

//-----------------------------------------------------
// Имя модуля : rom_using_case
// Имя файла : rom_using_case.v
// Функц. назначение : Инициализация ROM из файла "memory.list"
// Программист : portal-ed.ru/
//-----------------------------------------------------
module rom_using_file (
address , // Адресный вход
data , // Выход данных
read_en , // Разрешение чтения
ce // Выбор блока
);
input [7:0] address;
output [7:0] data;
input read_en;
input ce;
reg [7:0] mem [0:255] ;
assign data = (ce && read_en) ? mem[address] : 8'b0;
initial begin
$readmemb("memory.list", mem); // memory_list – это файл с содержимым // ROM
end
endmodule

{phocadownload view=file|id=36|text=СКАЧАТЬ ПРИМЕР|target=s}

ВСПОМНИТЬ КАК РАБОТАЕТ>>>

//-----------------------------------------------------
// Имя модуля : ram_dp_ar_aw
// Имя файла : ram_dp_ar_aw.v
// Функц. назначение : Асинхронный блок для записи/чтения RAM
// Программист : portal-ed.ru/
//-----------------------------------------------------
module ram_dp_ar_aw (
address_0 , // Вход address_0
data_0 , // Двунаправленный порт data_0
cs_0 , // Выбор блока
we_0 , // Разрешение записи/Разрешение чтения
oe_0 , // Разрешение выхода
address_1 , // Вход address_1
data_1 , // Двунаправленный порт data_1
cs_1 , // Выбор блока
we_1 , // Разрешение записи/Разрешение чтения
oe_1 // Разрешение выхода
);
parameter DATA_WIDTH = 8 ;
parameter ADDR_WIDTH = 8 ;
parameter RAM_DEPTH = 1 << ADDR_WIDTH;
//--------------Входные порты-----------------------
input [ADDR_WIDTH-1:0] address_0 ;
input cs_0 ;
input we_0 ;
input oe_0 ;
input [ADDR_WIDTH-1:0] address_1 ;
input cs_1 ;
input we_1 ;
input oe_1 ;
//--------------Двунаправленные порты-----------------------
inout [DATA_WIDTH-1:0] data_0 ;
inout [DATA_WIDTH-1:0] data_1 ;
//--------------Внутренние переменные----------------
reg [DATA_WIDTH-1:0] data_0_out ;
reg [DATA_WIDTH-1:0] data_1_out ;
reg [DATA_WIDTH-1:0] mem [0:RAM_DEPTH-1];
//--------------Начало кода------------------
// Блок записи памяти
// Write Operation : When we_0 = 1, cs_0 = 1
always @ (address_0 or cs_0 or we_0 or data_0
or address_1 or cs_1 or we_1 or data_1)
   begin : MEM_WRITE
           if ( cs_0 && we_0 ) begin
                                        mem[address_0] <= data_0;
                                        end else if (cs_1 && we_1) begin
                                                                                mem[address_1] <= data_1;
                                                                                end
   end
// Управление тристабильным буфером
// output : When we_0 = 0, oe_0 = 1, cs_0 = 1
assign data_0 = (cs_0 && oe_0 && !we_0) ? data_0_out : 8'bz;
// Блок чтения памяти
// Read Operation : When we_0 = 0, oe_0 = 1, cs_0 = 1
always @ (address_0 or cs_0 or we_1 or oe_0)
   begin : MEM_READ_0
             if (cs_0 && !we_0 && oe_0) begin
                                                     data_0_out <= mem[address_0];
                                                     end else begin
                                                                   data_0_out <= 0;
                                                                   end
   end
//Второй блок RAM
// Управление тристабильным буфером
// output : When we_0 = 0, oe_0 = 1, cs_0 = 1
assign data_1 = (cs_1 && oe_1 && !we_1) ? data_1_out : 8'bz;
// Memory Read Block 1
// Read Operation : When we_1 = 0, oe_1 = 1, cs_1 = 1
always @ (address_1 or cs_1 or we_1 or oe_1)
   begin : MEM_READ_1
             if (cs_1 && !we_1 && oe_1) begin
                                                      data_1_out <= mem[address_1];
                                                      end else begin
                                                                   data_1_out <= 0;
                                                                    end
   end
endmodule // Конец модуля ram_dp_ar_aw

{phocadownload view=file|id=30|text=СКАЧАТЬ ПРИМЕР|target=s}

ВСПОМНИТЬ КАК РАБОТАЕТ>>>

//-----------------------------------------------------
// Имя модуля : ram_dp_sr_sw
// Имя файла : ram_dp_sr_sw.v
// Функц. назначение : Синхронный блок для записи/чтения RAM
// Программист : portal-ed.ru/
//-----------------------------------------------------
module ram_dp_sr_sw (
clk , // Тактовый вход
address_0 , // Вход address_0
data_0 , // Двунаправленный порт data_0
cs_0 , // Выбор блока
we_0 , // Разрешение записи/Разрешение чтения
oe_0 , // Разрешение выхода
address_1 , // Вход address_1
data_1 , // Двунаправленный порт data_1
cs_1 , // Выбор блока
we_1 , // Разрешение записи/Разрешение чтения
oe_1 // Разрешение выхода
);
parameter data_0_WIDTH = 8 ;
parameter ADDR_WIDTH = 8 ;
parameter RAM_DEPTH = 1 << ADDR_WIDTH;
//--------------Входные порты-----------------------
input [ADDR_WIDTH-1:0] address_0 ;
input cs_0 ;
input we_0 ;
input oe_0 ;
input [ADDR_WIDTH-1:0] address_1 ;
input cs_1 ;
input we_1 ;
input oe_1 ;
//--------------Двунаправленные порты-------------------
inout [data_0_WIDTH-1:0] data_0 ;
inout [data_0_WIDTH-1:0] data_1 ;
//--------------Внутренние переменные----------------
reg [data_0_WIDTH-1:0] data_0_out ;
reg [data_0_WIDTH-1:0] data_1_out ;
reg [data_0_WIDTH-1:0] mem [0:RAM_DEPTH-1];
//--------------Начало кода------------------
// Запись блока памяти
// Write Operation : When we_0 = 1, cs_0 = 1
always @ (posedge clk)
begin : MEM_WRITE
          if ( cs_0 && we_0 ) begin
                                      mem[address_0] <= data_0;
                                      end else if (cs_1 && we_1) begin
                                                                              mem[address_1] <= data_1;
                                                                              end
end
// Управление тристабильным буфером
// output : When we_0 = 0, oe_0 = 1, cs_0 = 1
assign data_0 = (cs_0 && oe_0 && !we_0) ? data_0_out : 8'bz;
// Чтение блока памяти
// Read Operation : When we_0 = 0, oe_0 = 1, cs_0 = 1
always @ (posedge clk)
begin : MEM_READ_0
          if (cs_0 && !we_0 && oe_0) begin
                                                  data_0_out <= mem[address_0];
                                                  end else begin
                                                                data_0_out <= 0;
                                                                end
end
//Второй блок RAM
// Управление тристабильным буфером
// output : When we_0 = 0, oe_0 = 1, cs_0 = 1
assign data_1 = (cs_1 && oe_1 && !we_1) ? data_1_out : 8'bz;
// Чтение блока памяти 1
// Read Operation : When we_1 = 0, oe_1 = 1, cs_1 = 1
always @ (posedge clk)
begin : MEM_READ_1
          if (cs_1 && !we_1 && oe_1) begin
                                                  data_1_out <= mem[address_1];
                                                  end else begin
                                                                data_1_out <= 0;
                                                               end
end
endmodule // Конец блока ram_dp_sr_sw

{phocadownload view=file|id=31|text=СКАЧАТЬ ПРИМЕР|target=s}

ВСПОМНИТЬ КАК РАБОТАЕТ>>>

//-----------------------------------------------------
// Имя модуля : ram_sp_ar_aw
// Имя файла : ram_sp_ar_aw.v
// Функц. назначение : Аинхронная запись/чтение RAM
// Программист : portal-ed.ru/
//-----------------------------------------------------
module ram_sp_ar_aw (
address , // Адресный вход
data , // Двунаправленный порт данных
cs , // Выбор блока
we , // Разрешение записи/Разрешение чтения
oe // Разрешение выхода
);
parameter DATA_WIDTH = 8 ;
parameter ADDR_WIDTH = 8 ;
parameter RAM_DEPTH = 1 << ADDR_WIDTH;
//--------------Входные порты-----------------------
input [ADDR_WIDTH-1:0] address ;
input cs ;
input we ;
input oe ;
//--------------Двунаправленные порты------------------
inout [DATA_WIDTH-1:0] data ;
//--------------Внутренние переменные----------------
reg [DATA_WIDTH-1:0] data_out ;
reg [DATA_WIDTH-1:0] mem [0:RAM_DEPTH-1];
//--------------Начало кода------------------
// Управление тристабильным буфером
// output : When we = 0, oe = 1, cs = 1
assign data = (cs && oe && !we) ? data_out : 8'bz;
// Запись блока памяти
// Write Operation : When we = 1, cs = 1
always @ (address or data or cs or we)
begin : MEM_WRITE
           if ( cs && we ) begin
                                 mem[address] = data;
                                 end
end
// Чтение блока памяти
// Read Operation : When we = 0, oe = 1, cs = 1
always @ (address or cs or we or oe)
begin : MEM_READ
            if (cs && !we && oe) begin
                                          data_out = mem[address];
                                          end
end
endmodule // Конец модуля ram_sp_ar_aw

{phocadownload view=file|id=32|text=СКАЧАТЬ ПРИМЕР|target=s}

ВСПОМНИТЬ КАК РАБОТАЕТ>>>