{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 10章 サーボ系" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from control.matlab import *\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "#plt.rcParams['font.family'] ='sans-serif' #使用するフォント\n", "plt.rcParams['font.family'] = 'Times New Roman' # font familyの設定\n", "plt.rcParams['mathtext.fontset'] = 'cm' # math fontの設定\n", "plt.rcParams['xtick.direction'] = 'in' #x軸の目盛線が内向き('in')か外向き('out')か双方向か('inout')\n", "plt.rcParams['ytick.direction'] = 'in' #y軸の目盛線が内向き('in')か外向き('out')か双方向か('inout')\n", "plt.rcParams['xtick.major.width'] = 1.0 #x軸主目盛り線の線幅\n", "plt.rcParams['ytick.major.width'] = 1.0 #y軸主目盛り線の線幅\n", "plt.rcParams['font.size'] = 11 #フォントの大きさ\n", "plt.rcParams['axes.linewidth'] = 0.5 # 軸の線幅edge linewidth。囲みの太さ\n", "plt.rcParams['mathtext.default'] = 'it'#'regular'\n", "plt.rcParams['axes.xmargin'] = '0'\n", "plt.rcParams['axes.ymargin'] = '0.05'\n", "plt.rcParams['savefig.facecolor'] = 'None'\n", "plt.rcParams['savefig.edgecolor'] = 'None'\n", "\n", "plt.rcParams[\"legend.fancybox\"] = True # 丸角\n", "# plt.rcParams[\"legend.framealpha\"] = 1 # 透明度の指定、0で塗りつぶしなし\n", "# plt.rcParams[\"legend.edgecolor\"] = 'gray' # edgeの色を変更\n", "plt.rcParams[\"legend.handlelength\"] = 1.8 # 凡例の線の長さを調節\n", "plt.rcParams[\"legend.labelspacing\"] = 0.4 # 垂直方向（縦）の距離の各凡例の距離\n", "plt.rcParams[\"legend.handletextpad\"] = 0.7 # 凡例の線と文字の距離の長さ\n", "plt.rcParams[\"legend.markerscale\"] = 1.0 # 点がある場合のmarker scale" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def linestyle_generator():\n", " linestyle = ['-', '--', '-.', ':']\n", " lineID = 0\n", " while True:\n", " yield linestyle[lineID]\n", " lineID = (lineID + 1) % len(linestyle)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def plot_set(fig_ax, *args):\n", " fig_ax.set_xlabel(args[0])\n", " fig_ax.set_ylabel(args[1])\n", " fig_ax.grid(ls=':', lw=0.5)\n", " if len(args)==3:\n", " fig_ax.legend(loc=args[2])" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def bodeplot_set(fig_ax, *args):\n", " fig_ax[0].grid(which=\"both\", ls=':', lw=0.5)\n", " fig_ax[0].set_ylabel('Gain [dB]')\n", "\n", " fig_ax[1].grid(which=\"both\", ls=':', lw=0.5)\n", " fig_ax[1].set_xlabel('$\\omega$ [rad/s]')\n", " fig_ax[1].set_ylabel('Phase [deg]')\n", " \n", " if len(args) > 0:\n", " fig_ax[1].legend(loc=args[0])\n", " if len(args) > 1:\n", " fig_ax[0].legend(loc=args[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## サーボ系" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A = [[ 0. 1.]\n", " [ 0. -1.]]\n", "\n", "B = [[0.]\n", " [1.]]\n", "\n", "C = [[1. 0.]\n", " [0. 1.]]\n", "\n", "D = [[0.]\n", " [0.]]\n", "\n" ] } ], "source": [ "A = '0 1; 0 -1'\n", "B = '0; 1'\n", "C = '1 0 ; 0 1'\n", "D = '0; 0'\n", "P = ss(A, B, C, D)\n", "print(P)\n", "\n", "C1 = np.matrix([1,0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 例10.1: フィードフォワード項" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "pole = [-3+3j, -3-3j]\n", "F = -acker(P.A, P.B, pole)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "外乱がない場合" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[18.]]\n" ] }, { "data": { "text/plain": [ "(-0.5, 2.0)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "G1 = np.r_[ np.c_[P.A, P.B], np.c_[C1, 0] ]\n", "G1inv = np.linalg.inv(G1)\n", "G2 = np.c_[ np.zeros((1,2)), 1]\n", "\n", "G = np.c_[-F, 1] * G1inv * G2.T\n", "print(G)\n", "\n", "Acl = P.A + P.B*F\n", "Pfb = ss(Acl, P.B, P.C, P.D)\n", "\n", "Td = np.arange(0, 5, 0.01)\n", "rd = 1 * (Td>0)\n", "\n", "v = G[0,0]*rd\n", "\n", "x, t, _ = lsim(Pfb, v, Td, [-0.3, 0.4])\n", "\n", "fig, ax = plt.subplots(figsize=(3, 2.3))\n", "\n", "ax.plot(t, x[:,0], label = '$x_1$', c='k', lw=1)\n", "# ax.plot(t, x[:,1], ls = '-.', label = '$x_2$', c='k', lw=1)\n", "plot_set(ax, '$t$', '$y$')\n", "ax.set_xticks([0,1,2,3,4,5])\n", "ax.set_ylim(-0.5,2)\n", "\n", "# fig.savefig(\"sf_serfo_ff.pdf\", transparent=True, bbox_inches=\"tight\", pad_inches=0.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "外乱がある場合" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-0.5, 2.0)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Td = np.arange(0, 5, 0.01)\n", "rd = 1 * (Td>0)\n", "dd = 3 * (Td>3)\n", "\n", "v = G[0,0]*rd + dd\n", "\n", "x, t, _ = lsim(Pfb, v, Td, [-0.3, 0.4])\n", "\n", "fig, ax = plt.subplots(figsize=(3, 2.3))\n", "\n", "ax.plot(t, x[:,0], label = '$x_1$', c='k', lw=1)\n", "# ax.plot(t, x[:,1], ls = '-.', label = '$x_2$', c='k', lw=1)\n", "plot_set(ax, '$t$', '$y$')\n", "ax.set_xticks([0,1,2,3,4,5])\n", "ax.set_ylim(-0.5,2)\n", "\n", "#fig.savefig(\"sf_serfo_ff_dist.pdf\", transparent=True, bbox_inches=\"tight\", pad_inches=0.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 例10.2: 積分型サーボ" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "matrix([[-48., -10., 90.]])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Abar = np.r_[ np.c_[P.A, np.zeros((2,1))], -np.c_[ C1, 0 ] ]\n", "Bbar = np.c_[ P.B.T, 0 ].T\n", "Cbar = np.c_[ C1, 0 ]\n", "\n", "Pole = [-3-3j, -3+3j, -5]\n", "F = -acker(Abar, Bbar, Pole)\n", "F" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "matrix([[-48., -10., 90.]])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Abar = np.block([ [P.A, np.zeros((2,1))], [ -C1, 0 ] ])\n", "Bbar = np.block([ P.B.T, 0 ]).T\n", "Cbar = np.block([ C1, 0 ])\n", "\n", "Pole = [-3-3j, -3+3j, -5]\n", "F = -acker(Abar, Bbar, Pole)\n", "F" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-0.5, 2.0)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Acl = Abar + Bbar*F\n", "B2 = np.matrix([[0],[0],[1]])\n", "Pfb = ss(Acl, np.c_[Bbar,B2], np.eye(3), np.zeros((3,2)))\n", "\n", "Td = np.arange(0, 5, 0.01)\n", "dd = 3 * (Td>3)\n", "x, t, _ = lsim(Pfb, np.c_[dd, rd], Td, [-0.3, 0.4, 0])\n", " \n", "fig, ax = plt.subplots(figsize=(3, 2.3))\n", "ax.plot(t, x[:,0], label = '$x_1$', c='k', lw=1)\n", "# ax.plot(t, x[:,1], ls = '-.',label = '$x_2$')\n", "# ax.plot(t, Ud, c='k')\n", "plot_set(ax, '$t$', '$y$')\n", "ax.set_xticks([0,1,2,3,4,5])\n", "ax.set_ylim(-0.5,2)\n", "\n", "#fig.savefig(\"servo.pdf\", transparent=True, bbox_inches=\"tight\", pad_inches=0.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 例10.3: 最適サーボ系" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "Q = [ [100, 0, 0], [0, 10, 0], [0, 0, 1000]]\n", "R = 1\n", "\n", "Fbar, X, E = lqr(Abar, Bbar, Q, R)\n", "Fbar = -Fbar" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "X11=X[0:2,0:2]\n", "X12=X[0:2,2]\n", "X22=X[2,2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "F = Fbar[0,0:2]\n", "# FF = -(1/R)*P.B.T*X11\n", "G = Fbar[0,2]\n", "# GG = -(1/R)*P.B.T*X12" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "H1 = np.r_[ np.c_[P.A, P.B], np.c_[C1, 0] ]\n", "H1inv = np.linalg.inv(H1)\n", "H2 = np.c_[ np.zeros((1,2)), 1]\n", "\n", "H = np.c_[-F+G*(1/X22)*X12.T, 1] * H1inv * H2.T" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "x0 = np.matrix([-0.3, 0.4])\n", "xi0 = - G*(1/X22)*X12.T * x0.T - G*0" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-0.5, 2.0)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Acl = Abar + Bbar*Fbar\n", "B2 = np.matrix([[0],[0],[1]])\n", "Pfb = ss(Acl, np.c_[Bbar, B2], np.eye(3), np.zeros((3,2)))\n", "\n", "Td = np.arange(0, 5, 0.01)\n", "rd = 1 * (Td>0)\n", "dd = -0.5 * (Td>3)\n", "xi0d = xi0 * (Td>=0)\n", "\n", "v = np.array(H[0,0]*(rd+dd) + xi0d)\n", "\n", "x, t, _ = lsim(Pfb, np.c_[v[0,:],rd+dd], Td, [-0.3, 0.4, 0])\n", " \n", "fig, ax = plt.subplots(figsize=(3, 2.3))\n", "ax.plot(t, x[:,0], c='k', lw=1, label='Optimal servo')\n", "#ax.plot(t, x[:,2], ls = '-.',label = '$x_2$')\n", "# ax.plot(t, Ud, c='k')\n", "\n", "# 初期値の項がない場合\n", "v = np.array(H[0,0]*(rd+dd) + 0*xi0d)\n", "x, t, _ = lsim(Pfb, np.c_[v[0,:],rd+dd], Td, [-0.3, 0.4, 0])\n", "ax.plot(t, x[:,0], c='k', lw=1, ls='-.', label='w/o ξ0')\n", "\n", "# フィードフォワード項がない場合\n", "v = np.array(0*H[0,0]*(rd+dd) + xi0d)\n", "x, t, _ = lsim(Pfb, np.c_[v[0,:],rd+dd], Td, [-0.3, 0.4, 0])\n", "ax.plot(t, x[:,0], c='k', lw =1, ls='--', label='w/o $Hr$')\n", "\n", "plot_set(ax, '$t$', '$y$', 'best')\n", "ax.set_xticks([0,1,2,3,4,5])\n", "ax.set_ylim(-0.5,2)\n", "\n", "#fig.savefig(\"sim2_optimal_servo.pdf\", transparent=True, bbox_inches=\"tight\", pad_inches=0.0)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-0.5, 2.0)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN8AAACrCAYAAADmSkn7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAnzElEQVR4nO2deXgUVfa/39tZSVjClghhkU0QVBAERGVTQRwUQXQCiD80ooKKCyr6BRlWcQQdRUUGmVEYUNwgjiggCmKESNBAgAgCBgRCRAiBTICk0+k+vz+SNNlTSTpdt6Xe58mTvlV1qz5V3afuPXc5V4kIFhYW3sdmtgALi4sVy/gsLEzCMj4LC5OwjM/CwiQs47OwMAnL+CwsTMIyPgsLk/A346JKqbrAe0AnYD8wUkTOFdrfH+iZn1wjIru8r9LComZRZnSyK6VuA74H/gd8AGwRkbfy9wXn7+sBBAJfA33FGg1g8SfDlJJPRL4o+KyU2gqkFtp9HZCWb2x2pVQI0AI4XPgcnTp1kj179lzIdN119OvXD5fLhdPpBCAgIAARITc3150GcDgcAPj7+6OUcqf9/Pyw2WxF0n5+fuTk5JSadjgchIaG4nA4EBFsNhv+/v7utFKKgIAAcnNzcblcJdIAgYGBOJ1Ot+bi6YCAgArvKTs7Gz8/P4/cU/F7MHpP586dcz9fT9xTVb8nu91OSEiIR+6pqt/TvHnz/i0iY6kAU4yvGJcCCwqlLwHSC6WzgaYUM76hQ4fy888/17i48sjKyqJWrVqmatBFhw4adNExb968FCPHmdrgopQaBrwmIrmFNv8BhBRK1wFOFM+rQy204K1oNjro0EED6KPDCKYZn1JqILBbRI4opSKVUmFKqQBgMxCZf0wQ4BCR5OL5C6ooZpKVlWW2BEAPHTpoAH10GMGs1s4ngaeAk0opG7ANyAW+E5FPlFLTlVLPAX7Ag2ZotLCoacxqcHkdeL2c/WuANeWdo8ApN5OQkJCKD/ICOujQQQPoo8MIVie7hYVJ+KzxFTQzm8n58+fNlgDooUMHDaCPDiP4rPFZWPg6Pmt8/v7md1Ga3Z9UgA46dNAA+ugwgs8an1LKbAnYbHo8Ph106KAB9NFhBN9RWgwdfL5z585VfJAX0EGHDhpAHx1G8Fnjs7DwdXzW+AoGEptJUFCQ2RIAPXTooAH00WEEnzU+Her2OjT6gB46dNAA+ugwgvm/4Cpi+XwX0EGHDhpAHx1G8Fnjs7DwdXzW+HTw+QIDA82WAOihQwcNoI8OI1jGVw10+aJ10KGDBtBHhxF81vgKQgSYydmzZ82WAOihQwcNoI8OI/is8VlY+Do+a3xWtfMCOujQQQPoo8MIlvFVA106dHXQoYMG0EeHEcyM4dJBKbVaKdW3jP3fKKVSlFJblVIlLM3y+S6ggw4dNIA+Ooxg2nAAEflFKZUJlJieoJQaCkwRkXivC6sEOkRQAz106KAB9NFhBLPH4pRVfPUHhiultgHjReSP4gfExsYWmVb07LPPMmPGDHJzc7Hb7QCEhobicrncEa0K4nsUzHauVasWNpvNPSoiKCgIf39/dzowMJDAwED32zQwMJCgoCDOnj2LiJCdnU12djbnz5/H5XLh7+9PcHCwO22z2QgJCSE7O5vc3Fx32m6343A4UEpRu3Zt7Ha7uySvXbs2OTk57nRoaGiF95Sbm0taWppH7ikgIICgoKBK31N2djZpaWkeu6eqfk9nz5712D1V53syginh4t0XV2oJsERENpWyzw+YDPQWkYHF97/wwgsye/bsGtdYHtnZ2QQHB5uqQRcdOmjQRYdSaoaITK/oOG0bXETEKSKzgLql7ddhbKcu8UJ00KGDBtBHhxG0Mb5CQXPJj+VZsGhKbGnH61C31yU6sg46dNAA+ugwgmk+n1KqJXAZcL1SKh6YDXynlNoIfK+U+hrYB8wqLb81pegCOujQQQPoo8MIZrZ2HiZvRaICHiv0uWNF+XV4yGb7FgXooEMHDaCPDiOYX3xUEcvnu4AOOnTQAProMILPGp/l811ABx06aAB9dBjBZ43PCh14AR106KAB9NFhBN9RWgxroZQL6KBDBw2gjw4j+Kzx6bA+X3Z2ttkSAD106KAB9NFhBJ81Ph3q9jq8AEAPHTpoAH10GMFnjc/y+S6ggw4dNIA+OozgO0qLYfl8F9BBhw4aQB8dRvBZ49OhelGZEew1iQ46dNAA+ugwgs8anw4+nw4d/aCHDh00gD46jGD+GC0f5dy5c8THxzN48GA++OADNmzYQGhoKI0bN6ZNmzZ07tyZ9u3be2UYnA7+rw4aQB8dRvDZks+MQDkiwoYNG9i/fz9nzpzhww8/BKB58+b06tWLNm3akJ2dTUxMDMOGDeOWW24BYNOmTaSmptaYrtq1a9fYuX1JA+ijwwg+W/I5nU6vXu/QoUOMGzeOw4cPs2jRIvr27cuCBQsA6N27N1deeSXHjx8nPT2dIUOGEBgYSFhYGE6nky1bttCwYUNycnJYtGgRw4cPp1u3bh57S9vtdtMDB+mgQScdRrCMzwBr165lzJgxTJw4kaeffpqAgACys7P55JNP+Oabb9iyZQtnzpyhSZMmNGjQAKfTid1u58SJE6Snp9OsWTN++ukn2rRpw2+//UZUVBROp5M777yTYcOGcd1111UrGpsOwaQ8pSEtLY3vv/+egwcPkpOTg1KK9u3bExERQceOHalXr165Ly0dnoVRfNb4vMVHH33Ek08+yapVq7jhhhvIzs7mtdde47XXXqN9+/aMGjWKWbNm0bp161L7mLKzszl8+DA7d+5kx44dZGZmcurUKcLCwti0aROffvopAQEBHDhwgOPHj9OwYUOfeXNXB5fLxRdffMGyZcvYsWMHhw8fRimFy+XC6XS6DUwpRUBAALm5ue4XbkBAAL169SItLY3AwEC6d+9OVFQU/fv3N/OWKo+I+OTflClTpKZxOBxy8803y65du0REZPPmzdK+fXu54447ZNeuXZKVlVWl8+bm5kpiYqK89dZbEhUVJZdccok0adJEOnToIPfcc4/ExsbKe++9J8eOHTN0vqrq8CRGNLhcLlmwYIFERkaKzWYTm80mzZs3lzvvvFOefvppOXDggLhcrjLzO51OSUxMlHfffVeWLVsmN998s4SFhYmfn58AAkidOnWkTZs2Mnz4cJkwYYLs2bPHk7dpCGC6GPgNm25EVf17/vnnPfi4SrJ//37JyMhw/xjefvttCQ8Pl5UrV7qPycjI8Mi1XC6XJCcny9KlS2XcuHHSqVMn8fPzEz8/P2nQoIHccsst8sYbb8ihQ4dK/XF6Skd1KE/D0aNH5S9/+YsopQSQ8PBwmTdvnjidTo9d3+l0yvbt22X69OkyePBgadu2rfj7+0tgYKCEhIRIUFCQ1K9fX7p06SLjx4+X3bt3l2vo1cGo8ZkWvUwp1QGYB7wiIt8V29cf6JmfXCMiu4rnnzRpksydO7fG9M2ePZvLL7+c4cOHM3XqVD799FNWr15N27Zt3cekpaXRqFGjGrn+2bNn2bp1KzExMXz77bccOnSI7OxsrrjiClq0aEFISAgjRowgKCiIiIgIunbtamoU7+LP4uDBgzzzzDOsW7cOgC5dutClSxdeffVVatWq5TUdIsKuXbv45z//SVxcHEeOHOHs2bPuqm2tWrUICAigSZMmjB49moyMDC655BJ69OhBt27dqjQz3mj0Mu2C5uYHTZoL9AACga+VUn3Fi2+J1NRUXnjhBSDPCGNiYoiNjaVx48Y1cj0R4ffffycpKYns7GyGDBnCm2++yapVq/j999/dfuL777/Pk08+yYEDB8jNzeXQoUPs37+fzMxM97mCg4Np1qwZ586dc48CCg8PZ+rUqXz33Xfs3LmT0NBQQkJCePjhh2nYsCHLli2jVq1ahISE0KtXL/r27cuqVauw2+0EBgZSv359brjhBvbs2cPRo0eBPF/s2muvJSUlhaSkJNLT00lNTeXXX38lISGB48ePExERwU033cTSpUtp0KBBjTy7ilBK0blzZxYuXFhku4iwY8cOtm/fzpdffkl6ejp79uzhyy+/JCMjo8hk7YI4oHXq1CErK4uuXbsSGRlJUlISNpuNunXrUq9ePa6++mrq1atnXJtZJR+UHrdTKXUj8KyI3Jqf/gkYLnkxX9z06tVLtm7d6k57KmhubGwsjz/+OHFxcaxevZo5c+awevVqIiIiSgRjdTqd1KtXr0rBWE+dOsXJkyfp0qULvXr14vDhw3Ts2JGBAwfyxBNPsGPHDux2O5deeim1atUiODgYpVSp93Tu3Dl2797Nzp07OXbsGL///rs7fuUPP/xAkyZNANi+fTsOh8M9Oqjgu69VqxZOpxOHw0FgYCA5OTmlRgpQSmGz2XC5XCilCAkJKRKe3WazER4ezi233MKECRNo2bIl4N2guXa7nTp16ngkaG5aWhp79+7l6NGjHDp0iGPHjvHzzz+7az+xsbFkZmbicDhwOp2EhoZis9lIS0szVPKZ6rcBS4B+xbaNAt4vlN4M9CqetyZ8vqysLGndurWsWbNGtm/fLo0aNXI3tpTG//73v0qd3+Vyydq1a2Xo0KFSt25defHFF0VEJDU1tVr+R2V1lIbT6ZTs7GwRyWtoysnJEYfDIbm5uYa0eUKDJ9BBBwZ9Ph27Gv4ACg9NrwOcKH5QTfTzvfXWW1x55ZX07duXLl268Oabb3LllVeWeXzBW7YinE4nR48epUWLFvzrX/9i8ODBvPfee4SFhQG4S6aqYlRHedhsNncXR1WGxHlCgyfQRYcRtDE+pVQYcI68ku6l/G1BgENEkmv6+qdPn+bll18mNjaWF154gWuuuYYRI0ZU+7wbN25k4sSJdOzYkQ8++IBPP/3UA2ot/gxoFzRXRD5RSk1XSj0H+AEPlpbf0/P5Xn75ZYYNG8aZM2dYsWIFu3fvrjBPaGhouftfeuklFi1axKuvvsqdd97pKamV1uENdNAA+ugwgpZBc0VkDbCmgvwe1VO3bl3Gjx/PXXfdxbx58wx1IZQ1rWn79u20b9+eqKgoHn30UerWLXW5CY+hw/QqHTSAPjqM4LOzGjw5mTY9PZ3Jkyfz3Xff4efnx6hRowzlK2idK8zy5csZNGgQSUlJtG7dusYNrywd3kYHDaCPDiNo4/OZhYgwcOBAli9fzpQpU/jkk0+qHAdk6tSpfPDBB3z77bd06tTJw0ot/mz4bMnnKZ9PKcXWrVv56quvuOaaa7j22msN5y0eL+Syyy4jPj7e64anQ9wSHTSAPjqM4LPG5ykefvhhUlJSmDt3Ln/7298qnV9EePLJJ/n666+59957a2y4mcWfD581Pk/E6khISOCrr77i888/p1u3blx99dWVyn/+/HmmT5/Oli1b6NGjR7X1VBUdFgfRQQPoo8MIFfp8SqmhwC4ROVjzcrzL4sWLiY6O5h//+AcfffRRpfOvXLmS5cuXExcXV6kxfRYWYKzkawD8XSkVr5R6Tyl1b/7gZ1OpbmCizMxMPvroIyIjI2nSpAk9e/asOFMxBgwYwFdffUVERES1tFSXmpwl4EsaQB8dRqjQ+ETkXRH5q4j0BF4GhgIf5k8JMo3qxj/5+OOP6du3L8uXL+eJJ56oVN6jR49y1113ER4eXmSKkVnoEKVZBw2gjw4jVKhUKTVVKTVLKXWZiPwCrASGAQNqXF05VNfn++CDD+jTpw/79+9n+PDhhvPl5ORw99130717d20W5SgY3X+xawB9dBjByGviGPADMFUp9S3QDniAUgY7+xKPPPIIu3fvZvz48ZXqtnjuueeIiIhg0qRJNajO4mLAiOMUCzQVkXsLNiilhgBpNabKANWZtZ2cnEyfPn0YO3Yse/furVTe6667jqlTp6KU0ibQkQ46dNAA+ugwQoXGJyK/Ar8W2/Z5jSkySHXq9vPnzycoKIjevXtzySWXGMqTkZFBTEwM9913n3ubN6JRG0EHHTpoAH10GMF3vNNiVMfne+ONN9i2bRv333+/4TxPPPEE8fHxRbbp4l/ooEMHDaCPDiP4zmvCQyxcuJDc3Fz27t3L4MGDDeVZv3493333naFpRhYWRvFZ46uqz/fee+/Rrl077rnnHsPrPcTExLBgwYIS6wCYsV4E5JX6KSkp7tZWl8vFyZMnTdFSgA4avKnDz8+PsLAwGjVqVGUX6KIyvmPHjpGcnMyJEyeIiYkxlMdut/P222+X2q9olvGlpKRQp04dLr30UneUZ7P7t3TQ4C0dIoLD4eCPP/4gJSWFFi1aVOk85j+tKlKVmPyff/45PXr0IDg4mC5dulR4/P79+7niiivK9C8LR+7yJtnZ2TRs2ND9QvD2ojGloYMG8I4OpRSBgYFERkZWy8c0M4zEo0AO0BSYLyJniu3/BugApADXi0i1n+pnn31GYGAgUVFRhkbIPP7444wfP960Eq48fGkduj8r1S1hTSn5lFJdgZ4ishjYAEwrtn8oMEVEmonItaUZXmWrnRkZGfzwww8kJCQQFRVV4fHr1q3j0KFDTJgwocxjdDFKHap7OmgAfXQYwaySbyjwc/7nRGAZ8FSh/f2B4UqpbcB4Efmj+Ak2bdpU5O1fUdDc06dP88gjj7B69WrCw8NJS0srNxhro0aNWLhwIU6nk4yMDIASQXNFhOzs7CoFzXU4HCilqF27Nna73V2NNhpgtqAqbLPZ3D5IQVop5a5+GU27XK689QMKBcatbLogmG6BpoJ4Kn5+fpVKFxhQ4bTReyqI7eOpeyqcLk2z0+kkLS2txPdkBLOM7xLgx/zP2eRVPd2IyBNKqYnAZPIMc2DxE/Tu3Zsffvih1JMXj9sYGhqKiHD27FlGjhxZYsJr8ZHw27Zt47LLLuOaa64BKBGvv2AUxalTpwgODi6xv7Lp4qMySlsfoPA92Wy2IkPicnNzSwyRK14C1HS64OVTmOK1k8LpmJgYdu7cyfTp0w0dX/yaa9asYebMmRSOWm6z2cjNzXXn8/Q9lqWx8O+pMjFDzTK+woFxSw2Km1/VnKWU2lp8X2UREfr168eJEyeIi4sr99jMzExGjBjB6tWrKwxm6+kIalXFDB1Hjhxh4cKFtGvXDrvdzq+//srkyZNp2LBhmXkcDgfHjx+nefPmDBs2jCFDhlT5+gMGDOCRRx4psV2X78QIZlWQVwFd8j9fCXyulApTSgUAKKVs+f+DyRtbWoLK1O2VUixcuJDIyEjatWtX7rFz587l5ptvdpd65eHp2KFVxduNL2lpafTt25exY8cSHR3N+PHjuf322+nTp0+51a4pU6aQnHwh/nF1xueW9ex9qSHKlJJPRHYopfYopcYCLYAXyA+aq5TaCHyvlPoa2AfMKu0clRnDt3z5cr788kvuuOOOco+z2+0sWbKEzZs3GzqvLoN4a+IlUF4JsnjxYlq2bEmbNm3c2/r06UNmZiYrV64kNTWVxMREmjVrxqpVq3jhhRfo168fcXFx2Gw26tevz3/+8x/q169PdHQ00dHRDBgwgN9++434+HjmzJnDf//7XxITE1m/fj3p6em8+OKLdOvWjbi4OP7973+XqW3ZsmUEBwezYsUK5s6dS3h4OGvWrCEjI4O1a9eyePFi5s2bR2ZmJgcOHGD48OG8+uqr/O1vf3NHNYiMjOT2229n3rx5tGrVig0bNvDcc8/RsWNHjz5jM4Pmziu26bFCnyu8y8qM7Zw/fz6pqak888wz5R4XFBTEL7/8Yjjq8fnz56u0fpuncTgcXh1QfOjQoRID0l0uF02bNuXw4cNce+21bNq0ieXLlzNq1Ciuv/56Tp8+Tdu2bRk0aBCdO3fm8ssvJyUlhaZNm9KoUSPatm3L008/zd133825c+d48803GTFiBImJiQQFBXHbbbfRu3dvJk+eXK62mJgYJk2axL/+9S9yc3P5+9//zjXXXENkZCRt27blwIEDXHHFFSQkJLBx40Z3Y8rBg3lRUkJDQ4mKimLatGl06NCBkSNH0qJFC6Kjo4v4l57Ad9pli2G0bn/ixAn27duHUoquXbuWeVxqaipjx46tVOg5XaIje9vPadWqFceOHSuhIS0tjbZt26KUcjdCXHXVVQQHB7tbjAso/LLw9/d3x8AJDQ11fw4ODsZut9O+fXsOHjzItm3bKqxtTJ06lWeeeYYxY8YQFBREUlIS3bt3Z+jQobz++utcf/312Gw2Gjdu7G4lHTNmDB999BEpKSmEh4cDeY1uBQGPu3fvzq5dJdZnrTY+a3xGfb7169fTvHlz7rjjjnL9gTlz5lCvXr1K+Qy6TF/xtp8THR1NcnIy+/btc2+Lj48nNDSUoUOHAhdGmtjtdiIjI90jcgq6JCrDrFmzaNy4MTfddBNQ/kvv/PnzbN26lZ49e7J06VLat2/P1KlTcTqd/Pbbb/z0008l8tSuXZvBgwczbtw4brvtNgCuvvpqt/uRmZnJDTfcUCnNRtDj11MFjP7w161b517ttSyOHDnCihUrKj2xVocqJ3i/YzkiIoItW7Ywf/58OnXqhNPp5NChQ2zatMntfyYmJvL+++9z+PBhFi9eDOSVIK+88gqRkZH89NNPHD9+nKNHj7J//37i4+Np3749+/fvZ+vWre4q4tatW7nqqquYNm0ahw8fJjIykhUrVtCqVSvS09NJSkriiiuucGubPn06d955JyLC7bffTlhYGCNHjqRly5bcc889zJw5k6VLl5KcnFxkCenHHnuM999/363///7v/xg3bhyvvPIKWVlZ/POf//T8gzSyiJ+Of5MmTSplWcKiOJ1OadiwodSpU8e98GNprF27Vl566aUKz1ecU6dOVTqPJ9izZ0+RtMPhMEVHWRq+/fZbGTNmjOk6vEHx70LEtxfHNIQY8HMyMjLo2rUrYWFhZfoKOTk5DBo0iEGDBlVaw8Xq85WnweFw8P3333PgwAGOHTtGZGSkKTp8AZ/1+Yz4OfXr1yc4OLjcLoaHH36YJUuWVEmDLuMIdejbKtAQEBDA1KlT2bJli9cNr7AOX0CPX08VMNK3NXDgQDZs2MCtt95a6v59+/bxxRdfMGzYsCpp0GVRDh1eAjpoAH10GMFnq51G1ucbPXo0OTk5NGjQoNT9M2bM4KmnnqpyqPfs7GwtGl10mMiqgwaddBjBZ42vIn8rMTGRlStXlluq3XTTTYamF5WFJxforA46+Dk6aAB9dBjBN14RpVBR3X7+/Pls3LixzC6G+Ph4oqOjS8RlqQy6vGF18HNK0/D2228bapSaNWsWiYmJNaZDV/T49VSB8nw+EWH16tU0bdqUVq1aldifmJjI0KFDq72EsOXzla9BRAxpu+mmm8jNzeXRRx8lPT0dgA8//JA333yTmTNncvTo0Wrp0BWfrXaWV+XbvXs3TqeTu+++u9T906ZN4/nnn6+28djtdsvnK0NDUlKS4YHIDoeDNm3asGDBAiBvqN+7777L+vXrSUlJYcKECYYDXunwLIziGypLobzqzLp16wBK7WJITEwkISGBhx9+uNoaPLFApyeYMWMGSqkSf02b5s1Rnj59unvSatOmTUs9tvD+1NTUcq83Z84cunfvzunTp7n//vsZPnw4WVlZLF++nDfeeAOA2NhY+vTpg8vlYvbs2SxbtowHH3yw1BkjLVq04K233mLEiBEsWbKEdevWuWdMNGvWjK1btxoOjORLPp/pI1Wq+vfss8+WOeqgZ8+e0qBBA3E6nSX2OZ1OSU5OLjNvZUhLS/PIeSqL2SNcHA6HtGvXTs6dOyfff/+9dO7cWRwOhyxatMj9zOfPny8iIu+++67MmTNHREQOHjwoTZs2LfK95OTkyGuvvSYul8u97cUXX5TJkye705GRkZKammpYmzepzggXny35ygpe5HQ6+f333xk2bFiJ6sePP/7IqlWraN26tUc0VKexxpN4u5rl7+/PHXfcQUxMDElJSe7Syc/PD5vNxt69e91VzsKzA1q1aoXD4SAt7cIaO+vXr6d///5FGkoiIiKKLO+clZVF/fr1DWnzlSon+HC1s6xqiJ+fH82aNeOuu+4qse/555/nzJkzHtNQmWA5NYmYUNV64IEH+Mc//kHz5s156KGHGDt2LAMH5oXa2bhxI/369QOKzg7Izc2lefPmNG7c2H2egIAANm3aVOT7vO222/j557z4WkeOHOHaa6817Fub8Syqis82uJRlfNOmTWPnzp3079+/yPZNmzbx22+/MWbMGI9pqErg3prA5XJVKyRDVejQoQOdO3fm1ltvdbcuN2/eHMgzsoJZJ9HR0SQmJjJz5kyCgoJYtGhRkVJuwIABfPjhh9SrV4+cnByGDh3Kxx9/zMiRI1mwYAEnTpzg7bffNqzLjGdRZYzUTWviD3gUeJC8mJ1hxfb1B57P/7uqtPxl+XxTpkyRwYMHl9j++OOPy7JlyyqowVeOkydPevR8RinuZ+Tk5JiioyY0zJ07VwsdRvG5WQ2Fgub+P6XUDfkG+FT+vmBgLtADCAS+Vkr1zb8pN6X5fKdPn2bbtm1F1tCDvBfM66+/7vH70MXn0+FNX10NqampPPLII+6qq1k6vImOQXOvA9Lyjc2ulAohL8jS4cIn+Oabb3jxxRfd6WeffZb69euzadMmFi5c6A5kmpWVxcCBA1myZIm7oaXAmS8vaC7kGXhgYKB7TYbiQXPtdjsNGzY0PWiuy+WqdJBcTwfNzc3NdXdbVCVobkREBJ988glwwaWoStDcgu/BCppbNuUFzb0ESC+ULthfxPj69OlTIqBNQWCewlG1Fi1aRERERJHZzsU714sHzS2eLivIbVpamhZBc10ul+lBc5VSJTRUFAS3smkjmhwOhxU0twLKC5pbeF9p+0vlzJkz7Nmzh7lz57q3paenM2fOHDZu3Fh9xRYWHkbHoLmbgUgApVQQ4BCR5OInKP6W/eyzzwAYNWqUe9v58+eZOXNmkVLPkxgNMVjT6ODn6KAB9NFhBO2C5orIJ0qp6Uqp5wA/8lpES1B8eNnixYtp164dERERQN5E2fr16zNu3Lgauw9rSpFeGkAfHUbQMmiuiKwB1pSXv3A/n8vlYseOHcyePRvIM4qRI0cyceJERo8e7TnRxbDb7ZWq49cUOvRt6aBBJx1G8NkRLoU5d+4c/v7+7i6Gl19+mQYNGnDPPfeYK+wix+h8vgI+++wzmjZtysSJE9m7dy8JCQnceOONDBo0iPXr19egUnPw2REuhX2+sWPH0rNnTxo0aMDp06d555132Lx5c41PrLR8vvI1iBibz1fAbbfdxvjx45k7d657hIzNZuO5554rMWKpMjp0xWdLvsJ1+x9//JEHHniA3Nxc6tevzy+//OIe6lSTWKEDy9ZQmfl8BWzfvp2uXbu6Dc9ut7Nt2zZ69OhRZR0647MlX0Fjx9dff01OTg533XUXo0eP5tZbb/Xo+M3yyMrK0qL0M8PPmTNnDjExMaxfv56JEydy5swZVqxYwaeffkp6ejr+/v7uOZMul4s5c+bQsmVLYmNjGTNmTKnh1zdv3kydOnXcoRz37dtHhw4dCA0NJTY2ltjYWHbu3Mnll19Oeno6b731VolzWD6flxARRo0axY033si8efNITk7mr3/9q9myvM7MmTOLTIxNSEggISGhzMmyBdu6desGwEMPPVTk2Iom0wJMmjSJjIwMgoKCeOCBBzh48KB7dM9jjz1WZIXYpUuX4ufnx7333svkyZOJiooqtdawefNmJkyYwH333cd9991HvXr1uP766wFo1KgR4eHhXHfddcyYMYNXX33VQ0/PPHzW+AICAvjss89IT09n8ODBLFq0iJiYmBKjU2oSXWK4TJ8+vciA3W7dutGtW7ci2wqMLzU11b0tISEBgHfeeafIsQUz4MujtDl9cXFx+Pn5sW/fviJVzorm9BU+rvBKUvHx8e4SsmPHjnz77bcMGTIEpVSZEcit+XxeQER49NFH6d27N8OHDycuLo5mzZqZLeuiovCcvgcffJDo6GgGDhxYZD4fVDynD2D//v2Eh4cXeXn++OOP7pIP4Ndffy0ydNDX8VmfLzY2luPHj9OuXTv8/f0Nva09zfnz57Uo/czycwrP6cvJyWHt2rU0b968yHw+qHhOX3x8PG+88QYiQmxsLK1bt+bdd9/l1KlTfPPNN4wePZpjx46Vu75iAb7k8ylfah0qjFJKOnbsSFxcXJUjTleXwktMeZO9e/dy+eWXu9MOh8P09eF10GCGjuLfBYBSaoaITK8or8+WfG3atCEpKcnUIKne9C/LQwc/RwcNoI8OI/iO0mJERUWZHp1Yly/a7OegiwbQR4cR9Pj1VAEdYmYWTLo1G6MxLf/sGkAfHUbwWeO72PFVX/3PRHVHOPms8enQolVWX1NNExwczKlTp9wGqEP1VwcN4B0dIkJOTg7Hjh2r1ggnn21w0eHLLtyc7k2aNWtGSkoKJ0+eBHDHGTETHTR4U4e/vz/16tWrVmu3zxqfLj6fGS2eAQEBRVZfMqvLozA6aNBJhxHMLz6qyJYtW8yWUCRejJnooEMHDaCNjn5GDvJ6J7tSqj/QMz+5RkR2lXLMbOA+wAX0Ly2Gi1KqeChPr6OU0qLhQwcdOmjQRUe+hgrrvl6tdhoJiKuUagKcEBFroKbFnxpv+3xGAuLeAjyilLoPeEhEfirjXMeVUpcUSn8HbPK85HLpp5Ty9jVLQwcdOmgAPXSUvhZ5MWqs2qmUmg60LbZ5FLBCRO7JP2Yz8KyI/FBK/r8Ai4BOIvK/GhFpYWEiNVbylTawVCn1HoWilFFOQFwRWaOU+hJoTV5IeQuLPxXebu0sNSCuUipAKRWWv72wpnNcWNPBwuJPhRmtnX8hL0q1H7A2P4DuX4E+IvKYUmotcBqIJ6819IBXBVpYeAmfnc9nYeHr+Fwnu1LqUaXUg0qpaQVVVZN0dFBKrVZK9TXp+nWVUiuVUr8opT5XSpkSRk0p5a+UmqeU2qyUWpvfnWQKSqkQpVSiUupSEzVEKKUOKqVSlFJvlnesTxlfoUU1FwMbyFtU0xRE5BcgEzBrQGMfIBq4nDzf+H6TdDQDZorIDUAAJVu4vcl48paUM5MHgStFpJmITCjvQJ8yPkouqjnULCH5mLYou4h8ISIZ+X2mW4GK4/3VjI7fRCQzv8/2exFJMkOHUupe4GNMND6lVC3yhpYlK6X+rpQqtzfB14yv8MKZxRfVvJi5FPjcrIsrpeoCM4CHlFKdTbh+HyBZRI56+9qFEZEsEbkZaE9ejWRSecf7mvGVt6jmRYlSahjwmoiYtl6ZiPxPRJ4FnqOMJd1qmMeAOfkjW7oAHyqlGpebowYRkQzgYfKGUZaJr00pWgU8nv/5Skx82+uAUmogsFtEjiilIkXkmMmS9gFeDyUnIu4w5fkGeJ+InPS2jvzrF4z4Dwe+LO9YnzK+MhbVNAWlVEvgMuB6pVS8iGR5+fpPAk8BJ/MHJmwDam4l0LJ1DACeAT4CBHjH2xp0If9ZvKKUWgX8mt8wWPbxVj+fhYU5+JrPZ2Hxp8EyPgsLk7CMz8LCJCzjs7AwCcv4LCxMwjI+CwuTsIzPwsIkLOOzQCkVnN8xbOFFLOOzALge+MVsERcblvFd5Cilbgaez//cy2Q5FxXW8DILlFIbgCEioseCgxcJVsl3kZMf9sHPMjzvYxmfxTXAj0qpMKVUd7PFXExYxmfxB3nrZtwqIj+aLeZiwvL5LCxMwir5LCxMwjI+CwuTsIzPwsIkLOOzsDAJy/gsLEzCMj4LC5OwjM/CwiT+P0yW1cc97WOXAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Acl = Abar + Bbar*Fbar\n", "B2 = np.matrix([[0],[0],[1]])\n", "Pfb = ss(Acl, np.c_[Bbar, B2], np.eye(3), np.zeros((3,2)))\n", "\n", "Td = np.arange(0, 5, 0.01)\n", "rd = 1 * (Td>0)\n", "dd = 3 * (Td>3)\n", "xi0d = xi0 * (Td>=0)\n", "\n", "v = np.array(H[0,0]*rd + xi0d)\n", "\n", "x, t, _ = lsim(Pfb, np.c_[dd+v[0,:],rd], Td, [-0.3, 0.4, 0])\n", " \n", "fig, ax = plt.subplots(figsize=(3, 2.3))\n", "ax.plot(t, x[:,0], c='k', lw=1, label='Optimal servo')\n", "#ax.plot(t, x[:,2], ls = '-.',label = '$x_2$')\n", "# ax.plot(t, Ud, c='k')\n", "\n", "# 初期値の項がない場合\n", "v = np.array(H[0,0]*rd + 0*xi0d)\n", "x, t, _ = lsim(Pfb, np.c_[dd+v[0,:],rd], Td, [-0.3, 0.4, 0])\n", "ax.plot(t, x[:,0], c='k', lw=1, ls='-.', label='w/o ξ0')\n", "\n", "# 初期値の項とフィードフォワード項がない場合\n", "v = np.array(0*H[0,0]*rd + xi0d)\n", "x, t, _ = lsim(Pfb, np.c_[dd+v[0,:],rd], Td, [-0.3, 0.4, 0])\n", "ax.plot(t, x[:,0], c='k', lw =1, ls='--', label='w/o $Hr$')\n", "\n", "plot_set(ax, '$t$', '$y$', 'best')\n", "ax.set_xticks([0,1,2,3,4,5])\n", "ax.set_ylim(-0.5,2)\n", "\n", "# fig.savefig(\"sim_optimal_servo.pdf\", transparent=True, bbox_inches=\"tight\", pad_inches=0.0)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "F= [[-24.24478689 -6.71294845]]\n", "G= 31.622776601677565\n", "H= 14.184692456581072\n", "xi0= -2.496303364255667\n" ] } ], "source": [ "print('F=',F)\n", "print('G=',G)\n", "print('H=',H[0,0])\n", "print('xi0=', xi0[0,0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 章末問題" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-1.+1.j, -1.-1.j, -1.+0.j])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 章末問題3\n", "Acl = np.matrix([[0, 1, 0], [-2, -3, -2], [1, 1, 0]])\n", "np.linalg.eigvals(Acl)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0.5]]\n", "[[0.5]]\n" ] } ], "source": [ "# 章末問題4\n", "A = '0 1; 2 -1'\n", "B = '0; 1'\n", "C = '2 1'\n", "D = '0'\n", "P = ss(A, B, C, D)\n", "F = np.matrix([-3, -1])\n", "\n", "G = -1/(P.C * np.linalg.inv(P.A+P.B*F) * P.B)\n", "print(G)\n", "\n", "Abar = np.block([ [P.A, P.B], [ P.C, 0 ] ])\n", "Bbar = np.block([ np.zeros([1,2]), 1 ]).T\n", "Cbar = np.block([ -F, 1 ])\n", "G2 = Cbar*np.linalg.inv(Abar)*Bbar\n", "print(G2)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-4.+0.j]\n" ] }, { "data": { "text/plain": [ "matrix([[-0.5 , -0.25, 0.25]])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 章末問題5\n", "A = '0 1; -1 -2'\n", "B = '1; 2'\n", "C = '1 0'\n", "D = '0'\n", "P = ss(A, B, C, D)\n", "print(P.zero())\n", "\n", "Abar = np.block([ [P.A, np.zeros((2,1))], [ -P.C, 0 ] ])\n", "Bbar = np.block([ P.B.T, 0 ]).T\n", "Cbar = np.block([ P.C, 0 ])\n", "\n", "Pole = [-1, -1, -1]\n", "F = -acker(Abar, Bbar, Pole)\n", "F" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$$\\frac{s + 4}{s^2 + 2 s + 1}$$" ], "text/plain": [ "TransferFunction(array([1., 4.]), array([1., 2., 1.]))" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# -4が零点であることを確認する１\n", "tf(P)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "matrix([[ 4., 1., 1.],\n", " [-1., 2., 2.],\n", " [ 1., 0., 0.]])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# -4が零点であることを確認する２\n", "M = np.block([ [-(-4*np.eye(2) - P.A), P.B], [ P.C, 0 ] ])\n", "M" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linalg.matrix_rank(M)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }