20180202_Beschreibung

Automatisierung einer Garage
Gruppe 21B
Malte Katz, Tim Block, Nicolas Fritsche, Maxime Junghänel

Inhalt
Funktionsbeschreibung Parkhaus .................................................................................................. 3
Verwendete Hardware: ................................................................................................................ 4
Kontextdiagramm ........................................................................................................................ 5
SA/RT........................................................................................................................................... 6
Zustandsübergangsdiagramm ....................................................................................................... 7
Prozessaktivierungstabelle ........................................................................................................... 8
Dokumentation der Schnittstellen ................................................................................................ 9
LEDs ..................................................................................................................................................... 9
Empfängereinheiten ............................................................................................................................ 9
Fernbedienung .................................................................................................................................. 10
Motorsteuerung ................................................................................................................................ 12
Pinbelegung ............................................................................................................................... 14
Schaltplan .................................................................................................................................. 15
Verdrahtungsplan ...................................................................................................................... 16
Testplanung und Ergebnisse ....................................................................................................... 17
Source-Code ............................................................................................................................... 18
2

Funktionsbeschreibung Parkhaus
In dem Projekt wurde ein Parkhaus aus Lego mittels eines Nucleo F401RE automatisiert.
Das Parkhaus besteht aus einem Tor mit Lichtschranke, welches sich öffnen und schließen
lässt, einem Schlitten, welcher das Auto in der Horizontalen bewegen kann, einer
Fernbedienung zum Öffnen des Tors sowie einem Taster zum Schließen des Tors und Status-
LEDs.
Zunächst initialisiert sich das Parkhaus. Das bedeutet, der Schlitten fährt nach hinten. Bei der
Schlittenbewegung leuchtet die Gelbe LED. Ist der Schlitten angekommen, befindet sich das
Model im Zustand „TorZu“.
Durch einen Infrarotbefehl der Fernbedienung (Simulation eines personalisierten Signals)
wird ein Motor angesteuert und der Schlitten fährt nach vorne bis der Grenztaster ein Signal
liefert. Die Gelbe LED signalisiert erneut die Bewegung des Schlittens. Der Schlitten befindet
sich nun vorne und das Tor ist geschlossen.
Das Tor wird nun automatisch geöffnet. Der Motor wird dazu so lange angesteuert bis der
obere Grenztaster aktiviert wird. Eine Rote LED zeigt an, dass eine gefährliche Bewegung des
Tors stattfindet. Dabei überwacht eine Lichtschranke den Gefahrenbereich, um beim
Betreten des Gefahrenbereichs abzuschalten.
Nun kann das Auto auf den Schlitten gefahren werden. Eine Grüne LED signalisiert diesen
Zustand. Wenn der Taster betätigt wird (eine Person bestätigt, dass das Auto sicher auf dem
3

Schlitten steht), sowie die Lichtschranke kein Objekt erkennt, wird das Garagentor herunter
gefahren bis ein Grenztaster erkennt, dass das Tor unten ist.
Nachdem das Garagentor unten ist, startet der Motor, welcher den Schlitten mit Auto in die
Parkposition fährt. Die Endposition ist erreicht, wenn der Grenztaster im hinteren Bereich
ein Signal gibt. Solange der Schlitten fährt, wird die Gelbe LED erneut eingeschaltet. Nun ist
das Parkhaus im Zustand „TorZu“. Die LED´s sind ausgeschaltet.
Das erneut eingelesene Signal der Fernbedienung (personalisiertes Signal um zu wissen
welches Auto abgeholt werden soll) aktiviert den Motor des Schlittens woraufhin dieser mit
dem Auto nach vorne fährt, bis der vordere Grenztaster betätigt wird. Dabei wird die gelbe
LED eingeschaltet.
Danach wird das Tor geöffnet und durch die grüne LED wird angezeigt, dass das Auto
herausgefahren werden kann.
Mit dem Taster wird signalisiert das das Auto herausgefahren wurde. Somit fährt das Tor
wieder zu und fährt in die Position, der Schlitten befindet sich hinten um eventuell andere
Autos aus dem Lager abholen zu können.
Verwendete Hardware:
• Nucleo Board F401RE
• IR Sender/Empfänger
• 2x DC-Motoren
• Lichtschranke, Sender/Empfänger
• 4x Grenztaster
• 2x Taster
• Aufbau aus Lego
• Selbstgebautes Legogetriebe Tor (1:75)
• Selbstgebautes Legogetriebe Schlitten (1:36)
• 2x LED Grün;
• LED Rot
• LED Gelb,
• Widerstände in Ohm ( 3x 330 ; 75; 3,3M; 2,7M; 3x 2,2 ; 2x 1; 390 ; 3x 39k)
• L293D
• NE555
• 2x Keramik Kondensator; 10nF , 100nF
4

Kontextdiagramm
Im Kontext sind auf der linken Seite alle Aktoren zu sehen, dazu gehören die Leds und die
Motoren. Rechts hingegen sind die Sensoren, dazu gehören die 4 Grenztaster die das
Abschalten des Motors auslösen, der Empfänger der die Signale der Infrarot Fernbedienung
ausliest, eine Lichtschranke die prüft ob ein Objekt vor dem Tor ist und ein Taster zum
Schließen des Tors.
Die Sensoren liefern in unseren Fall alle einen Kotrollfluss (Rot dargestellt), da deren
Information essentiell für die Funktion ist, und im Zustandsautomat einen Zustandswechsel
auslösen werden.
5

SA/RT
Im SA/RT Diagramm sind alle Kreise Prozesse, die sich im Source Code als Funktion
widerspiegeln. Es gibt ein Prozess um jede Led anzuschalten und einen weitern um die Led
auszuschalten. Dies macht die Handhabung in der PAT Tabelle übersichtlicher.
Die Prozesse „IR_Empfaenger“ und „LS_Analog_Wert“ bekommen einen Analogwert von
0-4096 übergeben und werten in ein digitales Signal umgewandelt, welches als Kontrollfluss
auf den Knoten gehen.
Der Prozess „Warten“ hat keine Daten bzw. Kontrollflüsse, da nur ein Delay von 3 Sekunden
aufgerufen wird, falls sich ein Objekt in der Lichtschranke befindet und der Automat im
Notzustand ist. Wenn das Objekt jetzt aus der Lichtschranke entfernt wird, würde das Tor
sofort schließen und eventuell jemanden verletzen.
6

Zustandsübergangsdiagramm
Unser Zustandsdiagramm ist ein Mealy-Automat. Wir haben Sechs Zustände in denen sich
das System im regulären Betrieb befindet. Weiter gibt es noch einen Zustand für die
Initialisierung und einen zwei Not-Zustände. Die Bedingungen der Übergänge sind die
Kontrollflüsse unseres SA/RT Diagramms und die Aktionen der Übergänge rufen einen oder
mehrere Prozesse auf so wie es in der Prozessaktivierungstabelle vorgegeben ist. Es gibt hier
einige Besonderheiten die nicht direkt verständlich sind. Da wir in unserem Ruhezustand
„TorZu“ nichts machen außer auf ein richtiges Infrarot Signal zu warten gibt es hier einen
Übergang auf sich selbst, wenn keine andere Bedingung der Übergänge zutrifft, um dann
erneut das Infrarot Signal abzufragen. Nach demselben Prinzip gibt es einen Übergang auf
sich selber um Die Lichtschranke zwischen dem Tor abzufragen.
7

Prozessaktivierungstabelle
Aktionen\Prozesse 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Schlitten_Wegbringen 1 2
Schlitten_Ausschalten 2 1
Schlitten_Holen 1 2
Tor_Oeffnen 3 2 4 1
Tor_Schliessen 2 1 3
Tor_Zu_Einschalten 2 3 1
Tor_Auf_Einschalten 2 3 1
Tor_Ausschalten 2 1
Tor_Geoeffnet 3 2 1
Signal_Pruefen 1
Schranke_Pruefen 1
Prozesse: 1: LGe_An, 2: Lro_An, 3: LGr_An, 4: LGe_Aus, 5: Lro_Aus, 6: LGr_Aus, 7: M_Tor_Stopp, 8: M_Tor_Auf, 9: M_Tor_Zu, 10: M_Schlitten_Stopp,
11: M_Schlitten_Hinten, 12: M_Schlitten_Vorne, 13: Warten, 14: IR_Empf, 15: LS_Pruefen
8

Dokumentation der Schnittstellen
LEDs
RVor/ Ω UVersorg/ V IIst /mA IMax/ mA λ/ nm
LED Rot 330 5 15 20 660
LED Grün 330 5 15 20 570
LED Gelb 330 5 15 20 590
Tx Lichtschranke 75 5 66 100 940
Da der IMin in allen Fällen deutlich kleiner als IMax ist, kann von einer langen Lebensdauer
ausgegangen werden. Die Wellenlängen der Senderdiode der Lichtschranke sowie der
Fernbedienung liegen mit 940nm im Bereich der Fotoempfindlichkeit der Fotodiode.
Empfängereinheiten
Unter Zuhilfenahme eines Spannungsteilers, bestehend aus einem Widerstand und der
Fotodiode, wird überprüft, ob die Diode Bestrahlt wird. Der Widerstand der Fotodiode sinkt
bei Einstrahlung von UV-Licht. Dieser Spannungsabfall wird von den Pins PA5 und PA7 analog
gemessen. Es wird ein 2,7MΩ bzw. ein 3,3MΩ Widerstand Verwendet, da kein 3MΩ
Widerstand vorhanden war. An den Dioden Stellen sich die Spannungen aus untenstehender
Tabelle ein.
Fotoempfindlichkeit/nm Ubestrahlt/V Uunbestrahlt/ V
Rx Lichtschranke 880-1120 0,02 0,1
Rx Fernbedienung 880-1120 0,3 1,14
9

Fernbedienung
Die hier beschriebene Schaltung (Schaltplan S.11) stellt einen IR-Sender dar, der ein
Rechtecksignal mit ca. 1200 Hz sendet.
Die Schaltung wird mit 9 Volt Eingangsspannung betrieben, und das Rechteck Signal wird
durch ein IC (TI NE555) erzeugt. Um die gewünschte Frequenz zu erhalten, werden die 8
Eingänge des IC wie folgt beschaltet. Pin 4 und 8 werden an die 9 Volt angeschlossen, Pin 1
auf Ground.
Laut Datenblatt entspricht die Frequenz f =
1
0.693(39kΩ+2∗39kΩ)∗10nF
ist und ca. 1233 Hz ergibt.
1
0.693(R1+R2∗2)∗C1
, was in unserem Fall
Das Rechtecksignal wird auf den Ausgang gelegt (Pin3) und hat eine Amplitude von ca. 9
Volt.
Um die IR-LED zu betreiben muss ein geeigneter Vorwiederstand definiert werden, um einen
Arbeitspunkt von 1.2 V und 20 mA zu schaffen. Der Vorwiederstand ergibt sich aus R3 =
9V−1.2V
20mA = 390Ω .
Ein Taster(SW1) kann die gesamte Schaltung mit Masse verbinden, was verhindert das IR-
Sender dauerhaft sendet.
Die Grüne Led(Led2) zeigt dem Benutzer an, ob der IR-Sender aktiv ist oder nicht. Der
Vorwiederstand(R5) ergibt sich durch die selbe Rechnung wie R3 und beträgt 390 Ω.
Protokoll IR_Fernbedienung
gesendete Frequenz
Frequenzband Empfänger
Werte
1200 Hz +/- 50Hz
1100Hz-1300Hz
10

11

Motorsteuerung
Zur Motorsteuerung wird das IC L293D verwendet. Dieses beinhaltet zwei H-Brücken. Sowie
Dioden um Induktionsströme abzufangen, welche beim Nachdrehen der Motoren entstehen.
An dem Blockschaltbild erkennt man, wie die Ansteuerung funktioniert. Die Laufrichtung der
Motoren wird gesteuert, indem einen Input auf HIGH und den anderen auf LOW setzt. Sind
beide HIGH oder LOW bewegt sich der Motor nicht.
Name Pin 1A 2A
Prozes
M_Schlitten_Vorne
s
HIGH LOW
Name Pin 3A 4A
Prozess
M_Tor_Zu
HIGH LOW
M_Schlitten_Hinten LOW
HIGH
M_Tor_Auf LOW HIGH
In
In der folgenden Tabelle sind die Eigenschaften der Einzelnen Pins beschrieben.
Pin
Name
No.
Typ Description Pin on Board Pegel
1,2EN 1 I
Enable driver channels 1 and 2 (active high
input)
VCC
5V
1A 2 I
PC7
High/Low
2A 7 I PB6 High/Low
Driver inputs, noninverting
3A 10 I PA9 High/Low
4A 15 I PA8 High/Low
1Y 3 O
M2
9V/GND
2Y 6 O
Driver outputs
5,4Ω,
Widerstandsplatine
9V/GND
12

3Y 11 O M1 9V/GND
4Y 14 O
3,2Ω;
Widerstandsplatine
9V/GND
3,4EN 9 O
Enable driver channels 3 and 4 (active high
input)
VCC
5V
GROUND
4, 5,
12, 13 _
Device ground and heat sink pin. Connect to
printed-circuit-board ground plane with
multiple solid vias
GND
GND
VCC1 16 5-V supply for internal logic Translation VCC 5V
VCC2 8 _ Power VCC fordrivers 4.5V to 36V Netzteil 9V
Das IC kann pro Motor maximal 600mA schalten. Da pro Motoren 500mA fließen, besteht
keine Gefahr für das IC.
Um die Drehzahl nach unten zu korrigieren wurden Vorwiderstände an beiden Motoren
verwendet. Es sind jeweils drei Widerstände in Reihe geschaltet, damit die Widerstände eine
höhere Leistung verkraften. Die Anliegenden Ströme und Spannungen sind deutlich unter
den maximal zulässigen Werten.
Vorwiderstand/ Ω UMotor,Ist/V IMotor,Ist/ mA UMotor,max/V IMotor,max/ A
Motor Tor 3,2 5,6 500 12 1,1
Motor Schlitten 5,4 4,2 500 12 1,1
Die Drehzahl der Motoren wird mittels Getriebe übersetzt, damit eine ausreichende Kraft
das Tor bzw. den Schlitten bewegt. Die Übersetzung für das Tor beträgt 1:75 für den
Schlitten beträgt sie 1:36. Die Übersetzung des Schlittens ist geringer, da er sich schneller als
das Tor bewegen muss und eine geringere Kraft für die Bewegung erforderlich ist.
13

Pinbelegung
Aktorik/ Sensorik Pin des Boards Typ des Pins
Empfaenger CN10D13PA_5 In/ Analog
LS_Betaetigt CN10D11PA_7 In/ Analog
GT_Unten CN10D6PB_10 In/ Digital, Pullup
GT_Oben CN10D5PB_4 In/ Digital, Pullup
GT_Vorne CN10D4PB_5 In/ Digital, Pullup
GT_Hinten CN10D3PB_3 In/ Digital, Pullup
Taster CN10D2PA_10 In/ Digital, Interrupt
M_Schlitten_Vorne CN10D10PB_6 Out/ Digital
M_Schlitten_Hinten CN10D9PC_7 Out/ Digital
M_Tor_Zu CN10D8PA_9 Out/ Digital
M_Tor_Auf CN10D7PA_8 Out/ Digital
LGr CN10D14PB_9 Out/ Digital
LGe CN10D15PB_8 Out/ Digital
LRo CN10D12PA_6 Out/ Digital
14

Schaltplan
Die Beschriftung ist im Schaltplan nicht lesbar. Leider konnten wir die Schrift nicht Scharf stellen und dabei den gesamten Plan anzeigen. Daher ist
der Plan nochmal als PDF-Datei hochgeladen. Darin kann durch ZOOM die Schrift zum Lesen vergrößert werden.

Verdrahtungsplan
16

Testplanung und Ergebnisse
Was wird getestet? Wie wird der Test durchgeführt? Was ist das Ergebnis?
Funktion der eingebauten LEDs Die LEDs einzeln auf HIGH und wieder auf LOW setzen Die LEDs leuchten und gehen wieder aus
Funktion der Grenztaster Signal einlesen -> Wenn Signal erkannt wird Test-LED Test-LED leuchtet
leuchten lassen
Funktion der Motoren
Die Motoren abwechselnd in zwei gewollte Richtungen
ansteuern, dabei wird mit Sichtkontrolle überwacht
Motor dreht sich abwechselnd in die gewollten
Richtungen
Funktion des Tasters
Bei einem eingelesenen Signal wird ein sofortiger
Die LED wechselt auf Knopfdruck den Zustand
Zustandswechsel einer Lampe ausgelöst
Funktion der Lichtschranke Falls der Analogwert über einen gewissen Wert steigt ist
etwas zwischen der Lichtschranke und eine LED geht an
Beim Durchkreuzen der Lichtschranke leuchtet die
LED
Funktion der Fernbedienung
und dem Empfänger
Beim Tastendruck auf der Fernbedienung wird die Frequenz
des IR Signals bestimmt und bei der richtigen Frequenz
leuchtet eine LED bei einer falschen Frequenz soll nicht
passieren (im Debugger werden die ausgewerteten Werte
Die LED leuchtet, wenn man den Knopf drückt nur
bei der Fernbedienung mit der richtigen Frequenz
Den regulären Betrieb des
Zustandsautomaten testen
Den regulären Betrieb bei
irregulären Eingängen testen
überwacht)
Die einzelnen Zustände durchgehen und mit den richtigen
Eingaben in die nächsten Zustände springen und damit alle
möglichen Wege und Zustände durchlaufen (Überwachung
der Ergebnisse mit Debugger)
Die einzelnen Zustände und Wege durchgehen und mit allen
möglichen Eingängen versuchen in andere Zustände zu
springen
Es tritt bei allen Wegen das gewünschte Verhalten
gemäß der Funktionsbeschreibung auf
Es tritt das gewünschte Verhalten nur bei den
richtigen Eingaben auf
17

Source-Code
/*---------------------------------------------------------------------------------------------------------------------------*/
Authoren
: Tim Block, Malte Katz, Maxime Junghänel, Nicolas Fritsche
Version : 3.2
Datum zuletzt Bearbeitet : 17.1.2018
/*---------------------------------------------------------------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;
TIM_HandleTypeDef htim3;
/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
uint32_t value[2], read_value[2], adc_buffer[2]; // ADC Variablen
int Taster=0; // Interrupt merker für den Taster
int LS_Betaetigt=0; // Lichtschranke bei 1 nicht Aktiv bei 0 Objekt in Lichtschranke
int IR_Korrekt=0; // Variable zum speichern, ob IR Signal mit Richtiger Frequenz vorhanden ist
int wert =0;
// Wert des analog eingelesen Signales an der Lichtschranke
typedef enum STATE {TorOeffnen, TorOffen, TorZu, TorSchliessen, SchlittenNachVorne,
SchlittenNachHinten,Init,NotAuf,NotZu} TSTATE;
TSTATE state= Init;
18

typedef enum AKTION
{Schlitten_Wegbringen,Schlitten_Ausschalten,Tor_Oeffnen,Tor_Schliessen,Tor_Zu_Einschalten,Tor_A
uf_Einschalten
,Tor_Ausschalten,Tor_Geoeffnet,Signal_Pruefen,Schlitten_Holen, Schranke_Pruefen} TAKTION;
TAKTION aktion=Schlitten_Wegbringen;
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM3_Init(void);
int IR_Empf();
/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/
void delayUS(uint32_t us) {
// Delay auf Mirco Sekundenen Ebene
volatile uint32_t counter = 7*us;
while(counter--);
}
void M_Schlitten_Hinten(){ // Motorschlitten nach hinten fahren
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_SET); // M_SchlittenH 1 setzen
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);
// M_SchlittenV 0 setzen
}
19

void M_Schlitten_Vorne(){ // Motorschlitten nach vorne fahren
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_RESET); // M_SchlittenH 0 setzen
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);
// M_SchlittenV 1 setzen
}
void M_Schlitten_Stopp(){ // Motorschlitten stoppen
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_RESET); // M_SchlittenH 0 setzen
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);
// M_SchlittenV 0 setzen
}
void M_Tor_Stopp(){ //Tormotor stoppen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET); // M_TorA 0 setzen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_RESET);
//M_TorZ 0 setzen
}
void M_Tor_Zu(){ //Tor schließen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET); // M_TorA 0 setzen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_SET);
// M_TorZ 1 setzen
}
void M_Tor_Auf(){ // Tor öffnen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET); // M_TorA 1 setzen
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_RESET);
// M_TorZ 0 setzen
}
void LGe_An(){ //Gelbe LED an
}
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8,GPIO_PIN_SET); //Pin B8 auf 1 setzen
void LGr_An(){ // Grüne LED an
20

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9,GPIO_PIN_SET); //Pin B9 auf 1 setzen
}
void LRo_An(){ //Rote LED an
}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6,GPIO_PIN_SET); //Pin A6 auf 1 setzen
void LGe_Aus(){ //Gelbe LED aus
}
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8,GPIO_PIN_RESET); //Pin B8 auf 0 setzen
void LGr_Aus(){ // Grüne LED aus
}
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9,GPIO_PIN_RESET); //Pin B9 auf 0 setzen
void LRo_Aus(){ //Rote LED aus
}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6,GPIO_PIN_RESET); //Pin A6 auf 0 setzen
void Warten(){
//3 Sekunden warten
HAL_Delay(3000);
}
int LS_Pruefen(){
wert = adc_buffer[1];
if(wert< 50){ // Wenn wert kleiner 50, dann Lichtschranke nicht durch brochen
LS_Betaetigt=1;
}
else{
21

LS_Betaetigt=0; // Lichtschranke durchbrochen
}
}
return LS_Betaetigt;
int IR_Empf(){ // Funktion zur Bestimmung einer Frequenz, von einem IR Signal
int sensorValue = 0;
int counter=0;
int periodenCounter=0;
float frequenz =0;
float periodenDauer =0;
int state =0;
int vState =0;
int flag =0;
int counter1=0;
int flagReady=0;
do{
sensorValue = adc_buffer[0];
if(sensorValue < 50){ // Wenn Analog wert kleiner 50 ist , dann gilt dies als logische 1
state =1;
}
if(sensorValue >= 900){
state =0; // Wenn Analog wert größer als 900 ist , dann gilt dies als logische 0
}
if( state != vState){ // Prüfen ob ein 1 -0 durchgang statt gefunden hat
addiern
periodenDauer = periodenDauer + counter; // Perideondauer mit aktueller Periodendauer
22

counter =0;
// aktuelle Periodendauer auf 0 setzten
periodenCounter++; // Anzahl der Periden erhöhen
}
if(counter >125){ //Wenn mehr als 125 mal kein 1 - 0 Übergang statt gefunden hat wird
counter 1 hoch gezählt
counter =0;
counter1++;
if(counter1>=15){ // Wenn counter 1 den wert 15 erreicht hat wird die Messung
erfolgslos abgebrochen
}
}
counter1=0;
return 0;
if(periodenCounter ==10){ // Wenn 10 Perioden gemessen worden sind
periodenCounter =0;
periodenDauer = periodenDauer/10; // Durchschnitss Periode bestimmen
frequenz = (1/(periodenDauer*0.00001)); // bestimmung der Frequenz, aus anzahl der
Messungen mal 10 Micro Sekunden delay
}
flag =1; // Merker das Frequenz bestimmt worden ist
if(flag ==1){ // Wenn frequenz Bestimmt worden ist
liegt
if(frequenz < 1300 && frequenz > 1100){ // Prüfen ob Frequenz im Frequenzband
counter =0; // Alles auf 0 setzen
counter1=0;
frequenz =0;
periodenCounter=0;
flag =0;
flagReady++; // Erfolgreiche Messung Signalisieren
}
else{ // Wenn Nein, Messung als nicht gültig abbrechen
return 0;
23

}
}
if(flagReady==2){ // Wenn 2 Gültige Messungen hintereinander statt gefunden haben,
Messung als gültiges Signal beenden
}
}while(1);
}
return 1;
vState = state; // Alten State abspeichern für prüfung auf 1-0 Übergang
counter++;
counter1++;
delayUS(10); // 10 Micro Sekunden warten
void Pat(int aktion){ // Auflistung aller Aktionen als State Machine und Prozesse die auszuführen sind
switch(aktion){
case Schlitten_Wegbringen:
LGe_An();
M_Schlitten_Hinten();
break;
case Schlitten_Ausschalten:
M_Schlitten_Stopp();
LGe_Aus();
break;
case Schlitten_Holen:
LGe_An();
M_Schlitten_Vorne();
break;
case Tor_Oeffnen:
M_Schlitten_Stopp();
LGe_Aus();
LRo_An();
M_Tor_Auf();
24

eak;
case Tor_Schliessen:
LGr_Aus();
LRo_An();
M_Tor_Zu();
break;
case Tor_Zu_Einschalten:
Warten();
LRo_An();
M_Tor_Zu();
break;
case Tor_Auf_Einschalten:
Warten();
LRo_An();
M_Tor_Auf();
break;
case Tor_Ausschalten:
M_Tor_Stopp();
LRo_Aus();
break;
case Tor_Geoeffnet:
M_Tor_Stopp();
LRo_Aus();
LGr_An();
break;
case Signal_Pruefen:
IR_Korrekt = IR_Empf();
break;
case Schranke_Pruefen:
LS_Betaetigt = LS_Pruefen();
break;
25

}
}
/* USER CODE END PFP */
/* USER CODE BEGIN 0 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc){ //Zyklische Messung des Analog Pins
und Prüfen ob Taster gedrückt ist
if(!HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_10)){ // Taster gedrückt
Taster=1;
}
if(hadc->Instance==ADC1){ // Einlesen der 2 Analog Pins, sequenziell
for(int i=0; i

* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_TIM3_Init();
/* USER CODE BEGIN 2 */
HAL_ADC_Start_DMA(&hadc1, adc_buffer, 2);
/* USER CODE END 2 */
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */
27

* start timers, add new ones, ... */
/* USER CODE END RTOS_TIMERS */
/* Create the thread(s) */
/* definition and creation of defaultTask */
// osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
// defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
/* USER CODE END RTOS_THREADS */
/* USER CODE BEGIN RTOS_QUEUES */
/* add queues, ... */
/* USER CODE END RTOS_QUEUES */
/* Start scheduler */
//osKernelStart();
/* We should never get here as control is now taken by the scheduler */
//Zustände für den Automaten
typedef enum STATE {TorOeffnen, TorOffen, TorZu, TorSchliessen, SchlittenNachVorne,
SchlittenNachHinten,Init,NotAuf,NotZu} TSTATE;
TSTATE state= Init;
typedef enum AKTION
{Schlitten_Wegbringen,Schlitten_Ausschalten,Tor_Oeffnen,Tor_Schliessen,Tor_Zu_Einschalten,Tor_A
uf_Einschalten
,Tor_Ausschalten,Tor_Geoeffnet,Signal_Pruefen,Schlitten_Holen} TAKTION;
TAKTION aktion=Schlitten_Wegbringen;
28

Variablen zum Speicher der Digitalen Inputs festlegen und einlesen
int GT_Oben = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4);
int GT_Unten = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_10);
int GT_Vorne = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_5);
int GT_Hinten = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3);
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
//IR Signal und Frequenz einlesen
IR_Korrekt =IR_Empf();
//Einlesen der Ports
GT_Oben = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4);
GT_Unten = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_10);
GT_Vorne = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_5);
GT_Hinten = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3);
//Invertieren der Ports da Pull-Up
if(GT_Oben ==0){
GT_Oben =1;
}else{
GT_Oben =0;
}
29

if(GT_Unten ==0){
GT_Unten =1;
}else{
GT_Unten =0;
}
if(GT_Vorne ==0){
GT_Vorne =1;
}else{
GT_Vorne =0;
}
if(GT_Hinten ==0){
GT_Hinten =1;
}else{
GT_Hinten =0;
}
switch(state){ // State Machine zur bestimmung des nächsten
Zustandes und der Aktion die Ausgeführt werden muss
case Init: // Initial Zustand, Schlitten nach hinten fahren
aktion = Schlitten_Wegbringen;
if(GT_Hinten){
aktion = Schlitten_Ausschalten;
state = TorZu;
}
break;
case TorZu: // Garagen Tor ist zu
30

Fernbedinungsignal warten
aktion = Signal_Pruefen; // Auf
if(!GT_Vorne && IR_Korrekt){
state=SchlittenNachVorne;
aktion = Schlitten_Holen;
}
else if(GT_Vorne){
state=SchlittenNachHinten;
aktion = Schlitten_Wegbringen;
}
break;
case TorSchliessen: // Garagen Tor schließen
if(GT_Unten){
state=TorZu;
aktion = Tor_Ausschalten;
}
else if(!LS_Betaetigt){
state = NotZu;
aktion = Tor_Ausschalten;
}
else{
aktion= Schranke_Pruefen
}
break;
case TorOffen: // Garagen Tor ist offen
if(Taster && LS_Betaetigt){
state=TorSchliessen;
aktion = Tor_Schliessen;
Taster=0;
31

}
else{
aktion= Schranke_Pruefen
}
break;
case TorOeffnen: // Garagen Tor öffnen
if(GT_Oben){
state=TorOffen;
aktion = Tor_Geoeffnet;
Taster=0;
}
else if(!LS_Betaetigt){
aktion = Tor_Ausschalten;
state=NotAuf;
}
else{
aktion= Schranke_Pruefen
}
break;
fahren
case SchlittenNachVorne: // Schlitten nach vorne
if(GT_Vorne && LS_Betaetigt){
state=TorOeffnen;
aktion = Tor_Oeffnen;
}
else{
aktion= Schranke_Pruefen
}
break;
32

Fahren
case SchlittenNachHinten: // Schlitten nach hinten
if(GT_Hinten && LS_Betaetigt){
state=TorZu;
aktion = Schlitten_Ausschalten;
}
break;
Lichtschranke durchbrochen
case NotAuf: // Beim öffnen des Tors wirde
if(LS_Betaetigt){
state= TorOeffnen;
aktion = Tor_Auf_Einschalten;
}
else{
aktion= Schranke_Pruefen
}
break;
Lichtschranke durchbrochen
case NotZu: // Beim schließen des Tors wirde
if(LS_Betaetigt){
state= Tor_Schliessen;
aktion = Tor_Zu_Einschalten;
}
else{
aktion= Schranke_Pruefen
}
break;
}//Endeswitch
Pat(aktion);
33

}
/* USER CODE END 3 */
}
/* USER CODE END 3 */
/** System Clock Configuration
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_ClkInitTypeDef RCC_ClkInitStruct;
/**Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = 16;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
34

RCC_OscInitStruct.PLL.PLLM = 16;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
RCC_OscInitStruct.PLL.PLLQ = 7;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
/**Configure the Systick interrupt time
*/
HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
/**Configure the Systick
*/
HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
35

* SysTick_IRQn interrupt configuration */
HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
}
/* ADC1 init function */
static void MX_ADC1_Init(void)
{
ADC_ChannelConfTypeDef sConfig;
/**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of
conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.ScanConvMode = ENABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 2;
hadc1.Init.DMAContinuousRequests = ENABLE;
hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
}
_Error_Handler(__FILE__, __LINE__);
/**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its
sample time.
36

*/
sConfig.Channel = ADC_CHANNEL_5;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
/**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its
sample time.
*/
sConfig.Channel = ADC_CHANNEL_7;
sConfig.Rank = 2;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
}
_Error_Handler(__FILE__, __LINE__);
}
/* TIM3 init function */
static void MX_TIM3_Init(void)
{
TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;
htim3.Instance = TIM3;
htim3.Init.Prescaler = 0;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 0;
37

htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
}
/**
* Enable DMA controller clock
*/
static void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_CLK_ENABLE();
/* DMA interrupt init */
/* DMA2_Stream0_IRQn interrupt configuration */
38

HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}
/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
PA5 ------> SharedAnalog_PA5
PA7 ------> SharedAnalog_PA7
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6|M_TorA_Pin|M_TorZ_Pin|Taster_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(M_SchlittenH_GPIO_Port, M_SchlittenH_Pin, GPIO_PIN_RESET);
39

*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, M_SchlittenV_Pin|LGe_Pin|LGr_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin : B1_Pin */
GPIO_InitStruct.Pin = B1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : PA4 LRo_Pin IR_Lichtschranke_Pin */
GPIO_InitStruct.Pin = GPIO_PIN_4|LRo_Pin|IR_Lichtschranke_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : PA6 M_TorA_Pin M_TorZ_Pin Taster_Pin */
GPIO_InitStruct.Pin = GPIO_PIN_6|M_TorA_Pin|M_TorZ_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
//Taster
GPIO_InitStruct.Pin = Taster_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : GT_Unten_Pin GT_Hinten_Pin GT_Oben_Pin GT_Vorne_Pin */
40

GPIO_InitStruct.Pin = GT_Unten_Pin|GT_Hinten_Pin|GT_Oben_Pin|GT_Vorne_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : M_SchlittenH_Pin */
GPIO_InitStruct.Pin = M_SchlittenH_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(M_SchlittenH_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : M_SchlittenV_Pin LGe_Pin LGr_Pin */
GPIO_InitStruct.Pin = M_SchlittenV_Pin|LGe_Pin|LGr_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
41

* @param None
* @retval None
*/
void _Error_Handler(char * file, int line)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
while(1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t* file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
42

#endif
/**
* @}
*/
/**
*/
* @}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
43