FTDI SuperSpeed-FIFO Bridge　FT601を使ってみよう

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity TOP is

port(
	-- interface with FT601
	RST_N		: 	in std_logic;				-- CYclone5 starter kit CPU_Reset Sw is connected AB24: FPGA Pin number
	CLK_IN   :  in std_logic;                    -- from FT601
	TXE_N    :  in std_logic;                    -- from FT601, It means that Transmit FIFO is empty 
	WR_N     :  out std_logic;                    
	BE       :  inout std_logic_vector(3 downto 0);
	RXF_N    :  in std_logic;					-- from FT601, It means that Receive FIFO is empty
	OE_N     :  out std_logic;
	RD_N     :  out std_logic;
	DATA     : inout std_logic_vector(31 downto 0) ;

	 
	-- for debugging
	db_RXF_N_LED 			:  out std_logic; 	-- LEDG0  is connected L7:Cyclone5 GX Pin number
	db_TXE_N_LED			:  out std_logic; 	-- LEDG1  is connected K6:Cyclone5 GX Pin number
	db_MyFIFO_EMPTY_LED	:  out std_logic; 		-- LEDR0  is connected F7:Cyclone5 GX Pin number
	db_MyFIFO_FULL_LED	:  out std_logic 		-- LEDR1  is connected F3:Cyclone5 GX Pin number
		
	);
end entity;

architecture RTL of TOP is

	component FT601_245SYNCFIFO port (
	  RST_N		:  in std_logic;
	-- interface with FT601
	  CLK_IN   :  in std_logic;                     			-- from FT601
	  TXE_N    :  in std_logic;                     			-- from FT601, It means that Transmit FIFO is empty
	  WR_N     :  out std_logic;                    
	  BE       :  inout std_logic_vector(3 downto 0);
	  RXF_N    :  in std_logic;									-- from FT601, It means that Receive FIFO is Full
	  OE_N     :  out std_logic;
	  RD_N     :  out std_logic;
	  DATA     : inout std_logic_vector(31 downto 0);  

	-- interface with user cercuit
	  Tx_DATA        		: in std_logic_vector(31 downto 0); -- write data to FT601
	  Rx_DATA        		: out std_logic_vector(31 downto 0);-- read data from FT601
	  RX_Ready       		: in std_logic;
	  TX_Ready       		: in std_logic;
	  DATA_SendRequest      : out std_logic;
     DATA_ReceiveRequest   : out std_logic;
     FIFO_DATA_Received    : out std_logic;
     FIFO_DATA_Transmitted : out std_logic
	);
	end component;
	
	-- Mega function FIFO IP ( 32 bits x 1024 words single port FIFO )
	component FIFO
	PORT
	(
		aclr		: IN STD_LOGIC ;
		clock		: IN STD_LOGIC ;
		data		: IN STD_LOGIC_VECTOR (31 DOWNTO 0);
		rdreq		: IN STD_LOGIC ;
		wrreq		: IN STD_LOGIC ;
		empty		: OUT STD_LOGIC ;
		full		: OUT STD_LOGIC ;
		q		: OUT STD_LOGIC_VECTOR (31 DOWNTO 0)
	);
	end component;
	
	-- internal signal or buffer
	signal i_Tx_DATA			:	std_logic_vector(31 downto 0);
	signal i_Tx_DATA_Shifted	:	std_logic_vector(31 downto 0);
	signal i_Rx_DATA			:	std_logic_vector(31 downto 0);
	signal i_RX_Ready			:	std_logic;
	signal i_TX_Ready			:	std_logic;
	signal i_FIFO_DATA_Received	: 	std_logic;
	signal i_FIFO_DATA_Transmitted	:	std_logic;
	signal i_TXE_N				:	std_logic;
	signal i_RXF_N				:	std_logic;
	signal i_CLK_IN				:	std_logic;
	signal i_MyDATA_RD_REQUEST	:	std_logic;
	signal i_MyDATA_WR_REQUEST	:	std_logic;
	signal i_CLEAR_FIFO			:	std_logic;
	signal i_MyFIFO_EMPTY		:	std_logic;
	signal i_MyFIFO_FULL		:	std_logic;
	
	begin
	i_CLK_IN 		<= not CLK_IN;
	i_CLEAR_FIFO	<= not RST_N;
	i_RXF_N 			<= RXF_N;
	i_TXE_N 			<= TXE_N;
	
		
	-- for debugging
	db_RXF_N_LED 				<= not i_RXF_N; 
	db_TXE_N_LED 				<= not i_TXE_N;
	db_MyFIFO_EMPTY_LED		<= i_MyFIFO_EMPTY;
	db_MyFIFO_FULL_LED		<= i_MyFIFO_FULL;
	--
	
	
	FT601_0:FT601_245SYNCFIFO port map (
		RST_N				 =>	RST_N,	
		-- connected to outside (FT601)
		CLK_IN          =>  CLK_IN,                      
		TXE_N           =>  TXE_N,              
		WR_N            =>  WR_N,    		
		BE              =>  BE, 
		RXF_N           =>  RXF_N,
		OE_N            =>  OE_N,  
		RD_N            =>  RD_N,  
		DATA            =>  DATA,
	
		-- connectd to inside
		Tx_DATA         =>  i_Tx_DATA,     
		Rx_DATA         =>  i_Rx_DATA,        
		RX_Ready        => 	not i_MyFIFO_FULL, 
		TX_Ready        =>  i_MyFIFO_FULL,

		DATA_SendRequest		=>	i_MyDATA_RD_REQUEST,
		DATA_ReceiveRequest		=>	i_MyDATA_WR_REQUEST, 
		FIFO_DATA_Received      =>	i_FIFO_DATA_Received,
		FIFO_DATA_Transmitted   =>	i_FIFO_DATA_Transmitted  

	);
	
	FIFO_inst : FIFO PORT MAP (
		aclr	=> i_CLEAR_FIFO,
		clock	=> i_CLK_IN,					-- 
		data	=> i_Rx_DATA,					--	Write data from FT601 as i_RX_DATA
		rdreq	=> i_MyDATA_RD_REQUEST,	
		wrreq	=> i_MyDATA_WR_REQUEST,	
		empty	=> i_MyFIFO_EMPTY,				
		full	=> i_MyFIFO_FULL,				
		q		=> i_Tx_DATA					--	Read data from this FIFO, Write it to FT601's FIFO
	);


		
end RTL;

import ftd3xx
import sys
import numpy as np
from random import randint
import logging
import time

FT_OPEN_BY_SERIAL_NUMBER = 0x00000001
FT_OPEN_BY_DESCRIPTION = 0x00000002
FT_OPEN_BY_LOCATION = 0x00000004
FT_OPEN_BY_GUID = 0x00000008
FT_OPEN_BY_INDEX = 0x00000010


def information_fifo_mode(num):
    # The following defines refer to "FTD3XX.h"
    fifo_mode_list = ["CONFIGURATION_FIFO_MODE_245", "CONFIGURATION_FIFO_MODE_600",
                      "CONFIGURATION_MODE_COUNT"]
    return fifo_mode_list[num]


def information_channel_config(num):
    # The following defines refer to "FTD3XX.h"
    channel_config_list = ["CONFIGURATION_CHANNEL_CONFIG_4", "CONFIGURATION_CHANNEL_CONFIG_2",
                           "CONFIGURATION_CHANNEL_CONFIG_1", "CONFIGURATION_CHANNEL_CONFIG_1_OUTPIPE",
                           "CONFIGURATION_CHANNEL_CONFIG_1_INPIPE", "CONFIGURATION_CHANNEL_CONFIG_COUNT"]
    return channel_config_list[num]


def open_ft_usb_device(device_type, device_name):
    ascii_device_name = bytes(device_name, encoding="ASCII")
    for device_id in range(16):
        usb_object = ftd3xx.create(device_id, FT_OPEN_BY_INDEX)
        if sys.platform == 'win32' and usb_object.getDriverVersion() < 0x01020006:
            usb_object.close()
            return None, 'D3XX driver version is old. Please update driver!'
        if usb_object.getDeviceInfo()['Description'] != ascii_device_name:
            usb_object.close()
            continue
        return usb_object, 'Successfully opened %s USB device: %s' % (device_type, device_name)
    return None, 'open usb device failed!'


def close_ft_usb_device(usb_object):
    usb_object.close()


def get_random_data(data_length):
    data_array = [randint(0, 255) for i in range(data_length)]
    return bytes(data_array), len(data_array)


def get_incremental_data(data_length):
    # repeat = int(data_length / 256)
    data_array = []
    # for i in range(repeat):
    #     for j in range(256):
    #         data_array.append(j)
    # data_array = [j for i in range(repeat) for j in range(256)]
    # return bytes(data_array), len(data_array)
    size_of_int_data = int(data_length / 4)
    data_array = np.arange(0, size_of_int_data, dtype=np.int32)
    return bytes(data_array), len(data_array)


def WritePipe(D3XX, pipe, buffer, size):
    return D3XX.writePipe(pipe, buffer, size)


def ReadPipe(D3XX, pipe, size):
    received = D3XX.readPipeEx(pipe, size, True)
    return received['bytesTransferred'], received['bytes']


def upstream_test(usb_handle):
    send_data_length = 4096
    send_data, length = get_incremental_data(send_data_length)
    transferred_value = WritePipe(usb_handle, 0x02, send_data, send_data_length)
    if transferred_value != send_data_length:
        # close_ft_usb_device(usb)
        print("WritePile failed")
        return
    print("WritePile Successful")
    return


def downstream_test(usb_handle):
    receive_data_length = 4096
    value, receive_data = ReadPipe(usb_handle, 0x82, receive_data_length)
    if value == receive_data_length:
        f_receive = open("receive_data.dat", "wb")
        f_receive.write(receive_data)
        print("ReadPile Successful, receive data saved")
    return


def loop_back_test(usb_handle, option):
    send_data_length = 4096
    receive_data_length = 4096
    flg = False
    if option == 1:
        data_type = "random"
        send_data, length = get_random_data(send_data_length)
    else:
        data_type = "incremental"
        send_data, length = get_incremental_data(send_data_length)
    # start_write = time.perf_counter()
    transferred_value = WritePipe(usb_handle, 0x02, send_data, send_data_length)
    # end_write = time.perf_counter() - start_write
    # print(f'{end_write}秒！')
    if transferred_value != send_data_length:
        close_ft_usb_device(usb)
        print("WritePile failed")
        return
    else:
        # start_read = time.perf_counter()
        value, receive_data = ReadPipe(usb_handle, 0x82, receive_data_length)
        # end_read = time.perf_counter() - start_read
        # print(f'{end_read}秒！')
        if value == receive_data_length:
            flg = True
        if send_data != receive_data:
            print(" ** send_data and receive_data mismatch")
            return
        else:
            print(" send_data and receive_data match, loopback test passed **")

    if flg:
        f_send = open("send_data_" + data_type + ".dat", "wb")
        f_send.write(send_data)
        f_receive = open("receive_data_" + data_type + ".dat", "wb")
        f_receive.write(receive_data)


def main(handle):
    while True:
        try:
            print('***** 1: loopback_test_random')
            print('***** 2: loopback_test_incremental')
            print('***** 3: upstream_test_incremental')
            print('***** 4: downstream_test')
            print('***** 5: end test')
            cmd = input('command input >> ')
        except KeyboardInterrupt:
            break

        cmd = int(cmd)
        if cmd == 5:
            close_ft_usb_device(handle)
            break
        elif cmd == 1 or cmd == 2:
            loop_back_test(handle, cmd)
        elif cmd == 3:
            upstream_test(handle)
        elif cmd == 4:
            downstream_test(handle)
        else:
            print("invalid command")


if __name__ == '__main__':
    usb, message = open_ft_usb_device("FT60X", "FTDI SuperSpeed-FIFO Bridge")
    print(message)
    print("VendorID : 0x%X" % usb.getChipConfiguration().VendorID)
    print("ProductID : 0x%X" % usb.getChipConfiguration().ProductID)
    print("ChannelConfig : %s" % information_channel_config(usb.getChipConfiguration().ChannelConfig))
    print("FIFOMode : %s" % information_fifo_mode(usb.getChipConfiguration().FIFOMode))
    print("--------------------------------------------------------------------------")
    print("------------------------  Loop back test    ------------------------------")
    main(usb)