Geschwindigkeitsmessstrecke mit Arduino: Unterschied zwischen den Versionen
Zeile 238: | Zeile 238: | ||
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> | 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. 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. | 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. | 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 | (<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. | |||
{| class="wikitable" | {| class="wikitable" |
Version vom 19. Juli 2023, 12:49 Uhr
Author: Syed Rafsan Ishtiaque
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
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 |
Funktionaler Systementwurf/Technischer Systementwurf
-
Abb. 2: Dieser Entwurf zeigt die Wechselwirkungen zwischen den Komponenten des Systems
-
Abb. 3: Diese Animation zeigt, wie die Messeinheit funktionieren wird. Hier 300 mph(mile per hour) = 3 mps(meter per second)
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.
-
Abb. 4: Abstandsmesssensor
-
Abb. 5: Display LED Transistor
[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.
-
Abb. 6: LCD Vorderansicht
-
Abb. 7: LCD Rückansicht
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.
-
Abb. 8: externe Stromquelle für die Messeinheit
-
Abb. 9: SPST-Schalter zur Steuerung der externen Stromquelle
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
-
Abb. 10: Abschirmung auf dem Arduino (Draufsicht)
-
Abb. 11: Abschirmung und Arduino (Seitenansicht)
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.
-
Abb. 12: Die Vorderansicht des LCD-Display-Halters
-
Abb. 13: Die Rückansicht des LCD-Display-Halters
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.
-
Abb. 14: 3D-Konstruktion der Kabelzugentlastung
-
Abb. 15: 3D gedruckte Teile von Kabelzugentlastung
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.
-
Abb. 16: 3D-Design der Sensorabdeckung
-
Abb. 17: 3D-gedruckter Teil der Sensorabdeckung
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.
-
Abb. 18: 3D-Design der SwitchHalter
Der Grundrahmen
Der Grundrahmen unserer Messeinheit ist aus Holz gefertigt. Wir haben ihn mit Schrauben stabilisiert. Der Rahmen enthält alle Komponenten
-
Abb. 19: Der Grundrahmen
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.
-
Abb. 20: Kabelträger, in dem alle Kabel untergebracht sind
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.
GESCHWINDIGKEIT Wert im Code | 0 | 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100 | 110 | 120 | 130 | 140 | 150 | 160 | 170 | 180 | 190 | 200 | 210 | 220 | 230 | 240 | 250 |
Geschwindigkeit des Alphabots-Rads (m/s) |
- Als Referenz wird die Fahrt gefilmt und das Video analysiert, um die Referenzgeschwindigkeit zu ermitteln.
- Aus der Messung wir das vollständige Messergebnis mit Messunsicherheit Typ A () berechnet.
- Referenz, Messwerte und Ergebnis werden in Tabelle 3 eingetragen.
- Der Systemtest gilt als bestanden, wenn der Mittelwert dem Referenzwert entspricht und .
GeradeausfahrtAlphaBot.ino
|
/* Bibliotheken einbinden */
#include "AlphaBot.h"
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();
}
|
E15_RadInkrementalgeberFahrt.ino
|
/* Bibliotheken einbinden */
#include "AlphaBot.h"
/* Globale KONSTANTEN deklarieren */
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
}
}
|
# | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | |||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | 0,5 | 0,5 | 0,498 | 0,493 | 0,506 | 0,506 | 0,498 | 0,499 | 0,503 | 0,507 | 0,495 | 0,495 | 0,5 | 0,0071 | ✅ |
2 | 1 | 1 | 0.9812 | 0,9032 | 0,9055 | 0,9210 | 1,0254 | 0,9818 | 1,0312 | 1,0451 | 1,0297 | 0,9768 | 0,98 | 0,0181 | ❌ |
Matlab®-Skript für die Berechnung der Standardunsicherheit vom Typ A: berechneMessunsicherheit.m
Komponententest
ID | Testfallbeschreibung | Verschiedene Abstände zwischen dem Fahrzeug und der Messeinheit | Erwartetes Ergebnis | Testergebnis | Testperson | Datum |
---|---|---|---|---|---|---|
1 | Das Auto fährt vor der Messeinheit | Abstand 0 bis 20 cm | ||||
1 | Das Auto fährt vor der Messeinheit | Abstand 20 bis 40 cm | ||||
1 | Das Auto fährt vor der Messeinheit | Abstand 40 bis 60 cm | ||||
1 | Das Auto fährt vor der Messeinheit | Abstand 60 bis 80 cm |
Test im Labor
Wir haben unsere Messeinheit im Labor überprüft. Es misst die Geschwindigkeit eines Objekts, das vor ihm bewegt wird.
-
Abb. 21: Gemessene Geschwindigkeit in 2 Dezimalstellen auf dem LCD
-
Abb. 22: Gemessene Geschwindigkeit in 3 Dezimalstellen, die im seriellen Monitor des IDE angezeigt werden
Projektunterlagen
Projektplan
-
Abb. 23: Der Projektplan des Speedtrackers, beschrieben in einem Gantt-Diagramm
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
- ↑ 1,0 1,1 https://www.pololu.com/file/0J157/GP2D120-DATA-SHEET.pdf
- ↑ https://global.sharp/products/device/lineup/data/pdf/datasheet/gp2y0a41sk_e.pdf
- ↑ https://www.mikrocontroller.net/articles/LED
- ↑ https://datasheetgo.com/c547b-datasheet-npn-transistor/ C547B
- ↑ https://de.wikipedia.org/wiki/I%C2%B2C
→ zurück zum Hauptartikel: Messaufbauten mit Arduino