Welcome to Pynq Eclypse-Z7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Welcome to PYNQ\n",
    "\n",
    "## Getting Started\n",
    "\n",
    "To get started using PYNQ, try running the example notebooks in the folders described below. \n",
    "\n",
    "* **getting_started**: includes an introduction to using Jupyter notebook with PYNQ, the Python environment, and how to use some basic features of the current platform. \n",
    "\n",
    "* **common**: contains example notebooks on how to download an overlay, how to set the Zynq clocks, how to execute Linux shell commands, and how to use USB devices.\n",
    "\n",
    "If other overlays or packages are installed, other folders with example notebooks may also be available in this directory.  \n",
    "\n",
    "\n",
    "## Documentation\n",
    "\n",
    "Please see the latest <a href=\"http://pynq.readthedocs.io\">PYNQ Documentation on readthedocs</a>.  \n",
    "\n",
    "\n",
    "## Support\n",
    "\n",
    "For questions or support, go to the forum on the <a href=\"http://www.pynq.io\">PYNQ project webpage </a>.\n",
    "\n",
    "\n",
    "## Project webpage\n",
    "\n",
    "You can find details on the <a href=\"http://www.pynq.io\">PYNQ project webpage </a>.\n",
    "\n",
    "\n",
    "## GitHub\n",
    "\n",
    "The PYNQ Repository is hosted on github: <a href=\"https://github.com/Xilinx/PYNQ\">PYNQ GitHub Repository</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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"
    }
   ],
   "source": [
    "#Import PYNQ and its basic functions\n",
    "import pynq\n",
    "from pynq import Overlay\n",
    "from pynq import allocate\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Welcome to Pynq Eclypse-Z7.ipynb',\n",
       " '.ipynb_checkpoints',\n",
       " 'design_1.hwh',\n",
       " 'design_1_adv.hwh',\n",
       " 'design_1_adv.bit',\n",
       " 'getting_started',\n",
       " 'common',\n",
       " 'design_1.bit']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Os is really great is you don't know where to find bitstreams\n",
    "os.listdir(\"/home/xilinx/jupyter_notebooks/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['axi_dma_0', 'axi_gpio_0', 'axi_intc_0', 'mult_constant_0', 'add_0'])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Create some overlay from design_1.bit and design_1.hwh ()\n",
    "ol = Overlay(\"/home/xilinx/jupyter_notebooks/design_1.bit\")\n",
    "#List key IP'cores for example axi_dma, axi_gpio etc.\n",
    "ol.ip_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can always assign those IP's to variables for easier acces\n",
    "add = ol.add_0\n",
    "mult_constant = ol.mult_constant_0\n",
    "dma = ol.axi_dma_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RegisterMap {\n",
      "  a = Register(a=0),\n",
      "  b = Register(b=0),\n",
      "  c = Register(c=0),\n",
      "  c_ctrl = Register(c_ap_vld=1, RESERVED=0)\n",
      "}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Register(c=7)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Add IP will add two int numbers\n",
    "print(add.register_map)\n",
    "add.register_map.a = 3\n",
    "add.register_map.b = 4\n",
    "add.register_map.c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RegisterMap {\n",
      "  constant_V = Register(constant_V=0)\n",
      "}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PynqBuffer([ 0,  3,  6,  9, 12], dtype=uint32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#mult_constant IP will multiply in_buffer with constant_V variable\n",
    "print(mult_constant.register_map)\n",
    "in_buffer = allocate(shape=(5,), dtype=np.uint32)\n",
    "out_buffer = allocate(shape=(5,), dtype=np.uint32)\n",
    "\n",
    "for i in range(5):\n",
    "    in_buffer[i] = i\n",
    "\n",
    "mult_constant.register_map.constant_V = 3\n",
    "dma.sendchannel.transfer(in_buffer)\n",
    "dma.recvchannel.transfer(out_buffer)\n",
    "dma.sendchannel.wait()\n",
    "dma.recvchannel.wait()\n",
    "\n",
    "out_buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Axi_gpio0 test, this doesn't work because of wrong pin's assignments in board\n",
    "buttons = ol.axi_gpio_0.channel1\n",
    "leds = ol.axi_gpio_0.channel2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "leds.write(mask=0xFFFF, val=0x1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#But as you can see IP core is working \n",
    "leds.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['axi_dma_mult_constant', 'axi_gpio_0', 'axi_intc_0', 'mult_constant_0', 'add_0', 'addfloat_0'])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's load another bitstream, This bitstream has addfloat IP core\n",
    "#it works just like add in previous example but this time on floats\n",
    "ol_adv = Overlay(\"/home/xilinx/jupyter_notebooks/design_1_adv.bit\")\n",
    "ol_adv.ip_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This will turn off board leds\n",
    "mask = 0xffffff\n",
    "ol_adv.axi_gpio_0.channel2.write(0x0, mask)\n",
    "addfloat = ol_adv.addfloat_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's create translate functions that will turn float values into uint32\n",
    "import struct\n",
    "def float_to_uint(f):\n",
    "    return int(struct.unpack('<I', struct.pack('<f', f))[0])\n",
    "def uint_to_float(f):\n",
    "    return float(struct.unpack('<f', struct.pack('<I', f))[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Assign values\n",
    "a = np.float32(-1.5)\n",
    "b = np.float32(1.25)\n",
    "aint = float_to_uint(a)\n",
    "bint = float_to_uint(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.25\n"
     ]
    }
   ],
   "source": [
    "addfloat.register_map.a = aint \n",
    "addfloat.register_map.b = bint\n",
    "cint = addfloat.register_map.c\n",
    "\n",
    "print(uint_to_float(cint))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#All IP's sources are located in github https://github.com/bartokon/Eclypse-Z7-Notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": 1
}