Geschwindigkeitsmessstrecke mit Arduino: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
 
(205 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
[[Kategorie:Projekte]]  
[[Kategorie:Projekte]]  


'''Author:''' [[Benutzer:Syed-Rafsan_Ishtiaque| Syed Rafsan Ishtiaque ]]<br/>
[[Datei:SpeedTrackerGIF.gif|mini|600px|Abb. 1: Geschwindigkeitsmessstrecke]]
'''Category:''' Part of Main Internship<br>
'''Duration:''' 02.05.2023 - 21.08.2023<br>
'''Supervisor:''' [[Benutzer:Ulrich_Schneider| Prof. Dr.-Ing Ulrich Schneider]]<br/>


'''BILD!'''
'''Author:''' [[Benutzer:....| ... ]]<br/>
'''Art:''' Praxissemester<br>
'''Dauer:''' 02.05.2023 - 21.08.2023<br>
'''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Dr.-Ing Ulrich Schneider]]<br/>


== Einleitung ==
== Einleitung ==
Developing the speed measuring unit for any car project
Entwicklung der Geschwindigkeitsmesseinheit für jedes Fahrzeugprojekt. Das Messwerkzeug basiert auf Infrarotsensoren, die analoge Daten von einem vorbeifahrenden Auto erhalten und die Daten auf einem Arduino berechnen. Das Ergebnis kann auf einem LCD-Display angezeigt werden.


== Anforderungen ==
== Anforderungen ==
Zeile 25: Zeile 25:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|  
| 13.07.2023
|-
|-
| 2
| 2
Zeile 32: Zeile 32:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|  
| 13.07.2023
|-
|-
| 3
| 3
Zeile 39: Zeile 39:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|  
| 13.07.2023
|-
|-
| 4
| 4
Zeile 46: Zeile 46:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|  
| 13.07.2023
|-
|-
| 5
| 5
Zeile 53: Zeile 53:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|
| 13.07.2023
|-
|-
| 6
| 6
Zeile 60: Zeile 60:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|
| 13.07.2023
|-
|-
| 7
| 7
Zeile 67: Zeile 67:
| Ulrich Schneider
| Ulrich Schneider
| 30.06.2023
| 30.06.2023
|  
| Rafsan
|
| 13.07.2023
|-
| 8
| Die Messunsicherheit vom Typ A muss unter 1&thinsp;% liegen. Beispiel: 1&thinsp;m/s ± 0,01&thinsp;m/s (1&thinsp;𝜎)
| Ulrich Schneider
| 13.07.2023
| Rafsan
| 20.07.2023
|}
|}


== Funktionaler Systementwurf/Technischer Systementwurf ==
== Funktionaler Systementwurf/Technischer Systementwurf ==


== Komponentenspezifikation ==
<gallery widths="750" heights="400">
Datei:Technical system design.jpg|600px|mini|Abb. 2: Dieser Entwurf zeigt die Wechselwirkungen zwischen den Komponenten des Systems
Datei:Car 1 Uni Direction.gif|600px|mini|Abb. 3: Diese Animation zeigt, wie die Messeinheit funktionieren wird. Hier 300 mph(mile per hour) = 3 mps(meter per second)
</gallery>
 
== Komponentenspezifikation (Elektronische Komponenten) ==
 
 
=== Sensor ===
Sharp 2D120X F 09
 
Der Sharp Abstandsmesssensor wird verwendet, um die Geschwindigkeit der Kabineneinheit zu bestimmen. In diesem Fall wurden zwei identische Sensoren verwendet. Nach Angaben des Herstellers [https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf SHARP] <ref name="sharp"> https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf </ref>, Die Reichweite des Sensors beträgt 4 cm bis 30 cm, typische Ansprechzeit ca. 39 ms, typische Einschaltverzögerung ca. 44 ms, durchschnittliche Stromaufnahme: 33 mA. Die Betriebstemperatur beträgt -10°C bis 60°C, was ideal für dieses Projekt ist.
Laut dem Stempel auf dem Sensor war das Herstellungsdatum September 2016. Laut Datenblatt sollte der Sensor auf einem beliebigen Rahmen so montiert werden, dass er das
optimales Ergebnis liefert. Dazu gibt es eine allgemeine Anleitung auf der [https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf Data Sheet] <ref name="sharp" />.
 
 
''' [Aktualisierung] ''' <br>
Wir hatten ein Problem mit dem Sharp D120XF09 Modell des Infrarotsensors. Deshalb haben wir die Infrarotsensoren komplett ausgetauscht. Wir haben ein neues Modell eingesetzt, [https://global.sharp/products/device/lineup/data/pdf/datasheet/gp2y0a41sk_e.pdf Sharp 0A41SKF94] <ref name="sharp nue"> https://global.sharp/products/device/lineup/data/pdf/datasheet/gp2y0a41sk_e.pdf </ref>
 
=== Display ===
 
==== LED-basierte 8-Segment-Anzeige ====
Der ursprüngliche Plan für das Projekt war eine einfache LED-basierte 8-Segment-Anzeige. Als Referenz, die [https://www.mikrocontroller.net/articles/LED LED tutorial] <ref> https://www.mikrocontroller.net/articles/LED </ref> Leitfaden für Mikrocontroller verwendet wurde. Aber das hatte seine Grenzen.
Deshalb haben wir beschlossen, das Display mit [https://datasheetgo.com/c547b-datasheet-npn-transistor/ C547B transistor] <ref> https://datasheetgo.com/c547b-datasheet-npn-transistor/ C547B </ref> .
Ein erstes Modell wird mit dem Transistor C547B entwickelt. <br>
 
<gallery widths="600" heights="300">
Datei:Sensor_infrared.jpg|400px|mini|Abb. 4: Abstandsmesssensor
Datei:DisplayLEDTransistor.jpg|400px|mini|Abb. 5: Display LED Transistor
</gallery>
 
'''[Aktualisierung]'''<br>
1. Die Schaltung für die LED-Anzeige hat funktioniert. Sie wurde für ein Segment, bestehend aus zwei LED, getestet. Die Versorgungsspannung war 5V, Basiswiderstand 1K Ohm, Kollektorwiderstand 470 Ohm. <br>
2. Wir haben den kompletten Schaltungsaufbau für die LED-Anzeige abgeschlossen. Aber wir werden jetzt eine LCD-Anzeige implementieren. Der Grund dafür ist, dass eine digitale LCD-Anzeige es uns ermöglicht
mehr Daten im Zusammenhang mit dem Geschwindigkeitsmesssensor anzuzeigen. Außerdem sind die Daten übertragbar und können für spätere Zwecke gespeichert werden.
 
==== LCD-Anzeige Blau mit I²C  ====
Die LCD-Anzeige, die wir verwenden werden, ist QAPASS LCD I²C. Dies ist eine Variante der normalen LCD-Anzeige. Es ist kombiniert mit einer [https://de.wikipedia.org/wiki/I%C2%B2C I²C] module <ref>https://de.wikipedia.org/wiki/I%C2%B2C </ref>. Dies wird es uns ermöglichen, dem System weitere Funktionen hinzuzufügen.
Die nächste Entwicklung von I²C ist I³C. Sowohl I²C als auch I³C wurden als "Controller"- und "Target"-Bussystem konzipiert (früheres Master- und Slave-Buskonzept). Die beiden Signalleitungen für I²C sind SCL: Serial Clock und SDA: Serielle Datenleitung.
Aber wir müssen die [[Inter-Integrated_Circuit_Bus_(I2C)#:~:text=The%20I%202%20C%20bus%20is%20not%20used%20for%20data%20transmission%20over%20long%20distances.%20Common%20connections%20are%20in%20the%20range%20of%20less%20than%20one%20meter.%20One%20reason%20for%20this%20is%20the%20susceptibility%20of%20the%20bus%20to%20interference%20with%20longer%20lines%2C%20which%20is%20why%20it%20is%20usually%20only%20used%20within%20a%20shielded%20device.|distance]] der Datenübertragung bei Verwendung des I²C. Das LCD-Display ist funktionsfähig. Es empfängt Meldungen und zeigt sie an. Der nächste Schritt wird sein, die Sensordaten zu optimieren und ein robustes System zu entwickeln.
 
<gallery widths="600" heights="300">
Datei:LCD_Front.jpg|400px|mini|Abb. 6: LCD Vorderansicht
Datei:LCD_rear.jpg|400px|mini|Abb. 7: LCD Rückansicht
</gallery>
 
==== Weiterentwicklung mit display ====
Anstatt ein LCD-basiertes Display zu verwenden, können wir das MQTT-Protokoll implementieren, um das Endergebnis vom Sensor in unserem Smartphone mit Hilfe des Raspberry Pi zu erhalten. So können wir das Ergebnis bequemer aufzeichnen. Während der Implementierung des MQTT-Protokolls wird das Raspberry Pi-Modul als MQTT-Broker arbeiten und sowohl Arduino als auch Smartphone werden MQTT-Clients sein. Der Broker empfängt Sensordaten vom Arduino (1. Client) und leitet die Nachricht an das Smartphone (2. Client) weiter. Da das System nur dazu verwendet wird, die vom Sensor gesammelten und vom Arduino verarbeiteten Daten zu empfangen und den Sensor nicht zu steuern, wird es unidirektional sein; das bedeutet, dass wir den Teil ausschließen, der jeden Sensor von der Smartphone-Anwendung aus steuern kann.
 
=== Externe Energiequelle ===
 
Wir haben auch eine externe Stromquelle für die Messeinheit eingeführt. Wir verwenden 6 Stück 1,5-V-Batterien. Die Gesamtspannung beträgt 8,07 V. Die Batterien befinden sich in einem Batteriehalter, der ebenfalls an der Hauptstruktur befestigt ist.
 
<gallery widths="600" heights="300">
Datei:External_power_source.jpg|400px|mini|Abb. 8: externe Stromquelle für die Messeinheit
Datei:Switch_external_power.jpg|400px|mini|Abb. 9: SPST-Schalter zur Steuerung der externen Stromquelle
</gallery>
 
=== Schalter ===
 
Wir haben einen externen SPST-Schalter verwendet, um das Gerät zu steuern. Er wird zwischen der Batterie und dem Arduino angeschlossen.
 
=== Arduino-Schild ===
 
Unser Hauptmikrocontroller ist ein Arduino Uno. Aber wir haben ein externes Schild auf ihm verwendet. Der Grund für die Verwendung des Shields ist es, all die Drähte von den Sensoren und dem Display mit einer externen Einheit zu verbinden, die wiederum mit dem Haupt-Arduino verbunden ist. Die Verbindung zwischen dem Shield und den verschiedenen Sensoren/Displays/elektronischen Komponenten ist robuster, da wir sie mit Schrauben festziehen können. Auch die Pins des Shields haben wir nach unseren Anforderungen verlötet. Auf diese Weise müssen wir den Haupt-Arduino nicht anlassen, können aber trotzdem die Verdrahtung und die Verbindungen nach unseren Bedürfnissen ändern.
 
=== Arduino ===
 
Wir haben den Arduino Uno für unser Projekt verwendet. Dies ist ein perfektes Werkzeug für diese Art von Projekt
 
<gallery widths="600" heights="300">
Datei:Shield_on-top_of_arduino.jpg|400px|mini|Abb. 10: Abschirmung auf dem Arduino (Draufsicht)
Datei:Shield_arduino_side_view.jpg|400px|mini|Abb. 11: Abschirmung und Arduino (Seitenansicht)
</gallery>
 
== Umsetzung (Hardware) ==
 
 
 
=== LCD-Display-Halter ===
 
Um den LCD-Bildschirm an der Hauptstruktur zu befestigen, haben wir eine Halterung in Solidworks entworfen und im 3D-Drucker ausgedruckt. Das Halterungsmodell kann je nach Bedarf aktualisiert werden.
 
 
<gallery widths="750" heights="400">
Datei:LCD Holder front.jpg|600px|mini|Abb. 12: Die Vorderansicht des LCD-Display-Halters
Datei:LCD Holder back.jpg|600px|mini|Abb. 13: Die Rückansicht des LCD-Display-Halters
</gallery>
 
=== LCD kable zugentlastung ===
 
Unser LCD hat 4 Pins. Aber vor, die Drähte mit den Stiften verbunden waren nicht stabil genug. Manchmal hatten wir das Problem, dass die Verbindung nicht kohärent war. Dann haben wir eine kable zugentlastung entwickelt, um das Problem zu lösen. Es gab nur wenige Modelle davon auf dem Markt, aber wir haben sie nach unseren Anforderungen angepasst. Sie wird auf der Rückseite des LCD-Halters montiert.
 
<gallery widths="300" heights="480">
Datei:LCD kable zugentlastung.jpg|600px|mini|Abb. 14: 3D-Konstruktion der Kabelzugentlastung
Datei:LCD_kable_zugentlastung_printed.jpg|600px|mini|Abb. 15: 3D gedruckte Teile von Kabelzugentlastung
</gallery>
 
=== Abdeckung für Sensor ===
 
Um den Infrarotsensor vor Lichtreflexionen zu schützen, haben wir diese 3D-gedruckte Abdeckung angebracht. Diese wird oben auf den Sensor montiert.
 
<gallery widths="300" heights="480">
Datei:Sensor cover.jpg|500px|mini|Abb. 16: 3D-Design der Sensorabdeckung
Datei:Sensor-cover-printed.jpg|500px|mini|Abb. 17: 3D-gedruckter Teil der Sensorabdeckung
</gallery>
 
=== Schalterhalter ===
 
Wir haben eine Schalterhalterung für die externe Batteriestromquelle der Messeinheit entworfen. Der Halter hatte zwei Ausführungen. Wir haben uns für die zweite Variante entschieden.
 
 
 
<gallery widths="700" heights="300">
Datei:SwitchHalter.jpg|600px|mini|Abb. 18: 3D-Design der SwitchHalter
 
</gallery>
 
=== Der Grundrahmen ===
 
Der Grundrahmen unserer Messeinheit ist aus Holz gefertigt. Wir haben ihn mit Schrauben stabilisiert. Der Rahmen enthält alle Komponenten
 
<gallery widths="900" heights="300">
Datei:Main_structure.jpg|600px|mini|Abb. 19: Der Grundrahmen
 
</gallery>
 
=== Die Kabelrinne ===
 
Wir hatten so viele Kabel, die von den Sensoren ausgingen und zur Abschirmung führten. Um unser Gerät stabiler zu machen, haben wir einen Kabelträger eingeführt. Sie fasst alle Kabel in ihrem Inneren.
 
<gallery widths="600" heights="300">
Datei:Cable_tray.jpg|600px|mini|Abb. 20: Kabelträger, in dem alle Kabel untergebracht sind
 
</gallery>
 
== Umsetzung (Software) ==
 
=== Programmierung ===
 
 
Der Arduino-Code für den Sensor und die LCD-Anzeigen wird entwickelt und implementiert. Wir haben Medianfilter verwendet, um das Rauschen zu unterdrücken/zu begrenzen. Wir werden zwei getrennte Arrays für den Medianfilter erstellen. Für jedes Array gibt es separate Indexzeiger. Daher werden die Daten der beiden Sensoren separat herausgefiltert, sodass sich das Rauschen des einen nicht auf das des anderen auswirkt.<br>
Die nächste Modifikation kann eine bidirektionale Messung sein. Das bedeutet, dass der Geschwindigkeitsmesser die Geschwindigkeit aus beiden Richtungen messen kann.
 
 
 
=== Link zum Quelltext in SVN ===
 
Der Code für dieses Projekt wird auf den SVN-Server hochgeladen<br>
 
SVN-Link zum Arduino-Code für die Geschwindigkeitsmessstrecke: [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/FinalSpeedTrackerCode12-7-2023/FinalSpeedTrackerCode12-7-2023.ino <code>FinalSpeedTrackerCode12-7-2023.ino</code>]
 
== Systemtest ==
* Für den Systemtest wir ein AlphaBot verwendet, der mit konstanter Geschwindigkeit fährt (<code>GeradeausfahrtAlphaBot.ino</code>).
Um die Geschwindigkeit des Alphabots zu steuern, müssen wir die Geschwindigkeit des Motors steuern. Dazu haben wir den oben genannten Code geändert. <br>
 
Der neue Code  [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/AlphabotSpeedTest/AlphabotWheelSpeedGraduallyIncrease/AlphabotWheelSpeedGraduallyIncrease.ino <code>AlphabotWheelSpeedGraduallyIncrease.ino</code>] kann den Wert von GESCHWINDIGKEIT von 0 bis 250 mit einer Schrittweite von 10 ändern. Zu diesem Zweck haben wir eine weitere Tabelle (2) erstellt, die zeigt, bei welchem Wert von SPEED ( 0 bis 250) sich die Räder wie viele Meter in einer Sekunde drehen. Wir haben einige reale Variablen ausgeschlossen, wie z.B. den Wirkungsgrad der Batterie, die Reibung, die Oberfläche, die Last des Alphabots, etc. Unser Hauptziel in diesem Abschnitt ist es, den Alphabot mit der gewünschten Geschwindigkeit zu betreiben.  In unserem Fall ist der Durchmesser des Rades 0,064 Meter. Der Umfang ist also 3,1416 * 0,064 Meter. Das bedeutet, dass eine 360-Grad-Drehung des Rades 0,201 m zurücklegt. Wenn wir also unser Alphabot mit einer Geschwindigkeit von 1 Meter pro Sekunde laufen lassen wollen, müssen wir das Rad in 1 Sekunde etwa 5 Mal drehen. Aus unserer neuen GESCHWINDIGKEIT-Tabelle können wir also ersehen, mit welchem Wert von GESCHWINDIGKEIT im Code das Rad in einer Sekunde 5 Mal gedreht werden kann.<br>
 
Nun der zweite Teil der Ermittlung der Geschwindigkeit der Räder. Wir müssen die Anzahl der Drehungen der Räder messen. Im Abschnitt „Arduino IDE-Beispiele“ gibt es dafür bereits einen Code.
(<code>E15_RadInkrementalgeberFahrt.ino</code>). Aber wir haben den Code leicht geändert. Wir haben unseren Code zur schrittweisen Geschwindigkeitserhöhung damit kombiniert. Dieser neue modifizierte Code
[https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/AlphabotSpeedTest/AlphabotWheelEncoderGradualSpeedCombi/AlphabotWheelEncoderGradualSpeedCombi.ino <code>AlphabotWheelEncoderGradualSpeedCombi.ino</code>] ermöglicht es uns, die Drehung der Räder mit zunehmender Geschwindigkeit zu messen.<br>
 
Dann haben wir die Geschwindigkeit der Räder des Alphabots in Meter pro Sekunde berechnet. Da wir den Umfang der Räder kennen (0,201 Meter), und wir die Gesamtdrehung der Räder haben (Radumdrehungen-L/R), multiplizieren wir diese mit dem Radumfang Umfang des Rades multipliziert, erhalten wir die zurückgelegte Gesamtstrecke in Metern. Da die Räder 5 Sekunden lang gelaufen sind, ergibt die Division dieser Strecke durch 5 die Durchschnittsgeschwindigkeit in Metern pro Sekunde für jedes Rad. Durchschnitt der individuellen Geschwindigkeit des linken und des rechten Rades gebildet und die Referenzgeschwindigkeit des Alphabots berechnet.<br>
Linke oder rechte Räder Geschwindigkeit = RadumdrehungenLinks(oder RadumdrehungenRechts) * Radumfang / 5<br>
 
Alphabots Referenzgeschwindigkeit = ( Geschwindigkeit der linken Räder + Geschwindigkeit der rechten Räder ) / 2<br>
 
Die Daten des neuen Codes [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/AlphabotSpeedTest/AlphabotWheelSpeedFromRotation.ino <code>AlphabotWheelSpeedFromRotation.ino</code>]  sind in Tabelle 2 aufgeführt.<br>
 
Aber wir müssen bedenken, dass diese Daten, die wir in Tabelle 2 haben, anhand der freien Drehung der Räder gemessen werden. Auf dem Surface wird es also nicht dasselbe sein. Und der Grund für die Messung dieser Daten ist, dass wir den Unterschied in der Radgeschwindigkeit (links und rechts) sehen können. Wir wissen, dass wir die Radgeschwindigkeit einfach anpassen können, indem wir die Position des Potentiometers ändern, aber diese Methode kann es uns ermöglichen, die Radgeschwindigkeit genau einzustellen, selbst wenn wir separate Eingaben vornehmen müssen, unsere Ausgabe wird immer gleich sein. Wir haben unseren Code so geändert, dass er für die beiden verschiedenen Räder unterschiedliche Geschwindigkeitswerte annehmen kann, die kombinierte Geschwindigkeit jedoch immer gleich ist. <br>
 
Aber praktisch stellen wir die Referenzgeschwindigkeit manuell ein, indem wir den Alphabot zwischen zwei Punkten fahren lassen, die Zeit berechnen und die Geschwindigkeit ermitteln. Allerdings ist diese Methode nicht völlig fehlerfrei, und wenn wir die Zeit mit der Stoppuhr messen, sind wir möglicherweise nicht genau. <br>
 
Bei den Daten in Tabelle 2 müssen wir auch bedenken, dass die Position des Potentiometers wichtig ist. Diese Daten in Tabelle 2 haben wir für die folgende Position des Potentiometers erhalten. Wenn wir also die Position des Potentiometers ändern, werden sich auch die Werte oder die Geschwindigkeit der Räder ändern.
 
<gallery widths="400" heights="400">
Datei:Potentio meters position.jpg|600px|mini|Abb. 21: Die Position des Potentiometer für die spezifischen Daten in Tabelle 2, wenn wir die Position ändern, werden die Daten auch geändert werden
</gallery>


== Programmierung ==


== Komponententest ==
'''Beispiel'''
{| class="wikitable"
{| class="wikitable"
! style="font-weight: bold;" | ID
|+ style = "text-align: left"|Tabelle 2: Geschwindigkeit des Alphabots-Rads (Meter/Sekunde) in Bezug auf die Werte von GESCHWINDIGKEIT im Code<br>
! style="font-weight: bold;" | Testfallbeschreibung
|-
! style="font-weight: bold;" | Eingänge x,y,PosAlt,Ausrichtung,Karte,Bumper,Ultraschall,Perimeterschleife
| GESCHWINDIGKEIT Wert im Code (0-255)|| 0-75||80||85||90||95||100||105||110||115||120||125||130||135||140||145||150||155||160||165||170||175||180||185||190||195||200||205||210||215||220||225||230||235||240||245||250||255
! style="font-weight: bold;" | Erwartetes Ergebnis
|-
! style="font-weight: bold;" | Testergebnis
| Geschwindigkeit für Link (m/s)                      ||0||0.24||0.28||0.28||0.32||0.36||0.32||0.36||0.40||0.40||0.40||0.40||0.44||0.44||0.44||0.48||0.48||0.48||0.48||0.52||0.48||0.52||0.52||0.56||0.52||0.52||0.56||0.56||0.56||0.56||0.56||0.56||0.56||0.60||0.56||0.60||0.60
! style="font-weight: bold;" | Testperson
|-
! style="font-weight: bold;" | Datum
| Geschwindigkeit für Recht (m/s)                      ||0||0.40||0.44||0.48||0.52||0.52||0.56||0.56||0.56||0.60||0.64||0.68||0.68||0.68||0.68||0.72||0.76||0.76||0.76||0.76||0.80||0.76||0.80||0.80||0.80||0.84||0.80||0.80||0.84||0.84||0.88||0.88||0.84||0.88||0.88||0.88||0.92
|+ style = "text-align: left"|Tabelle 4: Testbericht für den Komponententest von <code>Kartenfunktion.m</code>
|-
|-
| 1
| Durchschnittsgeschwindigkeits (m/s)                  ||0||0.32||0.36||0.38||0.42||0.44||0.44||0.46||0.48||0.50||0.52||0.54||0.56||0.56||0.56||0.60||0.62||0.62||0.62||0.64||0.64||0.64||0.66||0.68||0.66||0.68||0.68||0.68||0.70||0.70||0.72||0.72||0.70||0.74||0.72||0.74||0.76
| Der Mäher fährt kein Feld weiter.
| 0.1, 0.0, [0;0], 0, Karte, 0, 0, 1000
| Kein neues Feld wird blau markiert.
| OK
| Prof. Schneider
| 21.01.2018
|}
|}
== Zusammenfassung ==


== Link zum Quelltext in SVN ==


{| class="wikitable"
 
|+ style = "text-align: left"|Table 1: Functional Requirement
<gallery widths="600" heights="400">
! style="font-weight: bold;" | ID
Datei:AlphabotSpeed5Incrementjpg.jpg|600px|mini|Abb. 22: Erhöhen der Geschwindigkeit des Alphabots um 5 und Zählen der Geschwindigkeit der beiden Räder
! style="font-weight: bold;" | Topic
 
! style="font-weight: bold;" | Result
Datei:AlphaSpeed5increment.gif|600px|mini|Abb. 23: Video über die Geschwindigkeit der einzelnen Alphabots
! style="font-weight: bold;" | Date
 
! style="font-weight: bold;" | Comment (if any)
</gallery>
 
 
 
* Als Referenz wird die Fahrt gefilmt und das Video analysiert, um die Referenzgeschwindigkeit zu ermitteln.<br>
 
Hier haben wir nun unseren zweiten Ansatz zur Bestimmung der Referenzgeschwindigkeit des Alphabots. Heute (20. Juli 2023) haben wir den Potentiometer so eingestellt, dass beide Räder die gleiche Geschwindigkeit haben. Dann sind wir mit dem Alphabot eine bestimmte Strecke gefahren, haben die Zeit mit einer Stoppuhr berechnet und die Geschwindigkeit gemessen. Später haben wir den Testlauf des Alphabots vor unserem Speed Tracker durchgeführt und die Geschwindigkeit des Alphabots mit der Speed Tracker-Messeinheit gemessen. Also haben wir den Wert von "GESCHWINDIGKEIT" in diesem Code geändert. [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/AlphabotSpeedTest/E01_MotorenTest/E01_MotorenTest.ino <code>E01_MotorenTest.ino</code>] . Wir haben die Messungen jeweils 10 mal für GESCHWINDIGKEIT = 100, 110, 120, 125, 150 durchgeführt. Die detaillierten Daten und Ergebnisse unseres Tests finden Sie in der folgenden Tabelle 3. Auch haben wir unsere Videos aufgenommen. Da wir aber eine hochwertige DSLR-Kamera verwendet haben, ist das Video zu groß, um es hier zu veröffentlichen. Aber wir haben sie in unserem Computer. Außerdem können wir die Videos wegen der Größe nicht auf SVN hochladen. <br>
 
<gallery widths="400" heights="250">
Datei:AlphabotinfrontofSpeedTracker.jpg|400px|mini|Abb. 24: Kameraeinstellung zu Dokumentations- und Testzwecken
Datei:0.54 ms.jpg|400px|mini|Abb. 25: Alphabots Geschwindigkeit gemessen mit dem Speed Tracker
Datei:0.53 ms.jpg|400px|mini|Abb. 26: Alphabots Geschwindigkeit gemessen mit dem Speed Tracker
</gallery>
 
<gallery widths="1200" heights="700">
Datei:FinalTestAlphaVideoPart.jpg|800px|mini|Abb. 27: Da das Video, das wir während des Tests aufgenommen haben, von der Länge und Größe her zu groß ist, haben wir hier einen Teil davon gepostet. Das Hauptvideo ist auf unserem Arbeitscomputer verfügbar. 
 
</gallery>
 
<gallery widths="400" heights="250">
Datei:0.63 ms.jpg|400px|mini|Abb. 28: Alphabots Geschwindigkeit gemessen mit dem Speed Tracker
Datei:0.44 ms.jpg|400px|mini|Abb. 29: Alphabots Geschwindigkeit gemessen mit dem Speed Tracker 
Datei:0.49 ms.jpg|400px|mini|Abb. 30: Alphabots Geschwindigkeit gemessen mit dem Speed Tracker 
</gallery>
 
 
Außerdem haben wir einen externen Reflektor am Alphabot angebracht, um einen genaueren Wert für die Geschwindigkeit zu erhalten. Dieser neue Reflektor ist auf dem Chassis des Alphabot montiert.
<gallery widths="400" heights="400">
Datei:NewReflector.jpg|400px|mini|Abb. 31:  Externen Reflektor am Alphabot angebracht, um einen genaueren Wert für die Geschwindigkeit zu erhalten 
 
</gallery>
 
 
 
 
* Aus der Messung wir das vollständige Messergebnis mit Messunsicherheit Typ A (<math>u_A</math>) berechnet. <br>
Wir haben das in Matlab berechnet und die Daten in Tabelle 3 eingetragen
* Referenz, Messwerte und Ergebnis werden in Tabelle 3 eingetragen. <br>
Alle Werte sind in Tabelle 3 gespeichert
* Der Systemtest gilt als bestanden, wenn der Mittelwert <math>\bar{v_{Mess}}</math> dem Referenzwert <math>v_{Ref}</math> entspricht und  <math>u_A <1\,\%\cdot v_{Ref}</math>. <br>
Der Systemtest ist erfolgreich bestanden
 
{| role="presentation" class="wikitable mw-collapsible mw-collapsed"
| <code>GeradeausfahrtAlphaBot.ino &thinsp;</code>
|-
|-
| 1
|
| Sensors measuring data
<syntaxhighlight lang="c" style="background-color: #EFF1C1; font-size:larger">
| Both of the sensors functional
/* Bibliotheken einbinden */
| 30.06.2023
#include "AlphaBot.h"
| The range of measurement is optimum, 30 cm
AlphaBot hAlphaBot = AlphaBot();  // Instanz des AlphaBot wird erzeugt.
 
/* Globale Konstanten definieren */
#define GESCHWINDIGKEIT 80  // Geschw. wählbar: 0 - 255; Min: 80
 
void setup() {
  hAlphaBot.SetSpeed(GESCHWINDIGKEIT);  // Geschw. setzen: 0 - 255
}
 
void loop() {
  /* Es folgen verschiedene Testmodule. Kommentieren Sie alles bis auf das gewünschte aus. */
 
  delay(1000);
  hAlphaBot.Forward(5000);  // AlphaBot fährt für 5s mit beiden Motoren vorwärts
  hAlphaBot.Brake();
}
 
</syntaxhighlight>
|}
 
 
 
{| role="presentation" class="wikitable mw-collapsible mw-collapsed"
| <code>E15_RadInkrementalgeberFahrt.ino &thinsp;</code>
|-
|-
| 2
| LCD display showing results
| The measured data can be seen
| 30.06.2023
| The display has a good color contrast
|-
| 3
| External power source
|
|
|
|
|-
<syntaxhighlight lang="c" style="background-color: #EFF1C1; font-size:larger">
| 4
/* Bibliotheken einbinden */
| Base & structure of the Unit
#include "AlphaBot.h"
| The measuring unit has a solid base and stable structure
 
| 30.06.2023
/* Globale KONSTANTEN deklarieren */
| The lose parts of the previous version were fixed
AlphaBot R2D2 = AlphaBot();              // Instanz des Alphabot wird erzeugt. */
|-
const byte PORT_ENC_L_u8 = 2;            // Die linke Lichtschranke (CNTL) liegt an Arduino D2
const byte PORT_ENC_R_u8 = 3;            // Die rechte Lichtschranke (CNTR) liegt an Arduino D3
const byte ANZAHL_INCREMENTE_u8 = 40;    // Die Encoderscheibe hat 20 Löcher und somit 40 Zustände
const int MOTOR_POWER_s16 = 80;          // Motorleistung
const unsigned long BAUDRATE_u32 = 9600;  // Serielle Übertragungsgeschwindigkeit in Baud
const unsigned long DELAY_MS_u32 = 1000;  // Delay in ms
 
/* Globale Variablen */
byte valEncL_u8 = 0;              // https://www.arduino.cc/reference/de/language/variables/data-types/byte/
byte valEncR_u8 = 0;              // Inkrementzähler
long int RadumdrehungenL_s32 = 0;  // https://www.arduino.cc/reference/de/language/variables/data-types/long/
long int RadumdrehungenR_s32 = 0;  // Zähler für die kompletten Radumdrehungen
 
/* Einmalige Systeminitialisierung */
void setup() {
  Serial.begin(BAUDRATE_u32);                // Seriellen Monitor starten
  pinMode(PORT_ENC_L_u8, INPUT);              // Eingangsport D2 definieren
  pinMode(PORT_ENC_R_u8, INPUT);              // Eingangsport D3 definieren
  attachInterrupt(0, updateEncoderL, CHANGE); // 0: D2 Auslösen des Interrupts bei Signalwechsel
  attachInterrupt(1, updateEncoderR, CHANGE); // 1: D3 https://www.arduino.cc/reference/de/language/functions/external-interrupts/attachinterrupt/
}
/* Zyklusschleife */
void loop() { 
  /* Ausgaben im Seriellen Monitor */
  Serial.print(valEncL_u8);
  Serial.print(" :-: ");
  Serial.print(valEncR_u8);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenL_s32);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenR_s32);
  Serial.print("\n");
  delay(DELAY_MS_u32);
 
  R2D2.MotorRun(MOTOR_POWER_s16, MOTOR_POWER_s16);  // Fahrt starten
  delay(DELAY_MS_u32);                              // Fahrzeit
  R2D2.Brake();                                    // Alle Motoren stoppen
}
 
/* Unterfunktionen */
void updateEncoderL(){                  // Inkrementalgeber Links
  valEncL_u8++;
  if (valEncL_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung
  {
    valEncL_u8 = 0;                    // Reset Inkrementzähler
    RadumdrehungenL_s32++;              // Umdrehungen inkrementieren
  }
}
 
void updateEncoderR(){                  // Inkrementalgeber Rechts
  valEncR_u8++;
  if (valEncR_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung
  {
    valEncR_u8 = 0;                    // Reset Inkrementzähler
    RadumdrehungenR_s32++;              // Umdrehungen inkrementieren
  }
}
 


</syntaxhighlight>
|}
|}
[[Datei:Test result.jpg||600px|mini|Abb. 31: Testergebnis aus Matlab-Skript]] 
<br>
<br>


{| class="wikitable"
{| class="wikitable"
|+ style = "text-align: left"|Table 2: Non-Functional Requirement
|+ style = "text-align: left"|Tabelle 3: Systemtest für die Geschwindigkeit
! style="font-weight: bold;" | ID
! style="font-weight: bold;" | Topic
! style="font-weight: bold;" | Result
! style="font-weight: bold;" | Date
! style="font-weight: bold;" | Comment (if any)
|-
|-
| 1
! # !! <math>v_{Soll}/\frac{m}{s}</math>    !! <math>v_{Ref}/\frac{m}{s}</math>!! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! <math>\bar{v}/\frac{m}{s}</math> !! <math>u_A/\frac{m}{s}</math>!! <math>u_A <1\,\%\cdot v_{Ref}</math>
| Sensors have protector shade on top
| The measured data is consistent
| 30.06.2023
| Direct interference of light can alter sensor data
|-
|-
| 2
| 1 || 0,44 || 0,44|| 0,44|| 0,43  || 0,44  ||  0,44    || 0,43||  0,44  ||  0,44 || 0,43 ||  0,44 ||0,44  ||0,4370  || 0,0013827 ||  ✅
| LCD user interface
| LCD shows a staring announcement and other necessary ones
| 30.06.2023
| The interface is user friendly
|-
|-
| 3
| 2 || 0,49 || 0,49|| 0,49|| 0,49  ||  0,48 ||    0,50  ||0,49 ||  0,49  ||  0,48  || 0,49 ||  0,49  || 0,49  || 0,4890 || 0,0029005 ||  ✅
| Controlling of the power source
|  
|  
|
|-
|-
| 4
| 3 || 0,52 || 0,52|| 0,52|| 0,53  ||  0,52 ||    0,53  ||0,53 ||    0,52 ||  0,53  || 0,53 || 0,52  || 0,52  ||  0,5250|| 0,0032354 ||  ✅
| Cable stress relief for LCD
|  
|  
|  
|-
|-
| 5
| 4 || 0,55 || 0,55||0,54 || 0,55  ||0,56  ||  0,56    || 0,55||    0,54 ||  0,55  || 0,56 || 0,54  ||  0,56 || 0,5510 || 0,0019316 ||
| Cable and wire holder for the Unit
| A protective tray on the bottom for holding cables
| 30.06.2023
| To avoid wire/ cable entanglement, it was necessary
|-
| 6
| External Arduino shield for future development
| A shield is attached on the arduino
| 30.06.2023
| Useful for any development or if needs to repair
|-
|-
| 5 || 0,64 ||0,64 || 0,64||  0,63 ||  0,64 ||    0,64  || 0,65||  0,64  ||  0,63  || 0,65 ||  0,64 || 0,64  || 0,6400 || 0,002232 ||  ✅
|}
Matlab<sup>®</sup>-Skript für die Berechnung der Standardunsicherheit vom Typ A: [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/Ergebnisauswertung/berechneMessunsicherheit.m <code>berechneMessunsicherheit.m</code>] <br>
Für den Systemtest des Speed-Trackers haben wir diese Version des ursprünglichen Matlab-Skripts verwendet: [https://svn.hshl.de/svn/HSHL_Projekte/trunk/ET_Versuchsaufbauten/Geschwindigkeitsmessstrecke/Software/Ergebnisauswertung/berechneMessunsicherheitSpeedTrackerWiki.m <code>berechneMessunsicherheitSpeedTrackerWiki.m</code>] <br>
Sehr wichtiger Hinweis. Da wir das Alphabots-Rad von Hand und mit Verschiebepotentiometer eingestellt haben, war es nicht ganz genau. So lief unser Alphabot die meiste Zeit nicht geradeaus. Auch die Batterieleistung war eine Tatsache. Da wir mindestens 40 Versuche brauchten, um 10 Ergebnisse zu erhalten, war die Batterie sehr schnell leer. Wenn das Alphabot also nicht geradeaus läuft oder seine Geschwindigkeit nicht konstant ist, verliert es seinen Wert als Referenz. Obwohl unser Ziel darin bestand, die Genauigkeit des Speed-Tracker-Systems zu testen, haben wir festgestellt, dass die Leistung unseres Speed-Trackers viel besser ist als die des Alphabot. Aber wir haben unser Bestes gegeben, um ein erfolgreiches Testergebnis zu erzielen.
== Komponententest ==


|}


== Hardware ==


=== Sensor ===
Sharp 2D120X F 09


The Sharp distance measuring sensor is used to determine the speed/ velocity of the car unit. In this case, two identical sensors were used. According to the manufacturer [https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf SHARP] <ref name="sharp"> https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf </ref>, the range of the sensor is 4 cm to 30 cm, typical response time apprx. 39 ms,  typical start up delay apprx. 44 ms,  Average Current Consumption: 33 mA. The operating temperature is -10°C to 60°C, so that is ideal for
=== Test im Labor ===
this project as it is initially an indoor project. according to the stamp on the sensor, the manufacturing date was September 2016. According to the data sheet, the sensor should be mounted on any frame in such way that it gives the
optimum result. For that the general instructions are available on the [https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf Data Sheet] <ref name="sharp" />.


=== Display ===
Wir haben unsere Messeinheit im Labor überprüft. Es misst die Geschwindigkeit eines Objekts, das vor ihm bewegt wird.


==== LED Based 8 segment display ====
<gallery widths="600" heights="300">
A simple LED based 8 segment display was the initial plan for the project. For reference, the [https://www.mikrocontroller.net/articles/LED LED tutorial] <ref> https://www.mikrocontroller.net/articles/LED </ref> guide for Micro-controller was used. But it had limitation.
Datei:Speed_2Decimal_Display.jpg|400px|mini|Abb. 32: Gemessene Geschwindigkeit in 2 Dezimalstellen auf dem LCD
So we decided to upgrade the display with [https://datasheetgo.com/c547b-datasheet-npn-transistor/ C547B transistor] <ref> https://datasheetgo.com/c547b-datasheet-npn-transistor/ C547B </ref> .
Datei:Speed_3Decimal_calculation.jpg|400px|mini|Abb. 33: Gemessene Geschwindigkeit in 3 Dezimalstellen, die im seriellen Monitor des IDE angezeigt werden
An initial model is developed with C547B transistor. <br>
</gallery>


'''[Update]'''<br>
== Projektunterlagen ==
1. The circuit for LED display worked. It was tested for one segment, consisting two LED. The supply voltage was 5V, base resistor 1K ohm, collector resistor 470 Ohm. <br>
=== Projektplan ===
2. We finalized the complete circuit setup for the LED display. But we will now implement a LCD display. The reason for doing that, a digital LCD display will enable us to
showcase more data related to the speed tracking sensor. Also the data can be transferable and possible to store it for future reference.


==== LCD Display Blue with I²C  ====
The LCD display we will use is QAPASS LCD I²C. This is a variant of the normal LCD display. It is combined with an [https://de.wikipedia.org/wiki/I%C2%B2C I²C] module <ref>https://de.wikipedia.org/wiki/I%C2%B2C </ref>. This will enable us to add further feature to the system.
The next development of I²C is I³C. Both I²C and I³C were designed as "Controller" and "Target" bus system (previous master & slave bus concept). The two signal lines for I²C are SCL: Serial Clock and SDA: Serial Data line.
But we have to consider the [[Inter-Integrated_Circuit_Bus_(I2C)#:~:text=The%20I%202%20C%20bus%20is%20not%20used%20for%20data%20transmission%20over%20long%20distances.%20Common%20connections%20are%20in%20the%20range%20of%20less%20than%20one%20meter.%20One%20reason%20for%20this%20is%20the%20susceptibility%20of%20the%20bus%20to%20interference%20with%20longer%20lines%2C%20which%20is%20why%20it%20is%20usually%20only%20used%20within%20a%20shielded%20device.|distance]] of the data transmission while using the I²C. The LCD display is functional. It is receiving messages and displaying them. Next step will be optimizing the sensor data and making a robust system.


==== Future development ====
Instead of using a led based display we can implement MQTT protocol to get the end result from the sensor in our smartphone with help of raspberry pi. That will allow to record the result more conveniently. During the implementation of MQTT protocol, the raspberry pi module will work as MQTT broker and both Arduino and Smartphone will be MQTT client. The broker will receive sensory data from the Arduino (1st client) and then it will forward the message to the smartphone (2nd client). As the system will only be used to receive the data collected by the sensor and processed by the arduino and not to control the sensor, it will be uni-directional; that means we will opt out the part to control any sensor from the smartphone application.


=== LCD Display Holder ===
<gallery widths="1100" heights="500">
Datei:SpeedTracker_Project.jpg|600px|mini|Abb. 34: Der Projektplan des Speedtrackers, beschrieben in einem Gantt-Diagramm (Die himmelblauen Aufgaben stammen aus dem Speed Tracker-Projekt)


To mount the LCD on the main structure, we have designed a holder in Solidworks and printed it in 3D printer. The holder model can be updated based on requirements.
</gallery>


== Source Code ==
== Zusammenfassung ==
The arduino code for the sensor and LCD displays are developed and implemented. We used median filters to cancel out/ limit the noise. We will made two separated arrays for the median filter. For each array there will be separate index pointers. So the two sensors data will be filtered out separately, in that way one's noise will not affect the other.<br>
'''[Update]''' We are modifying the code so that the speed tracker can measure the speed from both direction


== Test Run ==
Für das Projekt zur Geschwindigkeitsmessung mussten wir zunächst unser Hauptziel herausfinden. Dann mussten wir die verfügbaren Komponenten verwenden. Wenn die Komponenten geändert werden mussten, haben wir auch das getan (Beispiel Shield). Wir mussten den Code für unser Projekt passend machen. Die Implementierung des Filters war eine großartige Idee, um das Rauschen zu unterdrücken. Der Einsatz von Solidworks und 3D-Druck war notwendig, um die Hardware-Teile unseres Projekts realisierbar zu machen. Die Verdrahtung war am Anfang eine kleine Herausforderung. Die Arbeitsmethoden des Lötens wurden mit der Zeit entwickelt. Während des Projekts waren wir mit vielen Einschränkungen konfrontiert. Zum Beispiel hatten wir zunächst den Plan, ein LED-basiertes Display zu verwenden. Dann sind wir zu LCD übergegangen. Wir begannen mit einem anderen Sensor und änderten auch diesen später. Das Shield hat so viele Änderungen erfahren. Selbst als wir alles zusammengebaut hatten und das System nicht funktionierte, haben wir unsere Arbeit auf der Grundlage des aktuellen Szenarios ständig aktualisiert. Wann immer wir auf Komplikationen stießen, haben wir alles noch einmal gründlich überprüft. Wir experimentierten auf verschiedene Weise, um die Probleme und Lösungen herauszufinden. Alle unsere täglichen Arbeiten während des Projekts sind im Tagesprotokoll kurz beschrieben. Wir hatten unser Projekt sehr gut geplant und organisiert. Danke an die unermüdliche Unterstützung von Herrn Ebmeyer. Wir haben verschiedene Labore für verschiedene Zwecke genutzt. Auch die Online-Ressourcen waren hilfreich. Am Ende war es eine sehr schöne, positive Erfahrung in diesem Projekt zu arbeiten.
We tested our measurement setup the remote controlled car and it worked good for uni-directional way. For bi-Directional, we still are in development phase.


== Literature ==
== Literature ==

Aktuelle Version vom 13. Dezember 2023, 00:50 Uhr


Abb. 1: Geschwindigkeitsmessstrecke

Author: ...
Art: Praxissemester
Dauer: 02.05.2023 - 21.08.2023
Betreuer: Prof. Dr.-Ing Ulrich Schneider

Einleitung

Entwicklung der Geschwindigkeitsmesseinheit für jedes Fahrzeugprojekt. Das Messwerkzeug basiert auf Infrarotsensoren, die analoge Daten von einem vorbeifahrenden Auto erhalten und die Daten auf einem Arduino berechnen. Das Ergebnis kann auf einem LCD-Display angezeigt werden.

Anforderungen

Tabelle 1: Funktionale Anforderungen an die Geschwindigkeitsmessstrecke
ID Inhalt Ersteller Datum Geprüft von Datum
1 Die Geschwindigkeit eines vorbeifahrenden RC-Fahrzeugs muss in m/s auf 3 Nachkommastellen genau gemessen werden. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
2 Die Geschwindigkeitsmessstrecke muss im Akkubetrieb laufen. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
3 Die Geschwindigkeitsmessstrecke muss über einen Schalter ein- und ausgeschaltet werden können. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
4 Die Geschwindigkeitsmessstrecke muss auf einem Display auf 2 Nachkommastellen in m/s angezeigt werden. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
5 Der Aufbau muss robust und professionell sein und mind. 10 Jahre betrieben werden können. Alle Verbindungen müssen hierzu zugentlastet sein. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
6 Die Arduino IDE muss für die Programmierung verwendet werden. Die Programmierrrichtlinien sind einzuhalten und der Quelltext ist nachhaltig zu kommentieren. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
7 Der Quelltext ist in SVN zu sichern und in diesem Artikel zu verlinken. Ulrich Schneider 30.06.2023 Rafsan 13.07.2023
8 Die Messunsicherheit vom Typ A muss unter 1 % liegen. Beispiel: 1 m/s ± 0,01 m/s (1 𝜎) Ulrich Schneider 13.07.2023 Rafsan 20.07.2023

Funktionaler Systementwurf/Technischer Systementwurf

Komponentenspezifikation (Elektronische Komponenten)

Sensor

Sharp 2D120X F 09

Der Sharp Abstandsmesssensor wird verwendet, um die Geschwindigkeit der Kabineneinheit zu bestimmen. In diesem Fall wurden zwei identische Sensoren verwendet. Nach Angaben des Herstellers SHARP [1], Die Reichweite des Sensors beträgt 4 cm bis 30 cm, typische Ansprechzeit ca. 39 ms, typische Einschaltverzögerung ca. 44 ms, durchschnittliche Stromaufnahme: 33 mA. Die Betriebstemperatur beträgt -10°C bis 60°C, was ideal für dieses Projekt ist. Laut dem Stempel auf dem Sensor war das Herstellungsdatum September 2016. Laut Datenblatt sollte der Sensor auf einem beliebigen Rahmen so montiert werden, dass er das optimales Ergebnis liefert. Dazu gibt es eine allgemeine Anleitung auf der Data Sheet [1].


[Aktualisierung]
Wir hatten ein Problem mit dem Sharp D120XF09 Modell des Infrarotsensors. Deshalb haben wir die Infrarotsensoren komplett ausgetauscht. Wir haben ein neues Modell eingesetzt, Sharp 0A41SKF94 [2]

Display

LED-basierte 8-Segment-Anzeige

Der ursprüngliche Plan für das Projekt war eine einfache LED-basierte 8-Segment-Anzeige. Als Referenz, die LED tutorial [3] Leitfaden für Mikrocontroller verwendet wurde. Aber das hatte seine Grenzen. Deshalb haben wir beschlossen, das Display mit C547B transistor [4] . Ein erstes Modell wird mit dem Transistor C547B entwickelt.

[Aktualisierung]
1. Die Schaltung für die LED-Anzeige hat funktioniert. Sie wurde für ein Segment, bestehend aus zwei LED, getestet. Die Versorgungsspannung war 5V, Basiswiderstand 1K Ohm, Kollektorwiderstand 470 Ohm.
2. Wir haben den kompletten Schaltungsaufbau für die LED-Anzeige abgeschlossen. Aber wir werden jetzt eine LCD-Anzeige implementieren. Der Grund dafür ist, dass eine digitale LCD-Anzeige es uns ermöglicht mehr Daten im Zusammenhang mit dem Geschwindigkeitsmesssensor anzuzeigen. Außerdem sind die Daten übertragbar und können für spätere Zwecke gespeichert werden.

LCD-Anzeige Blau mit I²C

Die LCD-Anzeige, die wir verwenden werden, ist QAPASS LCD I²C. Dies ist eine Variante der normalen LCD-Anzeige. Es ist kombiniert mit einer I²C module [5]. Dies wird es uns ermöglichen, dem System weitere Funktionen hinzuzufügen. Die nächste Entwicklung von I²C ist I³C. Sowohl I²C als auch I³C wurden als "Controller"- und "Target"-Bussystem konzipiert (früheres Master- und Slave-Buskonzept). Die beiden Signalleitungen für I²C sind SCL: Serial Clock und SDA: Serielle Datenleitung. Aber wir müssen die distance der Datenübertragung bei Verwendung des I²C. Das LCD-Display ist funktionsfähig. Es empfängt Meldungen und zeigt sie an. Der nächste Schritt wird sein, die Sensordaten zu optimieren und ein robustes System zu entwickeln.

Weiterentwicklung mit display

Anstatt ein LCD-basiertes Display zu verwenden, können wir das MQTT-Protokoll implementieren, um das Endergebnis vom Sensor in unserem Smartphone mit Hilfe des Raspberry Pi zu erhalten. So können wir das Ergebnis bequemer aufzeichnen. Während der Implementierung des MQTT-Protokolls wird das Raspberry Pi-Modul als MQTT-Broker arbeiten und sowohl Arduino als auch Smartphone werden MQTT-Clients sein. Der Broker empfängt Sensordaten vom Arduino (1. Client) und leitet die Nachricht an das Smartphone (2. Client) weiter. Da das System nur dazu verwendet wird, die vom Sensor gesammelten und vom Arduino verarbeiteten Daten zu empfangen und den Sensor nicht zu steuern, wird es unidirektional sein; das bedeutet, dass wir den Teil ausschließen, der jeden Sensor von der Smartphone-Anwendung aus steuern kann.

Externe Energiequelle

Wir haben auch eine externe Stromquelle für die Messeinheit eingeführt. Wir verwenden 6 Stück 1,5-V-Batterien. Die Gesamtspannung beträgt 8,07 V. Die Batterien befinden sich in einem Batteriehalter, der ebenfalls an der Hauptstruktur befestigt ist.

Schalter

Wir haben einen externen SPST-Schalter verwendet, um das Gerät zu steuern. Er wird zwischen der Batterie und dem Arduino angeschlossen.

Arduino-Schild

Unser Hauptmikrocontroller ist ein Arduino Uno. Aber wir haben ein externes Schild auf ihm verwendet. Der Grund für die Verwendung des Shields ist es, all die Drähte von den Sensoren und dem Display mit einer externen Einheit zu verbinden, die wiederum mit dem Haupt-Arduino verbunden ist. Die Verbindung zwischen dem Shield und den verschiedenen Sensoren/Displays/elektronischen Komponenten ist robuster, da wir sie mit Schrauben festziehen können. Auch die Pins des Shields haben wir nach unseren Anforderungen verlötet. Auf diese Weise müssen wir den Haupt-Arduino nicht anlassen, können aber trotzdem die Verdrahtung und die Verbindungen nach unseren Bedürfnissen ändern.

Arduino

Wir haben den Arduino Uno für unser Projekt verwendet. Dies ist ein perfektes Werkzeug für diese Art von Projekt

Umsetzung (Hardware)

LCD-Display-Halter

Um den LCD-Bildschirm an der Hauptstruktur zu befestigen, haben wir eine Halterung in Solidworks entworfen und im 3D-Drucker ausgedruckt. Das Halterungsmodell kann je nach Bedarf aktualisiert werden.


LCD kable zugentlastung

Unser LCD hat 4 Pins. Aber vor, die Drähte mit den Stiften verbunden waren nicht stabil genug. Manchmal hatten wir das Problem, dass die Verbindung nicht kohärent war. Dann haben wir eine kable zugentlastung entwickelt, um das Problem zu lösen. Es gab nur wenige Modelle davon auf dem Markt, aber wir haben sie nach unseren Anforderungen angepasst. Sie wird auf der Rückseite des LCD-Halters montiert.

Abdeckung für Sensor

Um den Infrarotsensor vor Lichtreflexionen zu schützen, haben wir diese 3D-gedruckte Abdeckung angebracht. Diese wird oben auf den Sensor montiert.

Schalterhalter

Wir haben eine Schalterhalterung für die externe Batteriestromquelle der Messeinheit entworfen. Der Halter hatte zwei Ausführungen. Wir haben uns für die zweite Variante entschieden.


Der Grundrahmen

Der Grundrahmen unserer Messeinheit ist aus Holz gefertigt. Wir haben ihn mit Schrauben stabilisiert. Der Rahmen enthält alle Komponenten

Die Kabelrinne

Wir hatten so viele Kabel, die von den Sensoren ausgingen und zur Abschirmung führten. Um unser Gerät stabiler zu machen, haben wir einen Kabelträger eingeführt. Sie fasst alle Kabel in ihrem Inneren.

Umsetzung (Software)

Programmierung

Der Arduino-Code für den Sensor und die LCD-Anzeigen wird entwickelt und implementiert. Wir haben Medianfilter verwendet, um das Rauschen zu unterdrücken/zu begrenzen. Wir werden zwei getrennte Arrays für den Medianfilter erstellen. Für jedes Array gibt es separate Indexzeiger. Daher werden die Daten der beiden Sensoren separat herausgefiltert, sodass sich das Rauschen des einen nicht auf das des anderen auswirkt.
Die nächste Modifikation kann eine bidirektionale Messung sein. Das bedeutet, dass der Geschwindigkeitsmesser die Geschwindigkeit aus beiden Richtungen messen kann.


Link zum Quelltext in SVN

Der Code für dieses Projekt wird auf den SVN-Server hochgeladen

SVN-Link zum Arduino-Code für die Geschwindigkeitsmessstrecke: FinalSpeedTrackerCode12-7-2023.ino

Systemtest

  • Für den Systemtest wir ein AlphaBot verwendet, der mit konstanter Geschwindigkeit fährt (GeradeausfahrtAlphaBot.ino).

Um die Geschwindigkeit des Alphabots zu steuern, müssen wir die Geschwindigkeit des Motors steuern. Dazu haben wir den oben genannten Code geändert.

Der neue Code AlphabotWheelSpeedGraduallyIncrease.ino kann den Wert von GESCHWINDIGKEIT von 0 bis 250 mit einer Schrittweite von 10 ändern. Zu diesem Zweck haben wir eine weitere Tabelle (2) erstellt, die zeigt, bei welchem Wert von SPEED ( 0 bis 250) sich die Räder wie viele Meter in einer Sekunde drehen. Wir haben einige reale Variablen ausgeschlossen, wie z.B. den Wirkungsgrad der Batterie, die Reibung, die Oberfläche, die Last des Alphabots, etc. Unser Hauptziel in diesem Abschnitt ist es, den Alphabot mit der gewünschten Geschwindigkeit zu betreiben. In unserem Fall ist der Durchmesser des Rades 0,064 Meter. Der Umfang ist also 3,1416 * 0,064 Meter. Das bedeutet, dass eine 360-Grad-Drehung des Rades 0,201 m zurücklegt. Wenn wir also unser Alphabot mit einer Geschwindigkeit von 1 Meter pro Sekunde laufen lassen wollen, müssen wir das Rad in 1 Sekunde etwa 5 Mal drehen. Aus unserer neuen GESCHWINDIGKEIT-Tabelle können wir also ersehen, mit welchem Wert von GESCHWINDIGKEIT im Code das Rad in einer Sekunde 5 Mal gedreht werden kann.

Nun der zweite Teil der Ermittlung der Geschwindigkeit der Räder. Wir müssen die Anzahl der Drehungen der Räder messen. Im Abschnitt „Arduino IDE-Beispiele“ gibt es dafür bereits einen Code. (E15_RadInkrementalgeberFahrt.ino). Aber wir haben den Code leicht geändert. Wir haben unseren Code zur schrittweisen Geschwindigkeitserhöhung damit kombiniert. Dieser neue modifizierte Code AlphabotWheelEncoderGradualSpeedCombi.ino ermöglicht es uns, die Drehung der Räder mit zunehmender Geschwindigkeit zu messen.

Dann haben wir die Geschwindigkeit der Räder des Alphabots in Meter pro Sekunde berechnet. Da wir den Umfang der Räder kennen (0,201 Meter), und wir die Gesamtdrehung der Räder haben (Radumdrehungen-L/R), multiplizieren wir diese mit dem Radumfang Umfang des Rades multipliziert, erhalten wir die zurückgelegte Gesamtstrecke in Metern. Da die Räder 5 Sekunden lang gelaufen sind, ergibt die Division dieser Strecke durch 5 die Durchschnittsgeschwindigkeit in Metern pro Sekunde für jedes Rad. Durchschnitt der individuellen Geschwindigkeit des linken und des rechten Rades gebildet und die Referenzgeschwindigkeit des Alphabots berechnet.

Linke oder rechte Räder Geschwindigkeit = RadumdrehungenLinks(oder RadumdrehungenRechts) * Radumfang / 5

Alphabots Referenzgeschwindigkeit = ( Geschwindigkeit der linken Räder + Geschwindigkeit der rechten Räder ) / 2

Die Daten des neuen Codes AlphabotWheelSpeedFromRotation.ino sind in Tabelle 2 aufgeführt.

Aber wir müssen bedenken, dass diese Daten, die wir in Tabelle 2 haben, anhand der freien Drehung der Räder gemessen werden. Auf dem Surface wird es also nicht dasselbe sein. Und der Grund für die Messung dieser Daten ist, dass wir den Unterschied in der Radgeschwindigkeit (links und rechts) sehen können. Wir wissen, dass wir die Radgeschwindigkeit einfach anpassen können, indem wir die Position des Potentiometers ändern, aber diese Methode kann es uns ermöglichen, die Radgeschwindigkeit genau einzustellen, selbst wenn wir separate Eingaben vornehmen müssen, unsere Ausgabe wird immer gleich sein. Wir haben unseren Code so geändert, dass er für die beiden verschiedenen Räder unterschiedliche Geschwindigkeitswerte annehmen kann, die kombinierte Geschwindigkeit jedoch immer gleich ist.

Aber praktisch stellen wir die Referenzgeschwindigkeit manuell ein, indem wir den Alphabot zwischen zwei Punkten fahren lassen, die Zeit berechnen und die Geschwindigkeit ermitteln. Allerdings ist diese Methode nicht völlig fehlerfrei, und wenn wir die Zeit mit der Stoppuhr messen, sind wir möglicherweise nicht genau.

Bei den Daten in Tabelle 2 müssen wir auch bedenken, dass die Position des Potentiometers wichtig ist. Diese Daten in Tabelle 2 haben wir für die folgende Position des Potentiometers erhalten. Wenn wir also die Position des Potentiometers ändern, werden sich auch die Werte oder die Geschwindigkeit der Räder ändern.


Tabelle 2: Geschwindigkeit des Alphabots-Rads (Meter/Sekunde) in Bezug auf die Werte von GESCHWINDIGKEIT im Code
GESCHWINDIGKEIT Wert im Code (0-255) 0-75 80 85 90 95 100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180 185 190 195 200 205 210 215 220 225 230 235 240 245 250 255
Geschwindigkeit für Link (m/s) 0 0.24 0.28 0.28 0.32 0.36 0.32 0.36 0.40 0.40 0.40 0.40 0.44 0.44 0.44 0.48 0.48 0.48 0.48 0.52 0.48 0.52 0.52 0.56 0.52 0.52 0.56 0.56 0.56 0.56 0.56 0.56 0.56 0.60 0.56 0.60 0.60
Geschwindigkeit für Recht (m/s) 0 0.40 0.44 0.48 0.52 0.52 0.56 0.56 0.56 0.60 0.64 0.68 0.68 0.68 0.68 0.72 0.76 0.76 0.76 0.76 0.80 0.76 0.80 0.80 0.80 0.84 0.80 0.80 0.84 0.84 0.88 0.88 0.84 0.88 0.88 0.88 0.92
Durchschnittsgeschwindigkeits (m/s) 0 0.32 0.36 0.38 0.42 0.44 0.44 0.46 0.48 0.50 0.52 0.54 0.56 0.56 0.56 0.60 0.62 0.62 0.62 0.64 0.64 0.64 0.66 0.68 0.66 0.68 0.68 0.68 0.70 0.70 0.72 0.72 0.70 0.74 0.72 0.74 0.76



  • Als Referenz wird die Fahrt gefilmt und das Video analysiert, um die Referenzgeschwindigkeit zu ermitteln.

Hier haben wir nun unseren zweiten Ansatz zur Bestimmung der Referenzgeschwindigkeit des Alphabots. Heute (20. Juli 2023) haben wir den Potentiometer so eingestellt, dass beide Räder die gleiche Geschwindigkeit haben. Dann sind wir mit dem Alphabot eine bestimmte Strecke gefahren, haben die Zeit mit einer Stoppuhr berechnet und die Geschwindigkeit gemessen. Später haben wir den Testlauf des Alphabots vor unserem Speed Tracker durchgeführt und die Geschwindigkeit des Alphabots mit der Speed Tracker-Messeinheit gemessen. Also haben wir den Wert von "GESCHWINDIGKEIT" in diesem Code geändert. E01_MotorenTest.ino . Wir haben die Messungen jeweils 10 mal für GESCHWINDIGKEIT = 100, 110, 120, 125, 150 durchgeführt. Die detaillierten Daten und Ergebnisse unseres Tests finden Sie in der folgenden Tabelle 3. Auch haben wir unsere Videos aufgenommen. Da wir aber eine hochwertige DSLR-Kamera verwendet haben, ist das Video zu groß, um es hier zu veröffentlichen. Aber wir haben sie in unserem Computer. Außerdem können wir die Videos wegen der Größe nicht auf SVN hochladen.


Außerdem haben wir einen externen Reflektor am Alphabot angebracht, um einen genaueren Wert für die Geschwindigkeit zu erhalten. Dieser neue Reflektor ist auf dem Chassis des Alphabot montiert.



  • Aus der Messung wir das vollständige Messergebnis mit Messunsicherheit Typ A () berechnet.

Wir haben das in Matlab berechnet und die Daten in Tabelle 3 eingetragen

  • Referenz, Messwerte und Ergebnis werden in Tabelle 3 eingetragen.

Alle Werte sind in Tabelle 3 gespeichert

  • Der Systemtest gilt als bestanden, wenn der Mittelwert dem Referenzwert entspricht und .

Der Systemtest ist erfolgreich bestanden


Abb. 31: Testergebnis aus Matlab-Skript



Tabelle 3: Systemtest für die Geschwindigkeit
# 1 2 3 4 5 6 7 8 9 10
1 0,44 0,44 0,44 0,43 0,44 0,44 0,43 0,44 0,44 0,43 0,44 0,44 0,4370 0,0013827
2 0,49 0,49 0,49 0,49 0,48 0,50 0,49 0,49 0,48 0,49 0,49 0,49 0,4890 0,0029005
3 0,52 0,52 0,52 0,53 0,52 0,53 0,53 0,52 0,53 0,53 0,52 0,52 0,5250 0,0032354
4 0,55 0,55 0,54 0,55 0,56 0,56 0,55 0,54 0,55 0,56 0,54 0,56 0,5510 0,0019316
5 0,64 0,64 0,64 0,63 0,64 0,64 0,65 0,64 0,63 0,65 0,64 0,64 0,6400 0,002232


Matlab®-Skript für die Berechnung der Standardunsicherheit vom Typ A: berechneMessunsicherheit.m
Für den Systemtest des Speed-Trackers haben wir diese Version des ursprünglichen Matlab-Skripts verwendet: berechneMessunsicherheitSpeedTrackerWiki.m

Sehr wichtiger Hinweis. Da wir das Alphabots-Rad von Hand und mit Verschiebepotentiometer eingestellt haben, war es nicht ganz genau. So lief unser Alphabot die meiste Zeit nicht geradeaus. Auch die Batterieleistung war eine Tatsache. Da wir mindestens 40 Versuche brauchten, um 10 Ergebnisse zu erhalten, war die Batterie sehr schnell leer. Wenn das Alphabot also nicht geradeaus läuft oder seine Geschwindigkeit nicht konstant ist, verliert es seinen Wert als Referenz. Obwohl unser Ziel darin bestand, die Genauigkeit des Speed-Tracker-Systems zu testen, haben wir festgestellt, dass die Leistung unseres Speed-Trackers viel besser ist als die des Alphabot. Aber wir haben unser Bestes gegeben, um ein erfolgreiches Testergebnis zu erzielen.

Komponententest

Test im Labor

Wir haben unsere Messeinheit im Labor überprüft. Es misst die Geschwindigkeit eines Objekts, das vor ihm bewegt wird.

Projektunterlagen

Projektplan

Zusammenfassung

Für das Projekt zur Geschwindigkeitsmessung mussten wir zunächst unser Hauptziel herausfinden. Dann mussten wir die verfügbaren Komponenten verwenden. Wenn die Komponenten geändert werden mussten, haben wir auch das getan (Beispiel Shield). Wir mussten den Code für unser Projekt passend machen. Die Implementierung des Filters war eine großartige Idee, um das Rauschen zu unterdrücken. Der Einsatz von Solidworks und 3D-Druck war notwendig, um die Hardware-Teile unseres Projekts realisierbar zu machen. Die Verdrahtung war am Anfang eine kleine Herausforderung. Die Arbeitsmethoden des Lötens wurden mit der Zeit entwickelt. Während des Projekts waren wir mit vielen Einschränkungen konfrontiert. Zum Beispiel hatten wir zunächst den Plan, ein LED-basiertes Display zu verwenden. Dann sind wir zu LCD übergegangen. Wir begannen mit einem anderen Sensor und änderten auch diesen später. Das Shield hat so viele Änderungen erfahren. Selbst als wir alles zusammengebaut hatten und das System nicht funktionierte, haben wir unsere Arbeit auf der Grundlage des aktuellen Szenarios ständig aktualisiert. Wann immer wir auf Komplikationen stießen, haben wir alles noch einmal gründlich überprüft. Wir experimentierten auf verschiedene Weise, um die Probleme und Lösungen herauszufinden. Alle unsere täglichen Arbeiten während des Projekts sind im Tagesprotokoll kurz beschrieben. Wir hatten unser Projekt sehr gut geplant und organisiert. Danke an die unermüdliche Unterstützung von Herrn Ebmeyer. Wir haben verschiedene Labore für verschiedene Zwecke genutzt. Auch die Online-Ressourcen waren hilfreich. Am Ende war es eine sehr schöne, positive Erfahrung in diesem Projekt zu arbeiten.

Literature



→ zurück zum Hauptartikel: Messaufbauten mit Arduino