Geschwindigkeitsregelanlage: Unterschied zwischen den Versionen
(Änderung 69151 von Mario Wollschlaeger (Diskussion) rückgängig gemacht.) |
|||
(196 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
[[Datei:GRA-3000.png|650px|thumb|rechts|(Peppiges Bild) Geschwindigkeitsregelanlage GRA-3000]] | |||
[[Datei:Mercedes ML55 AMG RC-Car.JPG|650px|thumb|rechts|Gesamtfahrzeug]] | |||
[[Kategorie:Projekte]] | [[Kategorie:Projekte]] | ||
[[Kategorie:ProjekteET MTR BSE WS2020]] | [[Kategorie:ProjekteET MTR BSE WS2020]] | ||
<!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird. --> | <!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird. --> | ||
'''Autor:''' [[Benutzer: | '''Autor:''' [[Benutzer:Mario_Wollschlaeger|Mario Wollschläger]], [[Benutzer:Maik_Spinnrath|Maik Spinnrath]]<br/> | ||
'''Gruppe:''' 2.5<br/> | '''Gruppe:''' 2.5<br/> | ||
'''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Schneider]]<br/> | '''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Schneider]]<br/> | ||
Zeile 9: | Zeile 12: | ||
== Einleitung == | == Einleitung == | ||
Das Projekt Geschwindigkeitsregelanlage entsteht im Rahmen des [[:Kategorie:ProjekteET_MTR_BSE_WS2020|GET-Fachpraktikum]] des Studiengangs Mechatronik im 5 Semester. Zielsetzung ist die Realisierung eines Systems, welches die Geschwindigkeit eines modifizierten RC-Autos regeln soll. Die Reglung geschieht auf Basis von Daten aus Raddrehzahlsensoren. Die notwendigen Berechnungen werden von einem Microcontroller des Typs ATmega328 mit Arduino-Bootloader. | Das Projekt Geschwindigkeitsregelanlage entsteht im Rahmen des [[:Kategorie:ProjekteET_MTR_BSE_WS2020|GET-Fachpraktikum]] des Studiengangs Mechatronik im 5 Semester. Zielsetzung ist die Realisierung eines Systems, welches die Geschwindigkeit eines modifizierten RC-Autos regeln soll. Die Reglung geschieht auf Basis von Daten aus Raddrehzahlsensoren. Die notwendigen Berechnungen werden von einem Microcontroller des Typs ATmega328 mit Arduino-Bootloader durchgeführt. | ||
Die Umsetzung des Projektes wird durch die Mechatronik Studenten [[Benutzer:Maik_Spinnrath|Maik Spinnrath]] und [[Benutzer:Mario_Wollschlaeger|Mario Wollschläger]] realisiert. | Die Umsetzung des Projektes wird durch die Mechatronik Studenten [[Benutzer:Maik_Spinnrath|Maik Spinnrath]] und [[Benutzer:Mario_Wollschlaeger|Mario Wollschläger]] realisiert. | ||
Zeile 16: | Zeile 19: | ||
Für den Erfolg des Projektes bestehen die folgenden Anforderungen an das System: | Für den Erfolg des Projektes bestehen die folgenden Anforderungen an das System: | ||
{| class=" | {| class="wikitable" | ||
! style="font-weight: bold;" | Nr.: | ! style="font-weight: bold;" | Nr.: | ||
! style="font-weight: bold;" | | ! style="font-weight: bold;" | Anforderung | ||
! style="font-weight: bold;" | Status | ! style="font-weight: bold;" | Status | ||
|- | |- | ||
| 1.0 | | 1.0 | ||
| Echtzeitanforderung: Die Reglung muss in Echtzeit erfolgen, d.h. die notwendigen Berechnungen müssen in einer vorher definierten Zeit abgeschlossen sein. | | Echtzeitanforderung: Die Reglung muss in Echtzeit erfolgen, d.h. die notwendigen Berechnungen müssen in einer vorher definierten Zeit abgeschlossen sein. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 2.0 | | 2.0 | ||
| Platzbedarf: Das System muss in dem zur Verfügung stehendem Bauraum vollständig realisiert werden. | | Platzbedarf: Das System muss in dem zur Verfügung stehendem Bauraum vollständig realisiert werden. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 3.0 | | 3.0 | ||
| Energiebedarf: Ein Batteriebetrieb muss möglich sein um die Mobilität des Gesamtsystem Fahrzeug zu gewährleisten | | Energiebedarf: Ein Batteriebetrieb muss möglich sein, um die Mobilität des Gesamtsystem Fahrzeug zu gewährleisten. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 4.0 | | 4.0 | ||
| Erschütterungen dürfen zu keinen Beeinträchtigungen oder Beschädigungen führen. | | Erschütterungen dürfen zu keinen Beeinträchtigungen oder Beschädigungen führen. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 5.0 | | 5.0 | ||
| Gewicht: Die maximale Achslast des Fahrzeuges darf nicht überschritten werden. | | Gewicht: Die maximale Achslast des Fahrzeuges darf nicht überschritten werden. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 6.0 | | 6.0 | ||
| Das System muss den Auftraggeber | | Das System muss den Auftraggeber zufrieden stellen. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 7.0 | | 7.0 | ||
| Die Geschwindigkeit muss ermittelt werden und weiterverarbeitbar dargestellt werden. | | Die Geschwindigkeit muss ermittelt werden und weiterverarbeitbar dargestellt werden. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 7.0 | | 7.0 | ||
| Der Nutzer muss eine Sollgeschwindigkeit einstellen können. | | Der Nutzer muss eine Sollgeschwindigkeit einstellen können. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 8.0 | | 8.0 | ||
| Der Nutzer muss eine Rückmeldung über Soll- und Ist-Geschwindigkeit erhalten. | | Der Nutzer muss eine Rückmeldung über Soll- und Ist-Geschwindigkeit erhalten. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 8.1 | | 8.1 | ||
| Der Nutzer muss eine Rückmeldung über Regelfehler und Stellgrößer erhalten. | | Der Nutzer muss eine Rückmeldung über Regelfehler und Stellgrößer erhalten. | ||
| | | abgeschlossen | ||
|- | |- | ||
| 9.0 | | 9.0 | ||
| Die Geschwindigkeit muss zuverlässig geregelt werden. | | Die Geschwindigkeit muss zuverlässig geregelt werden. | ||
| | | abgeschlossen | ||
|} | |} | ||
== Funktionaler Systementwurf/Technischer Systementwurf == | == Funktionaler Systementwurf/Technischer Systementwurf == | ||
[[Datei:Systementwurf.png|thumb|rechts|Systementwurf <ref> Eigenes Dokument </ref>]] | [[Datei:Systementwurf.png|290px|thumb|rechts|Systementwurf <ref> Eigenes Dokument </ref>]] | ||
<div class="tright" style="clear:none;">[[Datei:Geschwindigkeitsregelanlage Systementwurf Erweiterung.png|thumb|ohne|rechts|Erweiterung des Systementwurf<ref> Eigenes Dokument </ref>]]</div> | <div class="tright" style="clear:none;">[[Datei:Geschwindigkeitsregelanlage Systementwurf Erweiterung.png|290px|thumb|ohne|rechts|Erweiterung des Systementwurf<ref> Eigenes Dokument </ref>]]</div> | ||
[[Datei:Morphologischer Kasten GRA.JPG|thumb|610px|rechts|Morphologischer Kasten]] | |||
Das System besteht aus verschiedenen Komponenten. Zur Erfassung der Geschwindigkeit werden Drehzahlsensoren eingesetzt. Die ermittelten Daten werden von einem Mikrocontroller verarbeitet. Anschließend kann die Geschwindigkeit durch die Anpassung der Stromzufuhr des Motors geregelt werden. Diese wird zuvor vom Benutzer angegeben. | Das System besteht aus verschiedenen Komponenten. Zur Erfassung der Geschwindigkeit werden Drehzahlsensoren eingesetzt. Die ermittelten Daten werden von einem Mikrocontroller verarbeitet. Anschließend kann die Geschwindigkeit durch die Anpassung der Stromzufuhr des Motors geregelt werden. Diese wird zuvor vom Benutzer angegeben. | ||
Optional kann das System durch einen Ultraschallsensor dahingehen erweitert werden, dass eine Abstandsregelung zu vorausfahrenden Fahrzeugen möglich wird. Hierfür kann die eingestellte Geschwindigkeit je nach Distanz verringert oder vergrößert werden, um den gewünschten Abstand zu halten oder einzustellen. | Optional kann das System durch einen Ultraschallsensor dahingehen erweitert werden, dass eine Abstandsregelung zu vorausfahrenden Fahrzeugen möglich wird. Hierfür kann die eingestellte Geschwindigkeit je nach Distanz verringert oder vergrößert werden, um den gewünschten Abstand zu halten oder einzustellen. | ||
=== Simulation === | |||
Zum besseren Verständnis wurde das System mit Regelstrecke, Regler simuliert. Der Sensor wurde hierbei als Ideal angenommen. Durch diese Simulation konnte erkannt werden, dass ein PI-Regler für die Reglung ausreicht. | |||
<gallery widths="250" heights="250"> | |||
Datei:Simulation GRA.JPG| Simulation | |||
Datei:Simulation Regelstrecke GRA.JPG| Regelstrecke | |||
Datei:Simulation Plot GRA.JPG| Simulationsergebnis | |||
</gallery> | |||
<br clear=all> | <br clear=all> | ||
Zeile 77: | Zeile 91: | ||
== Komponentenspezifikation == | == Komponentenspezifikation == | ||
{| class=" | {| class="wikitable" | ||
! style="font-weight: bold;" | Komponente | ! style="font-weight: bold;" | Komponente | ||
! style="font-weight: bold;" | Beschreibung | ! style="font-weight: bold;" | Beschreibung | ||
Zeile 83: | Zeile 97: | ||
|- | |- | ||
|Arduino UNO R3 | |Arduino UNO R3 | ||
|Die Kernkomponente ist ein Arduino Uno Board, auf diesem ist ein ATmega328P verbaut welche die Berechnungen des Systems übernimmt. Dieser arbeitet mit einer Taktfrequenz von 16MHz und besitzt eine Betriebsspannung von 5V. Über 14 I/O Pins können Sensoren und Aktoren angeschlossen werden, wovon jeweils 6 als PWM Ausgang oder als Analog Eingang genutzt werden können. Die I/O Pins können maximal 20mA leisten. Die Restlichen Informationen können aus diesem Datenblatt<ref name = 'DatenblattArduino'> Arduino: ''Arduino- ArduinoBoardUno''. 2021. Online im Internet: https://www.arduino.cc/en/Main/arduinoBoardUno> Abruf: 05.01.2021</ref> entnommen werden. | |Die Kernkomponente ist ein Arduino Uno Board, auf diesem ist ein ATmega328P verbaut welche die Berechnungen des Systems übernimmt. Dieser arbeitet mit einer Taktfrequenz von 16MHz und besitzt eine Betriebsspannung von 5V. Über 14 I/O Pins können Sensoren und Aktoren angeschlossen werden, wovon jeweils 6 als PWM Ausgang oder als Analog-Eingang genutzt werden können. Die I/O Pins können maximal 20mA leisten. Die Restlichen Informationen können aus diesem Datenblatt<ref name = 'DatenblattArduino'> Arduino: ''Arduino- ArduinoBoardUno''. 2021. Online im Internet: https://www.arduino.cc/en/Main/arduinoBoardUno> Abruf: 05.01.2021</ref> entnommen werden. | ||
|[[Datei:Fundiono UNO R3.jpg|126px|mini|zentriert|Fundiono UNO R3]] | |[[Datei:Fundiono UNO R3.jpg|126px|mini|zentriert|Fundiono UNO R3]] | ||
|- | |- | ||
| TLE4905L | | TLE4905L | ||
| Ein TLE4905L Hall-Effekt Sensor der Firma Infineon wurde verwendet um die Geschwindigkeit des Fahrzeuges über die Raddrehzahl zu ermitteln. Der Sensor kann auf Basis eines Magnetfeldes innerhalb einer Mikrosekunde schalten. Dieser arbeitet | | Ein TLE4905L Hall-Effekt Sensor der Firma Infineon wurde verwendet, um die Geschwindigkeit des Fahrzeuges über die Raddrehzahl zu ermitteln. Der Sensor kann auf Basis eines Magnetfeldes innerhalb einer Mikrosekunde schalten. Dieser arbeitet in einem Bereich von 3.8 bis 24 Volt und kann einen Ausgangsstrom von 100mA liefern. Nähere Informationen zum Sensor sind im [[Halleffektsensor Unipolar (TLE4905L)|Hauptartikel]] zu finden. | ||
|[[Datei:Infineon TLE4905L.jpg|126px|mini|zentriert|Infinion TLE4905L <ref> https://cdn-reichelt.de/bilder/web/artikel_ws/B400/PICTURE_2SS52M.jpg </ref>]] | |[[Datei:Infineon TLE4905L.jpg|126px|mini|zentriert|Infinion TLE4905L <ref> https://cdn-reichelt.de/bilder/web/artikel_ws/B400/PICTURE_2SS52M.jpg </ref>]] | ||
|- | |- | ||
| Display | | Display | ||
| Des | | Des Weiteren wurde ein Display mit einer Anzeige aus 16 Zeichen pro Zeile und zwei Zeilen verwendet, um dem Nutzer Rückmeldung über Systemparameter zu geben. Dieses Display wird über eine I²C Schnittstelle betrieben. | ||
|[[Datei:16x2 I2C Display.jpg|126px|mini|zentriert|16x2 | |[[Datei:16x2 I2C Display.jpg|126px|mini|zentriert|16x2 I²C Display]] | ||
|- | |- | ||
|STP16NF06L n-Kanal MOSFET | |STP16NF06L n-Kanal MOSFET | ||
Zeile 104: | Zeile 118: | ||
|- | |- | ||
|Widerstände | |Widerstände | ||
| Es wurden 2 330Ohm und 3 10kOhm Widerstände zur Realisierung der Schaltung verwendet. Dabei kommen die 330Ohm Widerständen zur Strombegrenzung und die 10kOhm | | Es wurden 2 330Ohm und 3 10kOhm Widerstände zur Realisierung der Schaltung verwendet. Dabei kommen die 330Ohm Widerständen zur Strombegrenzung und die 10kOhm Widerstände als Pullup- beziehungsweise Pulldown-Widerstand zum Einsatz. Aus Kostengründen wurden Kohleschichtwiderstände mit einer Genauigkeit von 5% verwendet. Aufgrund des Verwendungszweckes reicht diese Genauigkeit. | ||
|[[Datei:Widerstände.jpg|126px|mini|zentriert|Widerstände]] | |[[Datei:Widerstände.jpg|126px|mini|zentriert|Widerstände]] | ||
|- | |- | ||
Zeile 117: | Zeile 131: | ||
== Umsetzung (HW/SW) == | == Umsetzung (HW/SW) == | ||
[[Datei:Gesamtaufbau GRA.jpg|mini|400px|rechts|Gesamtaufbau]] | |||
Die Umsetzung der Hardware ist in vier Bereiche zu unterteilen. Die Schnittstelle zum Menschen stellt zwei dieser Bereiche dar, zum einen Nutzereingabe und zum anderen die Nutzerausgabe. Die Nutzereingabe erfolgt über die Fernbedienung des Modellautos und die Nutzerausgabe wird durch ein Display realisiert. Die verbleibenden Bereiche sind die Schnittstellen zu dem Antrieb des Fahrzeuges. Die Ansteuerung des Antriebsmotors ist ein Aktor und die Raddrehzahlerfassung ein Sensor. Die Software umfasst dieselben vier Bereiche und den Bereich der Regelung. | Die Umsetzung der Hardware ist in vier Bereiche zu unterteilen. Die Schnittstelle zum Menschen stellt zwei dieser Bereiche dar, zum einen Nutzereingabe und zum anderen die Nutzerausgabe. Die Nutzereingabe erfolgt über die Fernbedienung des Modellautos und die Nutzerausgabe wird durch ein Display realisiert. Die verbleibenden Bereiche sind die Schnittstellen zu dem Antrieb des Fahrzeuges. Die Ansteuerung des Antriebsmotors ist ein Aktor und die Raddrehzahlerfassung ein Sensor. Die Software umfasst dieselben vier Bereiche und den Bereich der Regelung. | ||
=== Hardware === | === Hardware === | ||
Prototypen der einzelnen Schaltungen wurden zunächst auf Steckbrettern umgesetzt. Diese wurden einzeln und im Anschluss als Gesamtsystem getestet, bevor die Schaltungen auf eine Lochrasterplatine zusammengefasst wurden. Diese Platine wurde anschließend fest im Fahrzeug verbaut. | |||
Das Display für die Nutzerausgabe wird über den | |||
====Nutzerausgabe==== | |||
Das Display für die Nutzerausgabe wird über den I²C-Bus an den Mikrokontroller angeschlossen. Zusätzlich wird das Display mit der Versorgungsspannung und der Masse des Arduino verbunden. | |||
[[Datei:Schaltung Nutzereingabe.jpg|mini|rechts|Schaltung für Nutzereingabe]] | ====Nutzereingabe==== | ||
[[Datei:Steckbrett Nutzereingabe.jpg|mini| | [[Datei:Schaltung Nutzereingabe.jpg|mini|400px|rechts|Schaltung für Nutzereingabe]] | ||
<div class="tright" style="clear:none;">[[Datei:Steckbrett Nutzereingabe.jpg|mini|192px|ohne|rechts|Steckbrettschaltung für Nutzereingabe]]</div> | |||
Die Nutzereingabe wird über die Fernbedienung realisiert, um die Signale abzugreifen werden die Ursprünglichen Signale zum Motor für vor und Rücklauf ausgewertet. Durch Versuche konnte herausgefunden werden, dass bei Vorlauf das gelbe Anschlusskabel des Motors ein Potential von 9,6 V zur Masse des Fahrzeuges, und das weiße Anschlusskabel ein Potential von 0,2 V aufweist. Bei Rücklauf des Motors sind diese Werte vertauscht und bei nicht aktiviertem Motor weisen beide Anschlüsse ein Potential von 3,6 V zur Masse auf. | |||
Die Nutzereingabe wird über die Fernbedienung realisiert, um die Signale abzugreifen werden die Ursprünglichen Signale zum Motor für vor und Rücklauf ausgewertet. Durch Versuche konnte herausgefunden werden, | |||
Diese Anschlüsse gehen auf eine Schaltung aus der Eingangsseite von zwei Optokoppler und einem 330Ohm Widerstand. Die beiden Optokoppler sind | Diese Anschlüsse gehen auf eine Schaltung aus der Eingangsseite von zwei Optokoppler und einem 330Ohm Widerstand. Die beiden Optokoppler sind parallelgeschaltet und gegenläufig gepolt. Der Widerstand ist in Reihe geschaltet und dient der Begrenzung des Stroms unter den maximal zulässigen Wert der Optokoppler 50mA. Durch die gegenläufige Polung wird je nach Richtung des fließenden Stroms immer nur ein Optokoppler aktiviert. Sollte keine Potenzialdifferenz zwischen den beiden Anschlüssen anliegen so wird keiner der beiden Optokoppler aktiviert. | ||
Die Ausgangsseite des ersten Optokopplers ist mit einem Interrupt fähigen Pin des Arduino verbunden, der durch einen 10kOhm Pullup-Widerstand mit der Versorgungsspannung des Arduinos verbunden ist. Wird der Optokoppler aktiviert so wird der Pin mit der Masse verbunden, sodass eine fallende Flanke entsteht welche | Die Ausgangsseite des ersten Optokopplers ist mit einem Interrupt fähigen Pin des Arduino verbunden, der durch einen 10kOhm Pullup-Widerstand mit der Versorgungsspannung des Arduinos verbunden ist. Wird der Optokoppler aktiviert so wird der Pin mit der Masse verbunden, sodass eine fallende Flanke entsteht, welche ein Interrupt auslösen kann. Der zweite Optokoppler ist mit einem digitalen Eingangspin verbunden und über eine Diode mit dem Interrupt-Pin. Bei Aktivierung des Optokopplers werden beide Pins mit der Masse verbunden, sodass ein Interrupt ausgelöst werden kann und der digitale Pin das Masse Potenzial annimmt. Beim Auftreten eines Interrupts kann so entschieden werden welcher der beiden Optokoppler aktiviert wurde und damit ausgelesen werden und damit die Nutzereingabe ausgelesen werden. | ||
Theoretisch könnte die Funktion ebenfalls mit zwei Interrupt-Pins gelöst werden, wodurch die Diode gespart werden kann. Da der verwendete Microcontroller jedoch nur zwei Interrupt-Pins besitz und einer für die Auswertung des Sensors verwendet werden soll, wurde die beschriebene Schaltung umgesetzt, welche einen Pin als Interrupt für Nutzereingabe verwendet. Alternativ könnte die Nutzereingabe auch über Polling geschehen, indem digitale Eingänge in sehr kurzen Abständen abgefragt werden. Um eine zuverlässige Eingabe zu ermöglichen, müsste der Microkontroller jedoch einen erheblichen Anteil der Rechenzeit mit der Nutzereingabe verbringe. Hierdurch könnte möglicherweise die eigentliche Aufgabe, die Geschwindigkeitsregelung, gestört werden. | Theoretisch könnte die Funktion ebenfalls mit zwei Interrupt-Pins gelöst werden, wodurch die Diode gespart werden kann. Da der verwendete Microcontroller jedoch nur zwei Interrupt-Pins besitz und einer für die Auswertung des Sensors verwendet werden soll, wurde die beschriebene Schaltung umgesetzt, welche einen Pin als Interrupt für Nutzereingabe verwendet. Alternativ könnte die Nutzereingabe auch über Polling geschehen, indem digitale Eingänge in sehr kurzen Abständen abgefragt werden. Um eine zuverlässige Eingabe zu ermöglichen, müsste der Microkontroller jedoch einen erheblichen Anteil der Rechenzeit mit der Nutzereingabe verbringe. Hierdurch könnte möglicherweise die eigentliche Aufgabe, die Geschwindigkeitsregelung, gestört werden. | ||
[[Datei:Schaltung Motoransteuerung.jpg|mini|| | ====Ansteuerung des Antriebsmotors==== | ||
[[Datei:Schaltung Motoransteuerung.jpg|mini||398px|rechts|Schaltung für Motoransteuerung]] | |||
<div class="tright" style="clear:none;">[[Datei:Steckbrett Motoransteuerung.jpg|mini|128px|ohne|rechts|Steckbrettschaltung für Motoransteuerung]]</div> | <div class="tright" style="clear:none;">[[Datei:Steckbrett Motoransteuerung.jpg|mini|128px|ohne|rechts|Steckbrettschaltung für Motoransteuerung]]</div> | ||
Der Motor benötigt im Betrieb eine Spannung von etwa 9,4 V und einen Strom von 500 mA. Um diese von der Versorgungsspannung des Microcontrollers abweichenden Spannung schalten zu können, wird ein Optokoppler verwendet. Dieser isoliert die Spannung des Mikrokontrollers zur Spannung des Fahrzeuges und | Der Motor benötigt im Betrieb eine Spannung von etwa 9,4 V und einen Strom von 500 mA. Um diese von der Versorgungsspannung des Microcontrollers abweichenden Spannung schalten zu können, wird ein Optokoppler verwendet. Dieser isoliert die Spannung des Mikrokontrollers zur Spannung des Fahrzeuges und wird an das Gate des n-Kanal MOSFETS angeschlossen, um den Strom schalten zu können. Dies ist aufgrund des maximalen Ausgangsstrom des Optokopplers notwendig. Die Motorleistung wird somit durch einen mit dem Motor in Reihe geschalteten n-Kanal MOSFET geregelt, wobei die Reihenschaltung die Versorgungsspannung mit der Masse des Fahrzeugs verbindet. Der Optokoppler verbindet bei Aktivierung das Gate des MOSFTES mit der Versorgungsspannung des Fahrzeugs. Zudem ist das Gate über einen 10kOhm Pulldown-Widerstand mit der Masse des Fahrzeugs verbunden, um bei nicht Aktivierung des Optokopplers den MOSFET zu sperren. Der Optokoppler wird mit einem PWM Pin des Mikrokontrollers verbinden und über einen 330Ohm Widerstand mit der Masse des Mikrokontrollers. Der Widerstand dient zur Begrenzung des Stroms unter den maximal zulässigen Wert der Eingangsseite des Optokopplers von 50mA. | ||
Die Motorleistung wird somit durch einen mit dem Motor in Reihe geschalteten n-Kanal MOSFET geregelt, wobei die Reihenschaltung die Versorgungsspannung mit der Masse des Fahrzeugs verbindet. Der Optokoppler verbindet bei Aktivierung das Gate des MOSFTES mit der Versorgungsspannung des Fahrzeugs. Zudem ist das Gate über einen 10kOhm Pulldown-Widerstand mit der Masse des Fahrzeugs verbunden um bei nicht Aktivierung des Optokopplers den MOSFET zu sperren. Der Optokoppler wird mit einem PWM Pin des Mikrokontrollers verbinden und über einen 330Ohm Widerstand mit der Masse des Mikrokontrollers. Der Widerstand dient zur Begrenzung des Stroms unter den maximal zulässigen | |||
Durch die Schaltung kann die Motorleistung daher durch eine Pulsweitenmodulation geregelt werden. Alternativ könnte der verwendete MOSFET im triodischer Bereich betrieben werden. Dadurch würden jedoch hohe Verlustleistungen entstehen, welche durch eine Verwendung als Schalter durch eine Pulsweitenmodulation nicht entstehen, da der MOSFET im Stromsättigungsbereich betrieben wird. | |||
<br clear=all> | <br clear=all> | ||
====Raddrehzahlerfassung==== | |||
[[Datei:Schaltung Hallsensor.jpg|mini||350px|rechts|Schaltung für den Hallsensor]] | [[Datei:Schaltung Hallsensor.jpg|mini||350px|rechts|Schaltung für den Hallsensor]] | ||
<div class="tright" style="clear:none;">[[Datei:Steckbrett Hallsensor.jpg|mini|150px|ohne|rechts|Steckbrettschaltung für Hallsensor]]</div> | <div class="tright" style="clear:none;">[[Datei:Steckbrett Hallsensor.jpg|mini|150px|ohne|rechts|Steckbrettschaltung für Hallsensor]]</div> | ||
Für die Auswertung der Geschwindigkeit wird ein Hall-Effekt Sensor verwendet. Durch den Hallsensor wird das Magnetfeld eines Permanentmagneten detektiert, welcher sich im Reifen des Fahrzeuges befindet. Dieser wird mit der Versorgungsspannung und der Masse des Mikrokontrollers sowie mit einem Interrupt-fähigen Pin verbunden. Um das Potenzial einzustellen wird ein 10kOhm Pullup Widerstand mit der Versorgungsspannung des Mikrokontrollers verbunden. | |||
Der TLE4905L ist ein Unipolarer Halleffektsensor auf Halbleiterbasis, welcher bei einer gewissen magnetischen Feldstärke den Ausgangspin mit der angeschlossenen Masse verbindet und bei geringerer magnetischen Feldstärke die Verbindung wieder trennt. Durch die Schalthysterese des Sensors wird gewährleistet, dass pro Radumdrehung der Sensor nur einmal ausgelöst wird. Die Schaltung setzt einen vereinfachten Anwendungsschaltkreis aus dem Datenblatt des Sensors um. Auf die aufgeführten 4,7nF Kondensatoren wurde aus Kostengründen und Lieferschwierigkeiten verzichtet, da bei Test auch ohne diese Komponenten eine gute Genauigkeit erzielt werden konnte, welche auf die gleichmäßige Spannungsversorgung und gleichmäßige geringe Leitung der Anwendungsschaltkreise zurückzuführen ist. | |||
<br clear=all> | <br clear=all> | ||
====Platine==== | |||
Alle Schaltungen sind auf einer Platine zusammengefasst. Diese Platine besitzt Schnittstellen zu anderen Komponenten des Gesamtsystems: Dem Hallsensor (3 Kabel), dem Kotrollerboard des RC-Autos (5 Kabel), zum Display (4 Stecker) und dem Arduino (8 Kabel). Die Kabel zum Arduino sind fest verlötet und könne in die Verbinder des Arduino gesteckt werden. Die Kabel zum Kotrollerboard des RC-Autos werden über Lüsterklemmen verbunden. Der Sensor ist fest verlötet und für das Display wurden Steckverbinder gewählt. | |||
Der Aufbau auf einer Lochrasterplatine wurde aufgrund von Anforderung 2.0 und 4.0 dem vorher realisiertem Aufbau auf einem Steckbrett vorgezogen. Die wichtigsten Verbindungen wurden auf der Platine verlötet, ebenfalls um Anforderung 4.0 zu erfüllen. | |||
<gallery widths="250" heights="250"> | |||
PlatineGRA.jpg|Platine | |||
InterfacesGRA.jpg|Interfaces | |||
VerdratungsplanGRA.jpg|Verdrahtungsplan | |||
</gallery> | |||
=== Software === | === Software === | ||
[[Datei:Modulstruktur.JPG|mini||400px|rechts|Modulstruktur und Anbindung an Hardwaredienest]] | |||
Die Software wurde mithilfe der Arduino-IDE umgesetzt. Die verwendete Programmiersprache ist damit C++. Für die Software wurde das Projekt in die oben beschriebenen Bereiche unterteilt. für jeden Bereich wurde eine Software Modul verwendet, wobei für die Displayausgabe bestehende Lösungen verwendet wurden, während für die Restlichen Bereiche neue Module mit cpp-Dateien und h-Dateien entwickelt wurden. | |||
==== Displayausgabe (Wire, LiquidCristal_I2C) ==== | |||
Für die Ansteuerung des Displays wurden die vom Zulieferer Funduino empfohlenen Bibliotheken Wire und LiquidCristal_I2C verwendet. Ein neues LCD-Display kann durch den folgenden Befehl angelegt werden: | |||
<pre> | |||
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); | |||
</pre> | |||
Die Initialisierung geschieht durch den folgenden Befehl: | |||
<pre> | |||
lcd.begin(16, 2); | |||
</pre> | |||
Mit den Folgenden Befehlen kann im Programmablauf das Display gelöscht werden, der Cursor an eine bestimmte Spalte und Zeile gesetzt werden und an diese ein String gedruckt werden. | |||
<pre> | |||
lcd.clear(); | |||
lcd.setCursor(0, 0); | |||
lcd.print("Hallo Welt"); | |||
</pre> | |||
====Geschwindigkeitsmessung (HallSpeed)==== | |||
[[Datei:Geschwindikeitsbestimmung PAP.png|mini||400px|rechts|Programmablaufplan der Methode "getSpeed"]] | |||
Für die Geschwindigkeitsmessung wurde ein einzelnes Modul erstellt, welches die Messung umsetzt. Für die Initialisierung sind der Anschluss-Pin des Hallsensors, der Radumfang im mm und eine Zeitkonstante zu übergeben. Zu beachten ist, das als Anschluss-Pin Pin 2 oder Pin 3 gewählt werden muss, da der Pin interruptfähig seien muss. Die Zeitkonstante gibt an, nach welcher Zeit ohne Auslösung ein Interrupt vom Stillstand des Rades ausgegangen wird. | |||
Zum Auslesen der Geschwindigkeit kann im Programm die Methode getSpeed verwendet werde, welche die Geschwindigkeit in mm/s zurückgibt. Die Berechnung der Geschwindigkeit basiert auf der Gemessene Zeit zwischen zwei Interrupts. | |||
<pre> | |||
#ifndef HallSpeed_h | |||
#define HallSpeed_h | |||
/** | |||
* Geschwindigkeitsmessung mittels eines Hallsensors | |||
* Datum: 29.12.2020 | |||
* Autor: Mario Wollschläger | |||
*/ | |||
unsigned int radumfang; //radumfang in mm | |||
unsigned int t0; | |||
unsigned long timeStamp; | |||
unsigned long delta; | |||
/** | |||
* ISR fuer ausloesen des Hallsensors | |||
*/ | |||
void hall(); | |||
/** | |||
* Initialisierung der Geschwindigkeitsmessung | |||
* pin: Anschlusspin des Sensors | |||
* pRadumfang: zurueckgelegte Strecke zwischen zwei Ausloeseungen des Sensors (vorzugsweise in mm) | |||
* pT0: Zeit bis von einem Stillstand ausgegangen wird in ms | |||
*/ | |||
void initSpeedometer(int pin, unsigned int pRadumfang, unsigned int pT0); | |||
/** | |||
* Methode um Aktuelle Geschwindigkeit abzufragen | |||
* Rückgabe in mm/s, falls pRadumfang in mm | |||
*/ | |||
int getSpeed(); | |||
#endif | |||
</pre> | |||
====Motoransteuerung (Motor)==== | |||
Das Modul zur Motoransteuerung besitzt eine Klasse Motor. Mit Objekten dieser Klasse kann die Leistung eines Motors über Pulsweitenmodulation gesteuert werden. Ein Motor kann mit dieser Klasse sowohl im Vorlauf als auch im Rücklauf betrieben werden. Hierfür wird jeweils beim Vorlauf und beim Rücklauf an einem bei der Initialisierung zu Übergebendem Pin ein PWM-Signal übergeben. Im Projekt Geschwindigkeitsregelanlage wird derzeit nur ein Motor mit Vorlauf verwendet, dies wird dem Programm signalisiert, indem für den Rücklauf-Pin der Wert -1 übergeben wird. | |||
Für die letztendlich Ansteuerung des Motors steht eine öffentliche Methode der Klasse Motor zur Verfügung. Dieser kann für die Motorleistung ein Wert von -255 bis 255, übergeben werden, wobei negative Werte für den Rücklauf stehen. Da im verwendeten Modus mit nur einer Laufrichtung gearbeitet wird, beschränkt sich der nutzbare Bereich auf 0 bis 255. | |||
<pre lang=cpp> | |||
#ifndef Motor_h | |||
#define Motor_h | |||
/** | |||
* PWM-Motorsteuerung | |||
* Datum: 29.12.2020 | |||
* Autor: Mario Wollschläger | |||
*/ | |||
class Motor{ | |||
private: | |||
char v; | |||
char r; | |||
public: | |||
/** | |||
* Initialisieren des Motors: | |||
* pinVor: PWM-Pin fuer Vorwaertsfahrt des Motors | |||
* pinRueck: PWM-Pin fuer Rueckwaertsfahrt des Motors (falls nicht vorhanden: auf -1 setzen) | |||
*/ | |||
Motor(int pinVor, int pinRueck); | |||
/** | |||
* Motor mit gegebener Power betreiben | |||
* wert: Kraft, 0 bis 255, falls nur Vorwaerts | |||
* -255 bis 255 falls Vor- und Rueckwarts | |||
*/ | |||
void power(int wert); | |||
}; | |||
#endif | |||
</pre> | |||
====Nutzereingabe (userInput)==== | |||
Die Nutzereingabe ist in einem Modul realisiert, welches dem Nutzer die Möglichkeit bietet, einen Wert in einer zuvor definierten Schrittweite zu erhöhen oder zu verringern. Dabei kann für diesen Wert ein Maximum und ein Minimum angegeben werden. | |||
<pre> | |||
#ifndef userInput_h | |||
#define userInput_h | |||
/** | |||
* Nutzereingabe mit einem Interuptpin und 2 Eingabemoeglichkeiten | |||
* Datum: 30.12.2020 | |||
* Autor: Mario Wollschläger | |||
*/ | |||
int uservalue; | |||
int stepsize; | |||
int inputPin1; | |||
int inputPin2; | |||
unsigned long lastUserInput; | |||
unsigned int entprellzeit; | |||
int userMax; | |||
int userMin; | |||
/** | |||
* ISR für Usereingabe | |||
*/ | |||
void userInput(); | |||
/** | |||
* Initialisuerung des Userinputs, der Nutzer kann einen Wert schrittweise um einen festgelegte Schrittweite erhoehen oder veringern (Startwert: 0) | |||
* inputA: Pin 1 fuer Usereingabe und Interupt-Pin | |||
* inputB: Pin 2 fuer Usereingabe | |||
* pStepsize: schritweite bei Usereingabe | |||
* pEntprellzeit: Entprellzeit für die Verweindung mechanischer Taster | |||
* pUserMax: Maximalwert der durch den Nutzer eingestellt werden kann | |||
* pUserMin: Minimalwert der durch den Nutzer eingestellt werden kann | |||
*/ | |||
void initUserInput(char inputA, char inputB, int pStepsize, unsigned int pEntprellzeit, int pUserMax, int pUserMin); | |||
/** | |||
* gibt den vom Nuter eingestellten Wert | |||
*/ | |||
int getUservalue(); | |||
#endif | |||
</pre> | |||
====Reglung der Motorleistung (begrenzterRegler)==== | |||
[[Datei:Regler PAP.png|mini||400px|rechts|Programmablauf der Methode "regelWert"]] | |||
Mit dem Modul begrenzterRegler können Objekte der Klasse BegrenzterRegler erzeugt werden. Diese sind die Umsetzung eines PI-Reglers, welcher in seinem maximalen und minimalen Ausgangswert beschränkt ist. Beim Erzeugen von Objekten der Klasse sind der I- und P-Anteil, sowie der Maximalwert und der Minimalwert anzugeben. Über die Methode regelWert des Objektes kann dann im laufenden Betrieb ein Regelwert errechnet werden. Hierfür sind der Regelfehler und die Zeit anzugeben, welche seit der letzten Reglung verstrichen ist. Die Zeit ist für die Berechnung des I-Anteils notwendig. | |||
Der Regler besitzt eine Anti-Windup-Strategie. In der aktuellen Implementierung wird hierfür der I-Anteil auf den Wertebereich des Reglers beschränkt. Somit wird auch das Windup-Phänomen beschränkt. | |||
<pre> | |||
#ifndef begrezterRegler_h | |||
#define begrezterRegler_h | |||
/** | |||
* PI-Regeler mit Stellgroessenbeeschraenkung | |||
* Datum: 29.12.2020 | |||
* Autor: Mario Wollschläger | |||
*/ | |||
class BegrenzterRegler{ | |||
private: | |||
double iAnteil; | |||
unsigned int p; | |||
unsigned int i; | |||
int rMax; | |||
int rMin; | |||
/** | |||
* Begrenzt einen Regewert auf rMin bis rMax | |||
* wert: zu begrenzender Wert | |||
*/ | |||
double begrenzung(double wert); | |||
/** | |||
* Umsetzung eines PI-Reglers | |||
* regelfehler: Regelabweichung e | |||
* zeitMs: Zeit seit des letzten Releraufruf in ms | |||
*/ | |||
double piRegler(int regelfehler, unsigned int zeitMs); | |||
public: | |||
/** | |||
* Initialisierung des Reglers | |||
* pP: P-Anteil des PI-Reglers | |||
* pI: I-Anteil des PI-Reglers | |||
* pRMax: Maximalwert des Reglers | |||
* pRMin: Minimalwert des Reglers | |||
*/ | |||
BegrenzterRegler(unsigned int pP, unsigned int pI, int pRMax, int pRMin); | |||
/** | |||
* Gibt eine Regelwert basierend auf einem Regelfeher zurueck | |||
* Beschraenkt auf rMin bis rMax | |||
* Umgestezt durch eine PI-Regler | |||
* regelfehler: Regelabweichung e | |||
* zeitMs: Zeit seit des letzten Releraufruf in ms | |||
*/ | |||
int regelWert(int regelfehler, unsigned int zeitMs); | |||
/** | |||
* Ermoeglicht das Aendern des P- und I- Wertes während des laufenden Betriebs | |||
* pP: P-Anteil des PI-Reglers | |||
* pI: I-Anteil des PI-Reglers | |||
*/ | |||
void setPI(unsigned int p, unsigned int i); | |||
}; | |||
#endif | |||
</pre> | |||
==== Gesamtablauf ==== | |||
Die implementierte Lösung entspricht dem folgenden Programm-Ablauf-Plan: | |||
[[Datei:Regelung PAP.png|mini||600px|links|Modulstruktur und Anbindung an Hardwaredienst]] | |||
<br clear = all> | |||
== Komponententest == | == Komponententest == | ||
Die Module wurden zunächst einzeln getestet, um eine aufwendige Fehlersuche im Gesamtsystem zu vermeiden. | |||
=== Halleffektsensor === | === Halleffektsensor === | ||
Zunächst wurde eine Schaltung auf einem Steckbrett aufgebaut. Die Auswertung der Schaltung wurde zunächst über eine LED und im Anschluss über ein Spannungsmessgerät vorgenommen. Durch diese Methoden konnte der Prinzip Aufbau validiert werden. In einem Zweiten Schritt wurde dann mithilfe des Arduinos und einem vorläufigen Programm die Drehzahl des RC-Autos im Leerlauf gemessen. Hier konnte erwiesen werden, dass die Drehzahl durch die Schaltung gemessen werden kann. Zur Validierung des Wertes wurde die Drehzahl eines Akkuschraubers gemessen und mit der vom Hersteller angegebenen verglichen. Die Werte stimmten überein womit nachgewiesen ist, dass der Sensor korrekte Werte misst. | |||
<gallery widths="350" heights="350"> | |||
Datei:Komponententest Hallsensor Schaltung.jpg|Steckbrettaufbau | |||
Datei:Komponententest Hallsensor.jpg|Messung am Rad | |||
Datei:Hallsensortest.JPG|Test mit Akkuschrauber | |||
Datei:Komponententest Hallsensor Daten.jpg|Drehzahlmessung am Akkuschrauber | |||
</gallery> | |||
<!-- [[Datei:Komponententest Hallsensor Daten.jpg|mini|links|600px|Test des Hallsensor, Drehzahlmessung am Akkuschrauber]] --> | |||
<br clear=all> | |||
=== Motoransteuerung === | === Motoransteuerung === | ||
Die Motoransteuerung wurde schrittweise aufgebaut. Hierfür wurde zunächst das zur Masse führende Zuleitungskabel des Motors getrennt und durch dessen Verbindung der Motor geschaltet. Im zweiten Schritt wurde das Schalten mithilfe des MOSFETs umgesetzt, dessen Gate mit der Versorgungsspannung und der Masse des Fahrzeuges verbunden wurde. Im Anschluss wurde diese Verbindung über den Optokoppler umgesetzt, welcher über einen passenden Vorwiderstand mit der Versorgungsspannung und der Masse des Arduinos verbunden wurde. | |||
Nachdem alle beschriebenen Teststufen erfolgreich waren, wurde der Optokoppler an einen PWM-Pin des Arduinos angeschlossen und die Leistung nach einem analogen Eingangssignal, eingestellt durch ein Potentiometer, geregelt. Auch dieser Test war erfolgreich. | |||
<gallery widths="350" heights="350"> | |||
Datei:Motoransteuerung Test.png| Versuch zur Motoransteuerung | |||
</gallery> | |||
=== Benutzereingabe === | === Benutzereingabe === | ||
Die Schaltung wurde nach der Planung auf einem Steckbrett aufgebaut. Hierfür wurden die Optokoppler zunächst durch Taster ersetzt, um die am Arduino angeschlossene Seite der Schaltung zu testen. Nachdem die Tests des Schaltungsaufbaus erfolgreich waren, wurde die Schaltung um die am Fahrzeug angeschlossene Seite erweitert. Die anschließenden Tests der Gesamtschaltung sind zunächst mit der Versorgungspannung des Arduinos durchgeführt worden bevor Tests am Fahrzeug vorgenommen wurden. Auch diese Tests sind erfolgreich abgenommen worden. | |||
<gallery widths="350" heights="350"> | |||
Datei:Komponententest Nutzereingabe.jpg| Test mit Tastern | |||
Datei:Steckbrett Nutzereingabe.jpg| Test mit Optokopplern | |||
</gallery> | |||
=== Display === | === Display === | ||
Der Test des Displays beschränkte sich aufgrund des geringen Schaltungsaufwands auf das Anschließen über Jumper-Cable und der Ausgabe von "Hallo Welt!". Beim Test traten keine Fehler auf. | |||
=== Gesamtschaltung Steckbrett === | === Gesamtschaltung Steckbrett === | ||
Nachdem die einzelnen Komponenten auf dem Steckbrett getestet wurden, konnte der Test aller Komponenten als Gesamtsystem durchgeführt werden. Hierfür wurde eine erste Softwareversion verwendet, welche alle Komponenten verwendet. Der Test wurde erfolgreich abgeschlossen. | |||
<gallery widths="350" heights="350"> | |||
Datei:Steckbrett Gesamt.jpg| Aufbau auf dem Steckbrett | |||
Datei:Steckbrett Gesamttest.jpg| Test des Gesamtsystems mit dem Steckbrettaufbau | |||
</gallery> | |||
=== Gesamtschaltung Platine === | === Gesamtschaltung Platine === | ||
Durch den erfolgreichen Test des Gesamtsystemaufbau auf dem Steckbrett konnte die nächste Projektphase begonnen werden: Der Aufbau auf einer Platine. Die Platine wurde nach dem Zusammenbau mit denselben Methoden wie der Steckbrettaufbau getestet. Hierbei ergab sich, dass die Ansteuerung des Motors nicht funktionstüchtig war. Nach dem Durchmessen der beteiligten Komponenten konnte ein Defekt im verwendeten Optokoppler festgestellt werden. Hierbei wies die Eingangsseite die Typische Vorwärtsspannung auf, jedoch wurde die Ausgangsseite nicht geschaltet. | |||
Da bereits bei der Beschaffung mit Puffern gerechnet wurde und somit mehr Komponenten bestellt als benötigt wurden, konnte der Fehler durch Austausch des Bauelements schnell behoben werden. Die anschließenden Tests verliefen reibungslos. | |||
<gallery widths="350" heights="350"> | |||
Datei:Komponententest Platine.jpg| Test der Platine | |||
Datei:Komponententest Platine gesamt.jpg| Gesamtaufbau des Tests | |||
Datei:Optokoppler defekt.JPG| Spannung über defektem Optokoppler-Ausgang <br> (1V/Div, 0.2ms/Div) | |||
Datei:Optokoppler intakt.JPG| Spannung über intaktem Optokoppler-Ausgang <br> (1V/Div, 0.2ms/Div) | |||
</gallery> | |||
== Ergebnis == | == Ergebnis == | ||
<!-- Immer mit der Ruhe, kommt noch. --> | <!-- Immer mit der Ruhe, kommt noch. --> | ||
Es funktioniert! | <!-- Es funktioniert! --> | ||
Die Geschwindigkeitsregelanlage erfüllt die an sie gestellten Erwartungen. Im Dauerbetrieb ist das Ergebnis der Regelung mit einer Abweichung von der Sollgeschwindigkeit, die 50 mm/s selbst bei relative rauem Fahrbahnbelag nicht überschreitet als "Gut" zu bewerten. Dabei können Geschwindigkeiten von bis zu 3 m/s (3000 mm/s) erreicht und geregelt werden. Auch Steigungen und Gefälle werden durch die Regelung kompensiert. Dabei passt das Gesamtsystem in den zur Verfügung stehen Bauraum. Auch der Energieverbrauch und Masse des Systems erlaubt einen mobilen Betrieb mit allen notwendigen Komponenten im Fahrzeug. Der Aufbau widersteht nicht nur den im Normalbetrieb auftretenden Erschütterungen, sondern ist auch gegenüber stärkeren Erschütterungen wie das Abkommen von der Fahrbahn resistent. | |||
Die 4,8 Watt des Motors werden in einer kontrollierten Art und Weise gesteuert und die Nutzereingabe funktioniert fehlerfrei. Der Sensor liefert zuverlässige und genaue Daten, lediglich bei geringen Geschwindigkeiten ist die Datenrate sehr gering, diese Beeinträchtigung konnte jedoch durch die anderen Bestandteile des Systems und die Software kompensiert werden. Auch die Rückmeldung an den Nutzer ist umfangreich zufriedenstellend, wobei alle gewünschten Werte auf dem Display anschaulich dargestellt werden. | |||
<gallery widths="350" heights="350"> | |||
Datei:GRA Final.jpg| Finaler Gesamtaufbau | |||
Datei:Sperrgebiet.jpg| Test der Regelanlage | |||
Datei:Gesamtansicht GRA.JPG| Gesamtansicht | |||
Datei:Fahrzeug GRA.JPG| Fahrzeug | |||
</gallery> | |||
== Zusammenfassung == | == Zusammenfassung == | ||
Es ist möglich mit einem Arduino Uno und weiteren Komponenten eine Geschwindigkeitsregelanlage umzusetzen. Hierbei kann ein Hallsensor für die Geschwindigkeitsermittlung verwendet werden und ein Mosfet zur Steuerung eines Elektromotors. Die Verwendung von Optokopplern ermöglicht zudem die Verbindung von Schaltungen mit unterschiedlichen Spannungen. | |||
Es wurde zunächst eine Simulation des Systems entwickelt, bevor Hard- und Software Komponente für Komponente entwickelt und getestet wurden. Im Anschluss wurde das Gesamtsystem aufgebaut und auf die gestellten Anforderungen getestet. | |||
=== Lessons Learned === | === Lessons Learned === | ||
*Eine Simulation kann das eigene Verständnis des Systems fördern, um so nachfolgende Arbeiten zu erleichtern. | |||
*Der Prototypenaufbau auf einem Steckbrett ermöglicht schnelle Änderungen und damit das schnelle Entwickeln neuer Schaltungen. | |||
*Durch das Durchmessen von Schaltungen können Defekte lokalisiert werden. Hierbei helfen Messgeräte wie Multimeter und Oszilloskop. | |||
*Durch eine Platine kann im Vergleich zu einem Steckbrettaufbau Bauraum gespart werden und solidere Komponenten hergestellt werden. | |||
*Zusätzliche Komponenten ermöglichen den Aufbau mehrere Schaltungen, beispielweise auf dem Steckbrett und gelötet auf einer Platine. Zudem kann so schnell auf Defekte reagiert werden. | |||
=== Verbesserungs- und Erweiterungsmöglichkeiten === | |||
[[Datei:Erweiterung Vor Rücklauf GRA.JPG|mini|400px|rechts|Schaltung für Rücklauf und Bremsvorgänge]] | |||
<div class="tright" style="clear:none;">[[Datei:Erweiterung Licht.jpg|mini|340px|ohne|rechts|Erweiterung Licht]]</div> | |||
Bei dem System gibt es zwei Aspekte, die verbessert werden könnten. Zum einen könnte die Datenrate der Drehzahlmessung durch mehr Magnete im Reifen bei niedriger Geschwindigkeit erhöht werden. Zum anderen wäre die Weiterentwicklung der Motoransteuerung für Rücklauf und Bremsvorgänge möglich. | |||
Das Basisfahrzeug hat sich als ideale Projektbasis erwiesen, um es nahezu beliebig zu erweitern. | |||
*Die GRA-3000 könnte mit einem Abstandsensor zu einer adaptiven Abstandsregelanlage erweitert werden. | |||
*Darauf aufbauend könnte ein Notbremsassistent realisiert werden. | |||
*Ein Umfangreicheres Nutzereingabe könnte durch verschiedene Tastenkombinationen wie doppeltes Drücken oder längeres gedrückt halten zum Einsatz kommen. | |||
*Das Fahrzeug könnte mit Licht und damit mit einer Lichtautomatik ausgestattet werden. | |||
*Der Umbau der Lenkung von digital auf analog ist empfehlenswert. | |||
<br clear=all> | |||
== Projektunterlagen == | == Projektunterlagen == | ||
=== Projektplan === | === Projektplan === | ||
{| class=" | [[Datei:ProjektplanGRA.JPG|800px|Dateibeschreibung/Tooltip]] | ||
=== Projektdurchführung === | |||
{| class="wikitable" | |||
! style="font-weight: bold;" | Datum | ! style="font-weight: bold;" | Datum | ||
! style="font-weight: bold;" | Aufgabe | ! style="font-weight: bold;" | Aufgabe | ||
Zeile 247: | Zeile 557: | ||
| Wiki-Artikel Komponentenspezifikation | | Wiki-Artikel Komponentenspezifikation | ||
| = | | = | ||
| | | Abgeschlossen | ||
|- | |||
| 05.01.2021 | |||
| Wiki-Artikel Umsetzung Hardware | |||
| = | |||
| Teilweise Abgeschlossen | |||
|- | |||
| 06.01.2021 | |||
| Wiki-Artikel Umsetzung Hardware | |||
| = | |||
| Abgeschlossen | |||
|- | |||
| 07.01.2021 | |||
| Wiki-Artikel Software, Komponententest | |||
| = | |||
| Teilweise Abgeschlossen | |||
|- | |||
| 08.01.2021 | |||
| Software Test, Sensorhalterung | |||
| = | |||
| Abgeschlossen | |||
|- | |||
| 11.01.2021 | |||
| Wiki-Artikel Software, Komponententest | |||
| = | |||
| Abgeschlossen | |||
|- | |||
| 15.01.2021 | |||
| Abschlusstest, Filmtag | |||
| = | |||
| Abgeschlossen | |||
|- | |||
| 16.01.2021 | |||
| Videoschnitt, Peppiges Foto | |||
| = | |||
| Abgeschlossen | |||
|- | |||
| 18.01.2021 | |||
| Wiki-Abschluss | |||
| = | |||
| Abgeschlossen | |||
|} | |} | ||
== YouTube Video == | == YouTube Video == | ||
Ein Video zum Projekt finden Sie [https://www.youtube.com/watch?v=WPTT4UUvFmc hier]. | |||
{{#ev:youtube|https://www.youtube.com/watch?v=WPTT4UUvFmc| 840 | | Promotion-Video der GRA 3000 |frame}} | |||
== Weblinks == | == Weblinks == | ||
Komponenten bei Reichelt: | |||
*[https://www.reichelt.de/hallsensor-digital-uni-bipolar-3-8-24-v-tle-4905l-p25717.html?CCOUNTRY=445&LANGUAGE=de&trstct=pos_0&nbc=1&&r=1 Hallsensor] | |||
*[https://www.reichelt.de/mosfet-n-ch-60v-16a-45w-to-220-stp-16nf06l-stm-p217370.html?&trstct=pos_0&nbc=1 N-Kanal-Mosfet] | |||
*[https://www.reichelt.de/optokoppler-5kv-35v-50ma-50-dip4-el-817-p146657.html?&trstct=pos_0&nbc=1 Optokoppler] | |||
*[https://www.reichelt.de/gleichrichterdiode-1000-v-1-a-do-41-ba-159-p4689.html?&trstct=pos_0&nbc=1 Diode] | |||
SVN-Projektordner: | |||
[https://svn.hshl.de/svn/Elektrotechnik_Fachpraktikum/trunk/Projekte/093-125/101_Geschwindigkeitsregelanlage 101_Geschwindigkeitsregelanlage] | |||
== Literatur == | == Literatur == |
Aktuelle Version vom 5. Juli 2022, 09:23 Uhr
Autor: Mario Wollschläger, Maik Spinnrath
Gruppe: 2.5
Betreuer: Prof. Schneider
→ zurück zur Übersicht: WS 20/21: Fachpraktikum Elektrotechnik (MTR)
Einleitung
Das Projekt Geschwindigkeitsregelanlage entsteht im Rahmen des GET-Fachpraktikum des Studiengangs Mechatronik im 5 Semester. Zielsetzung ist die Realisierung eines Systems, welches die Geschwindigkeit eines modifizierten RC-Autos regeln soll. Die Reglung geschieht auf Basis von Daten aus Raddrehzahlsensoren. Die notwendigen Berechnungen werden von einem Microcontroller des Typs ATmega328 mit Arduino-Bootloader durchgeführt.
Die Umsetzung des Projektes wird durch die Mechatronik Studenten Maik Spinnrath und Mario Wollschläger realisiert.
Anforderungen
Für den Erfolg des Projektes bestehen die folgenden Anforderungen an das System:
Nr.: | Anforderung | Status |
---|---|---|
1.0 | Echtzeitanforderung: Die Reglung muss in Echtzeit erfolgen, d.h. die notwendigen Berechnungen müssen in einer vorher definierten Zeit abgeschlossen sein. | abgeschlossen |
2.0 | Platzbedarf: Das System muss in dem zur Verfügung stehendem Bauraum vollständig realisiert werden. | abgeschlossen |
3.0 | Energiebedarf: Ein Batteriebetrieb muss möglich sein, um die Mobilität des Gesamtsystem Fahrzeug zu gewährleisten. | abgeschlossen |
4.0 | Erschütterungen dürfen zu keinen Beeinträchtigungen oder Beschädigungen führen. | abgeschlossen |
5.0 | Gewicht: Die maximale Achslast des Fahrzeuges darf nicht überschritten werden. | abgeschlossen |
6.0 | Das System muss den Auftraggeber zufrieden stellen. | abgeschlossen |
7.0 | Die Geschwindigkeit muss ermittelt werden und weiterverarbeitbar dargestellt werden. | abgeschlossen |
7.0 | Der Nutzer muss eine Sollgeschwindigkeit einstellen können. | abgeschlossen |
8.0 | Der Nutzer muss eine Rückmeldung über Soll- und Ist-Geschwindigkeit erhalten. | abgeschlossen |
8.1 | Der Nutzer muss eine Rückmeldung über Regelfehler und Stellgrößer erhalten. | abgeschlossen |
9.0 | Die Geschwindigkeit muss zuverlässig geregelt werden. | abgeschlossen |
Funktionaler Systementwurf/Technischer Systementwurf
Das System besteht aus verschiedenen Komponenten. Zur Erfassung der Geschwindigkeit werden Drehzahlsensoren eingesetzt. Die ermittelten Daten werden von einem Mikrocontroller verarbeitet. Anschließend kann die Geschwindigkeit durch die Anpassung der Stromzufuhr des Motors geregelt werden. Diese wird zuvor vom Benutzer angegeben.
Optional kann das System durch einen Ultraschallsensor dahingehen erweitert werden, dass eine Abstandsregelung zu vorausfahrenden Fahrzeugen möglich wird. Hierfür kann die eingestellte Geschwindigkeit je nach Distanz verringert oder vergrößert werden, um den gewünschten Abstand zu halten oder einzustellen.
Simulation
Zum besseren Verständnis wurde das System mit Regelstrecke, Regler simuliert. Der Sensor wurde hierbei als Ideal angenommen. Durch diese Simulation konnte erkannt werden, dass ein PI-Regler für die Reglung ausreicht.
-
Simulation
-
Regelstrecke
-
Simulationsergebnis
Komponentenspezifikation
Komponente | Beschreibung | Bild |
---|---|---|
Arduino UNO R3 | Die Kernkomponente ist ein Arduino Uno Board, auf diesem ist ein ATmega328P verbaut welche die Berechnungen des Systems übernimmt. Dieser arbeitet mit einer Taktfrequenz von 16MHz und besitzt eine Betriebsspannung von 5V. Über 14 I/O Pins können Sensoren und Aktoren angeschlossen werden, wovon jeweils 6 als PWM Ausgang oder als Analog-Eingang genutzt werden können. Die I/O Pins können maximal 20mA leisten. Die Restlichen Informationen können aus diesem Datenblatt[3] entnommen werden. | |
TLE4905L | Ein TLE4905L Hall-Effekt Sensor der Firma Infineon wurde verwendet, um die Geschwindigkeit des Fahrzeuges über die Raddrehzahl zu ermitteln. Der Sensor kann auf Basis eines Magnetfeldes innerhalb einer Mikrosekunde schalten. Dieser arbeitet in einem Bereich von 3.8 bis 24 Volt und kann einen Ausgangsstrom von 100mA liefern. Nähere Informationen zum Sensor sind im Hauptartikel zu finden. | |
Display | Des Weiteren wurde ein Display mit einer Anzeige aus 16 Zeichen pro Zeile und zwei Zeilen verwendet, um dem Nutzer Rückmeldung über Systemparameter zu geben. Dieses Display wird über eine I²C Schnittstelle betrieben. | |
STP16NF06L n-Kanal MOSFET | Zur Schaltung größerer Lasten wurde ein n-Kanal MOSFET der Firma ST verwendet. Dieser kann Spannungen bis 60 Volt schalten und hält Ströme bis zu 16 Amper aus. Durchlasswiderstand ist kleiner als 0,09 Ohm und typischerweise 0,07 Ohm. Der MOSFET wird in einem TO-220 Gehäuse geliefert.[5] | |
Optokoppler EL817 | Aufgrund der unterschiedlichen Spannungsniveaus der verschiedenen Stromkreise des Fahrzeuges und des Mikrokontroller wurde ein Optokoppler verwendet. Auf der Eingangsseite schaltet er mit 1,2Volt und auf der Ausgangsseite können bis zu 35Volt geschaltet werden. Hierbei ist eine Isolierung von Aus- und Eingangsseite bis zu 5000V gewährleistet. Beide Seiten können bis zu 50mA leiten. Die Gehäuseform entspricht einem DIP mit 4 Anschlüssen.[7] | |
Widerstände | Es wurden 2 330Ohm und 3 10kOhm Widerstände zur Realisierung der Schaltung verwendet. Dabei kommen die 330Ohm Widerständen zur Strombegrenzung und die 10kOhm Widerstände als Pullup- beziehungsweise Pulldown-Widerstand zum Einsatz. Aus Kostengründen wurden Kohleschichtwiderstände mit einer Genauigkeit von 5% verwendet. Aufgrund des Verwendungszweckes reicht diese Genauigkeit. | |
Diode BA 159 | In der Schaltung für die Nutzereingabe wurde eine Gleichrichterdiode verwendet. Diese Diode hält bis zu 1000 Volt in Sperrrichtung und 1 Amper stand.[9] | |
RC-Auto | Als Basis für das Projekt wurde ein Ferngesteuertes Modellauto der Firma Dickie Toys modifiziert. Es besitzt Federung, Heckantrieb und Lenkung. Der Motor kann in nur einer Leistungsstufe betrieben werden. |
Umsetzung (HW/SW)
Die Umsetzung der Hardware ist in vier Bereiche zu unterteilen. Die Schnittstelle zum Menschen stellt zwei dieser Bereiche dar, zum einen Nutzereingabe und zum anderen die Nutzerausgabe. Die Nutzereingabe erfolgt über die Fernbedienung des Modellautos und die Nutzerausgabe wird durch ein Display realisiert. Die verbleibenden Bereiche sind die Schnittstellen zu dem Antrieb des Fahrzeuges. Die Ansteuerung des Antriebsmotors ist ein Aktor und die Raddrehzahlerfassung ein Sensor. Die Software umfasst dieselben vier Bereiche und den Bereich der Regelung.
Hardware
Prototypen der einzelnen Schaltungen wurden zunächst auf Steckbrettern umgesetzt. Diese wurden einzeln und im Anschluss als Gesamtsystem getestet, bevor die Schaltungen auf eine Lochrasterplatine zusammengefasst wurden. Diese Platine wurde anschließend fest im Fahrzeug verbaut.
Nutzerausgabe
Das Display für die Nutzerausgabe wird über den I²C-Bus an den Mikrokontroller angeschlossen. Zusätzlich wird das Display mit der Versorgungsspannung und der Masse des Arduino verbunden.
Nutzereingabe
Die Nutzereingabe wird über die Fernbedienung realisiert, um die Signale abzugreifen werden die Ursprünglichen Signale zum Motor für vor und Rücklauf ausgewertet. Durch Versuche konnte herausgefunden werden, dass bei Vorlauf das gelbe Anschlusskabel des Motors ein Potential von 9,6 V zur Masse des Fahrzeuges, und das weiße Anschlusskabel ein Potential von 0,2 V aufweist. Bei Rücklauf des Motors sind diese Werte vertauscht und bei nicht aktiviertem Motor weisen beide Anschlüsse ein Potential von 3,6 V zur Masse auf.
Diese Anschlüsse gehen auf eine Schaltung aus der Eingangsseite von zwei Optokoppler und einem 330Ohm Widerstand. Die beiden Optokoppler sind parallelgeschaltet und gegenläufig gepolt. Der Widerstand ist in Reihe geschaltet und dient der Begrenzung des Stroms unter den maximal zulässigen Wert der Optokoppler 50mA. Durch die gegenläufige Polung wird je nach Richtung des fließenden Stroms immer nur ein Optokoppler aktiviert. Sollte keine Potenzialdifferenz zwischen den beiden Anschlüssen anliegen so wird keiner der beiden Optokoppler aktiviert.
Die Ausgangsseite des ersten Optokopplers ist mit einem Interrupt fähigen Pin des Arduino verbunden, der durch einen 10kOhm Pullup-Widerstand mit der Versorgungsspannung des Arduinos verbunden ist. Wird der Optokoppler aktiviert so wird der Pin mit der Masse verbunden, sodass eine fallende Flanke entsteht, welche ein Interrupt auslösen kann. Der zweite Optokoppler ist mit einem digitalen Eingangspin verbunden und über eine Diode mit dem Interrupt-Pin. Bei Aktivierung des Optokopplers werden beide Pins mit der Masse verbunden, sodass ein Interrupt ausgelöst werden kann und der digitale Pin das Masse Potenzial annimmt. Beim Auftreten eines Interrupts kann so entschieden werden welcher der beiden Optokoppler aktiviert wurde und damit ausgelesen werden und damit die Nutzereingabe ausgelesen werden.
Theoretisch könnte die Funktion ebenfalls mit zwei Interrupt-Pins gelöst werden, wodurch die Diode gespart werden kann. Da der verwendete Microcontroller jedoch nur zwei Interrupt-Pins besitz und einer für die Auswertung des Sensors verwendet werden soll, wurde die beschriebene Schaltung umgesetzt, welche einen Pin als Interrupt für Nutzereingabe verwendet. Alternativ könnte die Nutzereingabe auch über Polling geschehen, indem digitale Eingänge in sehr kurzen Abständen abgefragt werden. Um eine zuverlässige Eingabe zu ermöglichen, müsste der Microkontroller jedoch einen erheblichen Anteil der Rechenzeit mit der Nutzereingabe verbringe. Hierdurch könnte möglicherweise die eigentliche Aufgabe, die Geschwindigkeitsregelung, gestört werden.
Ansteuerung des Antriebsmotors
Der Motor benötigt im Betrieb eine Spannung von etwa 9,4 V und einen Strom von 500 mA. Um diese von der Versorgungsspannung des Microcontrollers abweichenden Spannung schalten zu können, wird ein Optokoppler verwendet. Dieser isoliert die Spannung des Mikrokontrollers zur Spannung des Fahrzeuges und wird an das Gate des n-Kanal MOSFETS angeschlossen, um den Strom schalten zu können. Dies ist aufgrund des maximalen Ausgangsstrom des Optokopplers notwendig. Die Motorleistung wird somit durch einen mit dem Motor in Reihe geschalteten n-Kanal MOSFET geregelt, wobei die Reihenschaltung die Versorgungsspannung mit der Masse des Fahrzeugs verbindet. Der Optokoppler verbindet bei Aktivierung das Gate des MOSFTES mit der Versorgungsspannung des Fahrzeugs. Zudem ist das Gate über einen 10kOhm Pulldown-Widerstand mit der Masse des Fahrzeugs verbunden, um bei nicht Aktivierung des Optokopplers den MOSFET zu sperren. Der Optokoppler wird mit einem PWM Pin des Mikrokontrollers verbinden und über einen 330Ohm Widerstand mit der Masse des Mikrokontrollers. Der Widerstand dient zur Begrenzung des Stroms unter den maximal zulässigen Wert der Eingangsseite des Optokopplers von 50mA.
Durch die Schaltung kann die Motorleistung daher durch eine Pulsweitenmodulation geregelt werden. Alternativ könnte der verwendete MOSFET im triodischer Bereich betrieben werden. Dadurch würden jedoch hohe Verlustleistungen entstehen, welche durch eine Verwendung als Schalter durch eine Pulsweitenmodulation nicht entstehen, da der MOSFET im Stromsättigungsbereich betrieben wird.
Raddrehzahlerfassung
Für die Auswertung der Geschwindigkeit wird ein Hall-Effekt Sensor verwendet. Durch den Hallsensor wird das Magnetfeld eines Permanentmagneten detektiert, welcher sich im Reifen des Fahrzeuges befindet. Dieser wird mit der Versorgungsspannung und der Masse des Mikrokontrollers sowie mit einem Interrupt-fähigen Pin verbunden. Um das Potenzial einzustellen wird ein 10kOhm Pullup Widerstand mit der Versorgungsspannung des Mikrokontrollers verbunden.
Der TLE4905L ist ein Unipolarer Halleffektsensor auf Halbleiterbasis, welcher bei einer gewissen magnetischen Feldstärke den Ausgangspin mit der angeschlossenen Masse verbindet und bei geringerer magnetischen Feldstärke die Verbindung wieder trennt. Durch die Schalthysterese des Sensors wird gewährleistet, dass pro Radumdrehung der Sensor nur einmal ausgelöst wird. Die Schaltung setzt einen vereinfachten Anwendungsschaltkreis aus dem Datenblatt des Sensors um. Auf die aufgeführten 4,7nF Kondensatoren wurde aus Kostengründen und Lieferschwierigkeiten verzichtet, da bei Test auch ohne diese Komponenten eine gute Genauigkeit erzielt werden konnte, welche auf die gleichmäßige Spannungsversorgung und gleichmäßige geringe Leitung der Anwendungsschaltkreise zurückzuführen ist.
Platine
Alle Schaltungen sind auf einer Platine zusammengefasst. Diese Platine besitzt Schnittstellen zu anderen Komponenten des Gesamtsystems: Dem Hallsensor (3 Kabel), dem Kotrollerboard des RC-Autos (5 Kabel), zum Display (4 Stecker) und dem Arduino (8 Kabel). Die Kabel zum Arduino sind fest verlötet und könne in die Verbinder des Arduino gesteckt werden. Die Kabel zum Kotrollerboard des RC-Autos werden über Lüsterklemmen verbunden. Der Sensor ist fest verlötet und für das Display wurden Steckverbinder gewählt.
Der Aufbau auf einer Lochrasterplatine wurde aufgrund von Anforderung 2.0 und 4.0 dem vorher realisiertem Aufbau auf einem Steckbrett vorgezogen. Die wichtigsten Verbindungen wurden auf der Platine verlötet, ebenfalls um Anforderung 4.0 zu erfüllen.
-
Platine
-
Interfaces
-
Verdrahtungsplan
Software
Die Software wurde mithilfe der Arduino-IDE umgesetzt. Die verwendete Programmiersprache ist damit C++. Für die Software wurde das Projekt in die oben beschriebenen Bereiche unterteilt. für jeden Bereich wurde eine Software Modul verwendet, wobei für die Displayausgabe bestehende Lösungen verwendet wurden, während für die Restlichen Bereiche neue Module mit cpp-Dateien und h-Dateien entwickelt wurden.
Displayausgabe (Wire, LiquidCristal_I2C)
Für die Ansteuerung des Displays wurden die vom Zulieferer Funduino empfohlenen Bibliotheken Wire und LiquidCristal_I2C verwendet. Ein neues LCD-Display kann durch den folgenden Befehl angelegt werden:
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
Die Initialisierung geschieht durch den folgenden Befehl:
lcd.begin(16, 2);
Mit den Folgenden Befehlen kann im Programmablauf das Display gelöscht werden, der Cursor an eine bestimmte Spalte und Zeile gesetzt werden und an diese ein String gedruckt werden.
lcd.clear(); lcd.setCursor(0, 0); lcd.print("Hallo Welt");
Geschwindigkeitsmessung (HallSpeed)
Für die Geschwindigkeitsmessung wurde ein einzelnes Modul erstellt, welches die Messung umsetzt. Für die Initialisierung sind der Anschluss-Pin des Hallsensors, der Radumfang im mm und eine Zeitkonstante zu übergeben. Zu beachten ist, das als Anschluss-Pin Pin 2 oder Pin 3 gewählt werden muss, da der Pin interruptfähig seien muss. Die Zeitkonstante gibt an, nach welcher Zeit ohne Auslösung ein Interrupt vom Stillstand des Rades ausgegangen wird.
Zum Auslesen der Geschwindigkeit kann im Programm die Methode getSpeed verwendet werde, welche die Geschwindigkeit in mm/s zurückgibt. Die Berechnung der Geschwindigkeit basiert auf der Gemessene Zeit zwischen zwei Interrupts.
#ifndef HallSpeed_h #define HallSpeed_h /** * Geschwindigkeitsmessung mittels eines Hallsensors * Datum: 29.12.2020 * Autor: Mario Wollschläger */ unsigned int radumfang; //radumfang in mm unsigned int t0; unsigned long timeStamp; unsigned long delta; /** * ISR fuer ausloesen des Hallsensors */ void hall(); /** * Initialisierung der Geschwindigkeitsmessung * pin: Anschlusspin des Sensors * pRadumfang: zurueckgelegte Strecke zwischen zwei Ausloeseungen des Sensors (vorzugsweise in mm) * pT0: Zeit bis von einem Stillstand ausgegangen wird in ms */ void initSpeedometer(int pin, unsigned int pRadumfang, unsigned int pT0); /** * Methode um Aktuelle Geschwindigkeit abzufragen * Rückgabe in mm/s, falls pRadumfang in mm */ int getSpeed(); #endif
Motoransteuerung (Motor)
Das Modul zur Motoransteuerung besitzt eine Klasse Motor. Mit Objekten dieser Klasse kann die Leistung eines Motors über Pulsweitenmodulation gesteuert werden. Ein Motor kann mit dieser Klasse sowohl im Vorlauf als auch im Rücklauf betrieben werden. Hierfür wird jeweils beim Vorlauf und beim Rücklauf an einem bei der Initialisierung zu Übergebendem Pin ein PWM-Signal übergeben. Im Projekt Geschwindigkeitsregelanlage wird derzeit nur ein Motor mit Vorlauf verwendet, dies wird dem Programm signalisiert, indem für den Rücklauf-Pin der Wert -1 übergeben wird.
Für die letztendlich Ansteuerung des Motors steht eine öffentliche Methode der Klasse Motor zur Verfügung. Dieser kann für die Motorleistung ein Wert von -255 bis 255, übergeben werden, wobei negative Werte für den Rücklauf stehen. Da im verwendeten Modus mit nur einer Laufrichtung gearbeitet wird, beschränkt sich der nutzbare Bereich auf 0 bis 255.
#ifndef Motor_h
#define Motor_h
/**
* PWM-Motorsteuerung
* Datum: 29.12.2020
* Autor: Mario Wollschläger
*/
class Motor{
private:
char v;
char r;
public:
/**
* Initialisieren des Motors:
* pinVor: PWM-Pin fuer Vorwaertsfahrt des Motors
* pinRueck: PWM-Pin fuer Rueckwaertsfahrt des Motors (falls nicht vorhanden: auf -1 setzen)
*/
Motor(int pinVor, int pinRueck);
/**
* Motor mit gegebener Power betreiben
* wert: Kraft, 0 bis 255, falls nur Vorwaerts
* -255 bis 255 falls Vor- und Rueckwarts
*/
void power(int wert);
};
#endif
Nutzereingabe (userInput)
Die Nutzereingabe ist in einem Modul realisiert, welches dem Nutzer die Möglichkeit bietet, einen Wert in einer zuvor definierten Schrittweite zu erhöhen oder zu verringern. Dabei kann für diesen Wert ein Maximum und ein Minimum angegeben werden.
#ifndef userInput_h #define userInput_h /** * Nutzereingabe mit einem Interuptpin und 2 Eingabemoeglichkeiten * Datum: 30.12.2020 * Autor: Mario Wollschläger */ int uservalue; int stepsize; int inputPin1; int inputPin2; unsigned long lastUserInput; unsigned int entprellzeit; int userMax; int userMin; /** * ISR für Usereingabe */ void userInput(); /** * Initialisuerung des Userinputs, der Nutzer kann einen Wert schrittweise um einen festgelegte Schrittweite erhoehen oder veringern (Startwert: 0) * inputA: Pin 1 fuer Usereingabe und Interupt-Pin * inputB: Pin 2 fuer Usereingabe * pStepsize: schritweite bei Usereingabe * pEntprellzeit: Entprellzeit für die Verweindung mechanischer Taster * pUserMax: Maximalwert der durch den Nutzer eingestellt werden kann * pUserMin: Minimalwert der durch den Nutzer eingestellt werden kann */ void initUserInput(char inputA, char inputB, int pStepsize, unsigned int pEntprellzeit, int pUserMax, int pUserMin); /** * gibt den vom Nuter eingestellten Wert */ int getUservalue(); #endif
Reglung der Motorleistung (begrenzterRegler)
Mit dem Modul begrenzterRegler können Objekte der Klasse BegrenzterRegler erzeugt werden. Diese sind die Umsetzung eines PI-Reglers, welcher in seinem maximalen und minimalen Ausgangswert beschränkt ist. Beim Erzeugen von Objekten der Klasse sind der I- und P-Anteil, sowie der Maximalwert und der Minimalwert anzugeben. Über die Methode regelWert des Objektes kann dann im laufenden Betrieb ein Regelwert errechnet werden. Hierfür sind der Regelfehler und die Zeit anzugeben, welche seit der letzten Reglung verstrichen ist. Die Zeit ist für die Berechnung des I-Anteils notwendig.
Der Regler besitzt eine Anti-Windup-Strategie. In der aktuellen Implementierung wird hierfür der I-Anteil auf den Wertebereich des Reglers beschränkt. Somit wird auch das Windup-Phänomen beschränkt.
#ifndef begrezterRegler_h #define begrezterRegler_h /** * PI-Regeler mit Stellgroessenbeeschraenkung * Datum: 29.12.2020 * Autor: Mario Wollschläger */ class BegrenzterRegler{ private: double iAnteil; unsigned int p; unsigned int i; int rMax; int rMin; /** * Begrenzt einen Regewert auf rMin bis rMax * wert: zu begrenzender Wert */ double begrenzung(double wert); /** * Umsetzung eines PI-Reglers * regelfehler: Regelabweichung e * zeitMs: Zeit seit des letzten Releraufruf in ms */ double piRegler(int regelfehler, unsigned int zeitMs); public: /** * Initialisierung des Reglers * pP: P-Anteil des PI-Reglers * pI: I-Anteil des PI-Reglers * pRMax: Maximalwert des Reglers * pRMin: Minimalwert des Reglers */ BegrenzterRegler(unsigned int pP, unsigned int pI, int pRMax, int pRMin); /** * Gibt eine Regelwert basierend auf einem Regelfeher zurueck * Beschraenkt auf rMin bis rMax * Umgestezt durch eine PI-Regler * regelfehler: Regelabweichung e * zeitMs: Zeit seit des letzten Releraufruf in ms */ int regelWert(int regelfehler, unsigned int zeitMs); /** * Ermoeglicht das Aendern des P- und I- Wertes während des laufenden Betriebs * pP: P-Anteil des PI-Reglers * pI: I-Anteil des PI-Reglers */ void setPI(unsigned int p, unsigned int i); }; #endif
Gesamtablauf
Die implementierte Lösung entspricht dem folgenden Programm-Ablauf-Plan:
Komponententest
Die Module wurden zunächst einzeln getestet, um eine aufwendige Fehlersuche im Gesamtsystem zu vermeiden.
Halleffektsensor
Zunächst wurde eine Schaltung auf einem Steckbrett aufgebaut. Die Auswertung der Schaltung wurde zunächst über eine LED und im Anschluss über ein Spannungsmessgerät vorgenommen. Durch diese Methoden konnte der Prinzip Aufbau validiert werden. In einem Zweiten Schritt wurde dann mithilfe des Arduinos und einem vorläufigen Programm die Drehzahl des RC-Autos im Leerlauf gemessen. Hier konnte erwiesen werden, dass die Drehzahl durch die Schaltung gemessen werden kann. Zur Validierung des Wertes wurde die Drehzahl eines Akkuschraubers gemessen und mit der vom Hersteller angegebenen verglichen. Die Werte stimmten überein womit nachgewiesen ist, dass der Sensor korrekte Werte misst.
-
Steckbrettaufbau
-
Messung am Rad
-
Test mit Akkuschrauber
-
Drehzahlmessung am Akkuschrauber
Motoransteuerung
Die Motoransteuerung wurde schrittweise aufgebaut. Hierfür wurde zunächst das zur Masse führende Zuleitungskabel des Motors getrennt und durch dessen Verbindung der Motor geschaltet. Im zweiten Schritt wurde das Schalten mithilfe des MOSFETs umgesetzt, dessen Gate mit der Versorgungsspannung und der Masse des Fahrzeuges verbunden wurde. Im Anschluss wurde diese Verbindung über den Optokoppler umgesetzt, welcher über einen passenden Vorwiderstand mit der Versorgungsspannung und der Masse des Arduinos verbunden wurde.
Nachdem alle beschriebenen Teststufen erfolgreich waren, wurde der Optokoppler an einen PWM-Pin des Arduinos angeschlossen und die Leistung nach einem analogen Eingangssignal, eingestellt durch ein Potentiometer, geregelt. Auch dieser Test war erfolgreich.
-
Versuch zur Motoransteuerung
Benutzereingabe
Die Schaltung wurde nach der Planung auf einem Steckbrett aufgebaut. Hierfür wurden die Optokoppler zunächst durch Taster ersetzt, um die am Arduino angeschlossene Seite der Schaltung zu testen. Nachdem die Tests des Schaltungsaufbaus erfolgreich waren, wurde die Schaltung um die am Fahrzeug angeschlossene Seite erweitert. Die anschließenden Tests der Gesamtschaltung sind zunächst mit der Versorgungspannung des Arduinos durchgeführt worden bevor Tests am Fahrzeug vorgenommen wurden. Auch diese Tests sind erfolgreich abgenommen worden.
-
Test mit Tastern
-
Test mit Optokopplern
Display
Der Test des Displays beschränkte sich aufgrund des geringen Schaltungsaufwands auf das Anschließen über Jumper-Cable und der Ausgabe von "Hallo Welt!". Beim Test traten keine Fehler auf.
Gesamtschaltung Steckbrett
Nachdem die einzelnen Komponenten auf dem Steckbrett getestet wurden, konnte der Test aller Komponenten als Gesamtsystem durchgeführt werden. Hierfür wurde eine erste Softwareversion verwendet, welche alle Komponenten verwendet. Der Test wurde erfolgreich abgeschlossen.
-
Aufbau auf dem Steckbrett
-
Test des Gesamtsystems mit dem Steckbrettaufbau
Gesamtschaltung Platine
Durch den erfolgreichen Test des Gesamtsystemaufbau auf dem Steckbrett konnte die nächste Projektphase begonnen werden: Der Aufbau auf einer Platine. Die Platine wurde nach dem Zusammenbau mit denselben Methoden wie der Steckbrettaufbau getestet. Hierbei ergab sich, dass die Ansteuerung des Motors nicht funktionstüchtig war. Nach dem Durchmessen der beteiligten Komponenten konnte ein Defekt im verwendeten Optokoppler festgestellt werden. Hierbei wies die Eingangsseite die Typische Vorwärtsspannung auf, jedoch wurde die Ausgangsseite nicht geschaltet.
Da bereits bei der Beschaffung mit Puffern gerechnet wurde und somit mehr Komponenten bestellt als benötigt wurden, konnte der Fehler durch Austausch des Bauelements schnell behoben werden. Die anschließenden Tests verliefen reibungslos.
-
Test der Platine
-
Gesamtaufbau des Tests
-
Spannung über defektem Optokoppler-Ausgang
(1V/Div, 0.2ms/Div) -
Spannung über intaktem Optokoppler-Ausgang
(1V/Div, 0.2ms/Div)
Ergebnis
Die Geschwindigkeitsregelanlage erfüllt die an sie gestellten Erwartungen. Im Dauerbetrieb ist das Ergebnis der Regelung mit einer Abweichung von der Sollgeschwindigkeit, die 50 mm/s selbst bei relative rauem Fahrbahnbelag nicht überschreitet als "Gut" zu bewerten. Dabei können Geschwindigkeiten von bis zu 3 m/s (3000 mm/s) erreicht und geregelt werden. Auch Steigungen und Gefälle werden durch die Regelung kompensiert. Dabei passt das Gesamtsystem in den zur Verfügung stehen Bauraum. Auch der Energieverbrauch und Masse des Systems erlaubt einen mobilen Betrieb mit allen notwendigen Komponenten im Fahrzeug. Der Aufbau widersteht nicht nur den im Normalbetrieb auftretenden Erschütterungen, sondern ist auch gegenüber stärkeren Erschütterungen wie das Abkommen von der Fahrbahn resistent.
Die 4,8 Watt des Motors werden in einer kontrollierten Art und Weise gesteuert und die Nutzereingabe funktioniert fehlerfrei. Der Sensor liefert zuverlässige und genaue Daten, lediglich bei geringen Geschwindigkeiten ist die Datenrate sehr gering, diese Beeinträchtigung konnte jedoch durch die anderen Bestandteile des Systems und die Software kompensiert werden. Auch die Rückmeldung an den Nutzer ist umfangreich zufriedenstellend, wobei alle gewünschten Werte auf dem Display anschaulich dargestellt werden.
-
Finaler Gesamtaufbau
-
Test der Regelanlage
-
Gesamtansicht
-
Fahrzeug
Zusammenfassung
Es ist möglich mit einem Arduino Uno und weiteren Komponenten eine Geschwindigkeitsregelanlage umzusetzen. Hierbei kann ein Hallsensor für die Geschwindigkeitsermittlung verwendet werden und ein Mosfet zur Steuerung eines Elektromotors. Die Verwendung von Optokopplern ermöglicht zudem die Verbindung von Schaltungen mit unterschiedlichen Spannungen.
Es wurde zunächst eine Simulation des Systems entwickelt, bevor Hard- und Software Komponente für Komponente entwickelt und getestet wurden. Im Anschluss wurde das Gesamtsystem aufgebaut und auf die gestellten Anforderungen getestet.
Lessons Learned
- Eine Simulation kann das eigene Verständnis des Systems fördern, um so nachfolgende Arbeiten zu erleichtern.
- Der Prototypenaufbau auf einem Steckbrett ermöglicht schnelle Änderungen und damit das schnelle Entwickeln neuer Schaltungen.
- Durch das Durchmessen von Schaltungen können Defekte lokalisiert werden. Hierbei helfen Messgeräte wie Multimeter und Oszilloskop.
- Durch eine Platine kann im Vergleich zu einem Steckbrettaufbau Bauraum gespart werden und solidere Komponenten hergestellt werden.
- Zusätzliche Komponenten ermöglichen den Aufbau mehrere Schaltungen, beispielweise auf dem Steckbrett und gelötet auf einer Platine. Zudem kann so schnell auf Defekte reagiert werden.
Verbesserungs- und Erweiterungsmöglichkeiten
Bei dem System gibt es zwei Aspekte, die verbessert werden könnten. Zum einen könnte die Datenrate der Drehzahlmessung durch mehr Magnete im Reifen bei niedriger Geschwindigkeit erhöht werden. Zum anderen wäre die Weiterentwicklung der Motoransteuerung für Rücklauf und Bremsvorgänge möglich.
Das Basisfahrzeug hat sich als ideale Projektbasis erwiesen, um es nahezu beliebig zu erweitern.
- Die GRA-3000 könnte mit einem Abstandsensor zu einer adaptiven Abstandsregelanlage erweitert werden.
- Darauf aufbauend könnte ein Notbremsassistent realisiert werden.
- Ein Umfangreicheres Nutzereingabe könnte durch verschiedene Tastenkombinationen wie doppeltes Drücken oder längeres gedrückt halten zum Einsatz kommen.
- Das Fahrzeug könnte mit Licht und damit mit einer Lichtautomatik ausgestattet werden.
- Der Umbau der Lenkung von digital auf analog ist empfehlenswert.
Projektunterlagen
Projektplan
Projektdurchführung
Datum | Aufgabe | Durchgeführt | Status |
---|---|---|---|
05.10.2020 | Ausarbeitung einer Grundidee | = | Abgeschlossen |
08.10.2020 | Wiki-Artikel anlegen | = | Abgeschlossen |
09.10.2020 | Systementwurf, Wiki-Artikel Konzept | = | Abgeschlossen |
05.11.2020 | Sensortest, Hallsensor | = | Teilweise Abgeschlossen |
18.12.2020 | Motoransteuerung | =, Sensortest, Hallsensor | Abgeschlossen |
21.11.2020 | Regelkreis und Simulation | = | Teilweise Abgeschlossen |
27.11.2020 | Gesamtaufbau Steckbrett | = | Abgeschlossen |
28.11.2020 | Software Projekt anlegen | = | Abgeschlossen |
29.11.2020 | Software Geschwindigkeitsmessung, Regler, Motor | = | Abgeschlossen |
30.11.2020 | Software und Steckbrett Benutzereingabe | = | Abgeschlossen |
02.01.2021 | Platine Zusammenbau | = | Teilweise Abgeschlossen |
03.01.2021 | Platine Test, Kontaktierung, Gesamtaufbau | =, Platine Zusammenbau | Abgeschlossen |
04.01.2021 | Informationsaustausch, Wiki-Artikel Struktur | = | Abgeschlossen |
04.01.2021 | Wiki-Artikel Komponentenspezifikation | = | Abgeschlossen |
05.01.2021 | Wiki-Artikel Umsetzung Hardware | = | Teilweise Abgeschlossen |
06.01.2021 | Wiki-Artikel Umsetzung Hardware | = | Abgeschlossen |
07.01.2021 | Wiki-Artikel Software, Komponententest | = | Teilweise Abgeschlossen |
08.01.2021 | Software Test, Sensorhalterung | = | Abgeschlossen |
11.01.2021 | Wiki-Artikel Software, Komponententest | = | Abgeschlossen |
15.01.2021 | Abschlusstest, Filmtag | = | Abgeschlossen |
16.01.2021 | Videoschnitt, Peppiges Foto | = | Abgeschlossen |
18.01.2021 | Wiki-Abschluss | = | Abgeschlossen |
YouTube Video
Ein Video zum Projekt finden Sie hier.
Weblinks
Komponenten bei Reichelt:
SVN-Projektordner:
101_Geschwindigkeitsregelanlage
Literatur
- ↑ Eigenes Dokument
- ↑ Eigenes Dokument
- ↑ Arduino: Arduino- ArduinoBoardUno. 2021. Online im Internet: https://www.arduino.cc/en/Main/arduinoBoardUno> Abruf: 05.01.2021
- ↑ https://cdn-reichelt.de/bilder/web/artikel_ws/B400/PICTURE_2SS52M.jpg
- ↑ STMikroelektronics: STP16NF06L/FP. 2004. Online im Internet: https://cdn-reichelt.de/documents/datenblatt/A200/TXSTM-POWERMOSFET-STX-16NF06L_EN.pdf; Abruf: 05.01.2021
- ↑ https://cdn-reichelt.de/bilder/web/xxl_ws/A200/TO-220.png
- ↑ EVERLIGHT ELETCRONICS CO., LTD: Technical Data Sheet - Photocoupler-EL817 Series. 2004. Online im Internet: https://cdn-reichelt.de/documents/datenblatt/A500/EL817-EVL.pdf; Abruf: 05.01.2021
- ↑ https://cdn-reichelt.de/bilder/web/artikel_ws/A501/DIP-4.jpg
- ↑ Continental Device India Limited: FAST SWITCHING PLASTIC RECTIFIERS - BA157, BA158, BA159. Jahr Unbekannt. Online im Internet: https://cdn-reichelt.de/documents/datenblatt/A400/BA157_BA158_BA159_CDIL.pdf; Abruf: 05.01.2021
- ↑ https://cdn-reichelt.de/documents/datenblatt/A400/BA157_BA158_BA159_CDIL.pdf
→ zurück zur Übersicht: WS 20/21: Fachpraktikum Elektrotechnik (MTR)