Interactive_Acceleration_Calculator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import sympy\n",
    "from scipy.interpolate import spline, splrep, BSpline\n",
    "\n",
    "from itertools import cycle\n",
    "\n",
    "from IPython.display import display, clear_output\n",
    "\n",
    "from sympy import *\n",
    "init_printing()\n",
    "\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual, FloatText, FloatSlider\n",
    "import ipywidgets as widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Symbols\n",
    "km, ke = symbols('k_m k_e', constant=True, real=True, ) # Proportionality Constants (torque & emf)\n",
    "Vo, Ve, Tm, Tf = symbols('V_o V_e T_m T_f', constant=True, real=True) # Supplied Voltage, Emf voltage, Motor Torque, Frictional Torque\n",
    "I, rm, rb = symbols('I r_m r_b', constant=True, real=True) # Current, motor resistance, battery resistance\n",
    "w = symbols('w', constant=True, real=True) # (omega) motor rotational speed\n",
    "\n",
    "#More symbols\n",
    "Tnet, rw, E= symbols('T_net r_w, E', constant=True, real=True) # net torque, wheel radius, Wheel efficiency\n",
    "Iw, m = symbols('I_w m', constant=True, real=True) # Wheel inertia, robot mass\n",
    "g = symbols('g', constant=True, real=True) # Gear ratio\n",
    "\n",
    "# More Symbols\n",
    "v = symbols('v', constant=True, real=True) # Robot velocity\n",
    "\n",
    "# Motor Constant Symbols\n",
    "Ts, Is, Io, wo, nm, Vm = symbols('T_s I_s I_o w_o nm V_m', constant=True, real=True) # Stall Torque, Stall Current, Free current, number of motors, nominal voltage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Acceleration Definition\n",
    "acelDef = Tnet / (rw*m/E + Iw/rw)\n",
    "\n",
    "# Torque Definition\n",
    "TorqueDef = km * (Vo - w*ke)/(rm + rb) - Tf\n",
    "\n",
    "# Rotational Velocity Definition\n",
    "wDef = v/(math.pi*rw )* 60 * g\n",
    "vDef = solve(Eq(wDef, w), v)\n",
    "\n",
    "# Motor Constant Definitions\n",
    "KmDef = Ts / Is\n",
    "KeDef = Vm / wo\n",
    "RmDef = Vm / (Is * nm)\n",
    "TfDef = Ts * Io * nm / Is\n",
    "\n",
    "# Manipulations\n",
    "workingAcel = simplify(acelDef.subs(Tnet, TorqueDef * g))\n",
    "workingAcel2 = workingAcel.subs(w, wDef)\n",
    "workingAcel3 = workingAcel2.subs([(km, KmDef), (ke, KeDef), (rm, RmDef), (Tf, TfDef)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graphRatios(distance, minRatio, maxRatio, stall_torque, motor_num, stall_current, no_load_current,\n",
    "                nominal_voltage, free_speed, radius, batery_resistance, wheel_efficiency, operating_voltage,\n",
    "                inertia, mass):\n",
    "        \n",
    "    def aceleration(vel, gratio):\n",
    "        return FVAL*gratio + SVAL *gratio*gratio*vel\n",
    "\n",
    "    def timeAtRatio(targetDist, ratio):\n",
    "        assert(not ratio == 0)\n",
    "        t_acum = 0\n",
    "        x_acum = 0\n",
    "        v_acum = 0\n",
    "        dt= 0.0005\n",
    "        while x_acum < targetDist:\n",
    "            a = aceleration(v_acum, ratio)\n",
    "            v_acum += a*dt\n",
    "            x_acum += v_acum*dt\n",
    "            t_acum += dt\n",
    "            if a < 0:\n",
    "                print(\"Error, the gear ratio is too low\")\n",
    "                return(0)\n",
    "            if t_acum > 10:\n",
    "                print('Error, the time is greater than 10 seconds')\n",
    "                return(0)\n",
    "        return t_acum\n",
    "\n",
    "    \n",
    "    subList = [(Ts, stall_torque), (nm, motor_num), (Is, stall_current), (Io, no_load_current), \n",
    "                     (Vm, nominal_voltage), (wo, free_speed), (rw, radius), (rb, batery_resistance), \n",
    "                     (E, wheel_efficiency), (Vo, operating_voltage), (Iw, inertia), (m, mass)]\n",
    "\n",
    "    acelExp = workingAcel3.subs(subList)\n",
    "\n",
    "    if wheel_efficiency == 1:\n",
    "        wheelType = 'Tank Drive'\n",
    "    elif wheel_efficiency == 0.7:\n",
    "        wheelType = 'Mecanum Drive'\n",
    "    else:\n",
    "        wheelType = '' + 100 * wheel_efficiency + '% efficiency'\n",
    "\n",
    "    FCOMP, SCOMP = acelExp.expand().args\n",
    "    FVAL = float(FCOMP.subs(g, 1))\n",
    "    SVAL = float(SCOMP.subs([(g, 1), (v, 1)]))\n",
    "    print('FVAL:', FCOMP)\n",
    "    print('SVAL:', SCOMP)\n",
    "    \n",
    "    progressBar = widgets.FloatProgress(min=minRatio, max=maxRatio, description='Calculating:')\n",
    "    display(progressBar)\n",
    "    def updateStatus(ratio):\n",
    "        progressBar.value = ratio\n",
    "        return None\n",
    "        \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ratios = np.arange(minRatio, maxRatio, .1)\n",
    "\n",
    "    time = [updateStatus(x) or timeAtRatio(distance, x) for x in ratios]\n",
    "    index, minTime = min(enumerate(time), key=operator.itemgetter(1))\n",
    "    minRatio = ratios[index]\n",
    "\n",
    "    label = 'Min: %.1f:1 (%.3fs)' %(minRatio, minTime)\n",
    "    ax.plot(ratios, time, label=label, color='blue')\n",
    "    ax.plot(minRatio, minTime, '-o', color='blue')\n",
    "\n",
    "    ax.set_xlabel(\"Gear Reduction\", fontsize=15)\n",
    "    ax.set_ylabel(\"Time\", fontsize=18)\n",
    "    ax.legend(loc=\"best\")\n",
    "    ax.set_title('%s  |  Mass = %.1f lbs | Dist = %.1f m' %(wheelType, mass*2.20462, distance), fontsize=13)\n",
    "    ax.margins(0.1)\n",
    "    fig.tight_layout()\n",
    "    \n",
    "    clear_output()\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "87b22efca99d471cbc5d94465ae89a2a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatText(value=0.8, description='Distance (m): ', style=DescriptionStyle(description_wi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "style = {'description_width': 'initial'}\n",
    "interact_manual(graphRatios, \n",
    "                distance = FloatText(value=0.8, description='Distance (m): ', style=style),\n",
    "                minRatio = FloatText(value=5, description='Minimum Ratio: ', style=style),\n",
    "                maxRatio = FloatText(value=40, description='Maximum Ratio: ', style=style),\n",
    "                stall_torque = FloatText(value=4.2 / 40, description='Motor Stall Torque (Nm): ', style=style),\n",
    "                motor_num = FloatText(value=4, description='Number of Motors: ', style=style),\n",
    "                stall_current = FloatText(value=8.5, description='Motor Stall Current (Amps): ', style=style),\n",
    "                no_load_current = FloatText(value=0.2, description='Motor Free Current (Amps): ', style=style),\n",
    "                nominal_voltage = FloatText(value=12, description='Motor Nominal Voltage (V): ', style=style),\n",
    "                free_speed = FloatText(value=150*40, description = 'Motor Free Speed (rpm): ', style=style),\n",
    "                radius = FloatText(value=0.102, description='Wheel Radius (m): ', style=style),\n",
    "                batery_resistance = FloatText(value=0.1, description = 'Battery Internal Resistance (Ohms): ', style=style),\n",
    "                wheel_efficiency = FloatText(value=1, description='Wheel Efficiency: ', style=style),\n",
    "                operating_voltage = FloatText(value=12.7, description='Operating Voltage (v): ', style=style),\n",
    "                inertia = FloatText(value=0.005, description='Rotational Inertia (kg m^2): ', style=style),\n",
    "                mass = FloatText(value=30 * 0.453592, description='Robot Mass (kg): ', style=style))\n",
    "print()"
   ]
  },
  {
   "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": 2
}