Задам вам вопрос о правильности применения констрейнов и их эффекте.

1. Создаю PLL в Vivado. Привык давно, что либо в Quartus особо на них констрейнов писать не надо, само подхватит при спец команде. Так и с Xilinx в Vivado особо не заморачивался, никогда не создавал (вроде само формирует xdc файл по ним, лень смотреть). В Vivado главное смотрю timing report, что все частоты совпадают и на месте

2. Обратил внимание, что один коллега, к этой pll прикрутил `create_clock` на каждый выход этой PLL (CLKOUT0,1,2,3,4)

И хожу я теперь в замешательстве, что с этим делать? на сколько это корректно?

Это еще не все.

Стали анализировать, и вот что вышло:

1. Дизайн с create_clock на выходах pll заметно быстрее собирается и с таймингами нет проблем

2. Дизайн по умолчанию без них собирается прям сложнее, дольше. Иногда надо что нибудь такое придумать, оптимизировать, чтобы тайминги свелись

И вот вроде бы я бы рад оставить констрейны, эффект вау, но как то на подсознании понимаю, что пути клока могут обсчитываться короче и из за этого сводится все без проблем.

Знатоки, рассудите, корректно ли применять дополнительно create_clock к выходам PLL?

ps. Советы типа, проверь периоды в pll и create_clock или номера выходов после синтеза не сработают ) проверил все от и до.

ALTUFM_OSC osc( .oscena(1'b1), .osc(clk));

Отключение:

ALTUFM_OSC osc( .oscena(0'b1), .osc(clk));

Вопросы:

1. До подключения генератор физически работал?

2. При отключении генератор физически перестает генерировать импульсы или только происходит логическое отключение?

Это интересует в связи с использованием ПЛИС для схем, чувствительных к наводкам.

Не могу понять, как в verilog делать округление. Пока что пользуюсь таким костылем:

localparam FREQ_DIV = (2*CLOCK_RATE/BAUD_RATE+1)/2;

Нашел такие варианты округления: через $round() и через приведение типа к int', но ни один из вариантов не работает. Среда Gowin IDE.

Эти варианты не работают:

localparam FREQ_DIV = $round(1.0*CLOCK_RATE/BAUD_RATE);
//ERROR (EX3817) : System function call 'round' is not allowed here("C:\...":22)


localparam FREQ_DIV = int'(1.0*CLOCK_RATE/BAUD_RATE);
// ERROR (EX3863) : Syntax error near '''("C:\...":22)

Как округлять без костылей?

Я правильно понимаю, что в verilog приведение к типу int округляет, а не отбрасывает дробную часть?

inout sda_master;
inout scl_slave;

input [2:0] Pos;

inout sda_slave[0:4];
inout scl_slave[0:4];

Не понимаю, пожалуйста, подскажите как мне на основании значения Pos (которое принимает значения от 0 до 4 включительно) соединять на (систем)верилоге эти мастер-слейв пины? Или это силами плиски невозможно сделать, и надо в ручную писать на FPGA i2c-шный интерфейс?

Спасибо!

ИИВ

Есть проект Vivado. Есть ли способ найти в проекте места, в которых можно задействовать блоки DSP32 c помощью инференса?

Я пробовал такой подход. Назначить на все ячейки проекта

Quote

set_property use_dsp yes [get_cells -hierarchical -filter { IS_PRIMITIVE == "FALSE" }]

А затем вывести список ячеек, на которых инференс произошел. Проблема в том, что некоторые дизайны не проходят синтез с такими настройками - падают с segmantation fault. Есть ли какой-то другой способ?

Сразу выскакивает ошибка при синтезе

Уже крыша едет... В проекте около 40 файлов, куча умножителей и никаких проблем. А с этим файлом замучался.

Коллеги, есть ли какие мысли?

Прошу посмотреть что не так в коде:

reg    [28:0] id;
wire  [7:0] acceptance_code_1;
wire  [7:0] acceptance_code_2;
wire  [7:0] acceptance_code_3;


wire  [7:0] acceptance_mask_1;
wire  [7:0] acceptance_mask_2;
wire  [7:0] acceptance_mask_3;

always @ (posedge clk )//or posedge rst)
begin
  if (rst)
    id <= 29'h0;
  else if (sample_point & (rx_id1 | rx_id2) & (~bit_de_stuff))
    id <= {id[27:0], sampled_bit};
end
wire          match_sf_std;

assign match_sf_std = ( (id[3]  == acceptance_code_0[0] | acceptance_mask_0[0] ) &
                        (id[4]  == acceptance_code_0[1] | acceptance_mask_0[1] ) &
                        (id[5]  == acceptance_code_0[2] | acceptance_mask_0[2] ) &
                        (id[6]  == acceptance_code_0[3] | acceptance_mask_0[3] ) &
                        (id[7]  == acceptance_code_0[4] | acceptance_mask_0[4] ) &
                        (id[8]  == acceptance_code_0[5] | acceptance_mask_0[5] ) &
                        (id[9]  == acceptance_code_0[6] | acceptance_mask_0[6] ) &
                        (id[10] == acceptance_code_0[7] | acceptance_mask_0[7] ) &

                        (rtr1   == acceptance_code_1[4] | acceptance_mask_1[4] ) &
                        (id[0]  == acceptance_code_1[5] | acceptance_mask_1[5] ) &
                        (id[1]  == acceptance_code_1[6] | acceptance_mask_1[6] ) &
                        (id[2]  == acceptance_code_1[7] | acceptance_mask_1[7] ) 
						);

Проблема в том что при несоответствии id и acception_code и acception_mask match_sf_std всегда остается 1

logic [31:0] cnt;

always_ff @(posedge clock_i or negedge arstn_i) begin
    if (!arstn_i) begin 
    	cnt <= '0;
    end
    else begin
    	cnt <= cnt + 1'b1;
    end 
end 

Максимальная частота работы допустим 300МГц.
Есть какие-то методы, чтобы повысить максимальную частоту работы такого счётчика допустим до 350МГц без смены плис?
Благодарю.

code.docx

Hello , In the attached TCL file and PDF file described block diagram in RFSOCK 4x2.

I want to create an IP block in VITIS HLS so I could import it into vivado, which writes samples into DDR so I could see the value of a 1.5GHz tone on the output.

Is there some example codes or guidelines in need to use for this purpose?

Thanks.

design_rf_18_09.pdf

design_rf_18_09_25.tcl

module exp_pipelined(
	input clk,
	input signed [ARG_HIGH+ ARG_LOW-1:0] ix,
	output [RES_HIGH+ RES_LOW-1:0] oexp
	);

parameter ARG_HIGH= 4;
parameter ARG_LOW= 16;
parameter ARG_GUARD= 0;

parameter RES_HIGH= 16;
parameter RES_LOW= 16;
parameter RES_GUARD= 0;

//	Внутренние константы, не переопределять.
parameter A_BITS= ARG_HIGH+ ARG_LOW+ ARG_GUARD;
parameter A_UP= A_BITS-1;

parameter R_BITS= RES_HIGH+ RES_LOW+ RES_GUARD;
parameter STEPS= RES_HIGH+ RES_LOW;
parameter R_UP= R_BITS-1;

bit [A_UP:0] x [STEPS:0];
bit [R_UP:0] bexp [STEPS:0];

assign oexp= bexp[STEPS]>>RES_GUARD;

`define LN2x64 (64'hB17217F7D1CF79AB)
wire signed [63:0] C_LN_10001 [63:0];	//	Ln(1+1/2^x)

always @( posedge clk ) 
begin
	integer ind;

	x[0]<= ix<<<ARG_GUARD;
	bexp[0]<= 64'h1<<(RES_LOW+RES_GUARD);
	for (ind=0; ind<ARG_HIGH; ind++ )
	begin
		if ( x[ind]>(`LN2x64>>( 64-A_BITS+ind )) )
		begin
			x [ind+1]<= x[ind] - (`LN2x64>>( 64-A_BITS+ind ));
			bexp[ind+1]<= bexp[ind]<<(64'h1<<(ARG_HIGH-ind-1));
		end
		else
		begin
			x [ind+1]<= x [ind];
			bexp[ind+1]<= bexp[ind];
		end
	end
	for (ind=ARG_HIGH; ind<STEPS; ind++ )
	begin
		if ( x[ind]>(C_LN_10001[ind-ARG_HIGH]>>( 67-A_BITS )) )
		begin
			x [ind+1]<= x[ind] - (C_LN_10001[ind-ARG_HIGH]>>( 67-A_BITS ));
			bexp[ind+1]<= bexp[ind] + (bexp[ind]>>(ind-ARG_HIGH+1));
		end
		else
		begin
			x [ind+1]<= x [ind];
			bexp[ind+1]<= bexp[ind];
		end
	end
end

//	for ( i=0; i<64; i++){
//		double dval= log(1+1./pow(2.,1+i)) * pow(2.,64.); //((long long)1 << i);
//		unsigned long long val= i>30 ? 1ull<<(63-i) :dval;
//		cout << "assign C_LN_10001[" << dec << i << "]= 64'h" << hex << val << ";" << endl;
//	}

assign C_LN_10001[0]= 64'h67cc8fb2fe613000;//	Точность первых понижена!
assign C_LN_10001[1]= 64'h391fef8f35344400;
assign C_LN_10001[2]= 64'h1e27076e2af2e600;
assign C_LN_10001[3]= 64'hf85186008b15300;
assign C_LN_10001[4]= 64'h7e0a6c39e0cc000;
assign C_LN_10001[5]= 64'h3f815161f807c80;
assign C_LN_10001[6]= 64'h1fe02a6b1067890;
assign C_LN_10001[7]= 64'hff805515885e00;
assign C_LN_10001[8]= 64'h7fe00aa6ac4398;
assign C_LN_10001[9]= 64'h3ff80155156220;
assign C_LN_10001[10]= 64'h1ffe002aa6ab11;
assign C_LN_10001[11]= 64'hfff8005551558;
assign C_LN_10001[12]= 64'h7ffe000aaa6aa;
assign C_LN_10001[13]= 64'h3fff800155515;
assign C_LN_10001[14]= 64'h1fffe0002aaa6;
assign C_LN_10001[15]= 64'hffff80005555;
assign C_LN_10001[16]= 64'h7fffe0000aaa;
assign C_LN_10001[17]= 64'h3ffff8000155;
assign C_LN_10001[18]= 64'h1ffffe00002a;
assign C_LN_10001[19]= 64'hfffff800005;
assign C_LN_10001[20]= 64'h7ffffe00000;
assign C_LN_10001[21]= 64'h3fffff80000;
assign C_LN_10001[22]= 64'h1fffffe0000;
assign C_LN_10001[23]= 64'hffffff8000;
assign C_LN_10001[24]= 64'h7fffffe000;
assign C_LN_10001[25]= 64'h3ffffff800;
assign C_LN_10001[26]= 64'h1ffffffe00;
assign C_LN_10001[27]= 64'hfffffff80;
assign C_LN_10001[28]= 64'h7ffffffe0;
assign C_LN_10001[29]= 64'h3fffffff8;
assign C_LN_10001[30]= 64'h1fffffffe;
assign C_LN_10001[31]= 64'h100000000;
assign C_LN_10001[32]= 64'h80000000;
assign C_LN_10001[33]= 64'h40000000;
assign C_LN_10001[34]= 64'h20000000;
assign C_LN_10001[35]= 64'h10000000;
assign C_LN_10001[36]= 64'h8000000;
assign C_LN_10001[37]= 64'h4000000;
assign C_LN_10001[38]= 64'h2000000;
assign C_LN_10001[39]= 64'h1000000;
assign C_LN_10001[40]= 64'h800000;
assign C_LN_10001[41]= 64'h400000;
assign C_LN_10001[42]= 64'h200000;
assign C_LN_10001[43]= 64'h100000;
assign C_LN_10001[44]= 64'h80000;
assign C_LN_10001[45]= 64'h40000;
assign C_LN_10001[46]= 64'h20000;
assign C_LN_10001[47]= 64'h10000;
assign C_LN_10001[48]= 64'h8000;
assign C_LN_10001[49]= 64'h4000;
assign C_LN_10001[50]= 64'h2000;
assign C_LN_10001[51]= 64'h1000;
assign C_LN_10001[52]= 64'h800;
assign C_LN_10001[53]= 64'h400;
assign C_LN_10001[54]= 64'h200;
assign C_LN_10001[55]= 64'h100;
assign C_LN_10001[56]= 64'h80;
assign C_LN_10001[57]= 64'h40;
assign C_LN_10001[58]= 64'h20;
assign C_LN_10001[59]= 64'h10;
assign C_LN_10001[60]= 64'h8;
assign C_LN_10001[61]= 64'h4;
assign C_LN_10001[62]= 64'h2;
assign C_LN_10001[63]= 64'h1;

endmodule

Вообще не пойму, что за алгоритм такой? На ряд Тейлора  не походит.
Походит что-то на способ вычисления e^a = e^(n*ln2)*e^x,

где a=n*ln2+x, n=int(a/ln2), x = a%ln2

Вот это походит на итеративное деление на ln2:

    for (ind=0; ind<ARG_HIGH; ind++ )
    begin
        if ( x[ind]>(`LN2x64>>( 64-A_BITS+ind )) )
        begin
            x [ind+1]<= x[ind] - (`LN2x64>>( 64-A_BITS+ind ));
            bexp[ind+1]<= bexp[ind]<<(64'h1<<(ARG_HIGH-ind-1));
        end
        else
        begin
            x [ind+1]<= x [ind];
            bexp[ind+1]<= bexp[ind];
        end
    end

А вот что второй цикл делает - вообще непонятно.

Кто в теме, подскажите пожалуйста, как математически вообще этот способ реализован? Общая формула вычисления по этому способу какая?

Не придумал как назвать тему, назвал как назвал. Вопрос (тема нониусных измерений) в следующем.

Пусть, на одном периоде основного клока где-то появляется асинхронный имульс. Вопрос - можно ли как-то средствами плис запустить какой-нибудь периодический сигнал, скажем меандр или строб, СИНХРОННЫЙ с передним(или задним) фронтом этого асинхронного импульса? 

Что-то ничего не придумывается, хотелось бы закрыть этот вопрос для себя, чтобы зря не ломать голову.

Спасибо.

Внимание привлекло правило 4 из пункта 3.2.2.1, а на следующем листе пример Case_nty демонстрирует нарушение правила

(строка "when 1 to Max_g", где Max_g - параметр, задаваемый с помощью generic).При попытке симуляции vhdl-исходника (стандарта VHDL-2008) с аналогичной конструкцией можно увидеть предупреждение типа:

"** Warning: D:/Work/Test_project/hdl/test_reg.vhd(193): (vcom-1937) Choice in ordinary CASE statement alternative must be locally static."

Я обычно игнорировал подобные предупреждения из соображений, что warning - это не ошибка, да и в железе вроде всегда работало)

Теперь вопрос к гуру: а правомерно ли я поступаю? Чревато ли чем-то подобное игнорирование? Возникновением ошибок, еще какими-либо неочевидными пока проблемами и т.п.?

Заранее всем спасибо за любые ответы по теме вопроса!

P.S.: Да, я знаю, что VHDL уже "дедушка", который лучше не использовать) Но заимствование кода и сопровождения существующих проектов еще никто не отменял)

P.P.S.: Бегло пробежался поиском в поисках ответа... Периодически вопрос всплывал, но не в конкретном виде. Если пропустил,  поделитесь ссылкой пожалуйста 

Ben Cohen - VHDL Coding Styles and Methodologies (pages).pdf

Подскажите, пожалуйста, (никогда не пробовал) можно ли сконвертить сырой rbj to jic (чтобы через JTAG залить)?

Заранее спасибо!

`include "bel_core/bel_fft_def.v"

module main_fft_twiddle_roms (clk_i, rst_i, adr_i, rd_i, dat_o, cfg_sel_i);

    parameter word_width = 16;
    parameter config_num = 1;
    parameter max_awidth = 6;

    parameter size = 256;
    parameter awidth = 6;
    parameter file_name = "bel_rom_twiddles.dat";

    parameter size2 = 256;
    parameter awidth2 = 6;
    parameter file_name2 = "bel_rom_twiddles2.dat";

    parameter size3 = 256;
    parameter awidth3 = 6;
    parameter file_name3 = "bel_rom_twiddles3.dat";

    parameter size4 = 256;
    parameter awidth4 = 6;
    parameter file_name4 = "bel_rom_twiddles4.dat";

    input clk_i;
    input rst_i;
    input [max_awidth - 1:0] adr_i;
    input rd_i;
    output [word_width * 2 - 1:0] dat_o;
    input [config_num - 1:0] cfg_sel_i;

    reg [word_width * 2 - 1:0] rom [0:size - 1];
    reg [awidth - 1:0] adr;
    reg [word_width * 2 - 1:0] dat_o;

    initial begin
        $readmemh (file_name, rom);
    end

    always @ (posedge rst_i or posedge clk_i) begin
        if (rst_i) begin
            adr <= 0;
        end else begin
            if (rd_i) begin
                adr <= adr_i;
            end
        end
    end

generate

    if (config_num > 1) begin
    
        reg [word_width * 2 - 1:0] rom2 [0:size2 - 1];

        initial begin
            $readmemh (file_name2, rom2);
        end

        if (config_num > 2) begin

            reg [word_width * 2 - 1:0] rom3 [0:size3 - 1];

            initial begin
                $readmemh (file_name3, rom3);
            end

            if (config_num > 3) begin

                reg [word_width * 2 - 1:0] rom4 [0:size4 - 1];

                initial begin
                    $readmemh (file_name4, rom4);
                end

                always @ (cfg_sel_i or adr) begin
                    case (cfg_sel_i)
                        4'b1000: begin
                            dat_o = rom4[adr[awidth4 - 1: 0]];
                        end
                        4'b0100: begin
                            dat_o = rom3[adr[awidth3 - 1: 0]];
                        end
                        4'b0010: begin
                            dat_o = rom2[adr[awidth2 - 1: 0]];
                        end
                        default: begin
                            dat_o = rom[adr];
                        end
                    endcase
                end

            end else begin

                always @ (cfg_sel_i or adr) begin
                    case (cfg_sel_i)
                        3'b100: begin
                            dat_o = rom3[adr[awidth3 - 1:0]];
                        end
                        3'b010: begin
                            dat_o = rom2[adr[awidth2 - 1:0]];
                        end
                        default: begin
                            dat_o = rom[adr[awidth - 1:0]];
                        end
                    endcase
                end

            end

        end else begin

            always @ (cfg_sel_i or adr) begin
                case (cfg_sel_i)
                    2'b10: begin
                        dat_o = rom2[adr[awidth2 - 1:0]];
                    end
                    default: begin
                        dat_o = rom[adr[awidth - 1:0]];
                    end
                endcase
            end

        end

    end else begin

        always @ (adr)
            dat_o = rom[adr[awidth - 1:0]];

    end

endgenerate

    
endmodule

module counter (
	input LD,
	input [8:0] DI,
	input clk,
	input EN,
	output [8:0] data,
	output CEO);

begin
if(LD) out<=DI
else out=out+1;
end

задача.docx

Успешно записываю и считываю данные из BRAM ПЛИС, но возник вопрос с адресацией.

BRAM настроена на ширину 32 бита.

В процессе преобразования адреса ошибочно оказалось что мой адрес не плюсует 4 байта, то есть я записываю считываю по адресам численно отличающиеся на 1.

В связи с этим вопрос почему при такой байтовой адресации, как я понимаю, я успешно читаю ранее записанные слова(из 4-х байт)?

Посоветуйте - как сделать цепочку из 2х делителей клока 100МГц на 10 и еще раз на 10 на verilog, чтобы Quartus не жаловался на Ripple Clock и счетчики были синхронные

Пытаюсь сделать так - но получаю ошибки тайминга.

reg [2:0] count_reg10M;		// 3 bit = 8   /счет до 4
reg [3:0] count_reg1M;		// 4 bit = 16  /счет до 9

always @(posedge clock_main)
	begin
		if (count_reg10M == 3'd4) // Reset counter after 5 cycles
			begin
				count_reg10M <= 3'b0;
				clock_10MHz <= ~clock_10MHz;
			end
		else
			count_reg10M <= count_reg10M + 1'd1;
	end

	// 1MHz clock 			
always @(posedge clock_main)
	begin
		if( count_reg10M[2] )	// Если счетчик 10MHz достиг 4
			begin
				if( count_reg1M == 4'd9 )		// Деление на 10 - счетчик до 9
					begin
						count_reg1M <= 4'b0;
						clock_1MHz  <= ~clock_1MHz;
					end
				else
					count_reg1M <= count_reg1M + 1'd1;
			end		
	end

1.1.    Мультиплексор имеет входной интерфейс и два выходных интерфейса обмена и обеспечивает приём пакета со входного интерфейса (типа ведомый) и выдачу пакета на один из выходных интерфейсов (типа ведущий) в зависимости от значения 2 байта, если считать с нуля от начала приёма пакета: если 0 – то пакет выдаётся на первый выходной интерфейс, иначе – на второй.

1.2.    Пакетом считаются данные, присутствующие на интерфейсе в момент высокого уровня сигнала CS интерфейса SPI. Сигнал CS должен быть заложен на всех интерфейсах модуля. Пакет не может превышать 10 байт данных.

1.3.    Модуль имеет вход сброса и вход тактовой частоты, являющейся синхронизирующим сигналом для выходных интерфейсов. Входные данные синхронны сигналу SCLK входного интерфейса SPI.
 

код.docx тест бенч.docx

Подскажите пожалуйста, как на комбинаторике на верилоге преобразовать байт little ebdian в big endian

Спасибо!

Мне нужно под Virtex6 и 7.

Алексей.