精华内容
下载资源
问答
  • PYNQ纯PL端开发

    2020-06-08 23:18:59
    必然要先试一试它的其他模式~正好我也没玩过ZYNQ系列,试一试纯PL开发,SDK,标准ZYNQ开发流程,最后再搞一搞PYNQ的开发。(其实因为我买的SD卡还没到) PYNQ-Z1 PYNQ-Z1开发板是全球第一块Python on FPGA开发板。...

    最近搞来一块PYNQ-Z1,不要问我为什么没搞Z2,因为花的不是俺的钱,俺不好意思提要求了。蛤蛤~
    我发现PYNQ给的官方文档都是直接刷系统写python的,我们新时代求知若渴好青年怎么能直接就这样开始了呢!必然要先试一试它的其他模式~正好我也没玩过ZYNQ系列,试一试纯PL开发,SDK,标准ZYNQ开发流程,最后再搞一搞PYNQ的开发。(其实因为我买的SD卡还没到)

    PYNQ-Z1

    PYNQ-Z1开发板是全球第一块Python on FPGA开发板。其所支持的 PYNQ 项目,是一个新的开源框架,使嵌入式编程人员能够在无需设计可编程逻辑电路的情况下即可充分发挥 Xilinx Zynq All Programmable SoC(APSoC)的功能。与常规方式不同的是,通过 PYNQ,用户可以使用 Python 进行 APSoC 编程,并且代码可直接在 PYNQ-Z1 上进行开发和测试。通过 PYNQ,可编程逻辑电路将作为硬件库导入并通过其 API 进行编程,其方式与导入和编程软件库基本相同。

    技术文档:http://www.digilent.com.cn/community/411.html

    简单来说就是一块芯片上既有PS又有PL这就是ZYNQ,可是这对小朋友的要求有点高,我们万物皆python吧!何不用python来开发硬件呢,这就诞生了PYNQ。

    纯PL开发的准备

    首先上图,粉红色的板子好似美娇娘2333
    在这里插入图片描述
    要把它当个FPGA用的话,我们用JTAG作为烧录方式。首先把左上角的跳线帽选到“JTAG”,左下角控制电源的跳线帽选到“USB”,如上图所示。这块板子的JTAG和UART就是一个,就左边那个micro-USB接口。
    至于我们用到的软件,X家的VIVADO想必是老朋友了,不多说。完成之后就可以开干了。

    用PLL产生不同时钟间歇点亮4个LED

    代码很简单,也没什么意思,仅供娱乐之用。

    首先创建一个VIVADO工程,就跟以前用FPGA一毛一样,然后选zynq XC7Z020这个芯片,一路next就OK了。

    1.使用Xilinx的PLL IP核
    进入工程界面,首先我们搞个PLL,点击IP Catalog
    在这里插入图片描述
    选择Clocking Wizard
    在这里插入图片描述
    做四个输出 25,50,100,200MHz
    在这里插入图片描述
    PYNQ-Z1的PL端板载晶振125MHz,这玩意我在网上找了半天,结果发现digilent网上给了约束文件,就在上面那个网址里面。我们给他设置成PLL,时钟输入125。
    在这里插入图片描述
    一路OK+next,完毕over

    2. 写设计文件
    我想让四个LED以不同频率闪烁,写两个小小verilog,如下:

    module pll_test(
    input sys_clk,
    input bt0,
    output led0,led1,led2,led3
        );
        wire locked;
        wire rst_n;
        reg[31:0] timer_cnt; 
        wire clk_1,clk_2,clk_3,clk_4;
        assign rst_n=~bt0;
          clk_wiz_0 clk
        (
        // Clock out ports  
        .clk_out1(clk_1),    //OUT 200MHz
        .clk_out2(clk_2),    //OUT 100MHz
        .clk_out3(clk_3),    //OUT 50MHz
        .clk_out4(clk_4),    //OUT 25MHz
        // Status and control signals               
        .reset(bt0), 
        .locked(locked),
       // Clock in ports
        .clk_in1(sys_clk)
        );
        led l0 (clk_1,rst_n,led0);
        led l1 (clk_2,rst_n,led1);
        led l3 (clk_3,rst_n,led2);
        led l4 (clk_4,rst_n,led3);
    endmodule
    
    module led(
    input clk,
    input rst_n,
    output reg led
        );
        reg [31:0] timer_cnt;
        always@(posedge clk or negedge rst_n) 
        begin 
            if (!rst_n) 
            begin 
                led <= 0 ; 
                timer_cnt <= 32'd0 ; 
            end 
            else if(timer_cnt >= 32'd49_999_999) 
            begin 
                led <= ~led; 
                timer_cnt <= 32'd0; 
            end 
            else 
            begin 
                led <= led; 
                timer_cnt <= timer_cnt + 32'd1; 
            end 
        end
    endmodule
    
    

    3.写约束文件
    拒绝GUI,我们要学会直接写约束文件!(复制官网上的文件再改改)
    新建一个约束文件。

    set_property -dict { PACKAGE_PIN H16   IOSTANDARD LVCMOS33 } [get_ports { sys_clk }]; #IO_L13P_T2_MRCC_35 Sch=sysclk
    create_clock -add -name sys_clk_pin -period 8.00 -waveform {0 4} [get_ports { sys_clk }];
    set_property -dict { PACKAGE_PIN D19   IOSTANDARD LVCMOS33 } [get_ports { bt0 }]; #IO_L4P_T0_35 Sch=btn[0]
    set_property -dict { PACKAGE_PIN R14   IOSTANDARD LVCMOS33 } [get_ports { led0 }]; #IO_L6N_T0_VREF_34 Sch=led[0]
    set_property -dict { PACKAGE_PIN P14   IOSTANDARD LVCMOS33 } [get_ports { led1 }]; #IO_L6P_T0_34 Sch=led[1]
    set_property -dict { PACKAGE_PIN N16   IOSTANDARD LVCMOS33 } [get_ports { led2 }]; #IO_L21N_T3_DQS_AD14N_35 Sch=led[2]
    set_property -dict { PACKAGE_PIN M14   IOSTANDARD LVCMOS33 } [get_ports { led3 }]; #IO_L23P_T3_35 Sch=led[3]
    

    不会有人对着原理图找引脚,一个一个的在VIVADO里面填吧,不会吧不会吧?不会有人不知道digilent上有XDC文件吧,不会吧不会吧?

    4.综合,生成bit,烧录

    在这里插入图片描述
    这没啥好说的,按照上面一个一个来呗,最后连上JTAG直接把bit文件烧进去。
    在这里插入图片描述

    康康最后结果吧~

    额,上传视频好麻烦,放两张照片吧…

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    总结

    这是篇没啥营养的笔记,FPGA大家都会用,我写的也不详细。PYNQ-Z1当成FPGA用就和其他没啥区别,其他FPGA上的也可以放到这上面来做一下好玩的,毕竟他有HDMI输入输出。总之就这样了,之后再尝试尝试SDK和Linux。

    走过路过点个赞QAQ~

    展开全文
  • 2018.9.13 xilinx PYNQ 驱动开发 --以sobel为例

    千次阅读 热门讨论 2019-05-24 23:30:26
    pynq的介绍:https://blog.csdn.net/xiaoqu001/article/details/79479208 pynq官方文档:http://pynq.readthedocs.io/en/latest/python_environment.html pynq github开源项目:https://github.com/xilinx/pynq pynq...

    pynq的介绍:https://blog.csdn.net/xiaoqu001/article/details/79479208
    pynq官方文档:http://pynq.readthedocs.io/en/latest/python_environment.html
    pynq github开源项目:https://github.com/xilinx/pynq
    pynq sobel github 代码:https://github.com/clancylea/pynq-sobel
    文中参考pynq 相关资料 ,使用python编写sobel的驱动部分,如有错误之处还请不吝赐教!
    1.Load overlay and Load sobel IP

    from pynq import Overlay
    overlay = Overlay("/home/xilinx/jupyter_notebooks/sobel/sobel.bit")
    sobel_ip=overlay.sobel_filter_0 
    

    2.使用PIL读取RGB 并转化为矩阵

    from PIL import Image as PIL_Image
    import numpy as np
    
    
    orig_img_path = "/home/xilinx/jupyter_notebooks/sobel/test_1080p.bmp"
    try:
        img = PIL_Image.open(orig_img_path)
        print("Open pictrue success!")
    except IOError:
        print('fail to load image!')
       
    #显示图片及图片信息
    print("pictrue format:",img.format)
    print("pictrue size:",img.size) #注意,省略了通道 (w,h)
    print("pictrue mode:",img.mode)  #L为灰度图,RGB为真彩色,RGBA为加了透明通道
    
    #RGB 通道分离
    img_r,img_g,img_b = img.split()
    #img = PIL_Image.merge("RGB",(r,g,b))
    
    #R,G,B转矩阵
    image_array_r = np.array(img_r,dtype='uint8')
    image_array_g = np.array(img_g,dtype='uint8')
    image_array_b = np.array(img_b,dtype= 'uint8')
    

    3.allocated memory 使用pynq 框架中Xlnk申请内存,存储输入输出图片

    from pynq import Xlnk
    import numpy as np
      
    nrows = 1080
    ncols = 1920
    xlnk = Xlnk()
    #allocated the memory  inbuff
    RGB_IN = xlnk.cma_array(shape=(nrows*ncols,), dtype=np.uint32)
    in_buffer_address=RGB_IN.physical_address
    
    #allocated the memory  outbuff
    RGB_OUT = xlnk.cma_array(shape=(nrows*ncols,), dtype=np.uint32)
    out_buffer_address=RGB_OUT.physical_address
    
    #write the image to memory
    RGB_3D = image_array_r*65536+image_array_g*256+image_array_b
    np.copyto(RGB_IN,RGB_3D.flatten())
    

    4.sobel驱动部分

    from pynq import MMIO
    mmio = MMIO(in_buffer_address,nrows*ncols)
    
    #write data
    byte_framein_offset = 1920
    nrows               = 1080
    ncol                = 1920
    
    
    #address
    IP_BASE_ADDRESS    =  0x43C00000
    ADDRESS_RANGE      =  1000
    #address offset
    ADDR_AP_CRTL       =  0x00
    ADDR_GIE           =  0x04
    ADDR_IER           =  0x08
    ADDR_ISR           =  0x0c
    
    ADDR_ROWS          =  0x24       
    ADDR_COLS          =  0x2c
    ADDR_RDOFFSET       = 0x14
    ADDR_WROFFSET       = 0x1c
    ADDR_FRAMEIN_OFFSET = 0x34
    
    # sobel mapping memory
    def XSOBEL_Init_EX():
        # mapping memory
    
        mmio = MMIO(IP_BASE_ADDRESS,ADDRESS_RANGE)
        mmio.write(ADDR_ROWS,nrows)
        mmio.write(ADDR_COLS,ncol)
        mmio.write(ADDR_RDOFFSET,in_buffer_address)
        mmio.write(ADDR_WROFFSET,out_buffer_address)
        mmio.write(ADDR_FRAMEIN_OFFSET,byte_framein_offset)
        
        print("inbuff_address:",mmio.read(ADDR_RDOFFSET))
        print("out_buffer_address:",mmio.read(ADDR_WROFFSET))
        print("nrows:",mmio.read(ADDR_ROWS))
        print("ncol:",mmio.read(ADDR_COLS))
        print("byte_framein_offse:",mmio.read(ADDR_FRAMEIN_OFFSET))
        
    #Start Or Stop the FPGA IP Core   start = 1; stop = 0;       
    def XSOBEL_StartStop_Ex(state):
        # mapping memory
        mmio = MMIO(IP_BASE_ADDRESS,ADDRESS_RANGE )
        if(state):
            #enable the interrupt
            mmio.write(ADDR_GIE,1)
            mmio.write(ADDR_IER,1)
            
            mmio.write(ADDR_AP_CRTL,0x1)
        else:
            while True:
                ap_done =  (mmio.read(ADDR_AP_CRTL)>>1)&0x01
                if(ap_done):
                    break
                    
            mmio.write(ADDR_GIE,0x0)
            mmio.write(ADDR_IER,0x0)
    

    5.run sobel hardware

    import numpy
    import time
    #Set Control Registers State Or Value
    XSOBEL_Init_EX() 
    time.sleep(3)
    #Start The FPGA IP Core
    start = time.time()
    XSOBEL_StartStop_Ex(1)
    #Stop The FPGA IP Core check Whether The IP Core is End
    XSOBEL_StartStop_Ex(0)
    stop = time.time()
    time_sobel_fpga = stop - start
    print("Sobel FPGA time:",time_sobel_fpga)
    time.sleep(3)
    

    6.read image from memory

    RGB_temp = np.zeros(1080*1920,dtype = np.uint32)
    RGB_temp = RGB_OUT.copy()
    RGB_temp = numpy.array(RGB_temp).reshape(1080,1920)
    
    
    image_array_r = RGB_temp//65536
    image_array_g = RGB_temp//256
    image_array_b = RGB_temp
    
    
    #img = PIL_Image.merge("RGB",(r,g,b))
    image_r = PIL_Image.fromarray(image_array_r.astype('uint8')).convert('RGB')
    image_g = PIL_Image.fromarray(image_array_g.astype('uint8')).convert('RGB')
    image_b = PIL_Image.fromarray(image_array_b.astype('uint8')).convert('RGB')
    
    print("The image via sobel filter!! ",image_b)
    image_r
    

    7.原图 -> sobel filter
    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • pynq的介绍:https://blog.csdn.net/xiaoqu001/article/details/79479208 pynq官方文档:http://pynq.readthedocs.io/en/latest/python_environment.html pynq github开源项目:https://github.com/xilinx/pynq pynq...

    pynq的介绍:https://blog.csdn.net/xiaoqu001/article/details/79479208
    pynq官方文档:http://pynq.readthedocs.io/en/latest/python_environment.html
    pynq github开源项目:https://github.com/xilinx/pynq
    pynq sobel github 代码:https://github.com/clancylea/pynq-sobel
    使用hls编写sobel的硬件加速部分参考ug902,如有错误之处还请不吝赐教!
    1.RGB转Y函数

    unsigned char rgb2y(RGB pix)
    {
    #pragma HLS INLINE
      unsigned char y;
      y = ((66 * pix.R.to_int() + 129 * pix.G.to_int() + 25 * pix.B.to_int() + 128) >> 8) + 16;
    
      return y;
    }
    

    2.sobel 滤波操作函数
    *注意这里edge_weight 可能会溢出,所以要加以判断。

    RGB sobel_operator(WINDOW *window)
    {
      short x_weight = 0;
      short y_weight = 0;
    
      short edge_weight;
      unsigned char edge_val;
      RGB pixel;
    
      char i;
      char j;
    
    
      const char x_op[3][3] = { {-1,0,1},
    			    {-2,0,2},
    			    {-1,0,1}};
    
      const char y_op[3][3] = { {1,2,1},
    			    {0,0,0},
    			    {-1,-2,-1}};
    
      //Compute approximation of the gradients in the X-Y direction
      for(i=0; i < 3; i++){
        for(j = 0; j < 3; j++){
    
          // X direction gradient
          x_weight = x_weight + (window->getval(i,j) * x_op[i][j]);
    
          // Y direction gradient
          y_weight = y_weight + (window->getval(i,j) * y_op[i][j]);
        }
      }
    
      edge_weight = ABS(x_weight) + ABS(y_weight);
    
      if(edge_weight > 255)
      {
    //	printf("edge_weight = %d,uchar = %d\n",edge_weight,(unsigned char)edge_weight);
    	edge_weight = 255;
      }
    
      edge_val = (255-(unsigned char)(edge_weight));
    
      //Edge thresholding
      if(edge_val > 200)
        edge_val = 255;
      else if(edge_val < 100)
        edge_val = 0;
    
      pixel.R = pixel.G = pixel.B = edge_val;
    
      return pixel;
    }
    
    1. load 像素到片上存储
    
    void LoadPixelM2B(PIXEL *inter_pix,PIXEL input_buffer[MAX_WIDTH],int rows,int cols,int row,int row_l2p[1])
    {
    	static int in_offset;
    	static int rows_c;
    	static int cols_c;
    
    	row_l2p[0] = row;
    
    	if(row == 0)
    	{
    		in_offset = 0;
    		rows_c = rows;
    		cols_c = cols;
    	}
    
    	bool enable = row < rows_c;
    
    	if(enable)
    	{
    		memcpy(input_buffer,(PIXEL *)(inter_pix + in_offset),cols_c*sizeof(PIXEL));
    		in_offset += cols_c;
    	}
    }
    
    1. 存储像素到DDR内存
    void StorePixelB2M(PIXEL *out_pix,PIXEL output_buffer[MAX_WIDTH],int cols,int row_p2s[1])
    {
    	static int out_offset;
    	static int cols_c;
    
    	int row = row_p2s[0];
    	if(row == 0){
    		out_offset = 0;
    		cols_c = cols;
    	}
    	bool enable = row > 0;
    	if(enable)
    	{
    		memcpy((PIXEL *)(out_pix + out_offset),output_buffer,cols_c*sizeof(PIXEL));
    		out_offset += cols_c;
    	}
    }
    
    

    5.行缓冲和窗口缓冲处理过程

    
    void Process(PIXEL input_buffer[MAX_WIDTH],PIXEL output_buffer[MAX_WIDTH],int rows,int cols,int row_l2p[1],int row_p2s[1])
    {
    	int col;
    	int in_offset = 0;
    	int out_offset = 0;
    
    	Y_BUFFER buff_A;
    	RGB_BUFFER buff_B;
    	WINDOW buff_C;
    
    
    	int row = row_l2p[0];
    	for(col = 0; col < cols+1; col++){
    #pragma HLS LOOP_TRIPCOUNT min=1920 max=1920
    #pragma HLS DEPENDENCE variable=buff_A inter false
    #pragma HLS PIPELINE II=1
    
    		// Temp values are used to reduce the number of memory reads
    		unsigned char temp;
    //			RGB tempx;
    		unsigned char tmpx_y;
    		unsigned char test_val;
    
    		//Line Buffer fill
    		if(col < cols){
    			buff_A.shift_up(col);
    			temp = buff_A.getval(0,col);
    		}
    
    		//There is an offset to accomodate the active pixel region
    		//There are only MAX_WIDTH and MAX_HEIGHT valid pixels in the image
    		if(col < cols & row < rows){
    			RGB new_pix;
    			PIXEL input_pixel;
    //				input_pixel = inter_pix[row][col];
    			input_pixel = input_buffer[col];
    			new_pix.B = input_pixel.range(7,0);
    			new_pix.G = input_pixel.range(15,8);
    			new_pix.R = input_pixel.range(23,16);
    			tmpx_y = rgb2y(new_pix);
    			buff_A.insert_bottom(tmpx_y,col);
    		}
    
    		//Shift the processing window to make room for the new column
    		buff_C.shift_right();
    
    		//The Sobel processing window only needs to store luminance values
    		//rgb2y function computes the luminance from the color pixel
    		if(col < cols){
    			buff_C.insert(buff_A.getval(2,col),0,2);
    			buff_C.insert(temp,1,2);
    			buff_C.insert(tmpx_y,2,2);
    		}
    		RGB edge;
    
    		//The sobel operator only works on the inner part of the image
    		//This design assumes there are no edges on the boundary of the image
    		if( row <= 1 || col <= 1 || row > (rows-1) || col > (cols-1)){
    			edge.R = edge.G = edge.B = 0;
    		}
    		else{
    		//Sobel operation on the inner portion of the image
    			edge = sobel_operator(&buff_C);
    		}
    
    		//The output image is offset from the input to account for the line buffer
    		if(row > 0 && col > 0){
    			PIXEL output_pixel;
    			ap_uint<8> padding = 0xff;
    			output_pixel = (edge.R,edge.G);
    			output_pixel = (output_pixel, edge.B);
    			output_pixel = (padding,output_pixel);
    //				out_pix[row-1][col-1] = output_pixel;
    //				out_pix[(row-1)*cols + (col-1)] = output_pixel;
    			output_buffer[col-1] = output_pixel;
    		}
    	}
    
    	row_p2s[0] = row;
    }
    
    1. top 函数 使用Axi master接口和axilite接口,以及dataflow
    
    void sobel_filter(PIXEL *inter_pix,PIXEL *out_pix, int rows, int cols)
    {
    #pragma HLS INTERFACE m_axi depth=2073600 port=inter_pix offset=slave bundle=DATA_IN
    #pragma HLS INTERFACE m_axi depth=2073600 port=out_pix offset=slave bundle=DATA_OUT
    
    #pragma HLS INTERFACE s_axilite register port=return bundle=CTRL_BUS
    #pragma HLS INTERFACE s_axilite register port=inter_pix bundle=CTRL_BUS
    #pragma HLS INTERFACE s_axilite register port=out_pix bundle=CTRL_BUS
    #pragma HLS INTERFACE s_axilite register port=rows bundle=CTRL_BUS
    #pragma HLS INTERFACE s_axilite register port=cols bundle=CTRL_BUS
    
    	PIXEL input_buffer[MAX_WIDTH];
    	PIXEL output_buffer[MAX_WIDTH];
    
    	int row;
    	int row_l2p[1];
    	int row_p2s[1];
    	for(row = 0; row < rows+1; row++){
    #pragma HLS LOOP_TRIPCOUNT min=1080 max=1080
    #pragma HLS DATAFLOW
    		LoadPixelM2B(inter_pix, input_buffer, rows, cols, row, row_l2p);
    
    		Process(input_buffer, output_buffer, rows, cols, row_l2p, row_p2s);
    
    		StorePixelB2M(out_pix, output_buffer, cols, row_p2s);
    	}
    }
    
    
    展开全文
  • 在进行开发之前先看看官方文档,感性的了解一下基本知识...首先找准自己的开发需要的资源方向:FPGA,Arduino,,,, 常规步骤: --------为相关应用创建FPGA设计 --------导出bit流文件对C、API进行编程...

    在进行开发之前先看看官方文档,感性的了解一下基本知识https://pynq.readthedocs.io/en/latest/pynq_package/pynq.lib/pynq.lib.arduino.html

    首先找准自己的开发需要的资源方向:FPGA,Arduino,,,,

    常规步骤:

    --------为相关应用创建FPGA设计

    --------导出bit流文件对C、API进行编程

    --------包装C、API以创建python库

    ------- 在Jupyter Notebook中导入比特流和库进行编写

    1.利用自带库(library)进行开发https://pynq.readthedocs.io/en/latest/pynq_package/pynq.lib/pynq.lib.arduino.html

    根据官方定义好的库进行开发(传参和调用函数) --- python编写:

    因为我经过一层层的查找官方库,发现arduino中的库都是microblaze库的子库,,就不需要我们费什么事了

    实例(MQ2烟雾传感器数值读取):相关库自行搜索链接进行查看  --- 包含传参类型,以及函数功能都需要注意

    from pynq.overlays.base import BaseOverlay
    base = BaseOverlay("base.bit")

    from pynq.lib.arduino import Arduino_Analog
    from pynq.lib.arduino import ARDUINO_GROVE_A1

    # 主类传参:
    analog1 = Arduino_Analog(base.ARDUINO,ARDUINO_GROVE_A1)

    # 函数传入数值:他包含通道0和通道1两个通道
    analog1.read()
    analog1.read_raw()[0]
    # 每隔多久读取一次:
    from time import sleep
    analog1.set_log_interval_ms(100)
    analog1.start_log()
    analog1.get_log()

    2.自己开发库(包含tcl和bit流文件),然后通过python引入即可

    先利用vivado开发,再进行python调用,具体参考枫雪天帖子:http://bbs.elecfans.com/jishu_1737834_1_1.html

    python引入方式自我对比:

    from pynq.overlays.base import BaseOverlay
    base = BaseOverlay("base.bit")

    展开全文
  • PYNQ开发中遇到问题(无法访问问题) 使用samba文件共享时,在资源管理器里输入\\pynq后会显示网络中共享图标, 但是双击后显示windows无法访问\PYNQ。 错误代码:“0x80070035” 找不到网络路径。 解决办法...
  • PYNQ-关于PYNQ的UART的使用(RPI接口)

    千次阅读 2019-10-25 21:32:05
    PYNQ是赛灵思开发的一个面向创客的板子,其实仔细查下官方的文档操作还是...PYNQ的串口使用 开发环境 PYNQ 这里我用的是2.3的官方镜像,jupyter-Notebook 官方文档参考 [https://pynq.readthedocs.io/en/latest/pyn...
  • 将一个完成的FPGA工程转换为PYNQ第三方包会方便我们进行PYNQ的开发。这个过程主要包括两个步骤:1.通过已经在PYNQ里的APIs对FPGA部分进行驱动的编写。2.将编写好的驱动做成Python库并且进行打包分...
  • 但是我完全不知道怎么用,该如何训练,有没有了解pynq或者做过相关案例技术大佬教一下我该怎么做,主要是教导我做,很急。![图片说明](https://img-ask.csdn.net/upload/202005/13/1589364232_560374.png)
  • 参加竞赛的缘故需要使用到Xilinx的PYNQ-Z2,但网上搜到的开发环境配置教程都是Windows下的,对于Mac用户不是很友好,虽然好像搞硬件开发对Mac一直都不太友好 (T_T) 。
  • PYNQ上手笔记 | ②PL端和PS端独立开发

    千次阅读 热门讨论 2018-10-12 22:55:03
    Zynq中PL端的开发和FPGA芯片的开发流程完全一样,需要注意的一点是,PL端的配置需要PS端配置,所以在这里我们只能使用JTAG方式下载测试程序,并且需要将Pynq-Z2开发板的启动方式切换为JTAG方式:将右上角的BOOT选择...
  • PYNQ常见问题

    2019-10-11 19:18:28
    PYNQ是Python On Zynq缩写,它是一个软件开发框架,指导硬件层、驱动层和应用层之间接口设计,不是ISE、Vivado、SDSoC这样IDE工具,更不是Zynq芯片下一代芯片产品。 PYNQ框架设计初衷是通过高层次封装...
  • PYNQ简介 ...PYNQ的优势是减少了RTL级别开发的难度,使得现在主流Pyhton可以加入到硬件开发这一领域中,并且大量的python库函数可以方便使用。简单来说使用PYNQ会减少开发周期,大大提高ZYNQ开发速度
  • 前言 本教程分两个部分 介绍使用官方镜像文件,使用Python进行开发的一个简单小例子,并且简单了解底层是如何运作...一、使用Python开发Pynq的简单介绍 概述 本节使用了Pynq官方镜像v2.5,基于Ubuntu 18.04,Linux...
  • pynq-z2 HLS开发

    千次阅读 2018-11-23 21:20:21
    用HLS生成一个定制IP功啊啊是合理创建标题,有助于目录生成如何改变是式插入链接与图片如何插入一段漂亮代码片生成一个适合你列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何...
  • PYNQ:使用python进行FPGA开发

    千次阅读 2019-02-22 12:33:57
    PYNQ 就是python+ZYNQ意思,简单来说就是使用python在Xilinx ZYNQ平台上进行开发。是Xilinx开发的一个新开源框架,使嵌入式编程人员能够在无需设计可编程逻辑电路情况下即可充分发挥 Xilinx Zynq All ...
  • PYNQ概述

    2021-02-15 10:44:32
    可以说 PYNQ 开发是 ZYNQ 开发的集大成,也可以说 PYNQ 是 ZYNQ 全栈式开发,里面涉及到内容不仅包括 FPGA 设计、 PS 与 PL 协同交互、 HLS、 linux 驱动开发,而且还要熟悉 Python开发并练使用 P.
  • PYNQ的串口使用拓展 GPIO的配置 类比配置别的IO功能 开发环境 PYNQ 这里我用的是2.3的官方镜像,jupyter-Notebook 官方文档参考 [https://pynq.readthedocs.io/en/latest/pynq_libraries.html#pynqmicroblaze] 1....
  • pynq z2系列PL和PS开发

    千次阅读 2018-12-01 10:55:30
    pynq上通过PS+PL实现软硬件联合开发 一 实验目标 1. 点亮开发板下面三个灯 2. 在SDK中输出“Hello Word” 二 实验步骤 1.PL端 启动Vivado,点击创建一个新工程,工程名为pynq_led 选择RTL工程 选择开发板...
  • PYNQ板卡

    千次阅读 2019-02-27 20:02:37
    看了PYNQ的相关资料,对PYNQ板卡有了一些自己的看法和观点,1、先说核心芯片。 PYNQ开发板的核心芯片是赛灵思公司的ZYNQ7020,该芯片由2个部分构成——PS和PL, 上图为ZYNQ的系统结构图,通俗的理解是PS是...
  • PYNQ基础

    2020-07-13 00:24:35
    PYNQ能够和Zynq, Zynq UltraScale+, Zynq RFSoC, Alveo, AWS-F1一起使用,来开发各种高性能应用。例如: 并行运算 高速图像处理 硬件加速算法 实时信号处理 高速通信 低延迟控制 基于Jupyter Notebo
  • 第一天:基于PYNQ开发板SOC软件开发 第二天:基于FPGASOC软硬件开发流程(一) 第三天:基于FPGASOC软硬件开发流程(二) 第四天:基于高层次综合硬件设计(一) 第五天:基于高层次综合硬件设计(二) 第六天...
  • PL 当做FPGA,流水灯 PS 独立运行PS端,通过USB线连接UART0串口()输出“Hello, world! ” https://blog.csdn.net/weixin_38438451/article/details/83688319
  • 的pynq-z2入门历程

    2021-03-14 12:38:29
    pynq-z2入门 文章目录0.pynq架构介绍1.下载pynq-z2镜像2.镜像烧录3.将pc端IP地址改为192.168.2.1004.开发板跳线帽连接5....以下参考PYNQ:使用python进行FPGA开发 ZYNQ 分为PS和PL两个部分,PS有
  • 一文认识PYNQ

    2021-03-06 07:58:25
    在使用上,可以说 PYNQ 开发是 ZYNQ 开发的集大成,也可以说 PYNQ 是 ZYNQ 全栈式开发,里面涉及到内容不仅包括 FPGA 设计、PS 与 PL 协同交互、HLS、linux 驱动开发,而且还要熟悉 Python开发并且使用 Python...
  • (2)PYNQ:使用python进行FPGA开发

    千次阅读 2019-06-20 22:39:54
    PYNQ 就是python+ZYNQ意思,简单来说就是使用python在Xilinx ZYNQ平台上进行开发。是Xilinx开发的一个新开源框架,使嵌入式编程人员能够在无需设计可编程逻辑电路情况下即可充分发挥 Xilinx Zynq All ...
  • PYNQ希望能够借助Python语言本身易用易学、扩展库多而全、社区活跃贡献度高等特性,有效降低Zynq嵌入式系统的开发门槛,并为人工智能,ADAS,机器视觉等高拓展性/高复杂度应用需求提供更好支撑。PYNQ将ARM处理器与FPGA...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 127
精华内容 50
关键字:

pynq的开发