Elektrik und Elektronik » 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.

#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.

#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 &lt;MobaTools.h&gt;
const int rotPin1       = 12;         // rotes Blinklicht &#252;ber Tor1 sw/we
const int blitzPin1     = 11;         // Blitzlicht LED (lila)
const int torservoPin   = 10;         // Anschlu&#223; f&#252;r den Servo Links/Rechts
const int lichtPin3     =  9;         //                        LED Strip (gelb)
const int lichtPin2     =  8;         // Hallenlicht Nebenhalle LED Strip (gr&#252;n)
const int torrelaisPin  =  7;         // via Darlington         (noch offen)
const int lichtPin1     =  2;         // Hallenlicht Haupthalle LED Strip (gr&#252;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&#228;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 &#252;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&#252;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&#252;r Tastenabfrage
int Taste_2_Wert = 0;     // Variable f&#252;r Tastenabfrage
int Druck_3_Wert = 0;     // Drucktaste
int entprellzeit = 1000 ;
int Tortaste1 = 0 ;       // Tastenwert f&#252;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()&gt; 160) {
      status_Tor1 = 0;
   }
   if (torServo.read()&lt; 10) {
      status_Tor1 = 1;
   } 
// Hallenlicht Haupthalle 1
 
      if (currentMillis - previousMillis_Halle1 &gt;= 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&#228;tigen
//
      if (currentMillis - previousMillis_Tor1 &gt;= 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 &gt;= 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&#246;nnen jetzt weitere Aktionen ausgef&#252;hrt werden.
//
// Loop Blink LED Tor 1
//
if (currentMillis - previousMillis_Rot1 &gt;= 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 &gt;= blitzOffB1) &amp;&amp; !(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 &gt; 410 &amp;&amp; Taste_1_Wert &lt; 640)      {return 0; }
  else if (Taste_1_Wert &gt; 300 &amp;&amp; Taste_1_Wert &lt; 400) {return 1; }
  else if (Taste_1_Wert &gt; 650 &amp;&amp; Taste_1_Wert &lt; 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 &lt; 100)       {return 1; }
  else if (Druck_3_Wert &gt; 1000) {return 0; }
}
//
 
 

#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 &lt;MobaTools.h&gt;
//
// LED und Pins f&#252;r Servo
//
const int rotPin1       = 12;                               // rotes Blinklicht &#252;ber Tor1 sw/we
const int torservoPin   = 10;                               // Anschlu&#223; f&#252;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&#252;n)
const int lichtPin4     =  7;                               // via Darlington         (noch offen) evtl rt Draht 
const int lichtPin1     =  2;                               // Hallenlicht Haupthalle LED Strip (gr&#252;n)
//
// Parameter Zeitabfragen
//
unsigned long previousMillis_Tor1   = 0;                    // Merke Zeitpunkt &#196;nderung
unsigned long previousMillis_Rot1   = 0;                    // Merke Zeitpunkt &#196;nderung
unsigned long previousMillis_Halle1 = 0;                    // Merke Zeitpunkt &#196;nderung
unsigned long previousMillis_Halle2 = 0;                    // Merke Zeitpunkt &#196;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 &#252;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 &#196;nderung
const long    blitzDauerB1       = 20000 ;                  // noch offen
long          blitzOffB1         = 2000;                    // noch offen
const int     blitzZeitB1        = 20 ;                     // L&#228;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&#252;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&#252;r Taste_1 bis Taste_3
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 ;
int entprellzeit         = 500 ;                            // Tastenprellen abwarten
int test_Taste1            = 0 ;                            // Tastenwert f&#252;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&#252;n)
   pinMode(lichtPin2, OUTPUT);                              // D08 Hallenlicht Nebenhalle LED Strip (gr&#252;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 &#252;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()&gt; 160) {
      status_Tor1 = 0;                                      // Tor 1 zu
   }
   if (torServo.read()&lt; 10) {
      status_Tor1 = 1;                                      // Tor 1 auf
   } 
//
// Hallenlicht Haupthalle 1
//
      if (currentMillis - previousMillis_Halle1 &gt;= wann_Halle1[status_Halle1]) {
         previousMillis_Halle1 = currentMillis;             // merke Zeitpunkt
         digitalWrite(lichtPin1, !digitalRead(lichtPin1));  // &#228;ndere Zustand
         status_Halle1 = 1-status_Halle1;                   // &#228;ndere Status
                                                            // 0 = Licht Halle 1 aus
         wann_Halle1[1] = random(40000,120000) ;            // Laufzeit Hallenlicht 1                                                    
      }         
//
// Ende Licht Haupthalle
//
 
//
// Tor Halle 1 automatisch bet&#228;tigen
//
      if (currentMillis - previousMillis_Tor1 &gt;= 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 &gt;= wann_Halle2[status_Halle2]) {
      previousMillis_Halle2 = currentMillis;               // merke Zeitpunkt
      digitalWrite(lichtPin2, !digitalRead(lichtPin2));    // &#228;ndere an / aus
      status_Halle2 = 1-status_Halle2;                     // setze Lichtstatus
   }                                                       // Ende IF Licht Halle 2
//
// Testtaste (noch offen)
//
  test_Taste1 = 0 ;                                        // Tastenwert f&#252;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&#252;r Tor 1 abfragen
//
   if (druck_1_Taste(Taste_3)==1)                          // 1 = Taste gedr&#252;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&#246;nnen jetzt weitere Aktionen ausgef&#252;hrt werden.
//
// Loop Blink LED Tor 1
//
if (currentMillis - previousMillis_Rot1 &gt;= 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 &gt;= blitzOffB1) &amp;&amp; !(torServo.moving())) 
      {
         blitzStateB1 = !blitzStateB1;                     // an/aus wechseln
         digitalWrite(blitzPin1, blitzStateB1);            // Pin schalten
         previousMillisB1 = currentMillis;                 // Zeitpunkt merken
         blitzOffB1 = random(1000, 3000);                  // Zeitpunkt zuf&#228;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] &lt; ohne_Drueck)
    {
      return 0;                                            // keine Taste gedr&#252;ckt
    }
  else if (Tasten_Wert[dieseTaste-14] &gt; ohne_Drueck)
    {
      return 1;                                            // Taste gedr&#252;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] &lt; 100)       
    {
      return 1;                                            // die Taste gedr&#252;ckt
    }
  else if (Tasten_Wert[dieseTaste-14] &gt; 1000) 
    {
      return 0;                                            // keine Taste gedr&#252;ckt
    }
  }
// --------------------------------------------------------------------------------
 
 

#5 von Running.Wolf , 20.01.2022 20:15

Moin

Bei einem anderen Schuppen klappte diese Mechanik aus Platzgründen nicht. Da mussten Steppermotoren ran.

RE: Arduino: Licht und Action (2)

Beiträge:	1.038
Registriert am:	15.01.2006
Homepage:	Link
Ort:	Isernhagen
Gleise	C-Gleis / M-Gleis
Spurweite	H0
Steuerung	CS 2
Stromart	Digital

Beiträge:	1.038
Registriert am:	15.01.2006
Homepage:	Link
Ort:	Isernhagen
Gleise	C-Gleis / M-Gleis
Spurweite	H0
Steuerung	CS 2
Stromart	Digital

Beiträge:	1.038
Registriert am:	15.01.2006
Homepage:	Link
Ort:	Isernhagen
Gleise	C-Gleis / M-Gleis
Spurweite	H0
Steuerung	CS 2
Stromart	Digital

Beiträge:	1.038
Registriert am:	15.01.2006
Homepage:	Link
Ort:	Isernhagen
Gleise	C-Gleis / M-Gleis
Spurweite	H0
Steuerung	CS 2
Stromart	Digital

Beiträge:	1.038
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

RE: Arduino: Lokschuppen und 3D

RE: Arduino: Lokschuppen und 3D

RE: Arduino: Lokschuppen und 3D

RE: Arduino: Lokschuppen und 3D

Bitte geben Sie einen Grund für die Verwarnung an