axi-graphics-vdma/axi_graphics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found bit file!\n",
      "Bitfile downloaded!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import warnings\n",
    "import time\n",
    "from pynq import PL\n",
    "from pynq import Overlay\n",
    "\n",
    "BF = os.path.join(\"./data/system_wrapper.bit\")\n",
    "\n",
    "# Download the bitfile\n",
    "\n",
    "if not os.path.exists(BF):\n",
    "    print (\"%s Doesn't exist!\" % BF)\n",
    "else:\n",
    "    print (\"Found bit file!\")\n",
    "    \n",
    "    ol = Overlay(BF)\n",
    "    ol.download()\n",
    "\n",
    "    print (\"Bitfile downloaded!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize Cores\n",
      "Configure Test Pattern\n",
      "Configure AXI VDMA\n",
      "Configuring Video Mixer\n",
      "Initialize AXI Graphics Enable\n",
      "Color Bars should be on HDMI Display\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import os,sys,inspect\n",
    "import argparse\n",
    "import warnings\n",
    "import time\n",
    "from pynq import PL\n",
    "from pynq import Overlay\n",
    "from pynq.lib.video import *\n",
    "from pynq.lib.video.hierarchies import *\n",
    "\n",
    "currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))\n",
    "parentdir = os.path.dirname(currentdir)\n",
    "sys.path.insert(0,parentdir) \n",
    "\n",
    "from drivers.video_mixer import VideoMixer\n",
    "from drivers.dynamic_clock import DynamicClock\n",
    "from drivers.timing_controller import TimingController\n",
    "from drivers.test_pattern_generator import TestPatternGenerator\n",
    "from drivers.test_pattern_generator import TestPatternID\n",
    "from drivers.axi_graphics import AXIGraphics\n",
    "from drivers.axi_stream_interconnect import AXISInterconnect\n",
    "from PIL import Image\n",
    "\n",
    "DEBUG   = False\n",
    "ENABLE_VDMA_WRITE = False\n",
    "ENABLE_VDMA_READ = False\n",
    "\n",
    "# Instantiate All Cores\n",
    "print (\"Initialize Cores\")\n",
    "ai = AXISInterconnect(\"video/axis_interconnect_0/xbar\")\n",
    "tc = TimingController(\"video/timing_generator\")\n",
    "tpg = TestPatternGenerator(\"video/v_tpg_0\")\n",
    "#vdma_h2c = AxiVDMA(ol.ip_dict[\"video/axi_vdma_h2c\"])\n",
    "#vdma_c2h = AxiVDMA(ol.ip_dict[\"video/axi_vdma_c2h\"])\n",
    "ag = AXIGraphics(\"video/axi_graphics_0\")\n",
    "g0 = ol.low_speed.axi_gpio_0\n",
    "\n",
    "tc.reset()\n",
    "while (not tc.is_reset_done()):\n",
    "    print (\".\")\n",
    "\n",
    "WIDTH   = tc.get_generator_width()\n",
    "HEIGHT  = tc.get_generator_height()\n",
    "\n",
    "vm = VideoMixer(\"video/v_mix_0\", WIDTH, HEIGHT)\n",
    "\n",
    "# Configure Sub Window\n",
    "\n",
    "#SUB_WIN_WIDTH = 1920\n",
    "#SUB_WIN_HEIGHT = 1080\n",
    "SUB_WIN_WIDTH = 640\n",
    "SUB_WIN_HEIGHT = 480\n",
    "#SUB_WIN_WIDTH = 16\n",
    "#SUB_WIN_HEIGHT = 4\n",
    "#SUB_WIN_WIDTH = WIDTH\n",
    "#SUB_WIN_HEIGHT = HEIGHT\n",
    "\n",
    "# Configure AXI Stream Routes\n",
    "ai.set_route(0, 0)  # From VMIX To output screen\n",
    "\n",
    "# Test Pattern\n",
    "print (\"Configure Test Pattern\")\n",
    "tpg.set_image_size(WIDTH, HEIGHT)\n",
    "tpg.set_color_format_to_rgb()\n",
    "#tpg.set_color_bar_test_pattern()\n",
    "#tpg.set_test_pattern(TestPatternID.SOLID_RED)\n",
    "#tpg.set_test_pattern(TestPatternID.SOLID_WHITE)\n",
    "tpg.set_test_pattern(TestPatternID.SOLID_BLACK)\n",
    "#tpg.set_test_pattern(TestPatternID.COLOR_BARS)\n",
    "tpg.start()\n",
    "\n",
    "\n",
    "# Configure VDMA\n",
    "print (\"Configure AXI VDMA\")\n",
    "mode = VideoMode(SUB_WIN_WIDTH, SUB_WIN_HEIGHT, 24)\n",
    "vdma_h2c = AxiVDMA(ol.ip_dict[\"video/axi_vdma_h2c\"])\n",
    "vdma_h2c.writechannel.mode = VideoMode(SUB_WIN_WIDTH, SUB_WIN_HEIGHT, 24)\n",
    "vdma_h2c.writechannel.parked = True\n",
    "vdma_h2c.writechannel.start()\n",
    "\n",
    "#vdma_c2h = AxiVDMA(ol.ip_dict[\"video/axi_vdma_c2h\"])\n",
    "#vdma_c2h.readchannel.reset()\n",
    "\n",
    "# Configure Video Mixer\n",
    "print (\"Configuring Video Mixer\")\n",
    "vm = VideoMixer(\"video/v_mix_0\", WIDTH, HEIGHT)\n",
    "vm.configure_layer(1, 0,                        0, SUB_WIN_WIDTH, SUB_WIN_HEIGHT)\n",
    "vm.enable_layer(1, True)\n",
    "vm.configure_master_layer(WIDTH, HEIGHT)\n",
    "vm.start()\n",
    "vm.enable_master_layer(True)\n",
    "\n",
    "# GPIO\n",
    "g0.write(0x0C, 0x01)\n",
    "\n",
    "# Enable Timing Control\n",
    "tc.enable(gen_enable = True, use_gen_src = True)\n",
    "\n",
    "# AXI Graphics\n",
    "print (\"Initialize AXI Graphics Enable\")\n",
    "ag.set_width(SUB_WIN_WIDTH)\n",
    "ag.set_height(SUB_WIN_HEIGHT)\n",
    "#ag.set_mode(0)  # Black\n",
    "#ag.set_mode(1)  # White\n",
    "#ag.set_mode(2)  # Red\n",
    "#ag.set_mode(3)  # Green\n",
    "#ag.set_mode(4)  # Blue\n",
    "ag.set_mode(5)  # Color Bars\n",
    "#ag.set_mode(6)  # Block\n",
    "#ag.set_mode(7)  # Ramp\n",
    "ag.set_alpha(0xFF)\n",
    "ag.set_ref0_xy(100, 100)\n",
    "ag.set_ref1_xy(200, 200)\n",
    "ag.set_interval(100)\n",
    "ag.enable_rgba_format(True)\n",
    "#ag.enable_rgba_format(False)\n",
    "ag.enable(True)\n",
    "\n",
    "print (\"Color Bars should be on HDMI Display\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Configure AXI Graphics\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ebe03a5e88f430c8f68fdbd154e1981",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Dropdown(description='Mode', index=5, options=(('Black Image', 0), ('White Image', 1), ('Red Im…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print (\"Configure AXI Graphics\")\n",
    "from IPython.display import display, Markdown, clear_output\n",
    "import ipywidgets as widgets\n",
    "\n",
    "out = widgets.Output()\n",
    "#ag.set_alpha(0xFF)\n",
    "#ag.set_ref0_xy(100, 100)\n",
    "#ag.set_ref1_xy(200, 200)\n",
    "#ag.enable(True)\n",
    "\n",
    "g_dropdown = widgets.Dropdown(\n",
    "    options = [   (\"Black Image\", 0),\n",
    "                  (\"White Image\", 1),\n",
    "                  (\"Red Image\",   2),\n",
    "                  (\"Green Image\", 3),\n",
    "                  (\"Blue Image\",  4),\n",
    "                  (\"Color Bars\",  5),\n",
    "                  (\"Block\",       6),\n",
    "                  (\"Ramp\",        7)],\n",
    "    value = 5,\n",
    "    description = \"Mode\")\n",
    "\n",
    "def mode_change_event(change_event):\n",
    "    global g_dropdown\n",
    "    if change_event['type'] == 'change' and change_event['name'] == 'value':\n",
    "        ag.set_mode(g_dropdown.value)\n",
    "    \n",
    "g_dropdown.observe(mode_change_event)\n",
    "\n",
    "widgets.VBox([g_dropdown,out])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enable VDMA Notebook to FPGA\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fdb67680bcd649818bd9ddb844d245d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(Button(description='Send Red Frame', style=ButtonStyle()), Button(description='S…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print (\"Enable VDMA Notebook to FPGA\")\n",
    "\n",
    "from IPython.display import display, Markdown, clear_output\n",
    "import ipywidgets as widgets\n",
    "from matplotlib.pyplot import imshow\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "mode = VideoMode(SUB_WIN_WIDTH, SUB_WIN_HEIGHT, 24)\n",
    "vdma_h2c = AxiVDMA(ol.ip_dict[\"video/axi_vdma_h2c\"])\n",
    "vdma_h2c.writechannel.mode = VideoMode(SUB_WIN_WIDTH, SUB_WIN_HEIGHT, 24)\n",
    "vdma_h2c.writechannel.reset()\n",
    "vdma_h2c.writechannel.parked = True\n",
    "vdma_h2c.writechannel.start()\n",
    "\n",
    "# Configure the Video Mixer Channel\n",
    "vm.configure_layer(2, SUB_WIN_WIDTH,            0, SUB_WIN_WIDTH, SUB_WIN_HEIGHT)\n",
    "vm.enable_layer(2, True)\n",
    "\n",
    "send_red_button = widgets.Button(description='Send Red Frame')\n",
    "send_art_button = widgets.Button(description='Send Art')\n",
    "out = widgets.Output()\n",
    "\n",
    "def send_red_button_clicked(_):\n",
    "    with out:\n",
    "        print (\"Send a Red Frame through VDMA\")\n",
    "        write_frame = vdma_h2c.writechannel.newframe()\n",
    "        for y in range(write_frame.shape[0]):\n",
    "            for x in range(write_frame.shape[1]):\n",
    "                write_frame[y, x, 0] = 0xFF\n",
    "                write_frame[y, x, 1] = 0x00\n",
    "                write_frame[y, x, 2] = 0x00\n",
    "        vdma_h2c.writechannel.writeframe(write_frame)\n",
    "\n",
    "def send_art_button_clicked(_):\n",
    "    with out:\n",
    "        print (\"Send Art Frame through VDMA\")\n",
    "        pil_im = Image.open('art.png', 'r')\n",
    "        write_frame = vdma_h2c.writechannel.newframe()\n",
    "        write_frame[:] = np.asarray(pil_im)\n",
    "        vdma_h2c.writechannel.writeframe(write_frame)\n",
    "\n",
    "send_red_button.on_click(send_red_button_clicked)\n",
    "send_art_button.on_click(send_art_button_clicked)\n",
    "\n",
    "widgets_view = widgets.HBox([send_red_button, send_art_button])\n",
    "widgets.VBox([widgets_view,out])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Capture a frame using VDMA Read\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e1a6a74b788499badb1daeda31fcf62",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Button(description='Capture Image', style=ButtonStyle()), Output()))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xae9c9cf0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xad9d4bb0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xad61ef50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print (\"Capture a frame using VDMA Read\")\n",
    "from IPython.display import display, Markdown, clear_output\n",
    "import ipywidgets as widgets\n",
    "from matplotlib.pyplot import imshow\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "button = widgets.Button(description='Capture Image')\n",
    "out = widgets.Output()\n",
    "def on_button_clicked(_):\n",
    "    # \"linking function with output\"\n",
    "    with out:\n",
    "        # what happens when we press the button\n",
    "        #clear_output()\n",
    "        print (\"Change the route of the AXI Stream Interconnect to route video from the Video Mixer to the Capture VDMA\")\n",
    "        ai.disable_all_routes()\n",
    "        ai.set_route(0, 1)  # From VMIX To Capture VDMA\n",
    "        vdma_c2h = AxiVDMA(ol.ip_dict[\"video/axi_vdma_c2h\"])\n",
    "        vdma_c2h.readchannel.reset()\n",
    "        vdma_c2h.readchannel.mode = VideoMode(WIDTH, HEIGHT, 24)\n",
    "        vdma_c2h.readchannel.start()\n",
    "        frame = vdma_c2h.readchannel.readframe()\n",
    "        vdma_c2h.readchannel.stop()\n",
    "        print (\"Change the route of the AXI Stream Interconnect to route video from the Video Mixer to the HDMI\")\n",
    "        ai.disable_all_routes()\n",
    "        ai.set_route(0, 0)  # From VMIX To output screen\n",
    "        im = Image.fromarray(frame)\n",
    "        imshow(im)\n",
    "            \n",
    "# linking button and function together using a button's method\n",
    "button.on_click(on_button_clicked)\n",
    "# displaying button and its output together\n",
    "widgets.VBox([button,out])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}