sim/MovementPlanning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "00cf41a2-b519-4cbb-8b47-63d59a5caea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from c_lang_integers import CUInt, UInt8, UInt16, UInt32"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17522c8-9317-454d-9b36-6401fd30e358",
   "metadata": {},
   "source": [
    "# Modeling\n",
    "\n",
    "We want to steer a linear motion of a camera by mobile phone or computer.\n",
    "The overall system consists of an Arduino UNO, a stepper motor with driver and a linear guide with thread drive.\n",
    "\n",
    "![Model Overview](modeling.svg)\n",
    "\n",
    "(Those components are chosen because I had them lying around, not because they are the best fit.)\n",
    "\n",
    "We roll up the system from its end, the camera mount.\n",
    "The screw drive is moving the camera mount and the rotation of the screw drive is driven by the stepper motor.\n",
    "We assume 3 mm of linear  movement per revolution.\n",
    "The stepper motor needs 200 steps per revolution, and the stepper motor in use breaks this down into even more micro steps, so we end up with 1600 steps per revolution.\n",
    "We summarize those relationships in the formula \n",
    "\n",
    "$x = m \\cdot n$.\n",
    "\n",
    "The variable $x$ is the position, $m$ denotes the overall transmission ratio and $n$ is the number of steps done.\n",
    "The number of steps is prescribed by our microcontroller (Arduino, ATMEGA 328P).\n",
    "Besides the number, we can control the frequency $f_\\mathrm{stepper}$ of the steps, which prescribes the velocity $v$ of the linear movement.\n",
    "Dividing the previous formula by the time interval $\\Delta t$ the stepper needed to do $n$ steps, moving the camera mount by distance $x$, we get\n",
    "\n",
    "$v = m \\cdot f_\\mathrm{stepper}$.\n",
    "\n",
    "The microcontroller has to generate pulses with a constant frequency.\n",
    "\n",
    "![Constant Frequency Pulses](constant_pulses.svg)\n",
    "\n",
    "The signal can be generated with the timer peripheral and in principal we are done.\n",
    "We use CDT mode with one timer to generate the rate and another timer to determine the pulse length.\n",
    "With regards to the rate we introduce the number of timer cycles $k$, which is used as OCR value for the rate \n",
    "generation and can be calculated with\n",
    "\n",
    "$k = f_\\mathrm{timer} / f_\\mathrm{stepper}$\n",
    "\n",
    "Here the clock frequency $f_\\mathrm{timer}$ of the timer peripheral is used.\n",
    "\n",
    "However, with this solution, we are limited to a fixed velocity and this fixed velocity has to be rather slow.\n",
    "Otherwise, the motor might loose steps at start or does not run at all.\n",
    "\n",
    "To overcome these limitations, we introduce a trapezodial velocity profile, defined by the acceleration $a$.\n",
    "\n",
    "![A trapezodial velocity profile](trapezodial_velocity_profile.svg)\n",
    "\n",
    "Subsequently, we can not use a fixed timer configuration anymore, but have to adapt the configuration between each step during acceleration and deacceleration.\n",
    "Acceleration and deacceleration are more or less equal, we assess the acceleration only.\n",
    "Here we calculate the velocity with\n",
    "\n",
    "$v = a_\\mathrm{a} \\cdot \\left( t - t_0 \\right)$.\n",
    "\n",
    "With the constant $a_\\mathrm{a}$, we get the linear behavior over time $t$.\n",
    "We have to calculate $k$ and adapt it regularly, to mimic this behavior with our timer peripheral.\n",
    "$k$ can be calculated, using\n",
    "\n",
    "$k(t) = \\frac{f_\\mathrm{timer}}{f_\\mathrm{stepper}} = \\frac{f_\\mathrm{timer} \\cdot m}{a \\cdot (t - t_0)}$.\n",
    "\n",
    "Each step, takes a certain period of time.\n",
    "Therefore $k(t)$ has to be evaluated only at certain points in time.\n",
    "Eventually, we get a sequence $k_i$ instead of a function.\n",
    "With the sequence, $t$ becomes $t_i$ which can be determined with\n",
    "\n",
    "$t_i = \\frac{\\sum_{j=0}^{i-1} k_i}{f_\\mathrm{timer}}$\n",
    "\n",
    "This is a division of pretty big numbers, and keeps the microcontroller busy for some time.\n",
    "To circumvent compute time bottlenecks, we transform this problem into another counter.\n",
    "The value $k$ is correlated to the time a step takes ($\\Delta t = k / f_\\mathrm{timer}$) and to the velocity (see above).\n",
    "So, we can determine the number of stepper steps, the system can make for each value of $k$ before it has to adapt $k$ to maintain the acceleration.\n",
    "We call this value $k_\\mathrm{sumlim}(k)$ and it is determined by\n",
    "\n",
    "$k_\\mathrm{sumlim}(k) = \\frac{f_\\mathrm{timer} \\cdot m}{a} \\left( \\frac{1}{k_i} - \\frac{1}{k_i-1}\\right) $\n",
    "\n",
    "Now, all we have to to, is starting with some value of $k$, for example $k = 255$, repeat steps with this value until we reached $k_\\mathrm{sumlim}(k=255)$ and then decrement $k$ by one and do the same with the next value.\n",
    "Given $k$ is bigger than $k_\\mathrm{sumlim}(k)$ we skip $k$ 's until we consumed the sum of the $k_\\mathrm{sumlim}$ 's is equal $k$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2525158b-9dc5-475d-81ee-cf6094a4409c",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "141bad01-86a9-46de-b122-7bf986839c09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transmission ratio m\n",
    "m = 3 / 1600\n",
    "\n",
    "# acceleration and deacceleration set point\n",
    "a = 30\n",
    "\n",
    "# velocity set point\n",
    "v_set = 10\n",
    "\n",
    "# position set point\n",
    "x_set = 15\n",
    "\n",
    "# clock frequency (atmega)\n",
    "f_clk = 16e6\n",
    "\n",
    "# counter with (8bit)\n",
    "n_cnt = 255\n",
    "\n",
    "# timer prescaler\n",
    "prescaler = 256\n",
    "\n",
    "# timer frequency\n",
    "f_timer = f_clk / prescaler"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d81fe338-4c79-4db3-a1ca-e180178b402c",
   "metadata": {},
   "source": [
    "## Prescale options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "95b68839-f88e-49a9-ba28-d14bc521a006",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.00000000e+00, 1.17647059e+02, 1.50000000e+04],\n",
       "       [8.00000000e+00, 1.47058824e+01, 1.87500000e+03],\n",
       "       [3.20000000e+01, 3.67647059e+00, 4.68750000e+02],\n",
       "       [6.40000000e+01, 1.83823529e+00, 2.34375000e+02],\n",
       "       [1.28000000e+02, 9.19117647e-01, 1.17187500e+02],\n",
       "       [2.56000000e+02, 4.59558824e-01, 5.85937500e+01],\n",
       "       [1.02400000e+03, 1.14889706e-01, 1.46484375e+01]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prescale_values = [1, 8, 32, 64, 128, 256, 1024]\n",
    "\n",
    "f_timer_arr = f_clk / np.array(prescale_values)\n",
    "\n",
    "min_velocities = f_timer_arr / 255 * m\n",
    "max_velocities = f_timer_arr / 2 * m\n",
    "\n",
    "np.vstack((prescale_values, min_velocities, max_velocities)).T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0ecd48-e87f-4d54-8d5f-8c6bc7474ecb",
   "metadata": {},
   "source": [
    "## Precalculated Steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de1d0b00-69b7-4cef-bada-78ef575a1813",
   "metadata": {},
   "outputs": [],
   "source": [
    "Dks = {n: round(m * f_timer**2 / a  * (1/(n-1) - 1/n)) for n in range(255, 2, -1)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d481fd8-0e60-4f64-b882-5e153c6847a5",
   "metadata": {},
   "source": [
    "## Movement Planning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31b9894",
   "metadata": {},
   "source": [
    "### Acceleration phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dc7718c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.71875"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m * f_timer / v_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "35fae0cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "33c85efb-18a3-410f-9a6a-1e016258eae0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "k = UInt8(255)\n",
    "Dk = UInt16(Dks[k.value])\n",
    "p = UInt8(0)\n",
    "pk = UInt16(0)\n",
    "\n",
    "movement_plan = [\n",
    "    [k.value, 1]\n",
    "]\n",
    "\n",
    "# \n",
    "f_clk100 = UInt16(int(f_clk / 100))\n",
    "\n",
    "k_target = round(m * f_timer / v_set)\n",
    "\n",
    "assert k_target in Dks.keys()\n",
    "\n",
    "while k.value > k_target and p.value < x_set:\n",
    "\n",
    "    if Dk.value > k.value:\n",
    "        Dk -= k\n",
    "    else:\n",
    "        r = UInt16(k.value) - Dk\n",
    "        k -= 1\n",
    "        \n",
    "        while r.value > Dks[k.value]:\n",
    "            r -= Dks[k.value]\n",
    "            k -= 1\n",
    "\n",
    "        Dk = UInt16(Dks[k.value]) - r\n",
    "\n",
    "    if k.value == movement_plan[-1][0] and movement_plan[-1][1] < 255:\n",
    "        movement_plan[-1][1] += 1\n",
    "    else:\n",
    "        movement_plan.append([k.value, 1])\n",
    "\n",
    "    pk += 1\n",
    "\n",
    "    if (pk.value > 533):\n",
    "        pk = UInt16(0)\n",
    "        p += 1\n",
    "\n",
    "p_acc = CUInt(p)\n",
    "pk_acc = CUInt(pk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9bcd0d48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(81, CInt(1,1), CInt(287,2))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(movement_plan), p_acc, pk_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "809f80b1",
   "metadata": {},
   "source": [
    "### Steady Phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a015be2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "246"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "533 - 287"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1e7d2b94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(13, 246)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steady_target = (x_set - p_acc.value - 1, 533 - pk_acc.value)\n",
    "steady_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "50e6c233-6337-4530-acb6-efa1bb611ffa",
   "metadata": {},
   "outputs": [],
   "source": [
    "while p.value < steady_target[0] or (p.value == steady_target[0] and pk.value < steady_target[1]):\n",
    "\n",
    "    if k_target == movement_plan[-1][0] and movement_plan[-1][1] < 255:\n",
    "        movement_plan[-1][1] += 1\n",
    "    else:\n",
    "        movement_plan.append([k_target, 1])\n",
    "\n",
    "    pk += 1\n",
    "\n",
    "    if (pk.value > 533):\n",
    "        pk = UInt16(0)\n",
    "        p += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f16a7f31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(movement_plan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d08f7256",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(CInt(13,1), CInt(246,2), CInt(1,1), CInt(287,2))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p, pk, p_acc, pk_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d330f024",
   "metadata": {},
   "source": [
    "### Deacceleration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9f479b63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(CInt(1,2), CInt(12,1))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r, k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7170e360",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "Dk = r\n",
    "\n",
    "while p.value < x_set:\n",
    "\n",
    "    if Dk.value > k.value:\n",
    "        Dk -= k\n",
    "    else:\n",
    "        r = UInt16(k.value) - Dk\n",
    "        k += 1\n",
    "        \n",
    "        while r.value > Dks[k.value] and k.value <= 254:\n",
    "            r -= Dks[k.value]\n",
    "            k += 1\n",
    "\n",
    "        Dk = UInt16(Dks[k.value]) - r\n",
    "\n",
    "\n",
    "    if k.value == movement_plan[-1][0] and movement_plan[-1][1] < 255:\n",
    "        movement_plan[-1][1] += 1\n",
    "    else:\n",
    "        movement_plan.append([k.value, 1])\n",
    "\n",
    "    pk += 1\n",
    "\n",
    "    if (pk.value > 533):\n",
    "        pk = UInt16(0)\n",
    "        p += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e835f939-2548-4ca4-bba2-50b2be67900b",
   "metadata": {},
   "source": [
    "## Display Movement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4a0fd499-e04a-4770-95ae-d08c28cd929f",
   "metadata": {},
   "outputs": [],
   "source": [
    "steps = sum([cnt*[n] for n, cnt in movement_plan], [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9917e43a-5e8a-44b5-897e-b2ae096d766b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8011"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fcc06cc4-2f6b-4f39-a36c-47854cb31d2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "t_s = []\n",
    "v_s = []\n",
    "x_s = []\n",
    "\n",
    "x = 0\n",
    "t = 0\n",
    "\n",
    "for n in steps:\n",
    "    T = n / f_timer\n",
    "    t += T\n",
    "    x += m\n",
    "\n",
    "    t_s.append(t)\n",
    "    v_s.append(m/T)\n",
    "    x_s.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2bcc2189-211b-4432-adfe-4f03332ab38e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "db5b6d6c-bbf0-444f-bad4-09d0e0668bc8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, [ax1, ax2] =  plt.subplots(2,1)\n",
    "\n",
    "ax1.plot(t_s, v_s)\n",
    "\n",
    "ax1.set_ylim((0,None))\n",
    "\n",
    "ax1.set_xlabel(\"Time in s\")\n",
    "ax1.set_ylabel(\"Velocity in mm/s\")\n",
    "ax1.grid()\n",
    "\n",
    "ax2.plot(t_s, x_s)\n",
    "\n",
    "ax2.set_ylim((0,None))\n",
    "\n",
    "ax2.set_xlabel(\"Time in s\")\n",
    "ax2.set_ylabel(\"Position in mm\")\n",
    "ax2.grid()\n",
    "\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfdfb2c4",
   "metadata": {},
   "source": [
    "## C Code Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee170a88",
   "metadata": {},
   "source": [
    "### Movment Plan\n",
    "\n",
    "For testing purposes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "606de83d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "static constexpr Block expected_movement_plan[] = {\n",
      "\t{255, 1}, {202, 1}, {173, 1}, {154, 1}, {141, 1}, {130, 1}, {122, 1}, {115, 1}, {109, 1}, {104, 1}, {100, 1}, {96, 1}, {92, 1}, {89, 1}, {87, 1}, {84, 1}, {82, 1}, {79, 1}, {78, 1}, {76, 1}, {74, 1}, {72, 1}, {71, 1}, {69, 1}, {68, 1}, {67, 1}, {66, 1}, {65, 1}, {64, 1}, {63, 1}, {62, 1}, {61, 1}, {60, 1}, {59, 1}, {58, 1}, {57, 2}, {56, 1}, {55, 1}, {54, 2}, {53, 2}, {52, 1}, {51, 2}, {50, 2}, {49, 2}, {48, 3}, {47, 2}, {46, 3}, {45, 2}, {44, 3}, {43, 3}, {42, 4}, {41, 3}, {40, 4}, {39, 4}, {38, 5}, {37, 5}, {36, 5}, {35, 6}, {34, 7}, {33, 7}, {32, 7}, {31, 9}, {30, 9}, {29, 10}, {28, 12}, {27, 13}, {26, 14}, {25, 17}, {24, 18}, {23, 21}, {22, 24}, {21, 27}, {20, 33}, {19, 37}, {18, 44}, {17, 53}, {16, 64}, {15, 77}, {14, 96}, {13, 120}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 255}, {12, 248}, {13, 120}, {14, 96}, {15, 77}, {16, 64}, {17, 53}, {18, 44}, {19, 38}, {20, 32}, {21, 28}, {22, 24}, {23, 21}, {24, 18}, {25, 16}, {26, 15}, {27, 13}, {28, 11}, {29, 11}, {30, 9}, {31, 9}, {32, 7}, {33, 7}, {34, 7}, {35, 6}, {36, 5}, {37, 5}, {38, 5}, {39, 4}, {40, 4}, {41, 3}, {42, 4}, {43, 3}, {44, 3}, {45, 3}, {46, 2}, {47, 3}, {48, 2}, {49, 2}, {50, 2}, {51, 2}, {52, 2}, {53, 1}, {54, 2}, {55, 2}, {56, 1}, {57, 1}, {58, 2}, {59, 1}, {60, 1}, {61, 1}, {62, 1}, {63, 1}, {64, 1}, {65, 1}, {66, 1}, {67, 1}, {68, 1}, {70, 1}, {71, 1}, {73, 1}, {74, 1}, {76, 1}, {78, 1}, {80, 1}, {82, 1}, {84, 1}, {87, 1}, {89, 1}, {92, 1}, {96, 1}, {99, 1}, {103, 1}, {108, 1}, {113, 1}, {120, 1}, {127, 1}, {136, 1}, {147, 1}, {161, 1}, {180, 1}\n",
      "};\n",
      "\n"
     ]
    }
   ],
   "source": [
    "template = \"\"\"\n",
    "static constexpr Block expected_movement_plan[] = {{\n",
    "\\t{}\n",
    "}};\n",
    "\"\"\"\n",
    "\n",
    "generated_code = template.format(\n",
    "    \", \".join([f\"{{{k}, {n}}}\" for k, n in movement_plan])\n",
    ")\n",
    "\n",
    "print(generated_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db474552",
   "metadata": {},
   "source": [
    "### Precalculated cycle update steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3a94be39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "static constexpr uint16_t calculate_cycleupdate_steps[256] = {\n",
      "\t0, 0, 0, 40690, 20345, 12207, 8138, 5813, 4360, 3391, 2713, 2219, 1850, 1565, 1341, 1163, 1017, 898, 798, 714, 642, 581, 528, 482, 442, 407, 376, 348, 323, 301, 281, 263, 246, 231, 218, 205, 194, 183, 174, 165, 157, 149, 142, 135, 129, 123, 118, 113, 108, 104, 100, 96, 92, 89, 85, 82, 79, 76, 74, 71, 69, 67, 65, 63, 61, 59, 57, 55, 54, 52, 51, 49, 48, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 33, 32, 31, 30, 30, 29, 29, 28, 27, 27, 26, 26, 25, 25, 24, 24, 23, 23, 22, 22, 22, 21, 21, 20, 20, 20, 19, 19, 19, 18, 18, 18, 17, 17, 17, 17, 16, 16, 16, 16, 15, 15, 15, 15, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4\n",
      "};\n",
      "\n",
      "static_assert(calculate_cycleupdate_steps[3] == 40690);\n",
      "static_assert(calculate_cycleupdate_steps[7] == 5813);\n",
      "static_assert(calculate_cycleupdate_steps[233] == 5);\n",
      "static_assert(calculate_cycleupdate_steps[234] == 4);\n",
      "\n"
     ]
    }
   ],
   "source": [
    "template = \"\"\"\n",
    "static constexpr uint16_t calculate_cycleupdate_steps[256] = {{\n",
    "\\t{}\n",
    "}};\n",
    "\n",
    "static_assert(calculate_cycleupdate_steps[3] == 40690);\n",
    "static_assert(calculate_cycleupdate_steps[7] == 5813);\n",
    "static_assert(calculate_cycleupdate_steps[233] == 5);\n",
    "static_assert(calculate_cycleupdate_steps[234] == 4);\n",
    "\"\"\"\n",
    "\n",
    "generated_code = template.format(\n",
    "    \", \".join([f\"{Dks.get(i, 0)}\" for i in range(0,256)])\n",
    ")\n",
    "\n",
    "print(generated_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0acdca2",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}