Willkommen 

RE: Arduino: Lokschuppen und 3D

#1 von Running.Wolf , 24.07.2020 15:52

Moin

zum Thema Lokschuppen gibt es schon einige Beiträge. Ich möchte hier meine Lösung in Verbindung mit 3D-Druck vorstellen.

Es geht um diesen Schuppen:



Ich wollte dort "Leben in die Bude" bringen. Also
- Bewegliche Tore (automatisch alle x Minuten)
- Bewegliche Tore auf Knopfdruck
- Licht (12 V LED Strips) in Schuppen und Nachbarschuppen
- 3 blaue LED blitzendes Schweisslicht.

Und so sieht er jetzt in etwa (auf der Werkbank) aus.



Und so steht er links vorne an der Anlage, daneben der Nachbarschuppen, der mit versorgt werden soll.



Ich habe verschiedene Lösungen gesehen, um die Tore mit einem Servo zu verbinden (Federdraht, Fahrradspeichen etc). Da meine Kinder mir einen 3D Drucker zum Geburtstag geschenkt haben, musste der dran glauben.



Die schwarzen Teile gehören zu dem Mechanismus Auf einer waagerechten Traverse schiebt ein T-Stück zwei Schubstangen, die an kleinen Lagern an den beiden Toren ansetzen. Durch die drehbare Lagerung unter den Schrauben können die Schubstangen den Drehbewegungen der Tore folgen.
Links hinten ist in einem Ausschnitt zum Anbau das blaue Servo senkrecht angebracht. Der Servoarm greift in ein Langloch einer weiteren, starren Schubstange, die mit dem T-Stück verbunden ist.

Dadurch wir die senkrechte Dreh-Schwenkbewegung des Servos in eine waagerechte Öffnungsbewegung der Tore umgesetzt.

Zwischen den beiden Anbauten habe ich einen Arbeitstisch gedruckt, an dem Preisser-Arbeiter schweissen. Da ich noch einen LC 6 von TAMS übrig hatte, der 5 Schweisslichter erzeigen kann, habe ich dort insgesamt 5 blaue LED verteilt.

Unter dem Dach und in den Anbauten habe ich 12 V LED Strips angeklebt, ebenso im Nachbarschuppen.

Für die Steuerung habe ich einen Arduino Nano eingesetzt, der auf einer passend gedruckten Halterung im Anbau sitzt. Alle Zuleitungen werden anch unten geführt und sind über Steckverbinder zu trennen. Auf diesem Bild ist er halb herausgezogen, in der Arbeitsposition sitzt er senkrecht in der Halterung im Anbau.



- Servo für Tore
- Licht (12 V LED Strips) in Schuppen und Nachbarschuppen
- Warnblinklicht über Tor
- 3 + 2 blaue LED blitzende Schweisslichter über den TAMS LC 6

Der Arduino Nano wird mit 12 V DC versorgt, ein 8 Bit Darlington Array hängt an 8 Binärausgängen, daran hängen die LED Strips und schalten gegen + 12 V.

An anderen Binärausgängen hängen LED über Vorwiderstände, die schalten gegen GND und nutzen daher die internen 5 V Pegel.

An den Darlington können noch Relais und andere 12 V Objekte angehängt werden.

Programmieren ist ebenso simpel: mit Laptop daneben setzen, Dach abnehmen, USB Port von oben einstöpseln, fertig.
Nur wenn ich weitere Darlington Ausgänge nutzen will, muss ich den Nano wie im Bild ein wenig rausziehen und weitere Leitungen anlöten.

Die Tore bewegen sich per Programm alle 20 bis 30 Minuten auf und nach einer Pause wieder zu.
Sie können auch per Taster gesteuert werden. Da der Arduino weiss, ob das Tor auf oder zu ist, reicht ein Taster aus, um die gegenläufige Bewegung auszulösen.


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: 756
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Lokschuppen und 3D

#2 von Running.Wolf , 24.07.2020 16:01

Moin

hier zeige ich Euch nun den Schaltplan, der noch viele Erweiterungsmöglichkeiten lässt.



Im Zentrum sieht man den Nano und das Darlington Array.

Von dort geht eine Steckverbindung "weiß" nach außen, um in der Halle 2 zwei 12 V Verbraucher zu schalten.
Rechts unten ist der TAMS LC 6, der über den Darlington ein- und ausgeschaltet wird.
Rechts oben sind die 3 LED der Deckenbeleuchtung (LED Strips).
Da ich gerade keinen 7808 zur Verfügung hatte, reduziere ich die Spannung links unten über vier LEDs.
In der Bildmitte ist eine rote LED, die als Warnlampe überr dem Tor blinkt, wenn es sich bewegt.
An S1, S2 und S3 hängt das blaue Servo.

Links oben sind die Steckverbinder, über die z.B. die 12 V DC eingespeist werden.

Dort sind auch Analogports rausgeführt, die weitere Möglichkeiten offen lassen.

Wie man sieht, sind die Möglichkeiten des Nano bei weitem nicht ausgereizt.


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: 756
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Lokschuppen und 3D

#3 von Running.Wolf , 24.07.2020 16:07

Moin

nun zeige ich Euch das Programm, bei dem ich gern auf die MOBATOOLS.H Library zurückgegriffen habe.
Da auch dieses Programm nicht fertig ist, denn der Nano hat noch Kapazitäten frei, sind einige Zeilen auskommentiert.
Falls ich noch Dinge zufüge, werde ich ein Update einstellen.

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
 

/*
* Lokschuppen mit Servo und Blinkdioden
* 2020-03-16
* Wolfgang aka Running_Wolf
*/
#include <MobaTools.h>
const int rotPin1 = 12; // rotes Blinklicht über Tor1 sw/we
const int blitzPin1 = 11; // Blitzlicht LED (lila)
const int torservoPin = 10; // Anschluß für den Servo Links/Rechts
const int lichtPin3 = 9; // LED Strip (gelb)
const int lichtPin2 = 8; // Hallenlicht Nebenhalle LED Strip (grün)
const int torrelaisPin = 7; // via Darlington (noch offen)
const int lichtPin1 = 2; // Hallenlicht Haupthalle LED Strip (grün)
 
unsigned long previousMillis_Tor1 = 0; // will store last time of change
 
unsigned long previousMillis_Rot1 = 0; // will store last time of change
unsigned long previousMillis_Halle1 = 0; // will store last time of change
unsigned long previousMillis_Halle2 = 0; // will store last time of change
unsigned long wann_Halle1[2] = { 30000,40000} ; // Startabstand, Laufzeit Hallenlicht 1
unsigned long wann_Halle2[2] = {310000,51000} ; // Startabstand, Laufzeit Hallenlicht 2
unsigned long wann_Tor1[2] = {300000,300000} ; // Startabstand, Laufzeit Hallentor 1
 
//unsigned long blitzStartenB1 = 0 ;
unsigned long previousMillisB1 = 0; // will store last time of change
const long blitzDauerB1 = 20000 ;
long blitzOffB1 = 2000;
//const int blitzZeitB1 = 20 ; // Länge Blitzlicht
//unsigned long wann_Blitz = 500 ; // Blitzfrequenz
int blitzStateB1 = LOW;
//byte blitzFlicker[] = {180, 30, 89, 23, 255, 200, 90, 150, 60, 230, 180, 45, 90};
 
unsigned long wann_Rot1 = 200 ; // rotes Blinklicht über Tor
int status_Halle1 = 0 ; // Licht Halle 1 aus
int status_Halle2 = 0 ; // Licht Halle 2 aus
int status_Tor1 = 0 ; // Tor 1 zu
int ziel_Tor1 = 0 ; // 0 = zu, 170 = auf
//
Servo8 torServo;
// EggTimer Pause; // Timer für Pausen zwischen den Servobewegungen
// byte schritt = 0; // Zustand Schrittkette
//
// Tastenfunktionen
int Taste_1 = A0; // Steuertaste 1
int Taste_2 = A1; // Steuertaste 2
int Taste_3 = A2; // Drucktaste
int Taste_1_Wert = 0; // Variable für Tastenabfrage
int Taste_2_Wert = 0; // Variable für Tastenabfrage
int Druck_3_Wert = 0; // Drucktaste
int entprellzeit = 1000 ;
int Tortaste1 = 0 ; // Tastenwert für Tor 1, 0 = nichts, 1 = zu, 2 = auf
//
//
void setup() {
Serial.begin(9600);
torServo.attach(torservoPin, true); //Servo an Pin 5
torServo.setSpeed( 3 ); // Verfahrgeschwindigkeit einstellen Links/Rechts
// pinMode(Taste_1, INPUT_PULLUP) ;
// pinMode(Taste_2, INPUT_PULLUP) ;
pinMode(Taste_3, INPUT_PULLUP) ;
pinMode(lichtPin1, OUTPUT);
pinMode(lichtPin2, OUTPUT);
pinMode( rotPin1, OUTPUT);
pinMode(blitzPin1, OUTPUT);
pinMode(torrelaisPin, OUTPUT) ;
digitalWrite(rotPin1, HIGH); // Licht aus
digitalWrite(lichtPin1, HIGH) ;
digitalWrite(lichtPin2, HIGH) ;
digitalWrite(blitzPin1, HIGH) ;
digitalWrite(torrelaisPin, HIGH) ; // Relais aus
}
//
void loop() {
unsigned long currentMillis = millis();
//
// Torstatus abfragen
// Serial.print ( "Torstatus: ");
// Serial.println(torServo.read()) ;
if (torServo.read()> 160) {
status_Tor1 = 0;
}
if (torServo.read()< 10) {
status_Tor1 = 1;
}
// Hallenlicht Haupthalle 1
 
if (currentMillis - previousMillis_Halle1 >= wann_Halle1[status_Halle1]) {
previousMillis_Halle1 = currentMillis; // save the last change
digitalWrite(lichtPin1, !digitalRead(lichtPin1));
status_Halle1 = 1-status_Halle1;
// Ende Licht Haupthalle
}
//
// Tor Halle 1 automatisch betätigen
//
if (currentMillis - previousMillis_Tor1 >= wann_Tor1[status_Tor1]) {
Serial.print("Automatikt: ") ;
Serial.println(wann_Tor1[1-status_Tor1]);
previousMillis_Tor1 = currentMillis; // save the last change
torServo.write(170 * status_Tor1); // 0 macht zu, 170 macht auf
}
// Ende Tor Haupthalle

//
if (torServo.moving()) {
digitalWrite(lichtPin1, HIGH);
previousMillis_Halle1 = currentMillis;}
//

// Hallenlicht Halle 2
 
if (currentMillis - previousMillis_Halle2 >= wann_Halle2[status_Halle2]) {
previousMillis_Halle2 = currentMillis; // save the last change
digitalWrite(lichtPin2, !digitalRead(lichtPin2));
status_Halle2 = 1-status_Halle2;
// Ende IF Licht Halle 2
}
//
Tortaste1 = 0 ;
Tortaste1 = Wert_Taste(Taste_1) ; // fragt Wert der Taste ab
//
if (Druck_Taste(Taste_3)==1) {
torServo.write(170 * status_Tor1); // 0 macht zu, 170 macht auf
}
 
// Servo Loop Anfang ----------------------------------------
//
if (digitalRead(torrelaisPin)) {
// noch nicht genutzt
} // torrelaisPin
//
//
// Hier können jetzt weitere Aktionen ausgeführt werden.
//
// Loop Blink LED Tor 1
//
if (currentMillis - previousMillis_Rot1 >= wann_Rot1) {
previousMillis_Rot1 = currentMillis; // save the last change
if (torServo.moving()) {
digitalWrite(rotPin1, !digitalRead(rotPin1)); }
else {
digitalWrite(rotPin1, LOW); }
}
//
// Loop Blink Ende
 
// Bltzer an wenn Tor nicht bewegt
//
currentMillis = millis();
// ----------------Beginn jetztTBlitzen--------------------------------------
// Anschalten
if ((currentMillis - previousMillisB1 >= blitzOffB1) && !(torServo.moving())) {
//
blitzStateB1 = !blitzStateB1;
digitalWrite(blitzPin1, blitzStateB1);
previousMillisB1 = currentMillis;
blitzOffB1 = random(1000, 3000);
//
}
// // Ende jetztBlitzen --------------------------------------------
 

} // Loop Ende
 
// Funktionen
//
// Analoge TASTE abfragen
//
int Wert_Taste(int dieseTaste){ // Widerstandsnetzwerk erlaubt ...
Taste_1_Wert = analogRead(dieseTaste); // ... zwei Tasten an einem Eingang
delay (entprellzeit);
Taste_1_Wert = analogRead(dieseTaste);
// Serial.print("Tastenwert: ") ;
// Serial.println(Taste_1_Wert);
if (Taste_1_Wert > 410 && Taste_1_Wert < 640) {return 0; }
else if (Taste_1_Wert > 300 && Taste_1_Wert < 400) {return 1; }
else if (Taste_1_Wert > 650 && Taste_1_Wert < 850) {return 2; }
} /// Ende Wert_Taste ///
//
int Druck_Taste(int dieseTaste){
Druck_3_Wert = analogRead(dieseTaste);
delay (entprellzeit);
Druck_3_Wert = analogRead(dieseTaste);
// Serial.print("Tastenwert: ") ;
// Serial.println(Druck_3_Wert);
if (Druck_3_Wert < 100) {return 1; }
else if (Druck_3_Wert > 1000) {return 0; }
}
//
 
 


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: 756
Registriert am: 15.01.2006
Homepage: Link
Ort: Isernhagen
Gleise C-Gleis / M-Gleis
Spurweite H0
Steuerung CS 2
Stromart Digital


RE: Arduino: Lokschuppen und 3D

#4 von Running.Wolf , 26.07.2020 12:42

Moin
nach dem Gesetz der größten Gemeinheit hatte ich einen alten und fehlerhaften Programmstand hochgeladen

Nun die Hoffnung, dass der aktuelle Stand korrekt ist.
Falls ich an dem Projekt weiterarbeite, kommt die Aktualisierung.

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
 
/*
* Lokschuppen mit Servo und Blinkdioden
* 2020-03-16
* Wolfgang aka Running_Wolf
*/
#include <MobaTools.h>
//
// LED und Pins für Servo
//
const int rotPin1 = 12; // rotes Blinklicht über Tor1 sw/we
const int torservoPin = 10; // Anschluß für den Servo Links/Rechts
const int lichtPin3 = 9; // via Darlington LED Strip (gelb) noch offen
const int lichtPin2 = 8; // Hallenlicht Nebenhalle LED Strip (grün)
const int lichtPin4 = 7; // via Darlington (noch offen) evtl rt Draht
const int lichtPin1 = 2; // Hallenlicht Haupthalle LED Strip (grün)
//
// Parameter Zeitabfragen
//
unsigned long previousMillis_Tor1 = 0; // Merke Zeitpunkt Änderung
unsigned long previousMillis_Rot1 = 0; // Merke Zeitpunkt Änderung
unsigned long previousMillis_Halle1 = 0; // Merke Zeitpunkt Änderung
unsigned long previousMillis_Halle2 = 0; // Merke Zeitpunkt Änderung
unsigned long wann_Halle1[2] = { 30000,40000} ; // Startabstand, Laufzeit Hallenlicht 1
unsigned long wann_Halle2[2] = {310000,51000} ; // Startabstand, Laufzeit Hallenlicht 2
unsigned long wann_Tor1[2] = {300000,300000} ; // Startabstand, Laufzeit Hallentor 1
unsigned long wann_Rot1 = 200 ; // rotes Blinklicht über Tor
//
// Parameter Blitzlich (noch offen)
//
const int blitzPin1 = 11; // Blitzlicht LED (lila) (noch offen)
unsigned long blitzStartenB1 = 0 ;
unsigned long previousMillisB1 = 0; // Merke Zeitpunkt Änderung
const long blitzDauerB1 = 20000 ; // noch offen
long blitzOffB1 = 2000; // noch offen
const int blitzZeitB1 = 20 ; // Länge Blitzlicht
unsigned long wann_Blitz = 500 ; // Blitzfrequenz
int blitzStateB1 = LOW; // Status Blitzlicht
//
// Parameter Tor und Hallenlicht
//
int status_Halle1 = 0 ; // Licht Halle 1 aus
int status_Halle2 = 0 ; // Licht Halle 2 aus
int status_Tor1 = 0 ; // Tor 1 zu
int ziel_Tor1 = 0 ; // 0 = zu, 170 = auf
//
Servo8 torServo; // Servo ansprechen
//
// Eggtimer noch offen
//
// EggTimer Pause; // Timer für Pausen zwischen den Servobewegungen
// byte schritt = 0; // Zustand Schrittkette
//
// Tastenfunktionen
//
int Taste_1 = A0; // Steuertaste 1 Eingang
int Taste_2 = A1; // Steuertaste 2 Eingang
int Taste_3 = A2; // Drucktaste Tor Eingang
int Tasten_Wert[3] = {0, 0,0} ; // speichert Werte für Taste_1 bis Taste_3
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 ;
int entprellzeit = 500 ; // Tastenprellen abwarten
int test_Taste1 = 0 ; // Tastenwert für Test 1, 0 = nichts, 1 = zu, 2 = auf
//
//
void setup() {
// Serial.begin(9600);
torServo.attach(torservoPin, true); //Servo an Pin 10
torServo.setSpeed( 3 ); // Verfahrgeschwindigkeit einstellen Links/Rechts
pinMode(Taste_1, INPUT_PULLUP) ; // noch nicht benutzt
pinMode(Taste_2, INPUT_PULLUP) ; // noch nicht benutzt
pinMode(Taste_3, INPUT_PULLUP) ; // Drucktaste Tor nur eine Taste angeschlossen
pinMode(lichtPin1, OUTPUT); // D02 Hallenlicht Haupthalle LED Strip (grün)
pinMode(lichtPin2, OUTPUT); // D08 Hallenlicht Nebenhalle LED Strip (grün)
pinMode(lichtPin3, OUTPUT) ; // D09 via Darlington LED Strip (gelb) noch offen
pinMode(lichtPin4, OUTPUT) ; // D07 via Darlington LED Strip (gelb) noch offen
pinMode( rotPin1, OUTPUT); // D12 rotes Blinklicht über Tor1
pinMode(blitzPin1, OUTPUT); // D11 LED via 1K noch offen
 
digitalWrite(rotPin1, HIGH) ; // Licht aus
digitalWrite(lichtPin1, HIGH) ; // Hallenlicht Haupthalle aus
digitalWrite(lichtPin2, HIGH) ; // Hallenlicht Nebenhalle aus
digitalWrite(lichtPin3, HIGH) ; // D09 via Darlington aus
digitalWrite(lichtPin4, HIGH) ; // D07 via Darlington aus
digitalWrite(blitzPin1, HIGH) ; // D11 LED aus
 
}
//
void loop() {
unsigned long currentMillis = millis(); // merke Zeitpunkt
//
// Torstatus abfragen
//
if (torServo.read()> 160) {
status_Tor1 = 0; // Tor 1 zu
}
if (torServo.read()< 10) {
status_Tor1 = 1; // Tor 1 auf
}
//
// Hallenlicht Haupthalle 1
//
if (currentMillis - previousMillis_Halle1 >= wann_Halle1[status_Halle1]) {
previousMillis_Halle1 = currentMillis; // merke Zeitpunkt
digitalWrite(lichtPin1, !digitalRead(lichtPin1)); // ändere Zustand
status_Halle1 = 1-status_Halle1; // ändere Status
// 0 = Licht Halle 1 aus
wann_Halle1[1] = random(40000,120000) ; // Laufzeit Hallenlicht 1
}
//
// Ende Licht Haupthalle
//
 
//
// Tor Halle 1 automatisch betätigen
//
if (currentMillis - previousMillis_Tor1 >= wann_Tor1[status_Tor1]) {
previousMillis_Tor1 = currentMillis; // merke Zeitpunkt
torServo.write(170 * status_Tor1); // 0 macht zu, 170 macht auf
}
//
// Ende Tor Haupthalle
//
if (torServo.moving()) { // Licht an wenn Tor 1 bewegt
digitalWrite(lichtPin1, HIGH); // Hallenlicht Haupthalle an
previousMillis_Halle1 = currentMillis;} // merke Zeitpunkt
//
//
// Hallenlicht Halle 2
//
if (currentMillis - previousMillis_Halle2 >= wann_Halle2[status_Halle2]) {
previousMillis_Halle2 = currentMillis; // merke Zeitpunkt
digitalWrite(lichtPin2, !digitalRead(lichtPin2)); // ändere an / aus
status_Halle2 = 1-status_Halle2; // setze Lichtstatus
} // Ende IF Licht Halle 2
//
// Testtaste (noch offen)
//
test_Taste1 = 0 ; // Tastenwert für Test
// 0 = nichts, 1 = zu, 2 = auf
test_Taste1 = druck_2_Taste(Taste_1) ; // fragt Wert der Taste ab noch offen
//
// Drucktaste Taste_3 für Tor 1 abfragen
//
if (druck_1_Taste(Taste_3)==1) // 1 = Taste gedrückt
{
torServo.write(170 * status_Tor1); // 0 macht zu, 170 macht auf
}
//
// Servo Loop Anfang ----------------------------------------
//
if (digitalRead(lichtPin3)) // noch offen
{
// irgendwas mit lichtPin3 machen
}
if (digitalRead(lichtPin4)) // noch offen
{
// irgendwas mit lichtPin4 machen
} // lichtPin4
//
//
// Hier können jetzt weitere Aktionen ausgeführt werden.
//
// Loop Blink LED Tor 1
//
if (currentMillis - previousMillis_Rot1 >= wann_Rot1)
{
previousMillis_Rot1 = currentMillis; // merke Zeitpunkt
if (torServo.moving())
{
digitalWrite(rotPin1, !digitalRead(rotPin1)); // Blinke wenn Tor bewegt
}
else
{
digitalWrite(rotPin1, LOW); // aus, wenn Tor steht
}
}
//
// Loop Blink Ende
//
// Blitzer noch offen
//
currentMillis = millis(); // Zeitpunkt abfragen
// ----------------Beginn jetztTBlitzen--------------------------------------
// Anschalten
if ((currentMillis - previousMillisB1 >= blitzOffB1) && !(torServo.moving()))
{
blitzStateB1 = !blitzStateB1; // an/aus wechseln
digitalWrite(blitzPin1, blitzStateB1); // Pin schalten
previousMillisB1 = currentMillis; // Zeitpunkt merken
blitzOffB1 = random(1000, 3000); // Zeitpunkt zufällig setzen
}
//
// Ende jetztBlitzen --------------------------------------------
//
 
} // Loop Ende
//
// Funktionen
//
// ----------------------------Tastenabfrage -----------------------------
//
// Drucktasten abfragen, zwei Tasten an Analogpin
//
int druck_2_Taste(int dieseTaste) // Fragt 2 Tasten ab
{
Tasten_Wert[dieseTaste-14] = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
delay (entprellzeit); // warte wegen Prellen
Tasten_Wert[dieseTaste-14] = analogRead(dieseTaste); // frag Taste noch einmal
if (Tasten_Wert[dieseTaste-14] < ohne_Drueck)
{
return 0; // keine Taste gedrückt
}
else if (Tasten_Wert[dieseTaste-14] > ohne_Drueck)
{
return 1; // Taste gedrückt
}
}
//
// Drucktaste abfragen, nur eine Taste an Analogpin
//
int druck_1_Taste(int dieseTaste) // Fragt 1 Taste ab
{
Tasten_Wert[dieseTaste-14] = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
delay (entprellzeit); // warte wegen Prellen
Tasten_Wert[dieseTaste-14] = analogRead(dieseTaste); // Lese Tastennummer von Analog Port
if (Tasten_Wert[dieseTaste-14] < 100)
{
return 1; // die Taste gedrückt
}
else if (Tasten_Wert[dieseTaste-14] > 1000)
{
return 0; // keine Taste gedrü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: 756
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 85
Xobor Einfach ein eigenes Forum erstellen
Datenschutz