MicroBlaze + DDR3 + my_IP на AXI, подключение к AXI Опции

[zuuuuk]

Добрый день.
У меня система на SPARTAN6 Mbz + MCB_DDR3 на шине AXI.
Я хочу подключить свой IP блок ко второму порту MCB и получить доступ к DDR3.
т.е. мой IP блок должен быть мастером. Для чтения данных из DDR3.

Подскажите,пожалуйста, какой-нибудь пример подключения своего IP к шине AXI.

[Golikov A.]

то данные из data_in на этом же цикле записываются в fifo.
цикле чего? когда на врайте 1, то каждый такт клока данные записываются, и произойдет это по переднему фронту.

Вот что-то такое и было на тестовом проекте.
да я тоже планирую подразогнать, но сильно усугубляет ЛвИП, все же он много чего еще делает кроме передачи данных...

Зачем нужны регистры, если речь идет о прокачке 2 MB/sec ?
для удобства пользования.

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


мне когда я генерю такую штуку получаю такой файл, это уже помененный мной,
по умолчанию он регистрам дает имена reg_0 reg_1 ....
и адреса
00001
00010
00100
....

Код

// ------------------------------------------------------
  // Example code to read/write user logic slave model s/w accessible registers
  //
  // Note:
  // The example code presented here is to show you one way of reading/writing
  // software accessible registers implemented in the user logic slave model.
  // Each bit of the Bus2IP_WrCE/Bus2IP_RdCE signals is configured to correspond
  // to one software accessible register by the top level template. For example,
  // if you have four 32 bit software accessible registers in the user logic,
  // you are basically operating on the following memory mapped registers:
  //
  //    Bus2IP_WrCE/Bus2IP_RdCE   Memory Mapped Register
  //                     "1000"   C_BASEADDR + 0x0
  //                     "0100"   C_BASEADDR + 0x4
  //                     "0010"   C_BASEADDR + 0x8
  //                     "0001"   C_BASEADDR + 0xC
  //
  // ------------------------------------------------------

  assign
    slv_reg_write_sel = Bus2IP_WrCE[10:0],
    slv_reg_read_sel  = Bus2IP_RdCE[10:0],
    slv_write_ack     = Bus2IP_WrCE[0] || Bus2IP_WrCE[1] || Bus2IP_WrCE[2] || Bus2IP_WrCE[3] || Bus2IP_WrCE[4] || Bus2IP_WrCE[5] || Bus2IP_WrCE[6] || Bus2IP_WrCE[7] || Bus2IP_WrCE[8] || Bus2IP_WrCE[9]  || Bus2IP_WrCE[10],
    slv_read_ack      = Bus2IP_RdCE[0] || Bus2IP_RdCE[1] || Bus2IP_RdCE[2] || Bus2IP_RdCE[3] || Bus2IP_RdCE[4] || Bus2IP_RdCE[5] || Bus2IP_RdCE[6] || Bus2IP_RdCE[7] || Bus2IP_RdCE[8] || Bus2IP_RdCE[9]  || Bus2IP_RdCE[10];

  // implement slave model register(s)
  always @( posedge Bus2IP_Clk )
    begin

      if ( Bus2IP_Resetn == 1'b0 )
        begin
                    fifo_write_signal <= 0;
          command_reg <= 0;
          path_data_reg <= 0;
          start_step_time_reg <= 0;
          max_step_time_reg <= 0;
          min_step_time_reg <= 0;
          step_time_plus_reg <= 0;
          step_time_minus_reg <= 0;
          stop_path_length <= 0;
          step_len <= 0;
                    dir_len <= 0;
                    STATUS_ADDR <= MAIN_STATUS;
        end
      else
                begin
                    //сбрасываем флаг если нет сигнала записи в данные пути
                    if(slv_reg_write_sel !=  11'b0000000010)
                        fifo_write_signal <= 2'b00;    

                    case ( slv_reg_write_sel )
                        STATUS_REG_CE : //запись в регистр статуса - выбор регистра
                            begin
                                if ( Bus2IP_BE[0] == 1 ) //только младший байт
                                    STATUS_ADDR <=  Bus2IP_Data[STATUS_ADR_SIZE - 1 : 0];
                            end
                        COMMAND_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    command_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        PATH_DATA_REG_CE :
                            begin
                                for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                    if ( Bus2IP_BE[byte_index] == 1 )
                                        path_data_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                                
                                //по клоку надо выдать строб на запись в фифо
                                if(fifo_write_signal == 0)
                                    fifo_write_signal <= 2'b01;
                                //по следующему клоку надо снять строб, но не поставить заново если будет еще клок
                                else if (fifo_write_signal == 2'b01)
                                    fifo_write_signal <= 2'b10;
                                //когда убиреться разрешение на запись, флаг сброситься в 0    
                            end            
                        START_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    start_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MAX_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    max_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MIN_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    min_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        PLUS_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_time_plus_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MINUS_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_time_minus_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STOP_PATH_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    stop_path_length[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STEP_LEN_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_len[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STEP_DIR_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    dir_len[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        default :
                            begin
                            end
                    endcase
                end    
    end // SLAVE_REG_WRITE_PROC

  // implement slave model register read mux
  always @( slv_reg_read_sel or status_reg or command_reg or path_data_reg or start_step_time_reg or max_step_time_reg or min_step_time_reg or step_time_plus_reg or step_time_minus_reg or stop_path_length or step_len or dir_len)
    begin
      case ( slv_reg_read_sel )
        STATUS_REG_CE : slv_ip2bus_data <= status_reg;
        COMMAND_REG_CE : slv_ip2bus_data <= command_reg;
        PATH_DATA_REG_CE : slv_ip2bus_data <= path_data_reg;
        START_STEP_REG_CE : slv_ip2bus_data <= start_step_time_reg;
        MAX_STEP_REG_CE : slv_ip2bus_data <= max_step_time_reg;
        MIN_STEP_REG_CE : slv_ip2bus_data <= min_step_time_reg;
        PLUS_STEP_REG_CE : slv_ip2bus_data <= step_time_plus_reg;
        MINUS_STEP_REG_CE : slv_ip2bus_data <= step_time_minus_reg;
        STOP_PATH_REG_CE : slv_ip2bus_data <= stop_path_length;
        STEP_LEN_REG_CE : slv_ip2bus_data <= step_len;
                STEP_DIR_REG_CE : slv_ip2bus_data <= dir_len;
        default : slv_ip2bus_data <= 0;
      endcase

    end // SLAVE_REG_READ_PROC