Ein Roboter mit bürstenlosem Antrieb, differenzial und NRF24L01 Funk. Großflächig gebaut um ein großes Solarpanel aufzunehmen. https://gitlab.informatik.hs-fulda.de/fdai5253/roboter
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

373 lines
23 KiB

  1. %---------------------------------------------
  2. % Lachaise Assignment
  3. % LaTeX Template
  4. % Version 1.0 (26/6/2018)
  5. %
  6. % This template originates from:
  7. % http://www.LaTeXTemplates.com
  8. %
  9. % Authors:
  10. % Marion Lachaise & François Févotte
  11. % Vel (vel@LaTeXTemplates.com)
  12. %
  13. % License:
  14. % CC BY-NC-SA 3.0 (http://creativecommons.org/licenses/by-nc-sa/3.0/)
  15. %
  16. %---------------------------------------------------
  17. %----------------------------------------------------------------------------------------
  18. % PACKAGES AND OTHER DOCUMENT CONFIGURATIONS
  19. %----------------------------------------------------------------------------------------
  20. \documentclass{article}
  21. % Include the file specifying the document structure and custom commands
  22. \input{structure.tex}
  23. %----------------------------------------------------------------------------------------
  24. % INFORMATION
  25. %----------------------------------------------------------------------------------------
  26. % Title
  27. \title{Open Source Roboter Plattform}
  28. \author{Lukas Reichwein\\ Yves Ehrlich\\ Nick Gnoevoj}
  29. \date{University of Applied Science Fulda --- \today}
  30. %----------------------------------------------------------------------------------------
  31. \begin{document}
  32. \maketitle % Print the title
  33. \tableofcontents % Inhaltsverzeichniss, Achtung zweimal Compilerien!
  34. \newpage
  35. %----------------------------------------------------------------------------------------
  36. % INTRODUCTION
  37. %----------------------------------------------------------------------------------------
  38. \section{Vorwort} % Unnumbered section
  39. \paragraph{Motivation: }
  40. Eine Plattform bieten ist etwas, das momentan sehr stark im Trend liegt, sei es im Software oder im Hardware Bereich. Im Softwarebereich zeigt sich dies meist durch Open-Source Bibliotheken, welche möglichst variabel einsetzbaren Code für jeden frei zugänglich machen.
  41. Ein solches Projekt war auch von einem der Projektmitglieder (Yves Ehrlich) als Privates Projekt geplant und so kam die Überlegung dies innerhalb des Modules Embedded Networking zu wählen.
  42. \paragraph{Basis des Projektes: }
  43. Als Basis des Projektes dient einer schon bereits von Yves Ehrlich angefertigter Arduino Nano Shield samt Code,
  44. \cite{nanoGame} welcher als Fernsteuerung verwendet wird.
  45. \paragraph{Ziel des Projektes: }
  46. Ziel des Projektes ist ein ferngesteuerte, Open-Source basierende Roboterplattform.
  47. \newpage
  48. \section{Überlegung}%Yves
  49. Die urprüngliche Idee war die Entwicklung eines Solarroboters, also eines Roboters, der tagsüber mit Hilfe der Sonneneinstrahlung seinen Eigenbedarf decken kann und somit nur einen kleinen Pufferakku benötigt.
  50. Praktische Anwendungen könnten z.B. die Nutzung als kompakte Straßenkehrmaschine oder als Rasenmäher sein. Bedingt durch die eingeschränkte Leistungsabgabe der Solarzellen vermutlich nur für kleine zu bearbeitende Flächen.
  51. Da es nur wenige brauchbare und frei zugängliche Quellen für solche Plattformen gibt, wollten wir eine eigene schaffen. Daher sollte das Projekt exemplarisch als Grundlage für eine Quelloffene Plattform dienen, die auch von anderen genutzt und weiterentwickelt werden kann.
  52. Da wir bei der Entwicklung der mechanischen Komponenten schnell feststellen mussten, dass das Fahrwerk recht komplex ist, insbesondere die Vorderachse, schwenkten wir schnell auf eine andere Bauweise um. Zunächst war der Aufbau mit 4 gleichen Rädern geplant, von denen zwei Stück (Hinterachse) von einem bürstenlosen Gleichstrommotor angetrieben werden sollten. Die Entwicklung eines Differenzials gestaltete sich noch als relativ einfach. Die Vorderachse aber mit dem Servo gestaltete sich dann, hinsichtlich des Zeitaufwandes, für zu komplex.
  53. \begin{figure}[h]
  54. \includegraphics[width=12cm]{hinterachse.png}
  55. \centering
  56. \caption{Hinterachse des urpsrünglichen Aufbaus}
  57. \end{figure}
  58. \begin{figure}[h]
  59. \includegraphics[width=12cm]{lagerschalen.png}
  60. \centering
  61. \caption{Lagerschalen}
  62. \end{figure}
  63. Somit schwenkten wir kurzer Hand zu einem sehr viel einfacheren Aufbau um, um uns schneller den wichtigeren Komponenten widmen zu können.
  64. Der neue Aufbau sah eine schlichte Grundplatte als Plattform für die weiteren Bauteile, wie Motoren (Mabuchi N20 mit Getriebe), Ultraschallsensor, Akku, Hauptplatine und uvm. vor.
  65. Um möglichst viele Montagemöglichkeiten zu bieten, wurde die Grundplatte mit Bohrungen in regelmäßigen Abständen versehen. Diese Bohrungen können zum durchstecken für Schrauben oder zum versenken von Gewindemuffen genutzt werden.
  66. Zum anbringen unserer Komponenten haben wir auf Messinggewindebuchsen und passende M3 Schrauben gesetzt.
  67. Alle selbstentworfenen Komponenten haben wir mit einem FFF 3D-Drucker aus PLA gedruckt.
  68. Mit Ausnahme der Hauptplatine natürlich.
  69. Bedingt durch den Zeitaufwand des gesamten Projektes und anderer Studienmodule haben wir uns entschieden, die Implementierung eines MPPT Ladereglers fallen zu lassen, somit wurde die Idee des Solarroboters auf die Idee der Entwicklung eines Roboters reduziert.
  70. \newpage
  71. \begin{figure}[h]
  72. \includegraphics[width=12cm]{roboter.png}
  73. \centering
  74. \caption{Der Roboter, aktueller Aufbau}
  75. \end{figure}
  76. \newpage
  77. \section{Mechanik}%Yves
  78. Wie bereits unter „Überlegung“ erwähnt, gestaltete sich der Aufbau mit Achsträger, Radlager und Lagerschalen uvm. als zu Zeitintensiv um in der vorgegebenen Zeit bewältig werden zu können.
  79. Zum Entwurf der mechanischen Bauteile wurde das CAD Programm Fusion 360 von Autodesk verwendet. Dabei gab es kaum Schwierigkeiten, da Yves Ehrlich bereits sehr viel Erfahrung mit 3D-CAD Programmen gesammelt hat. Lediglich der Zwang Windows zu benutzen stellt eine ständige Unannehmlichkeit dar.
  80. Alle Entwürfe wurden mit einem 3D Drucker gedruckt, einem HCmaker7, ein Klon des bekannten Creality CR-10S.
  81. Das Material der Wahl war PLA. Für einen Außeneinsatz ist das Material wegen der geringen Witterungsbeständigkeit kaum geeignet. Insbesondere die geringe Temperaturbeständigkeit (max. 60°C) disqualifizieren das Material für den Einsatz in der Sonne. Da dies aber ohnehin nicht mehr geplant war, ist das Material für unseren Zweck geeignet.
  82. Die Gewindebuchsen in den Kunststoff einzusetzen ist relativ einfach, man benötigt dafür lediglich eine Schraube die man in die Buchse einschraubt und einen Lötkolben mit einer Temperatur von etwa 240°C. Ohne Druck auszuüben legt man die Spitze des Lötkolbens auf den Schraubenkopf. Wenn die Schraube ausreichend Wärme an die Muffe übertragen hat, fängt die Muffe an im Kunststoff zu versinken. Die Schwerkraft sorgt hier für alles nötige. Wenn die Muffe weit genug versunken ist, kann der Lötkolben entfernt werden und man sollte die Schraube schnell abkühlen, z.B. durch pusten oder ein kleines Gebläse wie z.B. einen Radiallüfter.
  83. Beim Design der Kunststoffteile muss man darauf achten, dass für Gewindemuffen stehts eine ausreichend große Fase vorhanden sein muss, damit die Muffe einerseits zentriert wird beim versinken und andererseits kein verdrängtes Material die Muffe beim versinken behindert oder verstopft. Letzterem wird aber auch durch die eingeschraubte Schraube vorgebeugt.
  84. Da Kunststoffe auf glatten Oberflächen sehr wenig Bodenhaftung haben, wurden die Räder mit einer Nut versehen. In diese Nut kann man später ein einfaches Haushaltsgummiband einlegen, somit hat der Roboter auch auf glatten Oberflächen relativ gute Haftung.
  85. Der Aufbau sieht zwei Antriebsmotoren vor, welche jeweils ein Rad treiben. Zum abstützen verfügt der Roboter über ein selbstentworfenes Kugelrad. Dieses Kugelrad verwendet als Kugeln vier handelsübliche Airsoft Kugeln mit einem Durchmesser von 6mm.
  86. Die Gleiteigenschaften dieser Konstruktion sind nicht die besten, aber für diesen Prototypen ausreichend. Um die Reibung zu vermindern haben wir Silikonöl auf die Kugeln aufgetragen.
  87. \newpage
  88. \section{Elektronik}%Yves
  89. Lochrasterplatinen, wie sie häufig für Prototypzwecke genutzt werden, sind nicht nur unpraktisch für SMD Komponenten, auch wenn man ein 2,54mm Raster mit einigen Tricksereien durchaus auch für SMD Komponenten nutzen kann, sie sind auch relativ unzuverlässig und die Fehlersuche gestaltet sich z.T. als schwierig (je nach Menge und Komplexität der Verdrahtungslagen).
  90. Deshalb entschieden wir uns, eine eigene Platine zu entwickeln.
  91. Als Software nutzten wir dafür das kommerzielle Programm Sprint Layout 6 von der Firma Abacom.
  92. Da die Herstellung der Platine von Hand erfolgen sollte, haben wir die Strukturen der Platine sehr grob gezeichnet. Was auch durch die geringe Anzahl an Komponenten und deren modulare Bauweise begünstigt wurde.
  93. \section{Verfahren}%Yves
  94. Als Verfahren zum beschichten der Platine diente die Tonertransfermethode. Dabei wird die Schaltung mit einem Laserdrucker auf geeignetes Papier gedruckt, in diesem Fall Photopapier, und dann mit Hitze auf die blanke Platine gedrückt. Für diesen Zweck hat Yves Ehrlich ein Laminiergerät umgebaut, welches den Vorgang erheblich erleichtert.
  95. Da unsere Platine doppelseitig ist, müssen zuvor die zwei Seiten, welche die Schaltung enthalten Deckungsgleich aufeinander ausgerichtet werden und dann an den Rändern verklebt werden, damit man am Ende eine Art Tasche erhält, in welche dann die Platine eingesteckt werden kann.
  96. Das ganze läuft dann einige Male durch das Laminiergerät. Nach dem das erfolgt ist, lässt man die Platine etwas abkühlen und ab einer Temperatur von etwa 30-40°C schneidet man die Tasche seitlich auf und zieht vorsichtig das Papier ab. Der Toner bleibt am Kupfer haften und schützt an diesen Stellen, wie ein Fotolack, das Kupfer davor weggeätzt zu werden.
  97. Anschließen gibt man die beschichtete Platine in eine Ätzküvette welche mit einer Natriumpersulfat-Lösung gefüllt ist. Nach einiger Zeit kann man beim durchleuchten der Küvette sehen, wie sich das Kupfer immer weiter auflöst, bis am Ende die Schaltung klar und deutlich zu sehen ist. Dann wird die Platine entnommen und gründlich mit Wasser abgespült.
  98. Zum entfernen des Toners benötigt man etwas Aceton und einen Lappen.
  99. Für die THT Komponenten müssen nun noch Bohrungen gesetzt werden. 1,2mm, passend für die Durchkontaktiernieten von Bungard.
  100. Nach dem verpressen (mangels passender Presse eher mit einem Körner breitschlagen) der Nieten, müssen diese beidseitig verlötet werden. Danach können alle Komponenten bestückt werden.
  101. \begin{figure}[h]
  102. \includegraphics[width=16cm]{laminiergeraet.png}
  103. \centering
  104. \caption{Laminiergerät}
  105. \end{figure}
  106. %Platine
  107. \begin{figure}[h]
  108. \centering
  109. \subfigure[Top-Layer]{\includegraphics[width=7.5cm]{pcbTop.png}}
  110. \subfigure[Bottom-Layer]{\includegraphics[width=7.5cm]{pcbBottom.png}}
  111. \caption{fertig geätzte Platine}
  112. \end{figure}
  113. \newpage
  114. \section{Bestücken}%Yves
  115. Zum verlöten der Komponenten kam Feinlot mit Bleianteil zum Einsatz.
  116. Für SMD Komponenten wurde eine Pinzette als Hilfswerkzeug verwendet.
  117. \section{Schaltung}%Yves
  118. Die Schaltung ist relativ einfach gehalten. Im wesentlichen dient die Platine nur als Träger für die modularen Komponenten und für diverse Anschlussmöglichkeiten. Für den NRF24 wurde ein 3,3V Spannungsregler integriert.
  119. Um etwaige Motorenwechsel zu erleichtern, sind zu deren Anschluss Federzugklemmen verbaut worden.
  120. Wegen der Überschaubarkeit der Schaltung haben wir auf einen Schaltplan verzichtet, da das Layout selbsterklärend ist.
  121. \section{Fernsteuerung}%Yves
  122. Auf die Fernsteuerung soll an dieser Stelle nicht näher eingegangen werden, da diese zum Zeitpunkt der Erstellung dieses Projektes bereits „fertig“ war.
  123. Es wurden lediglich ein Joystick sowie ein NRF24 ergänzt.
  124. Detaillierte Informationen finden sich im dazugehörigen Repositorium\cite{nanoGame}.
  125. Im Rahmen eines Arduino Workshops für Anfänger entwickelte Yves Ehrlich eine Platine, welche als Shield für einen Arduino Nano fungiert. Sie enthält grundlegende Dinge wie Tasten, einen Akku, eine stabile 5V Spannungsversorgung sowie ein monochromes LCD Display mit Hintergrundbeleuchtung, um nur die wichtigsten Sachen zu nennen.
  126. Dank der Buchsenleiste auf der Rückseite, welche neben 3,3V und 5V Spannungsversorgung auch diverse I/Os und Analogeingänge bereitstellt, lässt sich das Shield „nanoGame“ hervorragend erweitern und für viele verschiedene Dinge nutzen, so auch als Fernsteuerung für unseren Roboter.
  127. Bei dem Joystick handelt es sich um eine Platine welche ein original Ersatzteil der Sony PSP enthält. Dieser Joystick ist sehr kompakt und ließ sich dadurch recht einfach in unsere Projekt integrieren. Es musste lediglich eine Halterung konstruiert werden, um den Joystick an das Gehäuse der Fernsteuerung zu schrauben.
  128. Beim Funkmodul sind wir kompromissloser vorgegangen. Dieses wurde mit ein wenig Silikonklebstoff an der Oberseite fixiert.
  129. Alle Verbindungsleitungen wurden Freiluft auf der Rückseite der Fernsteuerung zum Schacht der bereits erwähnten Buchsenleiste gelegt und dort mit Steckerleisten angeschlossen.
  130. \begin{figure}[h]
  131. \includegraphics[width=12cm]{rcVorn.png}
  132. \centering
  133. \caption{Fernsteuerung vorn}
  134. \end{figure}
  135. \begin{figure}[h]
  136. \includegraphics[width=12cm]{rcHinten.png}
  137. \centering
  138. \caption{Fernsteuerung hinten}
  139. \end{figure}
  140. \newpage
  141. \section{Code allgemein}%Yves
  142. Um die Einsatzmöglichkeiten für den Code möglichst flexibel zu gestalten, haben wir uns bemüht, nicht blockierenden Quelltext zu schreiben.
  143. Somit lässt sich auch mit dem recht kleinen Atmega328p bei 16 MHz Takt eine ganze Menge bewältigen.
  144. Aktuell ist der Roboter in der Lage auf Kommandos, die er von der Fernsteuerung erhält, zu reagieren. Aus Zeitgründen konnten wir leider nur einen manuellen Fahrmodus implementieren. Dieser beinhaltet das fahren mit digitalen Tasten sowie „analog“ mit dem ergänzten Joystick.
  145. Weiterhin implementiert wurden das erfassen von Temperaturen mit Hilfe eines DS1820 und eine Distanzmessung mit einem HC-SR04 Ultraschallsensor.
  146. Die Übertragung von Kommandos ist relativ einfach gehalten. Das erste Byte im commands Array ist ein Kommando, gefolgt von 2 Bytes mit Daten. Diesem Muster folgend ist jedes dritte Byte ein Kommando, gefolgt von zwei Datenbytes.
  147. Da das Array eine feste Größe von 32 Byte hat, lassen sich folglich bis zu 10 Kommandos übertragen. Wie viele Kommandos jeweils übertragen werden und in welcher Reihenfolge diese im Array vorkommen, also ob Byte 0,3,6,9...usw., spielt keine Rolle.
  148. \newpage
  149. \section{SPI}%Lukas
  150. \subsection{Was ist SPI?}
  151. SPI - Serial Peripheral Interface ist der Standard für ein Synchronen Seriellen Datenbus. Dieser Datenbus kann zwei digitale Schaltungen mittels Master-Slave prinzip verbinden \cite{SPI}. Der Bus ermöglicht die verwendung von Mehreren Slaves, jedoch wird die Anzahl der Slaves durch die Anzahl der CS - ChipSelect Leitungen begrenzt. Die Datenübertragung geschiet über eine Seperate Leitung, auch SD (Serial Data) genannt.
  152. \paragraph{Rolle des Masters}
  153. Der Master gibt das Taktsignal über den SCK (Serial Clock) Ausgang an, desweiteren wählt er einen Slave mit welchem er kommunizieren möchte über den CS (ChipSelect).
  154. \paragraph{Rolle des Slaves}
  155. Der Slave ist solange inaktiv bis dieser über den CS Pin aktiviert wird. Nach der Aktivierung wird über Serial Data kommuniziert, das Taktsignal wird über den SCK Synchronisiert bzw vom Master übernommen.
  156. \subsection{Einsatz von SPI innerhalb des Projektes}
  157. \paragraph{Verbindung: }
  158. Um die Verbindung zwischen dem nRF24L01 Chip und dem Arduino herzustellen wurden zunächst alle Verbindungen getätigt. Im Folgender Graphik ist das Pinout vom nRF24L01 Chip abgebildet. Dabei sind die Kürzel wie folgt benannt: CE - Chip Enable dieser entspricht dem Chip Select Pin, CSN -Ship Select Not dieser ist die Invertierte version des CE, SCK - Serial Clock, MISO - Master in Slave out, MOSI - Master out Slave in und die beiden Pins für die Stromversorgung VCC und Ground. Die beiden pins MISO und MOSI sind die Datenleitungen und werden an den Gleichnamingen Pins des Arduinos angeschlossen. Desweiteren ermöglicht der IRQ Interruptsteuerung dieser Pin ist Optional zu verwenden.
  159. \begin{figure}[h]
  160. \includegraphics[width=8cm]{nRF24L01Pinout.png}
  161. \centering
  162. \caption{Pinout des nRF24L01 Chips \cite{nRF24Pinout}}
  163. \end{figure}
  164. \newpage
  165. \section{Funksteuereung} %Lukas
  166. Wie schon zuvor erwähnt wird für die Basis der Funksteuerung das Arduino Shield verwendet, welches mit dem nRF24L01 Chip erweitert wurde. Der Roboter wurde ebenfalls mit dem nRF24L01 ausgestattet.
  167. \subsection{Allgemeine Verwendung von RF24} %Oder nur als paragraph je nachdem wie viel zusammen kommt.
  168. Die Opensoucre Bibliothek RF24 \cite{RF24Lib} diente als Codebasis für die Funksteuerung. Da diese Bibliothek bei korrekter Verwendung genau auf die Kommunikation zwischen zwei nRF24L01 Chips abgestimmt ist.
  169. Zur Verwendung der Bibliothek muss sie nur inkludiert und Instanziiert werden dabei werden die Beiden Pins CE und CSN für das Hardware-SPI konfiguriert.
  170. \begin{file}[RF24 initialisieren]
  171. \begin{lstlisting}[language=C++]
  172. #include <RF24.h>
  173. RF24 radio(A2, A3); // CE, CSN
  174. const byte address[6] = "00001";
  175. \end{lstlisting}
  176. \end{file}
  177. Damit sind bereits Sämtliche Konfigurationen für die Hardware-SPI Kommunikation zwischen Arduino nano und dem nRF24L01 erledigt.
  178. Kommunizieren zwischen zwei dieser Setups wird dann durch die Funktionen read und wirite,
  179. jedoch muss vor dem Start einer Kommunikation die Methoden begin(),
  180. openWritingPipe(address) mit address als Kommunikationsleitung und stopListening() bei Sender bzw startListening() beim Empfänger aufgerufen werden.
  181. Die Methode setPALevel() setzt den Power Amplifiyer Level umso höher dieser Wert umso Stärker das Signal,
  182. wodurch der Stromverbrauch Steigt.
  183. Der Anstieg des Stromverbrauchs kann auch bei einer nicht ganz konstanten Stromversorgung dazu führen das das Modul nicht korrekt funktioniert.
  184. \begin{file}[RF24 initialisieren]
  185. \begin{lstlisting}[language=C++]
  186. //An der Sender Seite
  187. radio.begin();
  188. radio.openWritingPipe(address);
  189. radio.setPALevel(RF24_PA_MAX);
  190. radio.stopListening();
  191. radio.write(&payload, sizeof(payload));
  192. //An der Empfaenger Seite
  193. radio.begin();
  194. radio.openReadingPipe(0, address);
  195. radio.setPALevel(RF24_PA_MAX);
  196. radio.startListening();
  197. if (radio.available()) {
  198. radio.read(&payload, sizeof(payload));
  199. //Payload weiter verarbeiten.
  200. }
  201. \end{lstlisting}
  202. \end{file}
  203. \subsection{Verwendung innerhalb dieses Projektes}
  204. \paragraph{Am Anfang des Projektes: }
  205. Zu Begin des Projektes wurde zuerst die Funkkommunikation zwischen zwei Arduino's mittels nRF24L01 getestet, dabei gab es schon die ersten Komplikationen. Da der Chip nicht korrekt mit den Hardware SPI Anschlüssen des Arduino verbunden wurde. Nach dem weiteren Einlesen in die Funktionsweise von SPI konnten die Verbindungen richtig gesetzt und diese Komplikation wieder aufgehoben werden.
  206. \paragraph{Logik hinter der Kommunikation: }
  207. Um den Roboter mit der Fernsteuerung auch Steuern zu können musste erst ermittelt werden welche Daten der Roboter benötigt um zu fahren. Diese Daten wurden dann in ein Commands Array gespeichert, welches dann übertragen wurde. Das Array besteht aus Folgenden Inhalten: %TODO Erklärung der Commandos
  208. \newpage
  209. \section{Arduino Libaries} %Lukas
  210. \newpage
  211. \section{Joystick Integration} %Lukas
  212. \newpage
  213. \section{Motorsteuerung} %Yves
  214. %Folgende beiden ließen sich auch durch subsections mittels sensoric als section realisieren, kommt aber auf die menge des textes an subsections sollten nicht über eine halbe seite lang sein.
  215. \newpage
  216. \section{Thermosensor} %Nick
  217. Wie bereits erwähnt benutzen wir einen Dallas DS1820 1-Wire Digital Thermometer, um die Motortemperatur zu messen. Der DS1820 speichert die Temperatur als einen 9bit Wert und kann Temperaturen im Bereich von -55°C bis 125°C messen. Für unsere Bedürfnisse reicht es wenn wir in 1-er Schritten messen. Der Sensor kommt aber auch mit halben Graden zu recht.
  218. Eine Messung wird durchgeführt indem der Sensor Takte, innerhalb eines Zeitfensters zählt. Der Zähler startet bei einem Wert, der -55°C darstellt. Erreicht der Zähler 0 schneller als das vorgegebene Zeitfenster wird das Temperaturregister inkrementiert. Der Zähler wird auf einen vom Slope Accumulator Circuitry abhängigen wert gestellt und wieder runtergezählt. Dies wiederholt sich solange bis das festgelegte Zeitfenster abgelaufen ist.
  219. \newpage
  220. \section{Ultraschallsensor} %Nick
  221. \newpage
  222. %----------------------------------------------------------------------------------------
  223. % Latex Beispeiele
  224. %----------------------------------------------------------------------------------------
  225. \section{Beispiele für Spezielle LaTeX Strukturen}
  226. \begin{info} % Information block
  227. benutze den Info block um wichtige informationen hervorzuheben.
  228. \end{info}
  229. %----------------------------------------------------------------------------------------
  230. % Beispiel für Pseudo Code.
  231. %----------------------------------------------------------------------------------------
  232. \begin{center}
  233. \begin{minipage}{0.5\linewidth} % Adjust the minipage width to accomodate for the length of algorithm lines
  234. \begin{algorithm}[H]
  235. \KwIn{$(a, b)$, two floating-point numbers} % Algorithm inputs
  236. \KwResult{$(c, d)$, such that $a+b = c + d$} % Algorithm outputs/results
  237. \medskip
  238. \If{$\vert b\vert > \vert a\vert$}{
  239. exchange $a$ and $b$ \;
  240. }
  241. $c \leftarrow a + b$ \;
  242. $z \leftarrow c - a$ \;
  243. $d \leftarrow b - z$ \;
  244. {\bf return} $(c,d)$ \;
  245. \caption{\texttt{FastTwoSum}} % Algorithm name
  246. \label{alg:fastTwoSum} % optional label to refer to
  247. \end{algorithm}
  248. \end{minipage}
  249. \end{center}
  250. %-----------------------------------------------------------------------------------------
  251. % Beispiel für Code Snippets.
  252. %----------------------------------------------------------------------------------------
  253. % File contents
  254. \begin{file}[hello.py]
  255. \begin{lstlisting}[language=Python]
  256. #! /usr/bin/python
  257. import sys
  258. sys.stdout.write("Hello World!\n")
  259. \end{lstlisting}
  260. \end{file}
  261. %----------------------------------------------------------------------------------------
  262. % Example for Console Prints (can also be usefull for displaying Serial monitor)
  263. %----------------------------------------------------------------------------------------
  264. % Command-line "screenshot"
  265. \begin{commandline}
  266. \begin{verbatim}
  267. $ chmod +x hello.py
  268. $ ./hello.py
  269. Hello World!S
  270. \end{verbatim}
  271. \end{commandline}
  272. % Warning text, with a custom title
  273. \begin{warn}[Notice:]
  274. Warungen könnten auch nützlich sein, immerhin braucht der RF24 3.3V und nicht 5V
  275. \end{warn}
  276. %----------------------------------------------------------------------------------------
  277. % Beispiel für ein Bild.
  278. %----------------------------------------------------------------------------------------
  279. \begin{figure}[h]
  280. \includegraphics[width=8cm]{fish.png}
  281. \centering
  282. \end{figure}
  283. %----------------------------------------------------------------------------------------
  284. % BIBLIOGRAPHY
  285. %----------------------------------------------------------------------------------------
  286. \bibliographystyle{unsrt}
  287. \bibliography{references.bib}
  288. %----------------------------------------------------------------------------------------
  289. \end{document}