{ "cells": [ { "cell_type": "markdown", "id": "584d6710", "metadata": { "kernel": "SoS", "nbgrader": { "grade": false, "grade_id": "cell-c562f6cc6e2ccb9e", "locked": true, "schema_version": 3, "solution": false, "task": false }, "tags": [] }, "source": [ "# ALPACA Kernel & Updated ALPACA Firmware\n", "#### `matplotlib`, `numpy`, and live plotting\n", "\n", "This notebook outlines two new tools at your disposal for doing the final assignment:\n", "- New Jupyter Notebook Kernel: *The Alpaca Kernel*\n", "- Updated *Alpaca Firmware*\n", "\n", "After installing both tools, you'll be able to do the following things:\n", "\n", "## Features:\n", "\n", "### 1. Plotting data directly from the Alpaca\n", "**Before**, plotting data was done like so:\n", "```python\n", "%use micropython\n", "pico.store_data(\"general_data.txt\", samples=[xx, yy])\n", "\n", "%use micropython\n", "%fetchfile --binary \"general_data.txt\" \"data_picopiX.txt\"\n", "\n", "%use python3\n", "samples=np.loadtxt(\"data_picopiX.txt\")\n", "xx, yy = (samples[0,:], samples[1,:])\n", "plt.plot(xx, yy)\n", "```\n", "\n", "**Now**, plotting can be done *directly* from MicroPython **(NEW!)**:\n", "```python\n", "%use micropython\n", "plt.plot(xx,yy)\n", "```\n", "------------------\n", "\n", "### 2. Using `numpy` directly from the Alpaca\n", "**Before**, numpy wasn't available for MicroPython. This meant that lists had to be modified using `for` loops (slow and ugly):\n", "```python\n", "%use micropython\n", "my_list = [1, 2, 3]\n", "\n", "for ii in range(len(my_list)):\n", " my_list[ii] = my_list[ii] * 3\n", "\n", "print(my_list)\n", "[3, 6, 9]\n", "```\n", "\n", "**Now**, `numpy` can be used *directly* from MicroPython **(NEW!)**:\n", "```python\n", "%use micropython\n", "import numpy as np\n", "my_array = np.array(my_list)\n", "my_array * 3\n", "\n", "print(my_array)\n", "array([3.0, 6.0, 9.0], dtype=float32)\n", "```\n", "------------------\n", "\n", "### 3. Live plotting\n", " **(NEW!)** Plot data as it comes in rather than after your measurement. This might be useful if you are performing a very long measurement and want to check if everthing is going alright.\n", "\n", "\n", "
\n", "\n", "
\n", "\n", "___________\n", "\n", "### Installing the kernel\n", "For now, the best way to install the ALPACA kernel is via the Anaconda Prompt:\n", "- Shut down Jupyter Notebook\n", "- `activate nb2211-2021`\n", "- `conda install -c twh alpaca_kernel`\n", "- `python -m alpaca_kernel.install`\n", "\n", "> ℹ️\n", ">\n", "> During the installation, the command line will give the following\n", "prompt:\n", ">\n", "> `Proceed ([y]/n)?`\n", ">\n", "> Press `Y` , then press `Enter`.\n", "\n", "---------------\n", "### Installing the firmware\n", "The newest version of the ALPACA Firmware can be downloaded from [Brightspace](https://brightspace.tudelft.nl/d2l/le/content/401270/viewContent/2486660/View). The installation instructions are also available [here](https://brightspace.tudelft.nl/d2l/le/content/401270/viewContent/2486663/View).\n", "\n", "- Unplug all the cables going to the ALPACA\n", "- Download `Alpaca_firmware.uf2` from Brightspace.\n", "- Push and hold the BOOTSEL button and plug your ALPACA into the USB port of your PC. Release the BOOTSEL button only after your Alpaca is connected.\n", "- It will mount as a Mass Storage Device called RPI-RP2.\n", "- Drag and drop the Alpaca firmware.uf2 file onto the RPI-RP2 volume. Your ALPACA will reboot. \n", "\n", "> ℹ️\n", ">\n", "> Make sure both USB cables are disconnected prior to re-connecting the ALPACA" ] }, { "cell_type": "markdown", "id": "acb5aa07", "metadata": {}, "source": [ "## Feature 0: MicroPython Bypass" ] }, { "cell_type": "code", "execution_count": 1, "id": "bd9e57d3", "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%python\n", "from IPython.lib.display import YouTubeVideo\n", "YouTubeVideo('4O4Qf2TgXwU', width = 600, height = 450)" ] }, { "cell_type": "code", "execution_count": 2, "id": "33e74974", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "adedd744fe764e91b553fbae300c3f44", "version_major": 2, "version_minor": 0 }, "text/plain": [ "FileUpload(value=(), accept='image/', description='Upload')" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%python\n", "from ipywidgets import FileUpload\n", "from IPython.display import Image\n", "import os\n", "\n", "upload=FileUpload(accept='image/', multiple=False )\n", "upload" ] }, { "cell_type": "code", "execution_count": 3, "id": "b94fde84", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAACWCAMAAACsAjcrAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAllBMVEXAwMCWlkPAwAAGq6cAwMAEnWYAwACOE47AAMCsA5DAAAAoBXMAAMAICHYTExOoA6iPBY8Fj48DqKh2dnYEFVoHGEgJGi8uOUWJiYmuha60hLRwLIBNBGlBBl0iCT4WEhkMUVEJaWkLV1cODg4REREYGBg8PDxpaWkAIUxNXnT///9RNHEyAGoXEB8JCQkPDw8UFBQdHR2i85PuAAAAAWJLR0QqU77UngAAAAd0SU1FB+YHGhMNNAs3rgUAAAEFSURBVHja7dDLTgJBEEDRUUR5CSqKvBRUUBEV/P+fI4E0mQVTvXVx7rI7ldSpogg6Ow+qXVRXvwy6alTXbAW1O0EFCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICEgWEn1ed4N6wT430eBtcIG7aLAfXh0EBAQEBAQE5B9C7oMeBvseh6cajctNpuWenk81O+wzf6nu9S21OO6/TL1/BBWf+VZf+dbf+X662Ra/qU162v6lltEkCAgICAgICAgICAgICAgICAgICAgICAgICAgISLkdKR33WzNDvWIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMjItMDctMjZUMTk6MTM6NTIrMDA6MDAAA00KAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDIyLTA3LTI2VDE5OjEzOjUyKzAwOjAwcV71tgAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, "execution_count": 3, "metadata": { "image/png": { "width": "50%" } }, "output_type": "execute_result" } ], "source": [ "%python\n", "file_name=\"test_card.png\"\n", "if upload.value:\n", " with open(file_name,\"wb\") as f:\n", " f.write(upload.value[-1][\"content\"]) # python 3.8 Kernel code, change kernel in Vocareum!\n", "Image(filename=file_name, width=\"50%\")" ] }, { "cell_type": "code", "execution_count": 4, "id": "9e66cd9b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[31mNo serial connected\n", "\u001b[0m %serialconnect to connect\n", " %esptool to flash the device\n", " %lsmagic to list commands" ] } ], "source": [ "print(\"Test\")" ] }, { "cell_type": "markdown", "id": "93452a51", "metadata": { "kernel": "SoS" }, "source": [ "## Feature 1: `numpy` built-in" ] }, { "cell_type": "code", "execution_count": 4, "id": "8ec42ee8", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[34mConnecting to --port=COM5 --baud=115200 \u001b[0m\n", "\u001b[34m\n", "Try one of these ports as --port= \n", " COM3\u001b[0m" ] } ], "source": [ "%serialconnect --port=\"COM5\"" ] }, { "cell_type": "markdown", "id": "73bc717b", "metadata": { "kernel": "SoS" }, "source": [ "This makes managing arrays much nicer than bare Micropython:" ] }, { "cell_type": "code", "execution_count": 5, "id": "c6702dfc", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f1 is larger than f2 from approx. x = 0.0 to x = 2.040816\n" ] } ], "source": [ "import numpy as np\n", "\n", "xx = np.linspace(0, 10, 50)\n", "f1 = np.sin(xx)\n", "f2 = np.log(xx)\n", "\n", "f1_larger = xx[f1 > f2]\n", "print(f'f1 is larger than f2 from approx. x = {np.min(f1_larger)} to x = {np.max(f1_larger)}')\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "2052332f", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "m:\n", " array([[1, 2, 3],\n", " [4, 5, 6],\n", " [7, 10, 9]], dtype=uint8)\n", "\n", "m^-1:\n", " array([[-1.25, 1.0, -0.25],\n", " [0.5, -1.0, 0.5],\n", " [0.4166666, 0.3333333, -0.25]], dtype=float32)\n", "\n", "m*m^-1:\n", " array([[1.0, 0.0, 0.0],\n", " [-4.768372e-07, 1.0, 0.0],\n", " [-9.536743e-07, 0.0, 1.0]], dtype=float32)\n" ] } ], "source": [ "m = np.array([[1, 2, 3], [4, 5, 6], [7, 10, 9]], dtype=np.uint8)\n", "n = np.linalg.inv(m)\n", "print(\"m:\\n\", m)\n", "print(\"\\nm^-1:\\n\", n)\n", "# this should be the unit matrix\n", "print(\"\\nm*m^-1:\\n\", np.dot(m, n))" ] }, { "cell_type": "markdown", "id": "680affb7", "metadata": { "kernel": "SoS" }, "source": [ "## Feature 2: `matplotlib` emulation\n", "The more popular functions from `matplotlib` are now availabe right on the ALPACA thanks to the new kernel. For now, only `pyplot` functions are supported, e.g. all the methods starting with `plt`. Saving files and transfering them to the PC is no longer needed. Faster feedback hopefully makes for a better user experience.\n", "\n", "Notes:\n", "- `plt` functions only work in a single cell and thus cannot span multiple cells." ] }, { "cell_type": "code", "execution_count": null, "id": "24355c02", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "xx = np.linspace(-5, 5, 50)\n", "f1 = np.sin(xx)\n", "f2 = np.log(xx)\n", "\n", "print(\"Printing something useful...\")\n", "plt.plot(xx, f1, label='$f_1 = sin(x)$')\n", "plt.plot(xx, f2, label='$f_2 = log(x)$')\n", "\n", "print(\"Printing more useful stuff...\")\n", "plt.xlabel('$x$')\n", "plt.ylabel('$y$')\n", "plt.title(\"Two functions plotted\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "markdown", "id": "5bdc7abc", "metadata": { "kernel": "SoS" }, "source": [ "## Feature 3: Live plotting\n", "Most importantly for the final assignment, live plotting is now supported. Enabling live plotting can be done by adding the magic command `%plot --mode live` to the top of the code. This works similarly to Arduino: when enabled, the serial output is monitored for a specifically formatted string:\n", "\n", "> `LABEL0 number0 LABEL1 number1 ...`\n", "\n", "For example:\n", "> `analog0 0.197 analog1 0.109`\n", "\n", "The example was printed using the function:\n", "```python\n", "print('analog0',value0,'analog1',value1)\n", "```\n", "\n", "Incoming data is automatticaly stored and appended to older data. The x-axis of the plot is automatticaly labled with the time elapsed from the start of the code to the arrival of the data in the serial output.\n", "\n", "Notes:\n", "- Due to differences in caching, the live plot flickers when Jupyter Notebook is run in the Firefox browser. In this case, it is best to use the Edge browser instead." ] }, { "cell_type": "markdown", "id": "0247d0bd", "metadata": { "kernel": "SoS" }, "source": [ "### Plotting one variable:" ] }, { "cell_type": "code", "execution_count": null, "id": "3deabdd1", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [], "source": [ "%serialconnect --port=\"COM5\"" ] }, { "cell_type": "code", "execution_count": null, "id": "d963dcf3", "metadata": { "kernel": "ALPACA - USB" }, "outputs": [], "source": [ "%plot --mode live\n", "from machine import ADC, Pin\n", "import time\n", "import matplotlib.pyplot as plt\n", "from functiongenerator import FuncGen, Sine, Triangle, DC\n", "\n", "adc = ADC(Pin(26))\n", "\n", "\n", "############### NEW METHOD ##################\n", "with FuncGen(Sine(Vpp=2, offset=0, freq=1)):\n", " for _ in range(250):\n", " value = adc.read_u16()*5.0354e-05\n", " plt.liveplot(value)\n", " \n" ] }, { "cell_type": "markdown", "id": "3d8bba94", "metadata": { "kernel": "ALPACA - USB" }, "source": [ "> ℹ️\n", ">\n", "> It might be wise to also *save* the data for later analysis:\n", "> ```python\n", "> with open('backup.txt', 'w+') as f:\n", "> # Do measurement\n", "> data_point = ...\n", "> f.writelines(str(data_point))\n", "> ```\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "89e2c576", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "39a7ad7f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "b75c886b", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Create Assignment", "kernelspec": { "display_name": "Alpaca Kernel", "language": "python", "name": "alpaca" }, "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.10.12" }, "sos": { "kernels": [ [ "ALPACA - USB", "alpaca", "alpaca", "", "python" ], [ "Python3", "python3", "Python3", "#FFD91A", "" ] ], "panel": { "displayed": true, "height": 0 }, "version": "0.22.3" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 5 }