Willkommen 

RE: Arduino: Licht und Action

#1 von Running.Wolf , 12.05.2020 20:43

Moin
Seit Jahren nutze ich Arduinos, seit Weihnachten einen 3D Drucker.
In Gebäude, Schuppen, Bahnhöfe setze ich Nanos oder Micro Pro.
Letztere haben keinen USB Port, aber sonst alle Möglichkeiten eines größeren UNO.
Ich habe mir einen Standard gebastelt.
- Versorgung über 12 V DC
- 8-fach Darlington Array an Digital Ausgänge 2 bis 9 (kurze Wege)
- Arduino und Darlington auf Fassungen.
- Licht mit 12 V DC verdrahteten LED mit Viessmann Boxen bzw. selbst gedruckten Lichtkästen
- Licht an „abgeschrittene“ LED Strips 12 V
- 1 K Widerstände an Digitalausgänge 10 bis 13 ( Einzel LED gegen Masse schalten)
- alles auf kleiner Platine
- selbst gedruckter kleiner Rahmen, passt in Bodenplatte von Faller Häusern

Alles mit 12 V DC per Steckverbindung angeschlossen. Dadurch Test am PC und leichter Wechsel au% Anlage.









Damit habe ich z.B Lokschuppen ausgestattet (Tore mit Servo, Licht, blaue LED für Schweissflackern , ...)


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#2 von Hardi , 20.05.2020 08:22

Hallo Wolfgang,

hast Du meine kleine Bastellei mit LEDs schon mal gesehen?
viewtopic.php?f=7&t=165060&sd=a&start=0
Damit kann man mit einem Arduino alle Häuser auf der Anlage steuern und noch viel,viel mehr...

Hardi


Haltet Euch unbedingt von diesen Seiten fern:
viewtopic.php?f=7&t=165060
https://wiki.mobaledlib.de/
sonst wird Eure Anlage niemals fertig…

Unsere Anlage findet Ihr hier:
RE: Unsere Kinder und Vater Anlage(n)


 
Hardi
EuroCity (EC)
Beiträge: 1.456
Registriert am: 28.12.2015
Homepage: Link
Ort: Mainz
Gleise C
Spurweite H0
Steuerung MS2 + Eigenbau
Stromart Digital


RE: Arduino: Licht und Action

#3 von Running.Wolf , 23.05.2020 21:25

Moin Hardi
Ja, das verfolge ich schon eine Weile. LEDs alleine habe ich zwar auch in einigen Häusern . Ich will aber auch Relais Servos Motoren 12 V LED Strips steuern, aber zu der jeweiligen Einheit nur eine zweiadrige Zuleitung (12 V DC) legen.
Daher Insellösungen, die am PC vorbereitet und dann mit Steckerverbindern auf der Anlage angeschlossen werden.
Ich bleibe aber an Deinem Wiki dran.

Beispiel meiner Action siehe Digitale Modellbahn 4/2018, mein Artikel:

Action mit Arduino und Easysound


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#4 von Running.Wolf , 30.06.2020 23:11

Moin
Es geht weiter

Aufgabe

    Getriebemotor in Fallerkran
    Führerhausbeleuchtung
    Blinklicht bei Drehbewegung
    Krankabinenbeleuchtung
    Alles auf Knopfdruck und Zufallsgesteuert

Dazu
    alter Märklinkran auf Knopfdruck heben und drehen
    sowie Drehbewegung zufallsgesteuert


Wie?

    Arduino Mini Pro
    H-Bridge für zwei Motoren
    Drei 12 V Relais
    Drei LED
    Versorgungsspannung 12 V DC
    Runtergebrochen mit 7808 auf 8 V für H Bridge
    Aus der H-Bridge 5 V für Arduino



    18 V AC für Märklin Kran über die Relais angesteuert
    Taster an A0 bis A3 für Aktionen.






    Programmierung des Arduino über PC und USB / TTL Adapter


Durch dieses Mischmasch an Aufgaben und Spannungen habe meine diskrete aber irgendwie standardisierte Lösung gewählt.

Zwei Digitalausgänge sind noch frei.

Bild vom Kran kommt wenn ich im Keller war.
Die Halterung des Getriebemotors habe ich mit dem 3D Drucker gemacht.
Der Motor kommt von C z.B. Bestell-Nr.: 1762749 - VQ


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#5 von Running.Wolf , 03.07.2020 12:48

Moin

hier der Schaltplan hinter dem Gewusel:



An den vier Analogeingängen können über einen rückstellenden Schalter neben dem Ruhezustand zwei weitere Zustände über die Eingangsspannung abgefragt werden.
Digitaleingänge:
0 und 1 steuern über Widerstände LEDs an
2 - 4 steuern über Transistoren die Reläis an
5 - 7 sind für Motor 1
8 - 10 sind für Motor 2
11 - 13 steuern über Widerstände LEDs an

Versorgung:
12 V DC
- für die Relais
- über einen 7808 für die H-Bridge
5 V DC
- von der H-Bridge auf den Arduino

Schalter Märklin Kran
- manuell einschaltbar für Drehen, Heben und Magnet/LIcht
- via Arduino für zufälliges Drehen


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#6 von Domapi , 03.07.2020 13:38

Hallo Wolfgang,

für evtl. Nachahmer ist neben der Schaltung natürlich der Arduino-Code interessant.
Sonst wird dieser Thread nicht besonders viele Besucher anziehen.

Ich persönlich setze auf die MobaLedLib und auf diverse Arduino- und Microcontroller-Eigenentwicklungen.


Viele Grüße
Martin

Mein noch namenloser Trennungsbahnhof: viewtopic.php?f=64&t=152275


 
Domapi
EuroCity (EC)
Beiträge: 1.162
Registriert am: 22.09.2015
Ort: Nämberch
Gleise Ohne Pickel
Spurweite H0
Steuerung Mit Hirn und Verstand
Stromart DC, Digital


RE: Arduino: Licht und Action

#7 von Running.Wolf , 24.07.2020 10:46

Moin
nachdem meine "höhere Gewalt" Renovierungsarbeiten angeordnet hat, komme ich erst jetzt dazu, hier weiter zu machen.

Da in der Schaltung einige Schaltprinzipien verwendet wurden, möchte ich sie jetzt Stück für Stück im Detail aufgreifen und erläutern.
Ich beginne mit der Spannungsversorgung.
Es werden folgende Spannungen benötigt:

12 V DC: für die Relais
8 V DC: für die H-Brücke zur Ansteuerung der kleinen Getriebe Motoren
5 V DC: für den Arduino
18 V AC: für anzusteuernde Modellbahnelemente, hier der "alte" Märklin Kran.

Die 12 V DC werden bei mir für jedes Anlagensegment durch Schaltnetzteile bereitgestellt, darauf gehe ich jetzt nicht weiter ein.

Beginnen wir mit den 8 V DC, das Detail ist dem obigen kompletten Schaltplan entnommen.



Die 12 V DC von dem Schaltnetzteil werden über eine Klemme eingespeist und über einen 7808 Spannungsregler auf 8 V DC gesenkt. Die beiden Elkos dienen zu Glättung, der 100 nF zur Siebung eventueller höherer Frequenzen.

Die 8 V DC werden dann der H Brücke zugeleitet. Dort geht es im nächsten Punkt weiter.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#8 von Running.Wolf , 24.07.2020 10:59

Moin
nun geht es mit der H-Brücke weiter.
Die von mir verwendete H-Bridge hat zwei nette Features
- Ansteuerung von zwei DC Motoren
- Spannungsstabilisator 5 V DC

Ich habe über Amazon diese Brücken bezogen:
Youmile 5er-Pack Dual H Bridge DC Stepper Motor Drive Controller Board Modul L298N für Arduino



Links und rechts sind zwei Klemmen, hier kommen die 6-9 V Getriebemotoren dran.
Unten sind drei Klemmen
1: 18 V DC plus Eingang
2: 8V DC GND und 5 V DC GND
3: 5 V DC plus Ausgang

Im Schaltplan oben sieht das dann so aus:



Neben den Spannungsklemmen sieht man 3 x 2 Stifte, an die der Arduino angeschlossen wird.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#9 von Running.Wolf , 24.07.2020 11:12

Moin

es geht weiter mit dem Anschluss an den Arduino.

Als Arduino läuft bei mir ein Arduino Mini Pro

Die habe ich bei AZ Delivery bezogen:

AZDelivery 3 x PRO MINI mit 5V ATmega328 und 16MHz



Es handelt sich um komplette Arduinos (wie ein UNO), aaaber sie sind kleiner und haben keinen direkten USB Anschluss. Wie sie trotzdem programmiert werden können, zeige ich dann noch.

Hier ist das Schaltungsdetail



Motor 1 geht an pins 10, 9 und 8
Motor 2 geht an pins 7, 6 und 5

Das Wichtige ist, dass von den 6 Stiften der H-Brücke der linke (Motor 1) und der rechte pin (Motor 2) an einen PWM Eingang kommen, damit die Geschwindigkeit des Arduino geregelt werden kann. Pin 10 und 5 sind solche PWM taugliche Ausgänge.

Weiterhin liegen alle schön nebeneinander, ich habe auf ein Stückchen Platine zwei Buchsenleisten (6 Kontakte) gelötet und auf Arduino und H-Bridge als Verbinder gesteckt. Das kann man ganz gut auf dem Gesamtbild weiter oben sehen.

Weiterhin geht eine Verbindung von dem 5 V Plus und 5 V Ground der H-Bridge auf die 5 V und GND Pin des Arduino.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#10 von Running.Wolf , 24.07.2020 11:26

Moin
weiter geht es mit den Ausgangsschaltungen zusätzlich zu der H-Bridge.

Hier nutze ich zwei:

1) Digitalausgang zur Ansteuerung einer LED
2) Digitalausgang zur Ansteuerung von 12 V Relais



Ich habe drei LEDs an Pins 11, 12 und 13 gehängt.
Sie werden gegen GND geschaltet, leuchten also, wenn die Ausgänge auf HIGH gelegt werden.



Die Relais können nicht direkt an den Arduino gelegt werden, daher ist ein klassischer NPN Transistor dazwischen. Der Emitter liegt jeweils an GND.
Die Relais ziehen an, wenn der Ausgang des Arduino auf HIGH gelegt wird. Der Transistor schaltet durch und verbindet die Relais mit 12 V DC plus. Als Relais habe ich 1 mal UM gewählt, wer mehr Kontakte benötigt, hat hier die Wahl.
Über der Relaisspule liegt eine Freilaufdiode.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#11 von Running.Wolf , 24.07.2020 11:39

Moin

weiter geht es mit den Analogen Eingängen.
Diese Eingänge benutze ich, um Taster abzufragen.
Die einfachste Methode ist es, einen Taster an einen Eingang zu legen. Das geht sowohl bei den analogen als auch bei den digitalen Pins.
Ich wollte aber in meinem Fall 8 "Taster" an 4 Pins legen.
Dazu nutze ich aus, dass die analogen Pins es ermöglichen eine Eingangsspannung abzufragen.



Die analogen Pins A0 bis A3 werden über den internen Pullup Widerstand "hochgezogen".
In dem Bild habe ich 4 Schalter mit selbststellender Mittelstellung eingezeichnet.
Bei Betätigung gehen die A0 bis A3 entweder über 470 Ohm oder über 4,7 KOhm gegen 5 V DC plus.
Gegen Masse liegt jeweils ein Widerstand von 10 kOhm.

Über die jeweiligen Spannungsteiler ergeben sich unterschiedliche Eingangsspannungen, die per Software abgefragt werden können
Nicht gedrückt: ca 2,5 V
470 Ohm gedrückt: über 3,5 V
4,7 K Ohm gedrückt: unter 2,5 V

Die genauen Werte zeige ich bei Erläuterung der Programmschritte. Der Vorteil dieser Schalter ist, dass technisch immer nur ein Widerstand geschaltet wird. Man kann natürlich auch zwei unabhängige Taster nehmen (wie ich noch zeige), dann können jedoch beide Taster gleichzeitig gedrückt werden und liefern eventuell unbestimmte Ergebnisse.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#12 von fbstr , 24.07.2020 12:32

Vielen Dank für die lehrreiche und detaillierte Dokumentation!


Gruss
Frank
---------------------------------------------------------------------------------------------------------------------
MobaLedLib Wiki
Projekt "Bahnpark Augsburg"
Stummitreff BB: normalerweise jeden 3. Freitag im Monat im Haus Sommerhof in Sindelfingen


 
fbstr
CityNightLine (CNL)
Beiträge: 1.510
Registriert am: 28.08.2016
Ort: Stuttgart
Gleise Peco Code 75, Trix C
Spurweite H0, H0e
Steuerung DR5000, Lenz LZV100, MLL
Stromart DC, Digital


RE: Arduino: Licht und Action

#13 von Running.Wolf , 24.07.2020 12:40

Moin

nach diesen technischen Details hier noch einmal das Thema:



Links ist der "Faller Kran", es war ein Bausatz ohne Antrieb. Rechts ist der alte "Märklin Kran", der über Taster und Schalter klassisch betätigt wird, das alte Schaltpult war verschwunden, ich musste einen Ersatz bauen. In der Mitter ist ein Wasserkran, da soll der zweite Motor rein.



Hier der Faller Kran auf der Werkbank.
Ich habe folgende Erweiterungen gemacht
- Kranführer in Kanzel gesetzt
- weißes Licht in Führerkanzel
- rotes Licht (als Blinklicht) an Vorderseite
- weißes Licht in den Hauptraum des Krans
- Adapter in Kranhaus (gedruckt und durch das Loch nach unten geführt)
- Getriebemotor von unten angeschraubt (Achse steckt in Adapter)
- Gehäuse um den Motor herum gedruckt
- Zuleitungen (insgesamt 6) durch schwarze Schrumpfschläuche nach unten geführt


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#14 von Running.Wolf , 24.07.2020 12:56

Moin

es geht weiter mit dem Programmieren.

Ich nutze die Arduino IDE auf einem PC. Die Hauptarbeit passiert am Desktop, das Feintuning mit dem Laptop im Keller. Daher sind alle Arduinodaten auf einem USB Stick.

Da der Mini Pro keinen USB Anschluss hat, muss ein Adapter her. Ich nutze den FTDI Adapter FT232RL von AZ Delivery.



Bei den ersten Mini Pro habe ich den Fehler gemacht, alle mitgelieferten Pinleisten anzulöten. Für den Anschluss des FTDI Adapter prallen dann Stifte auf Stifte, also musste ich zunächst Kabel (Buchsen auf Buchsen) kaufen und dazwischen stecken.
Nun habe ich mir für die alten (Stifte auf Stifte) einen ähnlichen Adapter gelötet wie für die H-Bridge.



Man erkennt hier auch die vier- bzw drei- bzw zwei-poligen Steckverbindungen. Damit kann ich die angeschlossenen Elemente abstöpseln und die Schaltung (auf eine Platte geschraubt) von der Anlage nehmen.

Bei meiner Mini Pro Lieferung hatte ich eine kleine Herausforderungen zu lösen.
Obwohl es sich um 5 V Typen handelte, musste ich bei einigen den Jumper auf dem FTDI Adapter von 5 V auf 3,3 V umsetzen.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#15 von Running.Wolf , 24.07.2020 14:13

Moin

auf in Programmdetails. In diesem Projekt ist bewusst nicht die MOBATOOLS.LIB, um verschiedene Techniken anwenden (und zeigen zu können)

Ich fang mal mit den beiden Schaltern / Tastern am Analogport an.

Den kompletten Programmcode bringe ich dann noch in der korrekten Form, hier extrahiere ich erst einmal die relevanten Teile.


Zunächst die Definitionen:

// Analogeingänge
// An jedem Analogeingang sind zwei Taster
// Pull-up Widerstand eingeschaltet
// 10 K Widerstand gegen GND
// Taster a über 470 Ohm gegen Vcc
// Taster b über 4,7 K gegen Vcc
//
const int Taste_1 = A0; // Steuertaste 1 auf Analog 0 liefert integer 14
const int Taste_2 = A1; // Steuertaste 2 15
const int Taste_3 = A2; // Steuertaste 3 16
const int Taste_4 = A3; // Steuertaste 4 17
int Taste_Wert [4] = { 0, 0, 0, 0 }; // Variable für Tastenabfrage, als 0 vorbelegt
int entprellzeit = 100 ; // Tastenprellen abwarten in msec
const int ohne_Drueck = 500 ; // Analogwert unter 500: nichts gedrückt
const int klein_Drueck = 850 ; // Analogwert über 850: 470 Ohm gedrückt
const int gross_Drueck_u = 600 ; // Analogwert zw. 600 und 800: 4,7 K gedrückt
const int gross_Drueck_o = 800 ;
//

Ich habe alle Zeilen kommentiert.
Die letzten 4 Zeilen zeigen die Rückgabewerte, je nachdem welche Taste gedrückt wurde (keine, gegen 470 oder 4,7K)
Zum Tastenentprellen habe ich 100 ms vorgesehen, was in meinem Fall gut funktioniert.
4 Eingänge liefern 4 ückgabewerte, die ich in einem Feld Taste_Wert speichere.

Die Tastenabfrage erfolgt in einer Funktion

//
// ----------------------------Tastenabfrage -----------------------------
//
int Druck_Taste(int dieseTaste){ // Fragt Tasten ab
int Druck_Wert = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
delay (entprellzeit); // warte wegen Prellen
Druck_Wert = analogRead(dieseTaste); // frag Taste noch einmal
Taste_Wert [dieseTaste] = Druck_Wert ; // lese Wert in Array
if (Druck_Wert < ohne_Drueck) {return 0; } // keine Taste gedrückt
else if (Druck_Wert > ohne_Drueck) {return 1; } // Taste gedrückt
}
//

dabei kann dieseTaste 0, 1, 2, oder 3 sein (entsprechend A0 bis A3).
Die Funktion liefert 0 zurück solange keine Taste gedrückt ist.
Wenn doch (egal welche an jeweils einem AnalogPort, dann Rückgabewert 1).

In der Programmschleife wird die Funktion dann wie folgt genutzt. Da ein Motor sowohl automatisch per Programm als auch per Tastendruck gestartet werden kann, reicht eine einfache WHILE nicht aus.

//
// Motor 1 checken, wird über Drucktaste an A0 gestartet
//
if (Druck_Taste(Taste_1-14)==1) // nur wenn die Taste überhaupt
{ // gedrückt wurde
while (Druck_Taste(Taste_1-14)==1) // Schleife solange Taste gedrückt
{
Motor (Mot1, an , Taste_Wert[Taste_1-14] > klein_Drueck) ; // Motor 1 anschalten
} // Richtung je nach Taste an A0
Motor (Mot1, aus , HIGH) ; // Nach Loslassen der Taste
} // Motor 1 ausschalten
//

Die Taste A0 liefert als Integerwert 14, also muss "Taste_1" (= A0, = 14) um 14 reduziert werden und liefert "0", z.B. für den Platz im Array.
Die übergeordnete IF Abfrage stellt fest, ob überhaupt eine Taste gedrückt wurde.
Ist dies der Fall, dann läuft WHILE so lange, wie die Taste gedrückt wurde. Nach Ende der WHILE Bedingung wird der Motor definiert angehalten.
Die Motorsteuerung findet in der Prozedur Motor statt.
erster Parameter = Motornummer (1 oder 2)
zweiter Parameter = an oder aus (boolesche variable
dritter Parameter = Drehrichtung, sie hängt von der Taste am Analogport ab (470 Ohm = rechtsrum, 4,7K = linksrum)

Nun kommt noch die Motorprozedur:

//
// --------------------------- Motor ansteuern -------------------------------
//
int Motor(int wen, boolean start, boolean wie){ // drei Parameter
// Motornummer
// wenn start HIGH lauf los
// wenn start LOW bleib stehen
// wenn wie HIGH rechts herum
// wenn wie LOW links herum
if (!start) { // soll stehen bleiben
digitalWrite(bridgePins[wen-1][0], LOW) ; // setzte H-Bridge auf Stop
digitalWrite(bridgePins[wen-1][1], LOW) ;
return wen; // gib Motornummer zurück
}
else if (start) { // soll loslaufen
digitalWrite(bridgePins[wen-1][0], wie) ; // setzte H-Bridge auf Los
digitalWrite(bridgePins[wen-1][1], !wie) ;
return wen;
}
else {return 0;}
}
//

Mit der Kommentierung sollte es klar sein. Die bridgePins sind die 6 Pins des Arduino, die mit der H-Bridge verbunden wurden, siehe oben.
Wenn die H-Bridge mit zweimal LOW oder HIGH angesprochen wird, bleibt der Motor stehen. Wenn sie nicht gleich sind, dann dreht der Motor rechts oder links.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#16 von Running.Wolf , 24.07.2020 14:24

Moin

es geht weiter im Programm.

Ausser bei dem Entprellen gibt es kein DELAY().

Das zeigt sich z.B. an der Motoransteuerung / Beleuchtungssteuerung etc per Programm.

Erst einmal für den Motor 1 (Drehmotor Fallerkran)

Zunächst die Definitionen:

//
// Motorpins generell
//
int bridgePins [2][2] = {{9, 8 }, {7, 6}} ; // Array für zwei Motor Pins,
// Motor 1: 9,8 / Motor 2: 7,6
boolean an = HIGH; // definiere für Motor Zustand an
boolean aus = LOW; // definiere für Motor Zustand aus
boolean links = LOW ; // definiere für Motor Linkslauf
boolean rechts = HIGH ; // definiere für MotorvRechtslauf
//
// Motor 1
//
const int PWM_1 = 10; // PWM für Motor 1
const int Mot1 = 1; // Motor 1
unsigned long previousMillis_Mot1 = 0; // Zeitmerker Motor 1
unsigned long wann_Mot1[2] = { 60000,8000} ; // Startabstand 60000, Laufzeit Motor 1 8000
boolean next_Mot1 = rechts ; // nächste Drehrichtung vorbelegen
int status_Mot1 = 0 ; // 0 = soll laufen, 1 = soll stoppen
//

Durch Versuche wurde der Parameter für die Geschwindigkeit ermittelt. Der Wert wird in der Loop gesetzt:
Ausserdem wird die abgelaufene Zeit abgefragt = currentMillis

//
void loop() {
//
unsigned long currentMillis = millis(); // abgelaufene Zeit abfragen
//
analogWrite(PWM_1, 40); // Motor 1 speed setzen
analogWrite(PWM_2, 80); // Motor 2 speed setzen
//


In der Loop wird u.a. die Zeit abgefragt, wann der Motor 1 an der Reihe ist. In dem Feld wann_Mot1 stehen die Werte für die Startzeit und die Laufzeit des Motors

//
// Motor 1: Drehmotor Fallerkran
//
if ((currentMillis - previousMillis_Mot1 >= wann_Mot1[status_Mot1]) && status_Mot1 == 0)
{ // soll loslaufen
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt für Motor 1
Motor (Mot1, an , next_Mot1) ; // Motor an
next_Mot1 = !next_Mot1 ; // Motor Richtung umkehren
status_Mot1 = 1-status_Mot1 ; // ändern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mot1 >= wann_Mot1[status_Mot1]) && status_Mot1 == 1)
{ // soll stehen bleiben
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt für Motor 2
status_Mot1 = 1-status_Mot1; // ändern auf loslaufen
Motor (Mot1, aus, HIGH) ; // Motor aus
previousMillis_Kabine = currentMillis; // merken für Kabinenlicht
previousMillis_deckPin1 = currentMillis; // merken für Deckenlicht
}
//

Eine ähnliche Abfrage gibt es für das Deckenlicht und das Blinklicht.
Das Kabinenlicht soll erst angehen, danach mit einiger Verzögerung das Blinklicht und der Drehmotor. Es soll blinken, solange der Motor sich bewegt und der Kran sich dreht.
Wenn er stehenbleibt, soll das Kabinenlicht noch kurz an bleiben und dann erlöschen.


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#17 von Running.Wolf , 24.07.2020 14:37

Moin

nun folgt der komplette Programmcode im derzeitigen Status.
Er enthält noch nicht
- automatische Ansteuerung des Märklin Kranes (Drehmotor) - Relais 1 und Relais 2
- letztendliche Drehbewegung des zweiten Motors für den Wasserkran
- weitere LED über D0 und D1
- Ansteuerung des Relais 3

Wenn das fertig ist aktualisiere ich den Code.

Hinweis: Die Schreibweise der Parameter etc mag nicht jedem gefallen. "Heute macht man das eventuell anders" .
Ich bitte daher zu akzeptieren, dass ich mein erstes Programm in ALGOL 60 im Jahre des Herrn 1968 geschrieben habe und mir seitdem in FORTRAN, BASIC, TURBOPASCAL, dBASE II+, CLIPPER und C++ meinen eigenen Stil angewöhnt habe, den ich nicht zu ändern gedenke.

Ansonsten sind Kommentare und Anregungen sehr willkommen. Spezielle und individuelle Fragen gern auch per PN.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
//
// Ansteuerung Faller Kran
/*
* Automatischeer Betrieb zur Drehbewegung bis 270 Grad rechts und links.
* LED in Kanzel und F&#252;hrerhaus
* Je zwei Taster auf A0 bis A3
* A0 f&#252;r direkte manuelle Drehung rechts links
* A1 f&#252;r zweiten Motor
* A2 f&#252;r Relais 1
* A3 zur freien Verf&#252;gung
*/
 
// Wolfgang aka Running_Wolf
// 2020-07-24
//
// LED
const int Kabine = 13; // F&#252;hrer Kabine
const int verzKabine = 3000; // Einchaltverzug vor Drehstart
unsigned long previousMillis_Kabine = 0; // Zeitmerker Kabinenlicht
const int rotPin1 = 12; // rotes Blinklicht
unsigned long previousMillis_rotPin1 = 0; // Zeitmerker Blinklicht
unsigned long wann_rotPin1 = 200 ; // rotes Blinklicht
const int deckPin1 = 11; // weisses Licht innen
const int verzDeck = 5000; // Einchaltverzug vor Drehstart
unsigned long previousMillis_deckPin1 = 0; // Zeitmerker Deckenlicht
//
// Motorpins generell
//
int bridgePins [2][2] = {{9, 8 }, {7, 6}} ; // Array f&#252;r zwei Motor Pins,
// Motor 1: 9,8 / Motor 2: 7,6
boolean an = HIGH; // definiere f&#252;r Motor Zustand an
boolean aus = LOW; // definiere f&#252;r Motor Zustand aus
boolean links = LOW ; // definiere f&#252;r Motor Linkslauf
boolean rechts = HIGH ; // definiere f&#252;r MotorvRechtslauf
//
// Motor 1
//
const int PWM_1 = 10; // PWM f&#252;r Motor 1
const int Mot1 = 1; // Motor 1
unsigned long previousMillis_Mot1 = 0; // Zeitmerker Motor 1
unsigned long wann_Mot1[2] = { 60000,8000} ; // Startabstand 60000, Laufzeit Motor 1 8000
boolean next_Mot1 = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mot1 = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Motor 2
//
const int PWM_2 = 5; // PWM f&#252;r Motor 2
const int Mot2 = 2; // Motor 2
unsigned long previousMillis_Mot2 = 0; // Zeitmerker Motor 2
unsigned long wann_Mot2[2] = { 30000,8000} ; // Startabstand 30000, Laufzeit Motor 2 8000
boolean next_Mot2 = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mot2 = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Motor M&#228;rklin Kran Drehen
//
//const int PWM_2 = 5; // PWM f&#252;r Motor 2
//const int Mot2 = 2; // Motor 2
unsigned long previousMillis_Mark = 0; // Zeitmerker M&#228;rklin Kran
unsigned long wann_Mark[2] = { 40000,8000} ; // Startabstand 30000, Laufzeit Motor 2 8000
boolean next_Mark = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mark = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Relaisausg&#228;nge
//
const int Rel_1 = 4; // Digitalpins f&#252;r Relais
const int Rel_2 = 3; //
const int Rel_3 = 2; //
//
// Analogeing&#228;nge
// An jedem Analogeingang sind zwei Taster
// Pull-up Widerstand eingeschaltet
// 10 K Widerstand gegen GND
// Taster a &#252;ber 470 Ohm gegen Vcc
// Taster b &#252;ber 4,7 K gegen Vcc
//
const int Taste_1 = A0; // Steuertaste 1 auf Analag 0 liefert integer 14
const int Taste_2 = A1; // Steuertaste 2 15
const int Taste_3 = A2; // Steuertaste 3 16
const int Taste_4 = A3; // Steuertaste 4 17
const int Pin_0 = 0 ; // Noch frei, als Test Pin genutzt
const int Pin_1 = 1 ; // Noch frei, als Test Pin genutzt
int Taste_Wert [4] = { 0, 0, 0, 0 }; // Variable f&#252;r Tastenabfrage, als 0 vorbelegt
int entprellzeit = 100 ; // Tastenprellen abwarten in msec
const int ohne_Drueck = 500 ; // Analogwert unter 500: nichts gedr&#252;ckt
const int klein_Drueck = 850 ; // Analogwert &#252;ber 850: 470 Ohm gedr&#252;ckt
const int gross_Drueck_u = 600 ; // Analogwert zw. 600 und 800: 4,7 K gedr&#252;ckt
const int gross_Drueck_o = 800 ;
//
void setup()
{
// Serial.begin(9600);
//
// Tasten / Relais einstellen auf INPUT / OUTPUT
//
pinMode(Pin_0 , OUTPUT);
pinMode(Pin_1 , OUTPUT);
pinMode(Rel_1 , OUTPUT);
pinMode(Rel_2 , OUTPUT);
pinMode(Rel_3 , OUTPUT);
pinMode(rotPin1, OUTPUT);
pinMode(deckPin1, OUTPUT);
pinMode(Kabine, OUTPUT);
//
// Motoranschlusspins setzen
//
pinMode(PWM_1, OUTPUT);
pinMode(PWM_2, OUTPUT);
pinMode(bridgePins[0][0], OUTPUT);
pinMode(bridgePins[0][1], OUTPUT);
pinMode(bridgePins[1][0], OUTPUT);
pinMode(bridgePins[1][1], OUTPUT);
//
// Interner Pullup Widerstand einschalten
//
pinMode(Taste_1, INPUT_PULLUP) ;
pinMode(Taste_2, INPUT_PULLUP) ;
pinMode(Taste_3, INPUT_PULLUP) ;
pinMode(Taste_4, INPUT_PULLUP) ;
}
//
// --------------------------------- LOOP geht los ----------------------------
//
void loop() {
//
unsigned long currentMillis = millis(); // abgelaufene Zeit abfragen
//
analogWrite(PWM_1, 40); // Motor 1 speed
analogWrite(PWM_2, 80); // Motor 2 speed
//
digitalWrite (Pin_0, HIGH) ; // Test Pin 0 aus
digitalWrite (Pin_1, LOW) ; // Test Pin 1 aus
//
// Motor 1 checken, wird &#252;ber Drucktaste an A0 gestartet
//
if (Druck_Taste(Taste_1-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_1-14)==1) // Schleife solange Taste gedr&#252;ckt
{
Motor (Mot1, an , Taste_Wert[Taste_1-14] &gt; klein_Drueck) ; // Motor 1 anschalten
} // Richtung je nach Taste an A0
Motor (Mot1, aus , HIGH) ; // Nach Loslassen der Taste
} // Motor 1 ausschalten
//
// Motor 2 manuell drehen &#252;ber A1
//
if (Druck_Taste(Taste_2-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_2-14)==1) // Schleife solange Taste gedr&#252;ckt
{
Motor (Mot2, an , Taste_Wert[Taste_2-14] &gt; klein_Drueck) ; // Motor 2 anschalten
} // Richtung je nach Taste an A1
Motor (Mot2, aus , HIGH) ; // Nach Loslassen der Taste
} // Motor 2 ausschalten
//
// Relais 1 &amp; 2 manuell &#252;ber A2 / Taste_3
//
if (Druck_Taste(Taste_3-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_3-14)==1) // Schleife solange Taste gedr&#252;ckt
{
if (Taste_Wert[Taste_3-14] &gt; klein_Drueck)
{
digitalWrite(Rel_1, HIGH); // Relais 1 ein
}
else
{
digitalWrite(Rel_2, HIGH); // Relais 2 ein
} // Ende WHILE
digitalWrite(Rel_1, LOW); // Nach Loslassen der Taste
digitalWrite(Rel_2, LOW); // Nach Loslassen der Taste
} // Relais 1 &amp; 2 ausschalten
}
//
// Relais 3 manuell &#252;ber A3 oben
//
if (Druck_Taste(Taste_4-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_4-14)==1 &amp;&amp; (Taste_Wert[Taste_3-14] &gt; klein_Drueck))
// Schleife solange Taste gedr&#252;ckt
{
digitalWrite(Rel_3, HIGH); // Relais 2 ein
} // Ende WHILE
digitalWrite(Rel_3, LOW); // Nach Loslassen der Taste
} // Relais 1 ausschalten
//
//
/*
Taste A0 ausgeblendet da Motor 2 dar&#252;ber gestartet werden soll
if (Druck_Taste(Taste_1-14)==1) { // A0 ist #14, also 14 abziehen
// da ==1 wurde eine Taste gedr&#252;ckt
if (Taste_Wert[0] &gt; klein_Drueck) { // Taste f&#252;r kleinen Widerstand
// Serial.println("Taste 1 unten gedr&#252;ckt ") ;
digitalWrite (Pin_0, HIGH) ; // Testausgabe
digitalWrite (Pin_1, LOW) ; // Testausgabe
}
else { // da Taste gedr&#252;ck, ist gro&#223;er Widerstand
Serial.println("Taste 1 oben gedr&#252;ckt ") ;
digitalWrite (Pin_1, HIGH) ;
digitalWrite (Pin_0, LOW) ;
}
}

if (Druck_Taste(Taste_2-14)==1) { // A0 ist #14, also 14 abziehen
// da ==1 wurde eine Taste gedr&#252;ckt
if (Taste_Wert[1] &gt; klein_Drueck) { // Taste f&#252;r kleinen Widerstand
// Serial.println("Taste 2 unten gedr&#252;ckt ") ;
digitalWrite (Pin_0, HIGH) ; // Testausgabe
digitalWrite (Pin_1, LOW) ; // Testausgabe
}
else {
// Serial.println("Taste 2 oben gedr&#252;ckt ") ;
digitalWrite (Pin_1, HIGH) ;
digitalWrite (Pin_0, LOW) ;
}

}
 
*/
//
if (Druck_Taste(Taste_4-14)==1) {
if (Taste_Wert[3] &gt; klein_Drueck) {
// Serial.println("Taste 4 unten gedr&#252;ckt ") ;
digitalWrite (Pin_0, HIGH) ; // Testausgabe
digitalWrite (Pin_1, LOW) ; // Testausgabe
}
else {
// Serial.println("Taste 4 oben gedr&#252;ckt ") ;
digitalWrite (Pin_1, HIGH) ;
digitalWrite (Pin_0, LOW) ;
}
 
}
//
// Deckenlicht Fallerkran
//
if ((currentMillis-previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]-verzDeck) &amp;&amp; status_Mot1==0)
{
previousMillis_deckPin1 = currentMillis; // Merke Zeitpunkt f&#252;r Deckenlicht
digitalWrite(deckPin1, HIGH) ; // Deckenlicht an
}
//
if (currentMillis - previousMillis_deckPin1 &gt;= verzDeck &amp;&amp; status_Mot1 == 0)
{
previousMillis_deckPin1 = currentMillis; // Merke Zeitpunkt f&#252;r Deckenlicht
digitalWrite(deckPin1, LOW) ; // Deckenlicht aus
}
//
// Kabinenlicht Fallerkran
//
if ((currentMillis-previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]-verzKabine) &amp;&amp; status_Mot1==0)
{
previousMillis_Kabine = currentMillis; // Merke Zeitpunkt f&#252;r Kabinenlicht
digitalWrite(Kabine, HIGH) ; // Kabinenlicht an
}
//
if (currentMillis - previousMillis_Kabine &gt;= verzKabine &amp;&amp; status_Mot1 == 0)
{
previousMillis_Kabine = currentMillis; // Merke Zeitpunkt f&#252;r Kabinenlicht
digitalWrite(Kabine, LOW) ; // Kabinenlicht aus
}
//
// Motor 1: Drehmotor Fallerkran
//
if ((currentMillis - previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]) &amp;&amp; status_Mot1 == 0)
{ // soll loslaufen
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 1
Motor (Mot1, an , next_Mot1) ; // Motor an
next_Mot1 = !next_Mot1 ; // Motor Richtung umkehren
status_Mot1 = 1-status_Mot1 ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]) &amp;&amp; status_Mot1 == 1)
{ // soll stehen bleiben
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
status_Mot1 = 1-status_Mot1; // &#228;ndern auf loslaufen
Motor (Mot1, aus, HIGH) ; // Motor aus
previousMillis_Kabine = currentMillis; // merken f&#252;r Kabinenlicht
previousMillis_deckPin1 = currentMillis; // merken f&#252;r Deckenlicht
}
//
// Blinklichr Bewegung Faller Kran
//
if (currentMillis - previousMillis_rotPin1 &gt;= wann_rotPin1)
{ // rotes Blinklicht,
// wenn Kran bewegt
previousMillis_rotPin1 = currentMillis; // merken f&#252;r Blinklicht
if (status_Mot1==1) {
digitalWrite(Rel_2, !digitalRead(Rel_2)); // Relaistest an dieser Stelle
digitalWrite(rotPin1, !digitalRead(rotPin1));
} // Blinklicht an/aus
else {
digitalWrite(Rel_2, LOW); // Relaistest an dieser Stelle
digitalWrite(rotPin1, LOW); } // Blinklicht aus
}
//
// Motor 2: Drehmotor
//
if ((currentMillis - previousMillis_Mot2 &gt;= wann_Mot2[status_Mot2]) &amp;&amp; status_Mot2 == 0)
{ // soll loslaufen
previousMillis_Mot2 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
Motor (Mot2, an , next_Mot2) ; // Motor an
next_Mot2 = !next_Mot2 ; // Motor Richtung umkehren
status_Mot2 = 1-status_Mot2 ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mot2 &gt;= wann_Mot2[status_Mot2]) &amp;&amp; status_Mot1 == 1)
{ // soll stehen bleiben
previousMillis_Mot2 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
status_Mot2 = 1-status_Mot2; // &#228;ndern auf loslaufen
Motor (Mot2, aus, HIGH) ; // Motor aus
}
//
// M&#228;rklin Kran: Drehmotor
//
if ((currentMillis - previousMillis_Mark &gt;= wann_Mark[status_Mark]) &amp;&amp; status_Mark == 0)
{ // soll loslaufen
previousMillis_Mark = currentMillis; // Merke Zeitpunkt f&#252;r Drehkran
if (next_Mark)
{
digitalWrite(Rel_1, HIGH); // Relais 1 f&#252;r rechts
}
else
{
digitalWrite(Rel_2, HIGH); // Relais 2 f&#252;r links
}
next_Mark = !next_Mark ; // Motor Richtung umkehren
status_Mark = 1-status_Mark ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mark &gt;= wann_Mark[status_Mark]) &amp;&amp; status_Mark == 1)
{ // soll stehen bleiben
previousMillis_Mark = currentMillis; // Merke Zeitpunkt f&#252;r Drehkran
status_Mark = 1-status_Mark; // &#228;ndern auf loslaufen
digitalWrite(Rel_1, LOW); // Relais 1 aus
digitalWrite(Rel_2, LOW); // Relais 2 aus
}
//
}
//
// --------------------------------- LOOP zu Ende ----------------------------
//
// --------------------------- Motor ansteuern -------------------------------
//
int Motor(int wen, boolean start, boolean wie){ // drei Parameter
// Motornummer
// wenn start HIGH lauf los
// wenn start LOW bleib stehen
// wenn wie HIGH rechts herum
// wenn wie LOW links herum
if (!start) { // soll stehen bleiben
digitalWrite(bridgePins[wen-1][0], LOW) ; // setzte H-Bridge auf Stop
digitalWrite(bridgePins[wen-1][1], LOW) ;
return wen; // gib Motornummer zur&#252;ck
}
else if (start) { // soll loslaufen
digitalWrite(bridgePins[wen-1][0], wie) ; // setzte H-Bridge auf Los
digitalWrite(bridgePins[wen-1][1], !wie) ;
return wen;
}
else {return 0;}
}
//
// ----------------------------Tastenabfrage -----------------------------
//
int Druck_Taste(int dieseTaste){ // Fragt Tasten ab
int Druck_Wert = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
delay (entprellzeit); // warte wegen Prellen
Druck_Wert = analogRead(dieseTaste); // frag Taste noch einmal
Taste_Wert [dieseTaste] = Druck_Wert ; // lese Wert in Array
if (Druck_Wert &lt; ohne_Drueck) {return 0; } // keine Taste gedr&#252;ckt
else if (Druck_Wert &gt; ohne_Drueck) {return 1; } // Taste gedr&#252;ckt
}
//
 
 


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Licht und Action

#18 von Running.Wolf , 26.07.2020 11:32

Moin

nach dem Gesetz der größten Gemeinheit waren natürlich noch Fehler im Programm. Nicht in der Kernfunktion des Fallerkrans, aber in den weiteren Funktionen (Relais für die Programmsteuerung der Relais für den Märklin Kran, Abschaltung des zweiten Motors).
Das habe ich korrigiert und auch gleich eingebaut, dass nach jedem Halt des Fallerkrans die Startzeit für die nächste Bewegung per RANDOM zufällig neu gesetzt wird. Die Grenzwerte sind

wann_Mot1[0] = random (60000, 600000) ; // Einschaltzeit zufällig neu setzen

im Moment 60 Sekunden = 1 Minute sowie 600 Sekunden = 10 Minuten. Diese Werte können nach Lust und Laune selbst gesetzt werden.
Dieselbe Funktion ist bereits vorgesehen für den Motor 2 und den Märklin Kran über die Relais Rel 1 und Rel 2, aber im Moment noch auskommentiert. Das ich noch weitere Funktionen teste mag ich nicht 10 Minuten warten

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
//
// Ansteuerung Faller Kran
/*
* Automatischer Betrieb zur Drehbewegung bis 270 Grad rechts und links.
* LED in Kanzel und F&#252;hrerhaus
* Je zwei Taster auf A0 bis A3
* A0 f&#252;r direkte manuelle Drehung rechts links
* A1 f&#252;r zweiten Motor
* A2 f&#252;r Relais 1 &amp; Relais 2 (M&#228;rklin Kran)
* A3 zur freien Verf&#252;gung
*/
 
// Wolfgang aka Running_Wolf
// 2020-07-24
//
// LED
const int Kabine = 13; // F&#252;hrer Kabine
const int verzKabine = 3000; // Einchaltverzug vor Drehstart
unsigned long previousMillis_Kabine = 0; // Zeitmerker Kabinenlicht
const int rotPin1 = 12; // rotes Blinklicht
unsigned long previousMillis_rotPin1 = 0; // Zeitmerker Blinklicht
unsigned long wann_rotPin1 = 200 ; // rotes Blinklicht
const int deckPin1 = 11; // weisses Licht innen
const int verzDeck = 5000; // Einchaltverzug vor Drehstart
unsigned long previousMillis_deckPin1 = 0; // Zeitmerker Deckenlicht
//
// Motorpins generell
//
int bridgePins [2][2] = {{9, 8 }, {7, 6}} ; // Array f&#252;r zwei Motor Pins,
// Motor 1: 9,8 / Motor 2: 7,6
boolean an = HIGH; // definiere f&#252;r Motor Zustand an
boolean aus = LOW; // definiere f&#252;r Motor Zustand aus
boolean links = LOW ; // definiere f&#252;r Motor Linkslauf
boolean rechts = HIGH ; // definiere f&#252;r MotorvRechtslauf
//
// Motor 1
//
const int PWM_1 = 10; // PWM f&#252;r Motor 1
const int Mot1 = 1; // Motor 1
unsigned long previousMillis_Mot1 = 0; // Zeitmerker Motor 1
unsigned long wann_Mot1[2] = { 30000,6000} ; // Startabstand 60000, Laufzeit Motor 1 8000
boolean next_Mot1 = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mot1 = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Motor 2
//
const int PWM_2 = 5; // PWM f&#252;r Motor 2
const int Mot2 = 2; // Motor 2
unsigned long previousMillis_Mot2 = 0; // Zeitmerker Motor 2
unsigned long wann_Mot2[2] = { 10000,8000} ; // Startabstand 30000, Laufzeit Motor 2 8000
boolean next_Mot2 = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mot2 = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Motor M&#228;rklin Kran Drehen
//
unsigned long previousMillis_Mark = 0; // Zeitmerker M&#228;rklin Kran
unsigned long wann_Mark[2] = { 60000,8000} ; // Startabstand 30000, Laufzeit Motor 2 8000
boolean next_Mark = rechts ; // n&#228;chste Drehrichtung vorbelegen
int status_Mark = 0 ; // 0 = soll laufen, 1 = soll stoppen
//
// Relaisausg&#228;nge Digitalpins f&#252;r Relais
//
const int Rel_1 = 4; // M&#228;rklin Kran rechts
const int Rel_2 = 3; // M&#228;rklin Kran links
const int Rel_3 = 2; // noch frei
//
// Analogeing&#228;nge
// An jedem Analogeingang sind zwei Taster
// Pull-up Widerstand eingeschaltet
// 10 K Widerstand gegen GND
// Taster a &#252;ber 470 Ohm gegen Vcc
// Taster b &#252;ber 4,7 K gegen Vcc
//
const int Taste_1 = A0; // Steuertaste 1 auf Analog 0 liefert integer 14
const int Taste_2 = A1; // Steuertaste 2 15
const int Taste_3 = A2; // Steuertaste 3 16
const int Taste_4 = A3; // Steuertaste 4 17
int Taste_Wert [4] = { 0, 0, 0, 0 }; // Variable f&#252;r Tastenabfrage, als 0 vorbelegt
int entprellzeit = 100 ; // Tastenprellen abwarten in msec
const int ohne_Drueck = 500 ; // Analogwert unter 500: nichts gedr&#252;ckt
const int klein_Drueck = 850 ; // Analogwert &#252;ber 850: 470 Ohm gedr&#252;ckt
const int gross_Drueck_u = 600 ; // Analogwert zw. 600 und 800: 4,7 K gedr&#252;ckt
const int gross_Drueck_o = 800 ;
//
const int Pin_0 = 0 ; // Noch frei, als Test Pin genutzt
const int Pin_1 = 1 ; // Noch frei, als Test Pin genutzt
//
void setup()
{
//
// Tasten / Relais einstellen auf INPUT / OUTPUT
//
pinMode(Pin_0 , OUTPUT); // Noch frei, als Test Pin genutzt
pinMode(Pin_1 , OUTPUT); // Noch frei, als Test Pin genutzt
pinMode(Rel_1 , OUTPUT); // M&#228;rklin Kran rechts
pinMode(Rel_2 , OUTPUT); // M&#228;rklin Kran linkss
pinMode(Rel_3 , OUTPUT); // noch frei
pinMode(rotPin1, OUTPUT); // rotes Blinklicht
pinMode(deckPin1, OUTPUT); // weisses Deckenlicht
pinMode(Kabine, OUTPUT); // F&#252;hrerkabine
//
// Motoranschlusspins setzen
//
pinMode(PWM_1, OUTPUT); // PWM Anschluss Motor 1
pinMode(PWM_2, OUTPUT); // PWM Anschluss Motor 2
pinMode(bridgePins[0][0], OUTPUT); // Steuerpin Motor 1
pinMode(bridgePins[0][1], OUTPUT); // Steuerpin Motor 1
pinMode(bridgePins[1][0], OUTPUT); // Steuerpin Motor 2
pinMode(bridgePins[1][1], OUTPUT); // Steuerpin Motor 2
//
// Interner Pullup Widerstand einschalten
//
pinMode(Taste_1, INPUT_PULLUP) ; // Steuertaste 1 auf Analog 0 liefert integer 14
pinMode(Taste_2, INPUT_PULLUP) ;
pinMode(Taste_3, INPUT_PULLUP) ;
pinMode(Taste_4, INPUT_PULLUP) ;
}
//
// --------------------------------- LOOP geht los ----------------------------
//
void loop() {
//
unsigned long currentMillis = millis(); // abgelaufene Zeit abfragen
//
analogWrite(PWM_1, 40); // Motor 1 speed
analogWrite(PWM_2, 80); // Motor 2 speed
//
digitalWrite (Pin_0, HIGH) ; // Test Pin 0 aus
digitalWrite (Pin_1, LOW) ; // Test Pin 1 aus
//
// Motor 1 checken, wird &#252;ber Drucktaste an A0 manuell gestartet
//
if (Druck_Taste(Taste_1-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_1-14)==1) // Schleife solange Taste gedr&#252;ckt
{
Motor (Mot1, an , Taste_Wert[Taste_1-14] &gt; klein_Drueck) ; // Motor 1 anschalten
} // Richtung je nach Taste an A0
Motor (Mot1, aus , HIGH) ; // Nach Loslassen der Taste
} // Motor 1 ausschalten
//
// Motor 2 manuell drehen &#252;ber A1
//
if (Druck_Taste(Taste_2-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_2-14)==1) // Schleife solange Taste gedr&#252;ckt
{
Motor (Mot2, an , Taste_Wert[Taste_2-14] &gt; klein_Drueck) ; // Motor 2 anschalten
} // Richtung je nach Taste an A1
Motor (Mot2, aus , HIGH) ; // Nach Loslassen der Taste
} // Motor 2 ausschalten
//
// Relais 1 &amp; 2 manuell &#252;ber A2 / Taste_3
//
if (Druck_Taste(Taste_3-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_3-14)==1) // Schleife solange Taste gedr&#252;ckt
{
if (Taste_Wert[Taste_3-14] &gt; klein_Drueck) // Taste
{
digitalWrite(Rel_1, HIGH); // Relais 1 ein
}
else
{
digitalWrite(Rel_2, HIGH); // Relais 2 ein
} // Ende WHILE
} // Relais 1 &amp; 2 ausschalten
digitalWrite(Rel_1, LOW); // Nach Loslassen der Taste ...
digitalWrite(Rel_2, LOW); // ... Rel 1 und Rel 2 aus
}
//
// Relais 3 manuell &#252;ber A3 unten = Taste_4
//
if (Druck_Taste(Taste_4-14)==1) // nur wenn die Taste &#252;berhaupt
{ // gedr&#252;ckt wurde
while (Druck_Taste(Taste_4-14)==1 &amp;&amp; (Taste_Wert[Taste_4-14] &gt; klein_Drueck))
// Schleife solange Taste gedr&#252;ckt
{
digitalWrite(Rel_3, HIGH); // Relais 3 ein halten
} // Ende WHILE
digitalWrite(Rel_3, LOW); // Nach Loslassen der Taste ...
} // ... Relais 3 ausschalten
//
//
// Deckenlicht Fallerkran
//
if ((currentMillis-previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]-verzDeck) &amp;&amp; status_Mot1==0)
{
previousMillis_deckPin1 = currentMillis; // Merke Zeitpunkt f&#252;r Deckenlicht
digitalWrite(deckPin1, HIGH) ; // Deckenlicht an
}
//
if (currentMillis - previousMillis_deckPin1 &gt;= verzDeck &amp;&amp; status_Mot1 == 0)
{
previousMillis_deckPin1 = currentMillis; // Merke Zeitpunkt f&#252;r Deckenlicht
digitalWrite(deckPin1, LOW) ; // Deckenlicht aus
}
//
// Kabinenlicht Fallerkran
//
if ((currentMillis-previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]-verzKabine) &amp;&amp; status_Mot1==0)
{
previousMillis_Kabine = currentMillis; // Merke Zeitpunkt f&#252;r Kabinenlicht
digitalWrite(Kabine, HIGH) ; // Kabinenlicht an
}
//
if (currentMillis - previousMillis_Kabine &gt;= verzKabine &amp;&amp; status_Mot1 == 0)
{
previousMillis_Kabine = currentMillis; // Merke Zeitpunkt f&#252;r Kabinenlicht
digitalWrite(Kabine, LOW) ; // Kabinenlicht aus
}
//
// Motor 1: Drehmotor Fallerkran
//
if ((currentMillis - previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]) &amp;&amp; status_Mot1 == 0)
{ // soll loslaufen
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 1
Motor (Mot1, an , next_Mot1) ; // Motor an
next_Mot1 = !next_Mot1 ; // Motor Richtung umkehren
status_Mot1 = 1-status_Mot1 ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mot1 &gt;= wann_Mot1[status_Mot1]) &amp;&amp; status_Mot1 == 1)
{ // soll stehen bleiben
previousMillis_Mot1 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
status_Mot1 = 1-status_Mot1; // &#228;ndern auf loslaufen
Motor (Mot1, aus, HIGH) ; // Motor aus
wann_Mot1[0] = random (60000, 600000) ; // Einschaltzeit zuf&#228;llig neu setzen
previousMillis_Kabine = currentMillis; // merken f&#252;r Kabinenlicht
previousMillis_deckPin1 = currentMillis; // merken f&#252;r Deckenlicht
}
//
// Blinklicht Bewegung Faller Kran
//
if (currentMillis - previousMillis_rotPin1 &gt;= wann_rotPin1)
{ // rotes Blinklicht,
// wenn Kran bewegt
previousMillis_rotPin1 = currentMillis; // merken f&#252;r Blinklicht
if (status_Mot1==1) {
digitalWrite(rotPin1, !digitalRead(rotPin1));
} // Blinklicht an/aus
else {
digitalWrite(rotPin1, LOW); } // Blinklicht aus
}
//
// Motor 2: Drehmotor
//
if ((currentMillis - previousMillis_Mot2 &gt;= wann_Mot2[status_Mot2]) &amp;&amp; status_Mot2 == 0)
{ // Motor 2 soll loslaufen
previousMillis_Mot2 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
Motor (Mot2, an , next_Mot2) ; // Motor an
next_Mot2 = !next_Mot2 ; // Motor Richtung umkehren
status_Mot2 = 1-status_Mot2 ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mot2 &gt;= wann_Mot2[status_Mot2]) &amp;&amp; status_Mot2 == 1)
{ // Motor 2 soll stehen bleiben
previousMillis_Mot2 = currentMillis; // Merke Zeitpunkt f&#252;r Motor 2
status_Mot2 = 1-status_Mot2; // &#228;ndern auf loslaufen
Motor (Mot2, aus, HIGH) ; // Motor aus
// wann_Mot2[0] = random (60000, 600000) ; // Einschaltzeit zuf&#228;llig neu setzen
}
//
// M&#228;rklin Kran: Drehmotor
//
if ((currentMillis - previousMillis_Mark &gt;= wann_Mark[status_Mark]) &amp;&amp; status_Mark == 0)
{ // soll loslaufen
previousMillis_Mark = currentMillis; // Merke Zeitpunkt f&#252;r Drehkran
digitalWrite(Rel_1, next_Mark); // Relais 1 an f&#252;r rechts
digitalWrite(Rel_2, !next_Mark); // Relais 2 aus und umgekehrt
next_Mark = !next_Mark ; // Motor Richtung umkehren
status_Mark = 1-status_Mark ; // &#228;ndern auf stehenbleiben
}
//
if ((currentMillis - previousMillis_Mark &gt;= wann_Mark[status_Mark]) &amp;&amp; status_Mark == 1)
{ // soll stehen bleiben
previousMillis_Mark = currentMillis; // Merke Zeitpunkt f&#252;r Drehkran
status_Mark = 1-status_Mark; // &#228;ndern auf loslaufen
digitalWrite(Rel_1, LOW); // Relais 1 aus
digitalWrite(Rel_2, LOW); // Relais 2 aus
// wann_Mark[0] = random (60000, 600000) ; // Einschaltzeit zuf&#228;llig neu setzen
}
//
}
//
// --------------------------------- LOOP zu Ende ----------------------------
//
// --------------------------- Motor ansteuern -------------------------------
//
int Motor(int wen, boolean start, boolean wie){ // drei Parameter
// Motornummer
// wenn start HIGH lauf los
// wenn start LOW bleib stehen
// wenn wie HIGH rechts herum
// wenn wie LOW links herum
if (!start) { // soll stehen bleiben
digitalWrite(bridgePins[wen-1][0], LOW) ; // setzte H-Bridge auf Stop
digitalWrite(bridgePins[wen-1][1], LOW) ;
return wen; // gib Motornummer zur&#252;ck
}
else if (start) { // soll loslaufen
digitalWrite(bridgePins[wen-1][0], wie) ; // setzte H-Bridge auf Los
digitalWrite(bridgePins[wen-1][1], !wie) ;
return wen;
}
else {return 0;}
}
//
// ----------------------------Tastenabfrage -----------------------------
//
int Druck_Taste(int dieseTaste){ // Fragt Tasten ab
int Druck_Wert = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
delay (entprellzeit); // warte wegen Prellen
Druck_Wert = analogRead(dieseTaste); // frag Taste noch einmal
Taste_Wert [dieseTaste] = Druck_Wert ; // lese Wert in Array
if (Druck_Wert &lt; ohne_Drueck) {return 0; } // keine Taste gedr&#252;ckt
else if (Druck_Wert &gt; ohne_Drueck) {return 1; } // Taste gedr&#252;ckt
}
//
 
 


Gruss Wolfgang

All that the young can do for the old is to shock them and keep them up to date. George Bernhard Shaw


 
Running.Wolf
InterCity (IC)
Beiträge: 763
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


   


  • Ähnliche Themen
    Antworten
    Zugriffe
    Letzter Beitrag
disconnected Foren-Chat Mitglieder Online 48
Xobor Einfach ein eigenes Forum erstellen
Datenschutz