33 мегапикселя на ладони

[andreichk]

тут импульсы вертикального переноса

[Дмитрий Бучинский]

Уже лучше, но из фаз хотелось бы видеть только A1T-A4T, С1Х-С3Х. Остальные сигналы лучше оставить.

[andreichk]

По 1й картинке - понятно что там куча фаз на каждую секцию ПЗС, но поскольку они запаралелены - их можно скрыть, чтобы не загромождали график, оставив только 4 значащих сигнала вертикальных и три горизонтальных фаз.
Также картинку лучше растянуть в районе паузы на 600й мкс, так чтобы в "кадр попал" интервал с 500ю по 700ю микросекунду.

растянул.

[andreichk]

Уже лучше, но из фаз хотелось бы видеть только A1T-A4T, С1Х-С3Х. Остальные сигналы лучше оставить.

но поскольку они запаралелены - их можно скрыть, чтобы не загромождали график, оставив только 4 значащих сигнала вертикальных и три горизонтальных фаз.

не знаю как убрать , сорри 

[andreichk]

Если нет явно назначенных стробов - выведите в график содержимое регистров, куда защелкиваются ADCH/L.

боюсь, что я не знаю, как это сделать в ИЗЕ.

[andreichk]

для понимания процесса, данные с ацп заводятся в спец. модуль, который посредством организации что то типа ФИФО внутри себя заносит данные в микруху УСБ Кипресс и далее в хост. как там всё происходит в этом модуле я к сож. не могу рассказать. могу только код выложить. Но этот код точно рабочий, его разработал некий Chris McClelland специально для связки фпга и кипреса . щас закину все даташиты на диск и скину ссылку
https://drive.google.com/open?id=0B-uW0Otv8WkQbWNiOU02S3NIX1E  lab8_usb_fpgalink.pdf

Код: [Выделить]

//
// Copyright (C) 2009-2012 Chris McClelland
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
module
comm_fpga_fx2(
// FX2 interface -----------------------------------------------------------------------------
input  wire      fx2Clk_in,       // 48MHz clock from FX2
output reg       fx2FifoSel_out,  // select FIFO: '0' for EP6OUT, '1' for EP8IN
inout  wire[7:0] fx2Data_io,      // 8-bit data to/from FX2

// When EP6OUT selected:
output wire      fx2Read_out,     // asserted (active-low) when reading from FX2
input  wire      fx2GotData_in,   // asserted (active-high) when FX2 has data for us

// When EP8IN selected:
output wire      fx2Write_out,    // asserted (active-low) when writing to FX2
input  wire      fx2GotRoom_in,   // asserted (active-high) when FX2 has room for more data from us
output reg       fx2PktEnd_out,   // asserted (active-low) when a host read needs to be committed early

// Channel read/write interface --------------------------------------------------------------
output wire[6:0] chanAddr_out,    // the selected channel (0-127)

// Host >> FPGA pipe:
output wire[7:0] h2fData_out,     // data lines used when the host writes to a channel
output reg       h2fValid_out,    // '1' means "on the next clock rising edge, please accept the data on h2fData_out"
input  wire      h2fReady_in,     // channel logic can drive this low to say "I'm not ready for more data yet"

// Host << FPGA pipe:
input  wire[7:0] f2hData_in,      // data lines used when the host reads from a channel
input  wire      f2hValid_in,     // channel logic can drive this low to say "I don't have data ready for you"
output reg       f2hReady_out     // '1' means "on the next clock rising edge, put your next byte of data on f2hData_in"
);

// The read/write nomenclature here refers to the FPGA reading and writing the FX2 FIFOs, and is therefore
// of the opposite sense to the host's read and write. So host reads are fulfilled in the S_WRITE state, and
// vice-versa. Apologies for the confusion.
localparam[3:0] S_IDLE                    = 4'h0;     // wait for requst from host & register chanAddr & isWrite
localparam[3:0] S_GET_COUNT0              = 4'h1;     // register most significant byte of message length
localparam[3:0] S_GET_COUNT1              = 4'h2;     // register next byte of message length
localparam[3:0] S_GET_COUNT2              = 4'h3;     // register next byte of message length
localparam[3:0] S_GET_COUNT3              = 4'h4;     // register least significant byte of message length
localparam[3:0] S_BEGIN_WRITE             = 4'h5;     // switch direction of FX2 data bus
localparam[3:0] S_WRITE                   = 4'h6;     // write data to FX2 EP8IN FIFO, one byte at a time
localparam[3:0] S_END_WRITE_ALIGNED       = 4'h7;     // end an aligned write (do not assert fx2PktEnd_out)
localparam[3:0] S_END_WRITE_NONALIGNED    = 4'h8;     // end a nonaligned write (assert fx2PktEnd_out)
localparam[3:0] S_READ                    = 4'h9;     // read data from FX2 EP6OUT FIFO, one byte at a time
localparam[1:0] FIFO_READ                 = 2'b10;    // assert fx2Read_out (active-low)
localparam[1:0] FIFO_WRITE                = 2'b01;    // assert fx2Write_out (active-low)
localparam[1:0] FIFO_NOP                  = 2'b11;    // assert nothing
localparam      OUT_FIFO                  = 2'b0;     // EP6OUT
localparam      IN_FIFO                   = 2'b1;     // EP8IN
reg[3:0]        state_next, state         = S_IDLE;
reg[1:0]        fifoOp                    = FIFO_NOP;
reg[31:0]       count_next, count         = 32'h0;    // read/write count
reg[6:0]        chanAddr_next, chanAddr   = 7'h00;    // channel being accessed (0-127)
reg             isWrite_next, isWrite     = 1'b0;     // is this access is an FX2 FIFO write or a read?
reg             isAligned_next, isAligned = 1'b0;     // is this FX2 FIFO write block-aligned?
reg[7:0]        dataOut;                              // data to be driven on fx2Data_io
reg             driveBus;                             // whether or not to drive fx2Data_io

// Infer registers
always @(posedge fx2Clk_in)
begin
state <= state_next;
count <= count_next;
chanAddr <= chanAddr_next;
isWrite <= isWrite_next;
isAligned <= isAligned_next;
end

// Next state logic
always @*
begin
state_next = state;
count_next = count;
chanAddr_next = chanAddr;
isWrite_next = isWrite;       // is the FPGA writing to the FX2?
isAligned_next = isAligned;   // does this FIFO write end on a block (512-byte) boundary?
dataOut = 8'h00;
driveBus = 1'b0;              // don't drive fx2Data_io by default
fifoOp = FIFO_READ;           // read the FX2 FIFO by default
fx2PktEnd_out = 1'b1;         // inactive: FPGA does not commit a short packet.
f2hReady_out = 1'b0;
h2fValid_out = 1'b0;

case ( state )
S_GET_COUNT0:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 )
begin
// The count high word high byte will be available on the next clock.
count_next[31:24] = fx2Data_io;
state_next = S_GET_COUNT1;
end
end

S_GET_COUNT1:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 )
begin
// The count high word low byte will be available on the next clock.
count_next[23:16] = fx2Data_io;
state_next = S_GET_COUNT2;
end
end

S_GET_COUNT2:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 )
begin
// The count low word high byte will be available on the next clock.
count_next[15:8] = fx2Data_io;
state_next = S_GET_COUNT3;
end
end

S_GET_COUNT3:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 )
begin
// The count low word low byte will be available on the next clock.
count_next[7:0] = fx2Data_io;
if ( isWrite == 1'b1 )
state_next = S_BEGIN_WRITE;
else
state_next = S_READ;
end
end

S_BEGIN_WRITE:
begin
fx2FifoSel_out = IN_FIFO;   // Writing to FX2
fifoOp = FIFO_NOP;
if ( count[8:0] == 9'b000000000 )
isAligned_next = 1'b1;
else
isAligned_next = 1'b0;
state_next = S_WRITE;
end

S_WRITE:
begin
fx2FifoSel_out = IN_FIFO;   // Writing to FX2
if ( fx2GotRoom_in == 1'b1 )
f2hReady_out = 1'b1;
if ( fx2GotRoom_in == 1'b1 && f2hValid_in == 1'b1 )
begin
fifoOp = FIFO_WRITE;
dataOut = f2hData_in;
driveBus = 1'b1;
count_next = count - 1;
if ( count == 32'h1 )
begin
if ( isAligned == 1'b1 )
state_next = S_END_WRITE_ALIGNED;  // don't assert fx2PktEnd
else
state_next = S_END_WRITE_NONALIGNED;  // assert fx2PktEnd to commit small packet
end
end
else
fifoOp = FIFO_NOP;
end

S_END_WRITE_ALIGNED:
begin
fx2FifoSel_out = IN_FIFO;   // Writing to FX2
fifoOp = FIFO_NOP;
state_next = S_IDLE;
end

S_END_WRITE_NONALIGNED:
begin
fx2FifoSel_out = IN_FIFO;   // Writing to FX2
fifoOp = FIFO_NOP;
fx2PktEnd_out = 1'b0;       // Active: FPGA commits the packet early.
state_next = S_IDLE;
end

S_READ:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 && h2fReady_in == 1'b1 )
begin
// A data byte will be available on the next clock
h2fValid_out = 1'b1;
count_next = count - 1;
if ( count == 32'h1 )
state_next = S_IDLE;
end
else
fifoOp = FIFO_NOP;
end

// S_IDLE and others
default:
begin
fx2FifoSel_out = OUT_FIFO;  // Reading from FX2
if ( fx2GotData_in == 1'b1 )
begin
// The read/write flag and a seven-bit channel address will be available on
// the next clock edge.
chanAddr_next = fx2Data_io[6:0];
isWrite_next = fx2Data_io[7];
state_next = S_GET_COUNT0;
end
end
endcase
end

// Drive stateless signals
assign fx2Read_out = fifoOp[0];
assign fx2Write_out = fifoOp[1];
assign chanAddr_out = chanAddr;
assign h2fData_out = fx2Data_io;
assign fx2Data_io = driveBus ? dataOut : 8'hZZ;

endmodule


[Дмитрий Бучинский]

Некоторый перебор со сжатием...
Нельзя ли оставить только промежуток 628.4-629.0ns.
Я так понял, что данным ADCL/H соответствуют строки data_lsb[], data_msb[].
Поскольку там постоянно нули, мне не видно, в какой момент происходит защелкивание данных из АЦП в каждый регистр. Прикрутите в качестве муляжа АЦП восьмибитный счетчик, тупо инкрементируемый сигналом RG, и вставьте в график строку содержимого счетчика.

[andreichk]

Я так понял, что данным ADCL/H соответствуют строки data_lsb[], data_msb[].

нет,это вообще к тактированию не относится,это биты значений тока пельтье, временно, потом их можно будет выкинуть

[andreichk]

Нельзя ли оставить только промежуток 628.4-629.0ns.

[Mixa]

Обвязка ПЗС (в вертикальный перенос не вникал, но на артефакты строк он и не влияет) и АЦП выглядит нормально. Полагаю даже, что и на выходе АЦП байты правильные появляются. Если регистры АЦП запрограмированы соответственно. Изначально считалось, что данные с АЦП доходят до файла без искажений, но появляется все больше признаков того, что это не совсем так. Загадочное падение приложения при изменении скважности ADCCLK (вещи, сторго говоря, не связанные совсем), загадочный верилоговский модуль связки FX2 и FPGA, непонятная его связь с модулем секвенсера ПЗС/АЦП. В общем, я в восторженном ожидании разгадки тайны, как те две дамы под впечатлением повествования Ватсона из фильма "Сокровища Агры".

P.S. На вход comm_fpga_fx2 не пробовали тестовую последовательность подавать в темпе выдачи байтов АЦП, с соотв. паузами?
P.P.S. ADCCLK не строб по сути, и даже не индикатор младшего/старшего байтов. Он вырабатывается секвенсером в сторону АЦП, секвенсер сам в курсе его фазы и в курсе того, какой байт и когда находится на шине. Секвенсер сам вырабатывает строб данных с шины АЦП и сам сопровождает передачу этого байта дальше, сигнализируя чем-то куда-то, это что-то и где-то зависит от выбранного протокола, который пока никто из присутствующих не знает

[andreichk]

Загадочное падение приложения при изменении скважности ADCCLK (вещи, сторго говоря, не связанные совсем),

с падением приложения я разобрался, там просто у меня недосчитывал байты с заголовка каждой строки, собственно ,это уже в сишномприложении пишется, я пока там всякие заглушки убрал и падать перестало даже с меандом. Но как я на картинке  Ответ #407 показал при ацп меандром, файл сжимается по вертикали, это заметно ,даже если я чуток пошире сделаю клок ацп, картинка появляется, но заметно искажение по вертикали ,да и по горизонтали тоже.

[andreichk]

P.S. На вход comm_fpga_fx2 не пробовали тестовую последовательность подавать в темпе выдачи байтов АЦП, с соотв. паузами?

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

зависит от выбранного протокола, который пока никто из присутствующих не знает

протокол именно чего?

[Mixa]

АЦП выдает байты пачками, под управлением секвенсера. Пачка длиной в строку, далее пауза на вертикальный перенос. Времянка неизменная, жесткая, без двустороннего квитирования, максимум - сигнал сопровождения (или строба) очередного байта. Эту пачку нужно передать в комп. В промежутке - модуль сопряжения FPGA и FX2, программа в FX2 и USB-шное приложение. Протокол между секвенсером и модулем сопряжения для начала хотя бы. В модуле comm_fpga_fx2 есть вот это, они как-то должны быть связаны с секвенсером, не видно, как:

// Host << FPGA pipe:
input  wire[7:0] f2hData_in,      // data lines used when the host reads from a channel
input  wire      f2hValid_in,     // channel logic can drive this low to say "I don't have data ready for you"
output reg       f2hReady_out     // '1' means "on the next clock rising edge, put your next byte of data on f2hData_in"

И не совсем ясно, как логически завязаны f2hValid_in и f2hReady_out. f2hValid_in это что-то вроде Ready от секвенсера в модуль comm_fpga_fx2, f2hReady_out логически лишний, но зачем-то используестя. По-любому, логика их работы завязана на логику прошивки FX2 и какую-то ожидаемую логику от секвенсера.

[andreichk]

я щас на работе, дома покажу код, там всё точно связано.

зы. чудное слово-то какое - секвенсер ........

[Mixa]

sequencer, генератор циклограммы, у меня секвенсер прижился, тем более, что такое словечко уже есть, из ранних электронных музыкальных экспериментов. (-ер. -ор, не знаю, как правильно)

[Дмитрий Бучинский]

Я в этом посте буду использовать термин "секвенсор" в качестве названия модуля ПЛИС, формирующего циклограмму управления ПЗС и АЦП, и термин "трансмиттер" в качестве блока связи АЦП и кипариса. Если Вам так не удобно - поправьте.

Смотрел осциллограммы - криминала нигде не видно, а несколько незначительных шероховатостей на проблему влиять не могут. Следовательно - проблема именно в связке АЦП-трансмиттер-кипарис. Тут для меня есть несколько неочевидных моментов:
 Кто в связке секвенсор-трансмиттер-кипарис является "мастером", формирующим клоки и разрешения на работу/остановку других блоков?
 Как формируется сигнал ADCCLK, только пожалуйста не мучайте меня этим непонятным VHDLом, а скиньте фрагмент графической схемы или текстовое описание в стиле "смерть кощея на конце, а конец..."
 Если фифо кипариса забито данными и он не может их отправить в хост из за занятости USB - он запрашивает от трансмиттера->секвенсора приостановку потока. Учтен ли этот момент, и если да, то каким образом? Не получается ли так, что у кипариса случился запор, а трансмиттер продолжает пихать данные.

[Дмитрий Бучинский]

Курил даташит на АЦП, не забыв завернуть в него немного грибов... 

Есть интересная возможность - методом замены одного компонента в обвязке АЦП и переделки проекта в ПЛИС, можно реализовать полностью цифровую ДКВ с многоточечным замером уровней черного и полезного. Но будет медленно, ибо только 12MSPS...
Если интересно - напишу подробности.

[andreichk]

Курил даташит на АЦП, не забыв завернуть в него немного грибов... 

Есть интересная возможность - методом замены одного компонента в обвязке АЦП и переделки проекта в ПЛИС, можно реализовать полностью цифровую ДКВ с многоточечным замером уровней черного и полезного. Но будет медленно, ибо только 12MSPS...
Если интересно - напишу подробности.

конечно интересно, особенно с грибами...

[andreichk]

вот главный модуль кода спартана. это не ВХДЛ, это православный верилог. основан на принципе програмирования проводами, как-то так. то есть одинаковые имена, те , что в скобках встроенных модулей, означают прямое физическое соеденение.

Код: [Выделить]

`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: BAYKONUR                              последнее обновление 01.12.2015
// Engineer:
// Create Date:  02/05/2015
// Module Name:  main
// Project Name: ASTROKAMERA DALSA FTF5066C FTF4052C
// Revision 0.01 - File Created 02.05.2015
//////////////////////////////////////////////////////////////////////////////////
module main(
//Spartan
  input  clk48,
  output wire led0,
  output wire led1,
//------------------Cypress CY7C68013A-56
  output wire[1:0] fx2Addr_out,   // select FIFO: "10" for EP6OUT, "11" for EP8IN
  inout  wire[7:0] fx2Data_io,    // 8-bit data to/from FX2
// When EP6OUT selected:
  output wire      fx2Read_out,   // asserted (active-low) when reading from FX2
  output wire      fx2OE_out,     // asserted (active-low) to tell FX2 to drive bus
  input  wire      fx2GotData_in, // asserted (active-high) when FX2 has data for us
// When EP8IN selected:
  output wire      fx2Write_out,  // asserted (active-low) when writing to FX2
  input  wire      fx2GotRoom_in, // asserted (active-high) when FX2 has room for more data from us
  output wire      fx2PktEnd_out, // asserted (active-low) when a host read needs to be committed early
 
//================================================================================
  inout  wire T_SENSOR,           //LOC = P161;//DALLAS DS18B20 THERMOSENSOR
  output wire PELTIER,            //LOC = P181;//ПЕЛЬТЬЕ
  output wire PROTIVOROSNIK,      //LOC = P25; //ПРОТИВОРОСНИК
  output wire SHUTTER,            //LOC = P28; //ЗАТВОР
//output wire RESERVE,            //LOC = P29; //
  output wire PWRTGDRW_MAX618,    //LOC = P190;//УПРАВЛЕНИЕ ПИТАНИЕМ MAX618
  output wire V_DRIVE11,          //LOC = P164;//УПРАВЛЕНИЕ ПИТАНИЕМ 1
  output wire PWRTGDRW,           //LOC = P189;//УПРАВЛЕНИЕ ПИТАНИЕМ 2
  output wire TD_WTHLVL,          //LOC = P102;//УПРАВЛЕНИЕ ПИТАНИЕМ

//======================CCD DALSA FTF5066C FTF4052C
  output wire CR,  //LOC = P103;
  output wire TGZ, //LOC = P100;
  output wire A1T, //LOC = P99;
  output wire A4T, //LOC = P97;
  output wire TGY, //LOC = P96;
  output wire A3T, //LOC = P94;
  output wire A2T, //LOC = P93;
  output wire A2B, //LOC = P90;
  output wire A3B, //LOC = P89;

  output wire TGX, //LOC = P80;
  output wire A4B, //LOC = P78;
  output wire A1B, //LOC = P77;
  output wire TGW, //LOC = P76;
  output wire RG,  //LOC = P75;
  output wire SG,  //LOC = P74;
  output wire C2X, //LOC = P69;
  output wire C1X, //LOC = P68;
  output wire C3X, //LOC = P65;
  output wire C3W, //LOC = P64;
  output wire C2W, //LOC = P63;
  output wire C1W, //LOC = P62;
 
//--------------------ADC AD9826
  output wire SLOAD,
  output wire SCLK,
  output wire SDATA,

  output wire adc_clock,
  output wire adc_cds1,
  output wire adc_cds2,
  input wire[7:0] adc_data
 );
 
 //=================== РЕГИСТРЫ, ЗАНЯТЫЕ В FPGALINK ========================
//reg0[0] byte=0x00; чтение данных АЦП

//reg1[0] byte=0x01;//CR Charge Reset (CR) pulse on VNS.
//reg1[1] byte=0x02;//подача питания на MAX618
//reg1[2] byte=0x04;//управление накоплением заряда
//reg1[3] byte=0x08;//управление экспозицией
//reg1[4] byte=0x10;//сброс термосенсора
//reg1[5] byte=0x20;//команда переноса значения температуры Термосенсора ???
//reg1[6] byte=0x40;//команда переноса значения температуры Термосенсора ???
//reg1[7] byte=0x80;//управление затвором

//reg2[7:0] //регулировка тока Пельтье мл.байт
//reg3[7:0] //регулировка тока Пельтье ст.байт

//reg4[7:0] //регулировка тока противоросника мл.байт
//reg5[7:0] //регулировка тока противоросника ст.байт

//reg6[7:0] //измерение температуры Пельтье
//reg7[7:0] //измерение температуры Пельтье

//reg8[5:0] //регулировка усиления АЦП
//reg9[7:0] //регулировка смещения АЦП
//reg10[0]  //запись в регистры АЦП

//reg11[0]  //команда переключения типа ПЗС "0" - FTF5066C, "1" - FTF4052C
//=============================================================================
 // Channel read/write interface -----------------------------------------------------------------
wire[6:0]  chanAddr;  // the selected channel (0-127)
// Host >> FPGA pipe: чтение Хоста
wire[7:0]  h2fData;   // data lines used when the host writes to a channel
wire       h2fValid;  // '1' means "on the next clock rising edge, please accept the data on h2fData_out"
wire       h2fReady;  // channel logic can drive this low to say "I'm not ready for more data yet"

// Host << FPGA pipe: чтение ФПГА
wire[7:0]  f2hData;   // data lines used when the host reads from a channel
//wire       f2hValid;  // channel logic can drive this low to say "I don't have data ready for you"
wire       f2hReady;  // '1' means "on the next clock rising edge, put your next byte of data on f2hData_in"
// ----------------------------------------------------------------------------------------------

// Needed so that the comm_fpga_fx2 module can drive both fx2Read_out and fx2OE_out
wire       fx2Read;
// Registers implementing the channels
reg[15:0]  checksum        = 16'h0000;
wire[15:0] checksum_next;
reg[7:0]   reg0            = 8'h00;
wire[7:0]  reg0_next;
reg[7:0]   reg1            = 8'h00;
wire[7:0]  reg1_next;
reg[7:0]   reg2            = 8'h00;
wire[7:0]  reg2_next;
reg[7:0]   reg3            = 8'h00;
wire[7:0]  reg3_next;
reg[7:0]   reg4            = 8'h00;
wire[7:0]  reg4_next;
reg[7:0]   reg5            = 8'h00;//
wire[7:0]  reg5_next;
reg[7:0]   reg6            = 8'h00;//
wire[7:0]  reg6_next;
reg[7:0]   reg7            = 8'h00;//
wire[7:0]  reg7_next;
reg[7:0]   reg8            = 8'h00;//
wire[7:0]  reg8_next;
reg[7:0]   reg9            = 8'h00;//
wire[7:0]  reg9_next;
reg[7:0]   reg10           = 8'h00;//
wire[7:0]  reg10_next;
reg[7:0]   reg11           = 8'h00;//
wire[7:0]  reg11_next;
 //.......................................................
 //.......................................................
wire c48;
//IBUFG X1Y0 (
//   .O(c48),   // Clock buffer output 48 MHz
//   .I(clk48)  // Clock buffer input from CYPRESS 48 MHz
//);
/**/
wire c0,c1,c48_;
BUF BUF_clk0_x4 (.O(c1),.I(c0));
DCMs_ALL #(.M(32),.D(32),.DV(2),.CP(0.02083)) clk2(//48 MHZ
    .in(clk48), // <=========
    .CLKFB(c1),// <=========
    .CLK0(c0), // =================> в буфер
    .CLK90(),.CLK180(),.CLK270(),.CLK2X(),.CLKDV(),
.CLKFX(c48) );
//.......................................................
reg [32:0] cc;//
always @ (posedge c48)//48 MHz
cc <= cc + 1;
//------ тестовые значения ---------------------------------------
reg [5:0]Gain_Reg = 6'b000111;
reg [7:0]Offset_Reg = 8'hFF;
//................конфигурация AD9826...........................
adc_spi init(
          .clock(c48),      // Clock
.init_en(reg10[0]),//(1),//
//.Gain_Reg(Gain_Reg[5:0]),
//.Offset_Reg(Offset_Reg[7:0]),
.Gain_Reg(reg8[5:0]),
.Offset_Reg(reg9[7:0]),
          .adc_sload(SLOAD),// ADC Out
          .adc_sclk(SCLK),
          .adc_sdata(SDATA)
);
/*
// Instantiate the module
AD9826 instance_name (
    .clock(c48),
    .addata(reg9[7:0]),
    .sdata(SDATA),
    .sclk(SCLK),
    .sload(SLOAD),
    .cdsclk1(),
    .cdsclk2(),
    .adclk(),
    .nOE(),
    .dataR(),
    .dataG(),
    .dataB()
    );
*/

//====================================================================
//данные термодатчика 2 байта
reg [7:0] data_msb = 8'h01;//тестовые значения
reg [7:0] data_lsb = 8'h10;
/*
//Термосенсор DALLAS DS18B20
/*
 Как этим пользоваться
 На вход clk подаются тактовые импульсы с периодом 6 мкс. Входы reset,
 read_byte, write_byte нужны для запуска соответствующей функции.
 На них выставляется 1, после появления 1 на busy их нужно сбросить в 0
 (что-то на подобии регистров в МК, записал 1 - пошла работа, только сбрасывать ручками надо),
 если этого не сделать, то по завершению текущих действий они снова повторятся,
 причем наивысший приоритет у reset, наименьший у read_byte.
 Busy выставляется в 1 когда модуль что-то делает, если busy переходит с 1 в 0
 можно считывать данные или запускать новый процесс.
 Здесь реализована только аппаратная часть, всю логику должен делать другой модуль
 или внешний контроллер (тогда сюда надо будет еще прикрутить SPI).
 Если все делать в ПЛИС то для нормальной работы нужна еще память где будут храниться адреса устройств.
*/

reg [7:0] in_byte;//
reg [7:0] out_byte_DS18B20;

wire w0;
BUF BUF_wire (
              .O(T_SENSOR),//двунаправленный порт
  .I(w0)       //<-------------------------------------|
);                         //                                      |
one_wire DALLAS_DS18B20 (  //                                      |
    .reset(reg1[4]),       //<==сброс термосенсора byte=0x10;      |
    .read_byte(reg1[5]),   //<==                                   |
    .write_byte(reg1[6]),  //<==                                   |
    .wire_out(w0),         //------------------------------------->|
    .wire_in(T_SENSOR),    //LOC = P161 DALLAS DS18B20 THERMOSENSOR
    .presense(presense),
    .busy(busy),
    .in_byte(in_byte),
    .out_byte(out_byte_DS18B20[7:0]), //данные температуры
    .clk(c48)
    );

//===========================================================
//........... тактируем матрицу и АЦП........................
wire adc_clock_5066C;
wire adc_cds1_5066C;
wire adc_cds2_5066C;
//===========================================================
wire frame_5066C;
wire header_5066C;
wire header_clock_5066C;
wire [7:0]header_data_5066C;
wire PWRTGDRW_MAX618_5066C;//LOC = P190;//УПРАВЛЕНИЕ ПИТАНИЕМ MAX618
wire V_DRIVE11_5066C;      //LOC = P164;//УПРАВЛЕНИЕ ПИТАНИЕМ 1
wire PWRTGDRW_5066C;       //LOC = P189;//УПРАВЛЕНИЕ ПИТАНИЕМ 2
wire TD_WTHLVL_5066C;      //LOC = P102;//УПРАВЛЕНИЕ ПИТАНИЕМ

//======================CCD DALSA FTF5066C
wire CR_5066C;  //LOC = P103;
wire TGZ_5066C; //LOC = P100;
wire A1T_5066C; //LOC = P99;
wire A4T_5066C; //LOC = P97;
wire TGY_5066C; //LOC = P96;
wire A3T_5066C; //LOC = P94;
wire A2T_5066C; //LOC = P93;
wire A2B_5066C; //LOC = P90;
wire A3B_5066C; //LOC = P89;

wire TGX_5066C; //LOC = P80;
wire A4B_5066C; //LOC = P78;
wire A1B_5066C; //LOC = P77;
wire TGW_5066C; //LOC = P76;
wire RG_5066C;  //LOC = P75;
wire SG_5066C;  //LOC = P74;
wire C2X_5066C; //LOC = P69;
wire C1X_5066C; //LOC = P68;
wire C3X_5066C; //LOC = P65;
wire C3W_5066C; //LOC = P64;
wire C2W_5066C; //LOC = P63;
wire C1W_5066C; //LOC = P62;

// Instantiate the module
FTF5066C_1 timegen ( // тактирование матрицы на частоте 1 МГц dalsa1.xsvf
//FTF5066C_2 timegen ( // тактирование матрицы на частоте 2 МГц   dalsa2.xsvf
//FTF5066C_4 timegen ( // тактирование матрицы на частоте 4 МГц dalsa4.xsvf
//FTF5066C_8 timegen ( // тактирование матрицы на частоте 8 МГц dalsa8.xsvf
.clock(c48), //Clock 48 MHz
.data_gain(reg8),       //<===== усиление АЦП задаётся в хосте
    .data_offset(reg9),     //<===== смещение данных АЦП задаётся в хосте
    .data_msb(out_byte_DS18B20[7:0]),//<===== значение тока Пельтье
    .data_lsb(data_lsb),             //<===== значение тока Пельтье
.CR_IN(reg1[0]),//перед открытием затвора и началом накопления заряда очищаем матрицу импульсом CR
.power_MAX618(reg1[1]), //<== подача питания на MAX618 00000010
.integration(reg1[2]),  //<== накопление пикселей       00000100
    .transport(reg1[3]),    //<== перенос заряда в хост     00001000

.PWRTGDRW_MAX618(PWRTGDRW_MAX618_5066C),//==> УПРАВЛЕНИЕ ПИТАНИЕМ MAX618
    .V_DRIVE11(V_DRIVE11_5066C),            //==> УПРАВЛЕНИЕ ПИТАНИЕМ 1 включить 11 вольт
    .PWRTGDRW(PWRTGDRW_5066C),              //==> УПРАВЛЕНИЕ ПИТАНИЕМ 2 SN74LVC1T45
    .TD_WTHLVL(TD_WTHLVL_5066C),            //==> ИМПУЛЬСЫ УПРАВЛЕНИЯ EL7156 off-11V, on-8V

    .CR(CR_5066C),  //Charge Reset is applied during the first line after the transition from L to H of Trig_in

    .TGZ(TGZ_5066C),             //Image Clock Transfer Gate (Phase 1)
    .TGY(TGY_5066C),             //Image Clock Transfer Gate (Phase 1)
    .TGX(TGX_5066C),             //Image Clock Transfer Gate (Phase 1)
    .TGW(TGW_5066C),             //Image Clock Transfer Gate (Phase 1)

    .A1T(A1T_5066C),             //Image Clock (Phase 1)
    .A2T(A2T_5066C),             //Image Clock (Phase 2)
    .A3T(A3T_5066C),             //Image Clock (Phase 3)
    .A4T(A4T_5066C),             //Image Clock (Phase 4)

    .A1B(A1B_5066C),             //Image Clock (Phase 1)
    .A2B(A2B_5066C),             //Image Clock (Phase 2)
    .A3B(A3B_5066C),             //Image Clock (Phase 3)
    .A4B(A4B_5066C),             //Image Clock (Phase 4)
 
    .C1X(C1X_5066C),             //Register Clock (Phase 1)
    .C2X(C2X_5066C),             //Register Clock (Phase 2)
    .C3X(C3X_5066C),             //Register Clock (Phase 3)

    .C1W(C1W_5066C),             //Register Clock (Phase 1)
    .C2W(C2W_5066C),             //Register Clock (Phase 2)
    .C3W(C3W_5066C),             //Register Clock (Phase 3)     

.SG(SG_5066C),               //Summing Gate
    .RG(RG_5066C),               //Reset Gate

    .CDSCLK1(adc_cds1_5066C),    //==> импульс фиксации
    .CDSCLK2(adc_cds2_5066C),    //==> импульс выборки
    .ADCCLK(adc_clock_5066C),    //==> тактирование ацп

    .frame(frame_5066C),         //==>
    .header(header_5066C),       //==>
    .header_data(header_data_5066C[7:0]),//==> заголовок начала строки
.header_clock(header_clock_5066C)
    );
 
//===========================================================
wire adc_clock_4052C;
wire adc_cds1_4052C;
wire adc_cds2_4052C;
//........... тактируем матрицу и АЦП........................
wire frame_4052C;
wire header_4052C;
wire header_clock_4052C;
wire [7:0]header_data_4052C;

wire PWRTGDRW_MAX618_4052C;//LOC = P190;//УПРАВЛЕНИЕ ПИТАНИЕМ MAX618
wire V_DRIVE11_4052C;      //LOC = P164;//УПРАВЛЕНИЕ ПИТАНИЕМ 1
wire PWRTGDRW_4052C;       //LOC = P189;//УПРАВЛЕНИЕ ПИТАНИЕМ 2
wire TD_WTHLVL_4052C;      //LOC = P102;//УПРАВЛЕНИЕ ПИТАНИЕМ

//======================CCD DALSA FTF4052C
wire CR_4052C;  //LOC = P103;
wire TGZ_4052C; //LOC = P100;
wire A1T_4052C; //LOC = P99;
wire A4T_4052C; //LOC = P97;
wire TGY_4052C; //LOC = P96;
wire A3T_4052C; //LOC = P94;
wire A2T_4052C; //LOC = P93;
wire A2B_4052C; //LOC = P90;
wire A3B_4052C; //LOC = P89;

wire TGX_4052C; //LOC = P80;
wire A4B_4052C; //LOC = P78;
wire A1B_4052C; //LOC = P77;
wire TGW_4052C; //LOC = P76;
wire RG_4052C;  //LOC = P75;
wire SG_4052C;  //LOC = P74;
wire C2X_4052C; //LOC = P69;
wire C1X_4052C; //LOC = P68;
wire C3X_4052C; //LOC = P65;
wire C3W_4052C; //LOC = P64;
wire C2W_4052C; //LOC = P63;
wire C1W_4052C; //LOC = P62;

FTF4052C_1 timegen2 (// тактирование матрицы на частоте 1 МГц dalsa1.xsvf
//FTF4052C_2 timegen2 (// тактирование матрицы на частоте 2 МГц dalsa1.xsvf
//FTF4052C_4 timegen2 (// тактирование матрицы на частоте 4 МГц dalsa1.xsvf
//FTF4052C_8 timegen2 (// тактирование матрицы на частоте 8 МГц dalsa1.xsvf
    .clock(c48), //Clock 48 MHz
.data_gain(reg8),       //<===== усиление АЦП задаётся в хосте
    .data_offset(reg9),     //<===== смещение данных АЦП задаётся в хосте
    .data_msb(out_byte_DS18B20[7:0]),//<===== значение тока Пельте
    .data_lsb(data_lsb),             //<===== значение тока Пельте
.CR_IN(reg1[0]),//перед открытием затвора и началом накопления заряда очищаем матрицу импульсом CR
.power_MAX618(reg1[1]), //<== подача питания на MAX618
.integration(reg1[2]),  //<== накопление пикселей
    .transport(reg1[3]),    //<== перенос заряда в хост

.PWRTGDRW_MAX618(PWRTGDRW_MAX618_4052C),//==> УПРАВЛЕНИЕ ПИТАНИЕМ MAX618
    .V_DRIVE11(V_DRIVE11_4052C), //==> УПРАВЛЕНИЕ ПИТАНИЕМ 1 включить 11 вольт
    .PWRTGDRW(PWRTGDRW_4052C),   //==> УПРАВЛЕНИЕ ПИТАНИЕМ 2 SN74LVC1T45
    .TD_WTHLVL(TD_WTHLVL_4052C), //==> ИМПУЛЬСЫ УПРАВЛЕНИЯ EL7156 off-11V, on-8V
 
    .CR(CR_4052C),  //Charge Reset is applied during the first line after the transition from L to H of Trig_in
    .TGZ(TGZ_4052C),             //Image Clock Transfer Gate (Phase 1)
    .TGY(TGY_4052C),             //Image Clock Transfer Gate (Phase 1)
    .TGX(TGX_4052C),             //Image Clock Transfer Gate (Phase 1)
    .TGW(TGW_4052C),             //Image Clock Transfer Gate (Phase 1)

    .A1T(A1T_4052C),             //Image Clock (Phase 1)
    .A2T(A2T_4052C),             //Image Clock (Phase 2)
    .A3T(A3T_4052C),             //Image Clock (Phase 3)
    .A4T(A4T_4052C),             //Image Clock (Phase 4)

    .A1B(A1B_4052C),             //Image Clock (Phase 1)
    .A2B(A2B_4052C),             //Image Clock (Phase 2)
    .A3B(A3B_4052C),             //Image Clock (Phase 3)
    .A4B(A4B_4052C),             //Image Clock (Phase 4)

    .RG(RG_4052C),               //Reset Gate
    .SG(SG_4052C),               //Summing Gate

    .C1X(C1X_4052C),             //Register Clock (Phase 1)
    .C2X(C2X_4052C),             //Register Clock (Phase 2)
    .C3X(C3X_4052C),             //Register Clock (Phase 3)

    .C1W(C1W_4052C),             //Register Clock (Phase 1)
    .C2W(C2W_4052C),             //Register Clock (Phase 2)
    .C3W(C3W_4052C),             //Register Clock (Phase 3)

    .CDSCLK1(adc_cds1_4052C),    //==> импульс фиксации
    .CDSCLK2(adc_cds2_4052C),    //==> импульс выборки
    .ADCCLK(adc_clock_4052C),    //==> тактирование ацп

    .frame(frame_4052C),         //==>
    .header(header_4052C),       //==>
    .header_data(header_data_4052C[7:0]),//==> заголовок начала строки
.header_clock(header_clock_4052C)
 );
//========== коммутатор матриц регистром reg11[0] == 1 FTF4052 , == 0 FTF5066C
wire frame = reg11[0] ? frame_4052C : frame_5066C;
wire header = reg11[0] ? header_4052C : header_5066C;
wire [7:0]header_data = reg11[0] ? header_data_4052C[7:0] : header_data_5066C[7:0];

assign header_clock = reg11[0] ? header_clock_4052C : header_clock_5066C;
 
assign adc_cds1 = reg11[0] ? adc_cds1_4052C : adc_cds1_5066C;
assign adc_cds2 = reg11[0] ? adc_cds2_4052C : adc_cds2_5066C;
assign adc_clock = reg11[0] ? adc_clock_4052C : adc_clock_5066C;
 
assign PWRTGDRW_MAX618 = reg10[0] ? PWRTGDRW_MAX618_4052C : PWRTGDRW_MAX618_5066C;
assign V_DRIVE11 = reg11[0] ? V_DRIVE11_4052C : V_DRIVE11_5066C;
assign PWRTGDRW  = reg11[0] ? PWRTGDRW_4052C  : PWRTGDRW_5066C;
assign TD_WTHLVL = reg11[0] ? TD_WTHLVL_4052C : TD_WTHLVL_5066C;

assign RG = reg11[0] ? RG_4052C : RG_5066C;
assign SG = reg11[0] ? SG_4052C : SG_5066C;

assign C1X = reg11[0] ? C1X_4052C : C1X_5066C;
assign C2X = reg11[0] ? C2X_4052C : C2X_5066C;
assign C3X = reg11[0] ? C3X_4052C : C3X_5066C;

assign C1W = reg11[0] ? C1W_4052C : C1W_5066C;
assign C2W = reg11[0] ? C2W_4052C : C2W_5066C;
assign C3W = reg11[0] ? C3W_4052C : C3W_5066C;

assign CR = reg11[0] ? CR_4052C : CR_5066C;

assign TGZ = reg11[0] ? TGZ_4052C : TGZ_5066C;
assign TGY = reg11[0] ? TGY_4052C : TGY_5066C;
assign TGX = reg11[0] ? TGX_4052C : TGX_5066C;
assign TGW = reg11[0] ? TGW_4052C : TGW_5066C;

assign A1T = reg11[0] ? A1T_4052C : A1T_5066C;
assign A2T = reg11[0] ? A2T_4052C : A2T_5066C;
assign A3T = reg11[0] ? A3T_4052C : A3T_5066C;
assign A4T = reg11[0] ? A4T_4052C : A4T_5066C;

assign A1B = reg11[0] ? A1B_4052C : A1B_5066C;
assign A2B = reg11[0] ? A2B_4052C : A2B_5066C;
assign A3B = reg11[0] ? A3B_4052C : A3B_5066C;
assign A4B = reg11[0] ? A4B_4052C : A4B_5066C;

//===============================================================
//===============================================================

// BEGIN_SNIPPET(registers)
// Infer registers
always @(posedge c48)
begin
checksum <= checksum_next;
reg0 <= reg0_next;
reg1 <= reg1_next;
reg2 <= reg2_next;
reg3 <= reg3_next;
reg4 <= reg4_next;
reg5 <= reg5_next;
reg6 <= reg6_next;
reg7 <= reg7_next;
reg8 <= reg8_next;
reg9 <= reg9_next;
  reg10 <= reg10_next;
  reg11 <= reg11_next;
end

// Drive register inputs for each channel when the host is writing
assign checksum_next =
    (chanAddr == 7'b0000000 && h2fValid == 1'b1) ? checksum + h2fData :
    (chanAddr == 7'b0000001 && h2fValid == 1'b1 && h2fData[0] == 1'b1) ? 16'h0000 : checksum;
assign reg0_next = (chanAddr == 7'b0000000 && h2fValid == 1'b1) ? h2fData : reg0;
assign reg1_next = (chanAddr == 7'b0000001 && h2fValid == 1'b1) ? h2fData : reg1;
assign reg2_next = (chanAddr == 7'b0000010 && h2fValid == 1'b1) ? h2fData : reg2;
assign reg3_next = (chanAddr == 7'b0000011 && h2fValid == 1'b1) ? h2fData : reg3;
assign reg4_next = (chanAddr == 7'b0000100 && h2fValid == 1'b1) ? h2fData : reg4;
assign reg5_next = (chanAddr == 7'b0000101 && h2fValid == 1'b1) ? h2fData : reg5;
assign reg6_next = (chanAddr == 7'b0000110 && h2fValid == 1'b1) ? h2fData : reg6;
assign reg7_next = (chanAddr == 7'b0000111 && h2fValid == 1'b1) ? h2fData : reg7;
assign reg8_next = (chanAddr == 7'b0001000 && h2fValid == 1'b1) ? h2fData : reg8;
assign reg9_next = (chanAddr == 7'b0001001 && h2fValid == 1'b1) ? h2fData : reg9;
assign reg10_next =(chanAddr == 7'b0001010 && h2fValid == 1'b1) ? h2fData : reg10;
assign reg11_next =(chanAddr == 7'b0001011 && h2fValid == 1'b1) ? h2fData : reg11;

// Select values to return for each channel when the host is reading
assign f2hData = (chanAddr == 7'b0000000) ? reg0
               : (chanAddr == 7'b0000001) ? reg1
               : (chanAddr == 7'b0000010) ? reg2
               : (chanAddr == 7'b0000011) ? reg3
               : (chanAddr == 7'b0000100) ? reg4
  : (chanAddr == 7'b0000101) ? reg5
  : (chanAddr == 7'b0000110) ? reg6
               : (chanAddr == 7'b0000111) ? reg7
  : (chanAddr == 7'b0001000) ? reg8
  : (chanAddr == 7'b0001001) ? reg9
  : (chanAddr == 7'b0001010) ? reg10
  : (chanAddr == 7'b0001011) ? reg11
               : 8'h00;

reg [7:0]adc_data_;
reg [7:0]header_data_;

always @ (posedge c48)
begin
     header_data_ <= header_data;
        adc_data_ <= adc_data;
end

//данные и такт с видео АЦП
wire expos_clk = (frame && adc_clock) || (header && header_clock);
wire [7:0]expos_data = (frame) ? adc_data_[7:0] : (header) ? header_data_[7:0] : 8'd0;//

// коммутатор данных и такта, подаваемых в FPGALINK
wire    comp_valid = (reg1[3]) ? expos_clk : 1'b0;//
wire [7:0]comp_out = (reg1[3]) ? expos_data[7:0] : 8'b00000000;//

// Assert that there's always data for reading, and always room for writing
//подтверждение наличия данных для чтения и записи
//assign f2hValid = 1'b1;
assign h2fReady = 1'b1;        // END_SNIPPET(registers)

// CommFPGA module
assign fx2Read_out = fx2Read;
assign fx2OE_out = fx2Read;
assign fx2Addr_out[1] = 1'b1;  // Use EP6OUT/EP8IN, not EP2OUT/EP4IN.
comm_fpga_fx2 Cypress(
// FX2 interface
.fx2Clk_in(c48),
.fx2FifoSel_out(fx2Addr_out[0]),
.fx2Data_io(fx2Data_io),
.fx2Read_out(fx2Read),
   .fx2GotData_in(fx2GotData_in),
.fx2Write_out(fx2Write_out),
.fx2GotRoom_in(fx2GotRoom_in),
.fx2PktEnd_out(fx2PktEnd_out),

// Channel read/write interface
.chanAddr_out(chanAddr),

.h2fData_out(h2fData[7:0]), //HOST ==> FPGA принятые из консоли данные
.h2fValid_out(h2fValid),    //
.h2fReady_in(h2fReady),     //готовность. всегда 1

.f2hData_in(comp_out[7:0] ),//HOST <== FPGA посылка данных в консоль
.f2hValid_in(comp_valid),   //<==  если есть валидные данные
.f2hReady_out(f2hReady)     //==>  «1» означает передачу след. байта данных на f2hData_in» по фронту импульса
);
//============================================================================================
// ПРИНИМАЕМ 2 байта С КОНСОЛИ, преобразуем их в 16 бит И ОТПРАВЛЯЕМ В PWM PELTIER
wire inv_peltier;
PWM to_Peltier (
    .clk(cc[8]), //тут можно подгонять частоту ШИМ для ПЕЛЬТЬЕ
    .PWM_in1(reg2[7:0]), //<==мл.бaйт
.PWM_in2(reg3[7:0]), //<==ст.байт
    .PWM_out(inv_peltier)//==> P181;//ПЕЛЬТЬЕ
    );
assign PELTIER = !inv_peltier;
// ПРИНИМАЕМ 2 байта С КОНСОЛИ, преобразуем их в 16 бит И ОТПРАВЛЯЕМ В PWM ПРОТИВОРОСНИК
PWM to_Protivorosnik (
    .clk(cc[8]), //тут можно подгонять частоту ШИМ
    .PWM_in1(reg4[7:0]),   //<==мл.байт
.PWM_in2(reg5[7:0]),   //<==ст.байт
    .PWM_out(PROTIVOROSNIK)//==> P25;//ПРОТИВОРОСНИК
    );
//=============================================================================================

 assign SHUTTER = reg1[7]; // управление затвором
 assign led1 = SHUTTER;    // header_data[3];//SHUTTER;   
 assign led0 = reg1[3];    // cc[22];//comp_out[5];// f2hReady;//adc_data[3];//reg0[1];//
 
endmodule
клок на спартан ==48 МГц и подаётся извне, а именно от кипреса, дале он раскидывается по разным модулям, если надо делится на 2 или 4 , вобщем это не важно пока.

Как формируется сигнал ADCCLK, только пожалуйста не мучайте меня этим непонятным VHDLом, а скиньте фрагмент графической схемы или текстовое описание в стиле "смерть кощея на конце, а конец..."

Дмитрий, там есть конечно возможностьв схематике всё это представить, но нафига он вам надо? суть в том, что пришел в модуль клок 48 МГц, и в нём сформировался меандр или импульс или то, что программист захочет.. в камне там всякие регистры, ЛУТы, триггеры, которые всё это организуют и крутят.

[andreichk]

конкретно сигнал от АЦП вот в этом куске попадает в модуль связи с кипресом. его имя comp_out
в строке .f2hData_in(comp_out[7:0] ),//HOST <== FPGA посылка данных в консоль

Код: [Выделить]

reg [7:0]adc_data_;
reg [7:0]header_data_;

always @ (posedge c48)
begin
     header_data_ <= header_data;
        adc_data_ <= adc_data;
end

//данные и такт с видео АЦП
wire expos_clk = (frame && adc_clock) || (header && header_clock);
wire [7:0]expos_data = (frame) ? adc_data_[7:0] : (header) ? header_data_[7:0] : 8'd0;//

// коммутатор данных и такта, подаваемых в FPGALINK
wire    comp_valid = (reg1[3]) ? expos_clk : 1'b0;//
wire [7:0]comp_out = (reg1[3]) ? expos_data[7:0] : 8'b00000000;//

// Assert that there's always data for reading, and always room for writing
//подтверждение наличия данных для чтения и записи
//assign f2hValid = 1'b1;
assign h2fReady = 1'b1;        // END_SNIPPET(registers)

// CommFPGA module
assign fx2Read_out = fx2Read;
assign fx2OE_out = fx2Read;
assign fx2Addr_out[1] = 1'b1;  // Use EP6OUT/EP8IN, not EP2OUT/EP4IN.
comm_fpga_fx2 Cypress(
// FX2 interface
.fx2Clk_in(c48),
.fx2FifoSel_out(fx2Addr_out[0]),
.fx2Data_io(fx2Data_io),
.fx2Read_out(fx2Read),
   .fx2GotData_in(fx2GotData_in),
.fx2Write_out(fx2Write_out),
.fx2GotRoom_in(fx2GotRoom_in),
.fx2PktEnd_out(fx2PktEnd_out),

// Channel read/write interface
.chanAddr_out(chanAddr),

.h2fData_out(h2fData[7:0]), //HOST ==> FPGA принятые из консоли данные
.h2fValid_out(h2fValid),    //
.h2fReady_in(h2fReady),     //готовность. всегда 1

.f2hData_in(comp_out[7:0] ),//HOST <== FPGA посылка данных в консоль
.f2hValid_in(comp_valid),   //<==  если есть валидные данные
.f2hReady_out(f2hReady)     //==>  «1» означает передачу след. байта данных на f2hData_in» по фронту импульса
);