Kirchenglocke
Steuerung mit Arduino und zwei Näherungsschaltern
Mit einem Gleichstrommotor und dem Motortreiber L9110H soll eine Kirchenglocke zum Läuten gebracht werden. Zu Testzwecken kann eine beliebige
Glocke benutzt werden, hier führen wir den Test mit einer Glocke, die stolze 500 Gramm wiegt. Die Aufgabe der Schaltung besteht darin, die Glocke zum Schwingen
zu bringen, was durchaus mit Problemen verbunden werden kann. Je nach Größe und Gewicht der Glocke muss die Leistung des Motors entsprechend angepasst werden.
Auch die Kette, Zahnriemen oder Getriebe müssen der geforderten Leistung gerecht werden.
Bei unserer kleinen Glocke stellen sich solche Fragen nicht, ein kleiner Getriebemotor mit 6mm breitem Zahnriemen bewältigt die Aufgabe problemlos.
Nach jedem Satz der Glocke nach Links oder Rechts muss die Drehrichtung des Motors geändert werden. Diese Aufgabe überlassen wir dem Motortreiber L9110H.
Der Chip mit acht Beinen ist klein, benötigt nur wenig Verdrahtung und ist für solche Aufgaben wie das Ansteuern eines Kleinleistungsmotors besonders
prädestiniert.
Mit zwei Näherungsschaltern werden die Positionen Rechts und Links der Glocke abgefragt. Sie bestimmen den Moment der Drehrichtungsumkehr.
Mit einem kurzen Ablaufprogramm koordiniert das Schwingen der Glocke der Mikrocontroller Arduino Nano. Gestartet wird mit
einem Ein/Aus - Taster.
Arduino Nano
Bei Einsetzung eines Mikrocontrollers muss stets seine Arbeitsspannung beachtet werden. Die Arduino-Ein- und Ausgänge arbeiten mit 5VDC. Deswegen ist
es notwendig, die Signale der Näherungssensoren, die in diesem Fall 12VDC betragen, an den Mikrocontroller anzupassen. Diese Aufgabe übernehmen in der
Schaltung zwei lineare Spannungsregler aus der L78-Reihe.
Die eigentliche Arbeit übernimmt der Gleichstrommotor JGB7-520-CE. Er arbeitet nominal mit 12 VDC und ist vom Werk mit einem Getriebe ausgestattet.
In diesem Fall, um die Schwingfrequenz der Glocke passend einzustellen, wird seine Spannung mit einem Spannungsregler eingestellt. In der Testschaltung wird er
mit ca. 9VDC eingespeist.
Der Baustein arbeitet mit einer Spannung im Bereich 2,5V bis 12V und kann mit 800 mA belastet werden. Mit jeweils einem Eingang wird die Links-
oder Rechtsdrehung des Motors bestimmt. Das war‘s dann schon.
In der Schaltung kommen zwei Spannungsregler L78L05AC vor. Sie regeln die Signalspannung der Näherungssensoren auf 5 VDC runter. Die
Näherungssensoren arbeiten in der Schaltung mit 12 VDC. Eine höhere Spannung als 5 VDC an den Eingängen des Arduino könnte den Mikrocontroller beschädigen.
Das Modul mit dem Spannungsregler LM2596 stellt die Spannung für den Motor bereit. Mit ihr kann die gewünschte Schwingungsfrequenz der Glocke
eingestellt werden. Diese ist auch von der Getriebe des Motors und Zahnradübersetzung abhängig. Die in der Testschaltung eingestellte Motorspannung beträgt
ca. 9 VDC.
Zwei induktive Näherungsschalter von Turck überwachen die aktuelle Position unserer Mini-Kirchenglocke. Beide Sensoren markieren die Punkte, wo die
Drehrichtungsumkehr des Motors stattfindet. Sie arbeiten mit 12 VDC. Die Signale, die zu Arduino geführt werden, werden zunächst mit zwei 5V-Spannungsregler
auf Arduino taugliche Spannung runtergeregelt.
// *****************************************************************************************
// Kirchenglocke (Steuerung mit Arduino)
// Eine Schaltung mit Arduino Nano
// Arduino IDE 1.8.19
// *****************************************************************************************
int Ini_Links = 2; // Abfrage Glocke Position links
int Ini_Rechts = 3; // Abfrage Glocke Position rechts
int Taster_Start = 4; // Start - Taster
int Rechtslauf = 5; // Ausgang Rechtsdrehung
int Linkslauf = 6; // Ausgang Linksdrehung
int Schritt = 0; // Aktueller Abfolgeschritt
bool Start_Stop; // Hilfsvariable
// *****************************************************************************************
void setup() {
pinMode (Ini_Links, INPUT); // Pin D2 Eingang
pinMode (Ini_Rechts, INPUT); // Pin D3 Eingang
pinMode (Taster_Start, INPUT_PULLUP); // Pin 4 Eingang (Pullup)
pinMode (Rechtslauf, OUTPUT); // Pin 5 Ausgang
pinMode (Linkslauf, OUTPUT); // Pin 6 Ausgang
}
// *****************************************************************************************
void loop() {
if (digitalRead (Taster_Start) == LOW) { // Ablauf Start wenn Taster betätigt
Start_Stop = true; // Hilfsvariable (es läuft) auf TRUE
}
if (Start_Stop == true) { // Ablauf start
if (Schritt == 0) { // Begin mit Linksdrehung
digitalWrite (Linkslauf, HIGH); // L9110H - Linksdrehung EIN
digitalWrite (Rechtslauf, LOW); // L9110H - Rechtsdrehung AUS
Schritt = 1;
}
if ((Schritt == 1) & (digitalRead (Ini_Rechts) == LOW)) { // Geber Pos. Rechts verlassen
Schritt = 2; // Linksdrehung aktiv
}
if ((Schritt == 2) & (digitalRead (Ini_Links) == LOW)) { // Geber Pos. Links verlassen
Schritt = 3; // Gleich kommt Drehrichtungsumkehr
}
if (Schritt == 3) { // Drehrichtungsumkehr
digitalWrite (Linkslauf, LOW); // L9110H - Linksdrehung AUS
digitalWrite (Rechtslauf, HIGH); // L9110H - Rechtsdrehung EIN
Schritt = 4; // Rechtsdrehung aktiv
}
if ((Schritt == 4) & (digitalRead (Ini_Links) == HIGH)) { // Geber Pos. Links angefahren
Schritt = 5; // Rechtsdrehung aktiv
}
if ((Schritt == 5) & (digitalRead (Ini_Rechts) == HIGH)) {// Geber Pos. Rechts angefahren
Schritt = 6; // Rechtsdrehung aktiv
}
if ((Schritt == 6) & (digitalRead (Ini_Links) == LOW)) { // Geber Pos. Links verlassen
Schritt = 7; // Rechtsdrehung aktiv
}
if ((Schritt == 7) & (digitalRead (Ini_Rechts) == LOW)) { // Geber Pos. Rechts verlassen
Schritt = 8; // Gleich kommt Drehrichtungsumkehr
}
if (Schritt == 8) { // Drehrichtungsumkehr
digitalWrite (Linkslauf, HIGH); // L9110H - Linksdrehung EIN
digitalWrite (Rechtslauf, LOW); // L9110H - Rechtsdrehung AUS
Schritt = 9; // Linksdrehung aktiv
}
// Stop Sequenz
if ((Schritt == 9) & (digitalRead (Taster_Start) == HIGH)) { // Taster losgelassen
delay(170); // Wartezeit bis UT
digitalWrite (Linkslauf, LOW); // L9110H - Linksdrehung AUS
digitalWrite (Rechtslauf, LOW); // L9110H - Rechtsdrehung AUS
Start_Stop = false; // Hilfsvariable (es läuft) auf FALSE
Schritt = 0; // Schrittzähler zurücksetzen
}
if ((Schritt == 9) & (digitalRead (Ini_Rechts) == HIGH)) {// Geber Pos. Rechts angefahren
Schritt = 10; // Linksdrehung aktiv
}
if ((Schritt == 10) & (digitalRead (Ini_Links) == HIGH)) {// Geber Pos. Links angefahren
Schritt = 1; // Linksdrehung aktiv
// Mit Schritt 1 Wiederholung
}
}
}
// *****************************************************************************************
Der Programmablauf ist nicht kompliziert. Es wird laufend die Position der Glocke überprüft. Nach jeder vollständigen Schwingung der Glocke erfolgt,
sofern der Taster gedrückt gehalten wird, eine Wiederholung des Vorgangs. Die notwendigen Informationen liefern die beiden Näherungsschalter. Sobald die an der
Achse angebrachte Nocke beide Schalter verlassen hat, erfolgt eine Drehrichtungsumkehr.
Je nach Aufbau einer Testeinrichtung kann es, so wie auch in diesem Fall, notwendig sein, mit zusätzlichen Maßnahmen dafür zu sorgen, dass die Glocke nach
dem Stopp im unteren Bereich stehen bleibt. In dem Programm wird das Problem mit einer Zeitfunktion gelöst. Nach Drehrichtungsumkehr, wenn der Start Taster
bereits losgelassen wurde, dreht der Motor, bevor er stehen bleibt, noch eine in der Anweisung „delay“ eingegeben Zeit weiter.
