home *** CD-ROM | disk | FTP | other *** search
/ AMIGA PD 1 / AMIGA-PD-1.iso / Meeting_Pearls_II / html / sw / nbsd / FuzzyPendel / design.txt < prev    next >
Text File  |  1994-06-28  |  8KB  |  256 lines
  1. <HEAD>
  2. <TITLE>Fuzzy Pendel - Infos zur Implementierung</TITLE>
  3. </HEAD>
  4.  
  5. <BODY>
  6.  
  7.  
  8. <H1>Das Design des Fuzzy-gesteuerten Pendels</H1>
  9. <!------------------------------------------------------->
  10.  
  11. <H2>Das Berechnungsschema</H2>
  12. <!--------------------------->
  13.  
  14. Prinzipiell handelt es sich bei der Steuerung des Pendels um ein
  15. rückgekoppeltes System, bei dem zuerst die eigentliche, ungesteuerte
  16. Bewegung des Pendels berechnet wird. Aus dieser Pendelbewegung -
  17. charakterisiert durch Winkel und Winkelgeschwindigkeit - wird dann
  18. berechnet, wie stark gegengesteuert werden muss, um das Pendel wieder
  19. aufzurichten.
  20. <P>
  21.  
  22. Diese aufrichtende Kraft beeinflusst dann im nächsten
  23. Iterationsschritt wiederum Winkel und -geschwindigkeit:
  24. <P>
  25.  
  26. ________________<IMG SRC="rueckkopplung.gif">
  27. <P>
  28.  
  29. Die Funktion f1 entspricht dabei der Simulation der Pendelbewegungen,
  30. f2 ist für das Ausbalancieren derselben zuständig. Diese Schleife
  31. kann auch im
  32. <A HREF="pendel.c">C-Quellcode der Curses-Version</A>
  33. des Programmes gefunden werden:
  34. <P>
  35.  
  36. <PRE>
  37.     while (alpha>=0.0 && alpha<=pi){
  38.     ...
  39.  
  40.     /* f1: Pendel-Verhalten nach Ch. Ziegaus */
  41.     Fres       = sqrt(sqr(Fg) + sqr(Fa));
  42.     rho        = alpha - arccos(Fa/Fres);
  43.     Fz         = sin(rho) * Fres;
  44.     deltaAlpha = Fz/(2.0*m*l)*sqr(deltaT) + alphaDot*deltaT;
  45.     alphaDot   = Fz/(m*l)*deltaT + alphaDot;
  46.     alpha      = alpha + deltaAlpha;
  47.  
  48.     /* f2: Ausgleichen der Pendelbewegung */
  49.     Fa = m*balance(alpha,alphaDot)*a0;
  50.  
  51.     ...
  52.     }
  53. </PRE>
  54.  
  55. Hier werden zuerst Winkel (<CODE>alpha</CODE>) und
  56. Winkelgeschwindigkeit (<CODE>alphaDot</CODE>) berechnet, anschliessend
  57. wird mit Hilfe der Funktion <CODE>balance()</CODE> die Balancier-Kraft
  58. <CODE>Fa</CODE> errechnet, mit der der Wagen am Fußpunkt des Pendels
  59. beschleunigt wird.
  60.  
  61.  
  62. <H2>Der eigentliche Fuzzy-Algorithmus</H2>
  63. <!--------------------------------------->
  64.  
  65. Die Funktion <CODE>balance()</CODE> ist also für das eigentliche
  66. Balancieren verantwortlich, sie bewerkstelligt dies anhand einer
  67. Fuzzy-Steuerung. Diese besteht aus den folgenden Teilen:
  68. <P>
  69.  
  70. <OL>
  71. <LI> Bestimmen, zu welchem Grad der <A
  72.      HREF="#WinkelGrad">Auslenkwinkel</A> in einem
  73.      bestimmten Bereich (groß/mittle/klein Negativ, ...) liegt.
  74. <LI> Bestimmen, zu welchem Grad die <A
  75.      HREF="#WinkelgeschwindigkeitGrad">
  76.      Winkelgeschwindigkeit </A> in einem bestimmten Bereich liegt.
  77. <LI> <A HREF="#RegelnAnwenden">Anwenden der Regeln</A>:
  78.      Wenn Winkel im Bereich ... und Winkelgeschwindigkeit in ..., dann
  79.      steuere mit ... Kraft nach.
  80. <LI> <A HREF="#Defuzzifizierung">Defuzzifizierung</A>: Im
  81.      vorhergehenden Schritt wurde berechnet, zu welchem Grad(en)
  82.      (gross/mittel/klein, positiv und/oder negativ) beschleunigt werden
  83.      soll. Aus diesen Werten wird nun der Mittelwert gebildet.
  84. </OL>
  85.  
  86.  
  87. <A NAME="WinkelGrad">
  88. <H3> Grad der Auslenkung des Winkels <CODE>alpha</CODE></H3>
  89. <!--------------------------------------------------------->
  90.  
  91. Als erstes soll bestimmt werden, in welchem Bereich(en) sich der
  92. Winkel <CODE>alpha</CODE> befindet. Dazu wird für jeden der möglichen
  93. Bereiche (NB, NS, NM, ZE, PS, PM, PB) abgeprüft, zu welchem Grad der
  94. Winkel in diesem Bereich liegt. Dieser Grad kann zwischen 0.0 und 1.0
  95. liegen, er wird im Array <CODE>b_alpha[]</CODE> für jeden Bereich
  96. festgehalten. 
  97. <P>
  98.  
  99. Die folgende Grafik soll dies verdeutlichen:
  100. <P>
  101.  
  102. <IMG SRC="impl_alpha.gif">
  103. <P>
  104.  
  105. Da sich die Bereich überschneiden können, kann <CODE>alpha</CODE>
  106. in mehreren Bereichen einen Grad >0 haben.
  107. Der oben beschriebene Berechnungsvorgang wird im
  108. <A HREF="pendel.c">C-Quellcode der Curses-Version</A>
  109. durch das folgende Code-Fragment abgedeckt:
  110. <P>
  111.  
  112. <PRE>
  113. /* Gewichte von alpha ausrechnen */
  114. for(i=0;i<NRANGES;i++){
  115.     if((b_alpha_u[i] > alpha) && (alpha > b_alpha_l[i])){
  116.         mid = (b_alpha_u[i]+b_alpha_l[i])/2.0;
  117.         if(alpha>mid){
  118.             /* linke Haelfte */
  119.             b_alpha[i] = 1.0-(alpha-mid)/(b_alpha_u[i]-mid);
  120.         }else{
  121.             /* rechte Haelfte */
  122.             b_alpha[i] = (alpha-b_alpha_l[i])/(mid-b_alpha_l[i]);
  123.         }
  124.     }else{
  125.         b_alpha[i] = 0.0;
  126.     }
  127. }
  128. </PRE>
  129.  
  130. <CODE>i</CODE> wird dabei über alle Bereiche von 0=NB bis
  131. 7=PS(=<CODE>NRANGES</CODE>) iteriert. Liegt der Winkel <CODE>alpha</CODE>
  132. im jeweiligen Bereich (dessen untere und obere Grenze in
  133. <CODE>b_alpha_l[]</CODE> bzw. <CODE>b_alpha_u[]</CODE> stehen), so wird
  134. in <CODE>b_alpha[i]</CODE> festgehalten, wie stark sich der Winkel in
  135. der Mitte des jeweiligen Bereichs <CODEi</CODE> befindet. Liegt er
  136. ausserhalb des Bereiches, so wird <CODE>b_alpha[i]</CODE> auf
  137. 0.0 gesetzt.
  138. <P>
  139.  
  140. Während der Simulation werden die so berechneten Werte sowohl in
  141. <A HREF="06_alpha_values.html">tabellarischer</A>
  142. als auch in
  143. <A HREF="09_alpha_ranges.html">grafischer</A>
  144. Form angezeigt.
  145. <P>
  146.  
  147.  
  148. <A NAME="WinkelgeschwindigkeitGrad">
  149. <H3> Grad der Auslenkung der Winkelgeschwindigkeit <CODE>alphaDot</CODE></H3>
  150. <!-------------------------------------------------------------------------->
  151.  
  152. Hier wird analog zur Berechnung der Winkel-Grade vorgegangen, die
  153. Grenzen der einzelnen Bereiche stehen in den Arrays
  154. <CODE>b_alphaDot_l[]</CODE> und <CODE>b_alphaDot_u[]</CODE>. Die
  155. berechneten Grade der einzelnen Bereiche werden im Array
  156. <CODE>b_alphaDot[]</CODE> gespeichert und während der Simulation
  157. ebenfalls in
  158. <A HREF="07_alphaDot_values.html">tabellarischer</A> und
  159. <A HREF="10_alphaDot_ranges.html">grafischer</A> Form angezeigt.
  160. <P>
  161.  
  162.  
  163. <A NAME="RegelnAnwenden">
  164. <H3> Anwenden der Fuzzy-Regeln</H3>
  165. <!-------------------------------->
  166.  
  167. Nachdem nun die Grade von <CODE>alpha</CODE> und <CODE>alphaDot</CODE>
  168. bestimmt sind ist es möglich, die Regeln zur Aussteuerung des Pendels
  169. anzuwenden. Diese treffen für Kombinationen von Winkel und
  170. Winkelgeschwindigkeit Aussagen darüber, wie die Ausgleichkraft
  171. <CODE>Fa</CODE> beschaffen sein muß, um das Pendel aufzurichten, z. B.:
  172. <P>
  173.  
  174. Wenn <CODE>alpha</CODE>=PS und <CODE>alphaDot</CODE>=NS, dann setze
  175. <CODE>Fa</CODE>=ZE.
  176. <P>
  177.  
  178.  
  179. Aufgrund der "und"-Verknüpfung der beiden Bedingungen wird
  180. <CODE>Fa</CODE>gleich dem kleineren der beiden Werte <CODE>alpha</CODE>
  181. und <CODE>alphaDot</CODE> gesetzt. Dies soll auch nochmal in der
  182. folgenden Grafik veranschaulicht werden:
  183. <P>
  184.  
  185. <IMG SRC="impl_regel.gif">
  186. <P>
  187.  
  188. Im <A HREF="pendel.c">C-Quellcode der Curses-Version</A>
  189. sieht dies so aus:
  190. <P>
  191.  
  192. <PRE>
  193. /* Regeln anwenden */
  194. for(i=0;i<NRANGES;i++){
  195.     b_Fa[i] = 0.0;
  196. }
  197. for(i=0;i<NRULES;i++){
  198.     b_Fa[b_rule_a[i]] = Max(b_Fa[b_rule_a[i]],
  199.                             Min(b_alpha[b_rule_alpha[i]],
  200.                                 b_alphaDot[b_rule_alphaDot[i]]));
  201. }
  202. </PRE>
  203.  
  204. Dabei wird <CODE>Fa</CODE> zuerst für alle Bereiche von 0 (=NB) bis
  205. NRULES (=7=PB) auf 0 gesetzt, d. h. es soll keine Kraft wirken.
  206. <P>
  207.  
  208. Dann werden nacheinander sämtliche Regeln angewandt.
  209. <CODE>b_rule_a[]</CODE> enthält dabei die Aussage, wie stark und in
  210. welche Richtung die Kraft wirken soll, <CODE>b_rule_alpha[]</CODE>
  211. und <CODE>b_rule_alphaDot[]</CODE> bestimmen, unter welchen Bedingungen
  212. diese Kraft angewandt werden soll.
  213. <P>
  214.  
  215. Wie oben erwähnt wird der Betrag der Kraft aus dem Minimum der Grade
  216. von Winkel und Winkelgeschwindigkeit ermittelt (aufgrund der
  217. "und"-Verknüpfung). Falls bereits eine Regel auf den angesprochenen
  218. Bereich gewirkt hat, so wird die maximale Kraft der beiden zur Berechnung
  219. der Ausgleichskraft verwendet.
  220. <P>
  221.  
  222.  
  223. <A NAME="Defuzzifizierung">
  224. <H3> Defuzzifizierung</H3>
  225. <!----------------------->
  226.  
  227. Nachdem durch das Anwenden der Regeln ein oder meist sogar mehrere
  228. Aussagen über die Stärke der Ausgleichskraft <CODE>Fa</CODE> getroffen
  229. wurden, soll nun in einem letzten Schritt <I>ein</I> Zahlenwert
  230. (<CODE>max</CODE>) aus den gesamten Aussagen errechnet werden.
  231. <P>
  232.  
  233. Im vorliegenden Fall wurden dabei die einzelnen Bereiche mit Gewichten
  234. versehen, mit denen die einzelnen Grade Multipliziert und anschliessend
  235. aufaddiert wurden:
  236. <P>
  237.  
  238. <PRE>
  239. /* Mittelwert ausrechnen */
  240. max=0.0;
  241. for(i=0;i<NRANGES;i++){
  242.     max =max + (i-(NRANGES/2))*b_Fa[i];
  243. }
  244. </PRE>
  245.  
  246.  
  247. <HR><!----------------------------------------------------------------->
  248.  
  249. <A HREF="index.html">Hier</A> geht's zur Einführung zum Fuzzy-Pendel
  250. zurück, und <A HREF="implement.html">hier</A> gibt's Informationen
  251. über die Implementierung.
  252.  
  253. <HR><!----------------------------------------------------------------->
  254.  
  255. Hubert Feyrer, <A HREF="http://dusk.rz.uni-regensburg.de/Personal/hubert/hubert_feyrer.html">hubert.feyrer@rz.uni-regensburg.de</A>
  256.