Automated Door for Chicken Coop

Hatch automatically opens and closes depending on light and time. After 2 years in use also some ideas what I would do differently.

Oct 1, 2022

•

898 views

•

2 respects

environmental sensing

animals

remote control

Components and supplies

Real Time Clock (RTC)

Infrared Receiver, Remote Control

DC motor (generic)

Arduino UNO

Limit Switch, 5 A

Breadboard (generic)

Photo resistor

Resistor 10k ohm

RGB LCD Shield Kit, 16x2 Character Display

Relay (generic)

Project description

Code

sfr_ChickenManII.ino

arduino

Sorry, comments are in German

1/* Steuerung fr motorisierte Hhnerklappe ber Lichtsensor
2 *  Material:
3  *  Arduino Uno mit Protyping Board
4 *  Lichtsensor
5 *  IR Receiver
6 *  Fernbedienung
7  *  2 Relais
8 *  16x2 LCD
9 *  2 Endlagenschalter
10 *  Real Time Clock
11  *  Scheibewischermotor mit montierter Rolle
12 *  Zustzliches 12V Netzteil
13  */
14
15
16/***************************
17 * 
18 *  ANLEITUNG FR DIE HHNERKLAPPE
19  * 
20 *  Im AUTO Modus ffnet die Klappe sich morgens um 9.00 und fhrt Abends bei  Dunkelheit herunter.
21 *  Im manuellen Modus kann die Klappe mit den Tasten <<<  und >>> schrittweise bewegt werden, und bleibt in der Position.
22 * 
23 *  >|  - Schaltet um zwischen AUTO Modus und manuellem Modus
24 *  <<< - Fhrt im manuellen  Modus die Klappe einen Schritt herunter  
25 *  >>> - Fhrt im manuellen Modus die  Klappe einen Schritt hoch
26 *  +   - Schaltet die Hintergrundbeleuchtung ein
27  *  -   - Schaltet die Hintergrundbeleuchtung aus
28 *   
29 *  Achtung: Beim Umschalten  von manuellem in AUTO-Modus muss die Klappe zuvor wieder in die richtige Position  gebracht werden (tagsber auf, nachts unten). 
30 *  
31 */
32
33
34
35// Klappe  & Motor
36
37int statusKlappe = 2;   // 1= down, 2 = up, d.h. der Initialstatus  der Klappe ist oben, 
38                        // wenn das Gert einschaltet. Klappe  sollte oben sein, oder 
39                        // manuell da hin gefahren werden
40#define  CW 8            // CW auf LOW fhrt die Klappe runter
41#define CCW 9           //  CCW auf LOW fhrt die Klappe hoch
42#define lift 4000        // Manuelle Hebezeit  in millisekunden (War mal auf kleine 500er 
43                         // Schritte  eingestellt, aber mit den Endlagenschaltern ist das nicht mehr ntig
44#define liftUp  4000     // Automatische Hebezeit
45#define liftDown 3000   // Automatische Senkzeit
46
47
48#define  endDownPin 6
49#define endUpPin 7
50unsigned long motorCounter = millis();
51
52//  COM an 5V, NC an PIN & GND via 10KOhm = HIGH wenn Taster nicht gedrckt, LOW wenn  gedrckt
53// Zum Simulieren des nicht gedrckten Tasters drhte Kurzschlieen
54
55
56
57//  Buttons & Modes
58
59int modeAuto = 1;     // 0=Auto, 1= Manual
60int button  = 0;       // Status der IR RC Knpfe
61#define threshold 35  // Schwellenwert fr  den Auto-Mode wird festgelegt.
62#define unlockTime 8    // Die Automatik ffnet  die Klappe nur, wenn Uhrzeit erreich ist
63
64// Light Sensor
65
66int sensorPin  = A0;
67int sensorValue = 0;
68int sensorAvg1;
69int sensorAvg2;
70int sensorAvg3;
71int  sensorAvg;
72unsigned long counterStart = millis();
73int pass = 1;
74
75//  Remote
76
77#include <IRremote.h>
78int RECV_PIN = 11;
79IRrecv irrecv(RECV_PIN);
80decode_results  results;
81
82// Display
83#include <Wire.h>
84#include <LiquidCrystal_I2C.h>
85#include  <LCD.h>
86LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);
87
88// Clock
89#include  "RTClib.h"
90RTC_DS3231 rtc;
91char daysOfTheWeek[7][12] = {"Sunday", "Monday",  "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
92
93
94
95char  buffer[30];
96
97/*---------------------------------------------------------------------------------------------------------*/
98  
99void setup() {
100
101// Only for Testing: Remove for Production
102// Serial.begin(9600);
103
104
105//  Display initial beschreiben
106
107  lcd.begin(16,2);
108  lcd.clear();
109  lcd.setCursor(0,0);
110  lcd.print("L: ");
111  lcd.setCursor(0,1);
112  lcd.print("M:");
113  lcd.setCursor(2,1);
114  lcd.print("Mn");
115  lcd.setCursor(6,1);
116  lcd.print("D:");
117  lcd.setCursor(8,1);
118  lcd.print ("Mn");  
119
120  // Remote einschalten
121 
122  irrecv.enableIRIn();  
123
124  // Motor und Endlagen PINs zuweisen
125
126  pinMode(CW, OUTPUT); //Set  CW as an output//
127  pinMode(CCW, OUTPUT); //Set CCW as an output// 
128 
129  digitalWrite(CW, HIGH); //Motor stops// 
130  digitalWrite(CCW, HIGH); //Motor  stops// 
131  
132  pinMode(endDownPin, INPUT); // Endlagenschalter fr unten
133  pinMode(endUpPin, INPUT); // Endlagenschalterfr oben
134  
135
136// Initiate  RTC
137
138 if (! rtc.begin()) {
139     lcd.setCursor(0,1);
140    lcd.print("Couldn't  find RTC");
141    while (1);
142  }
143
144
145  if (rtc.lostPower()) {
146    lcd.setCursor(0,1);
147    lcd.print("RTC lost power!");
148    // following line sets the RTC to the  date & time this sketch was compiled
149    // rtc.adjust(DateTime(F(__DATE__),  F(__TIME__)));
150    // This line sets the RTC with an explicit date & time, for  example to set
151  //   rtc.adjust(DateTime(2020, 8, 1, 14, 30, 0));
152  }
153
154  // Uhr stellen
155  // rtc.adjust(DateTime(2020, 4, 20, 17, 18, 0));
156  // Uhr  beim kompilieren stellen
157  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
158  
159  DateTime now = rtc.now();
160
161}
162
163/* --------------------------------------------------------------------------------------*/
164          
165void loop() {
166
167// Lesen des Lichtsensors und schreiben des Ergebnisses
168
169sensorValue  = analogRead(sensorPin);
170lcd.setCursor(2,0);
171sprintf(buffer,"%04d", sensorValue);
172lcd.print(buffer);
173
174//  Display Clock 
175
176  DateTime now = rtc.now();
177
178  lcd.setCursor(11,12);
179  sprintf(buffer,"%02d",now.hour());
180  lcd.print(buffer);
181  lcd.print(":");
182  sprintf(buffer,"%02d",now.minute());
183  lcd.print(buffer);
184
185
186
187
188//  Lesen und bersetzen der IR Fernbedienung
189
190  if (irrecv.decode(&results))          //Wenn  ein IR-Signal erkannt wurde,
191  {
192      if (results.value == 16720605)  {               //  Wenn der Schalter <<< gedrckt wurde
193        button = 1;
194        if (modeAuto  == 1) {                           // uns der Modus "manuell" ist         
195          motorCounter = millis();                     // Motorzhler auf jetzt.
196          
197          while ((millis()-motorCounter < lift) && (digitalRead(endDownPin)  == HIGH)){  // Solange die Zeit "lift" nicht erreicht                                                                          
198            digitalWrite(CW,LOW);                                                   //  und der Endlagenschalter nicht gedrckt ist.
199          }                                                                         //  fhrt die Klappe runter
200          digitalWrite(CW, HIGH);                                                   //  und schaltet wieder ab.  
201          
202        }            
203      }
204      else if (results.value == 16712445)  {            // Wenn der Schalter >>>  gedrckt wurde
205        button = 2;
206        // statusKlappe=0;
207        if  (modeAuto == 1) {                            // uns der Modus "manuell" ist
208          motorCounter = millis();                                      
209          while  ((millis()-motorCounter < lift) && (digitalRead(endUpPin) == HIGH )){                 
210            digitalWrite(CCW,LOW);                         
211          }                                           
212          digitalWrite(CCW, HIGH);                       
213        }    
214      }
215      else if (results.value == 16761405)  {            // Wenn der "Modus" Knopf  >|| gedrckt wurde schalte den Modus um
216        button = 3;
217        // statusKlappe=0;
218        if (modeAuto == 0) {
219          modeAuto= 1;
220          lcd.setCursor(2,1);
221          lcd.print("Mn  ");
222        }
223        else if (modeAuto == 1) {
224          modeAuto=0;
225          lcd.setCursor(2,1);
226          lcd.print("Au  ");
227          if (now.hour() < unlockTime) { // Wenn die unlockTime nicht  erreicht ist, wird ein Sternchen angezeigt
228            lcd.setCursor(4,1);            
229            lcd.print ("*");  
230          }
231          if (statusKlappe ==  1) {
232            lcd.setCursor(8,1);
233            lcd.print ("Dn");  
234          }
235          else if (statusKlappe == 2) {
236            lcd.setCursor(8,1);
237            lcd.print ("Up  ");  
238          }
239        }  
240      }
241      else if (results.value == 16769055)  {            // Knopf - schaltet Backlight  ab
242        button = 4;
243        lcd.noBacklight();
244      }
245      else  if (results.value == 16754775)  {            // Knopf + schaltet Backlight an
246        button = 5;
247        lcd.backlight();
248      }
249      else {
250        button  =0;
251      }
252
253    irrecv.resume();
254  }
255  else
256     {
257      button  =0;
258     }
259
260
261
262// Drei Messdurchgnge werden durchgefhrt
263
264  if  (millis() - counterStart >= 3000) {
265    
266       counterStart = millis();
267       lcd.setCursor(12,0);
268       lcd.print("P:");
269       lcd.print (pass);
270  //      sensorAvg[pass] = sensorValue; // Sensorwert wird in Array geschrieben
271      if (pass == 1) {
272        sensorAvg1 = sensorValue;
273      }
274      else  if (pass == 2) {
275        sensorAvg2 = sensorValue;
276      }
277      else if  (pass == 3) {
278        sensorAvg3 = sensorValue;
279      }
280
281       // Hochzhlen  bis 3 
282
283
284       
285       if (pass < 3) { 
286        pass++;
287       }
288
289      // Beim dritten Durchgang wird der Klappenstatus gesetzt.
290       
291       else  {
292
293        sensorAvg = (sensorAvg1 + sensorAvg2 + sensorAvg3)/3; 
294        lcd.setCursor(7,0);
295        sprintf(buffer,"%04d", sensorAvg);
296        lcd.print(buffer);
297
298//  Wenn es dunkel ist und die Klappe oben, dann fhrt sie runter
299
300        if ((modeAuto  == 0) && (sensorAvg < threshold) && (statusKlappe == 2)) { 
301          statusKlappe=1;   
302          
303          motorCounter = millis();                                                  //  Motorzhler auf jetzt.
304          while ((millis()- motorCounter < liftDown) &&  (digitalRead(endDownPin) == HIGH )){  // Solange die Zeit "lift" nicht erreicht  
305            digitalWrite(CW,LOW);                 
306          } 
307          digitalWrite(CW,  HIGH);                     // und schaltet wieder ab        
308        }
309
310//  Wenn es vor Unlocktime ist und die Klappe oben, dann fhrt sie runter
311
312        else  if ((modeAuto == 0) && (now.hour() < unlockTime) && (statusKlappe == 2) ) { 
313          statusKlappe=1;   
314          
315          motorCounter = millis();                                                      // Motorzhler auf jetzt.
316          while ((millis()-motorCounter < liftDown) && (digitalRead(endDownPin)  == HIGH )){  // Solange die Zeit "lift" nicht erreicht           
317            digitalWrite(CW,LOW);                         
318          }
319          digitalWrite(CW, HIGH);                            
320        }
321
322// Wenn es hell ist und die Klappen unten und die Unlcktime erreicht,  fhrt sie hoch
323        
324        else if ((modeAuto == 0) && (sensorAvg >= threshold)  && (statusKlappe == 1) && (now.hour() >= unlockTime)) {
325          statusKlappe=2;
326          motorCounter = millis();                                                      //  Motorzhler auf jetzt.
327          while ((millis()-motorCounter < liftUp) && (digitalRead(endUpPin)  == HIGH )){  // Solange die Zeit "lift" nicht erreicht             
328            digitalWrite(CCW,LOW);                        // Relais schaltet 
329          }
330          digitalWrite(CCW,  HIGH);                      // und schaltet wieder ab          
331        }
332
333        pass =1;
334       }
335  }
336
337
338// Status korrekt schreiben
339
340if  (modeAuto == 1) {
341  lcd.setCursor(8,1);
342  lcd.print ("Mn");  
343}
344else  if (statusKlappe == 1) {
345  lcd.setCursor(8,1);
346  lcd.print ("Dn");  
347}
348else  if (statusKlappe == 2) {
349  lcd.setCursor(8,1);
350  lcd.print ("Up");  
351}
352
353}
354

/* Steuerung fr motorisierte Hhnerklappe ber Lichtsensor
 *  Material:
  *  Arduino Uno mit Protyping Board
 *  Lichtsensor
 *  IR Receiver
 *  Fernbedienung
  *  2 Relais
 *  16x2 LCD
 *  2 Endlagenschalter
 *  Real Time Clock
  *  Scheibewischermotor mit montierter Rolle
 *  Zustzliches 12V Netzteil
  */


/***************************
 * 
 *  ANLEITUNG FR DIE HHNERKLAPPE
  * 
 *  Im AUTO Modus ffnet die Klappe sich morgens um 9.00 und fhrt Abends bei  Dunkelheit herunter.
 *  Im manuellen Modus kann die Klappe mit den Tasten <<<  und >>> schrittweise bewegt werden, und bleibt in der Position.
 * 
 *  >|  - Schaltet um zwischen AUTO Modus und manuellem Modus
 *  <<< - Fhrt im manuellen  Modus die Klappe einen Schritt herunter  
 *  >>> - Fhrt im manuellen Modus die  Klappe einen Schritt hoch
 *  +   - Schaltet die Hintergrundbeleuchtung ein
  *  -   - Schaltet die Hintergrundbeleuchtung aus
 *   
 *  Achtung: Beim Umschalten  von manuellem in AUTO-Modus muss die Klappe zuvor wieder in die richtige Position  gebracht werden (tagsber auf, nachts unten). 
 *  
 */



// Klappe  & Motor

int statusKlappe = 2;   // 1= down, 2 = up, d.h. der Initialstatus  der Klappe ist oben, 
                        // wenn das Gert einschaltet. Klappe  sollte oben sein, oder 
                        // manuell da hin gefahren werden
#define  CW 8            // CW auf LOW fhrt die Klappe runter
#define CCW 9           //  CCW auf LOW fhrt die Klappe hoch
#define lift 4000        // Manuelle Hebezeit  in millisekunden (War mal auf kleine 500er 
                         // Schritte  eingestellt, aber mit den Endlagenschaltern ist das nicht mehr ntig
#define liftUp  4000     // Automatische Hebezeit
#define liftDown 3000   // Automatische Senkzeit


#define  endDownPin 6
#define endUpPin 7
unsigned long motorCounter = millis();

//  COM an 5V, NC an PIN & GND via 10KOhm = HIGH wenn Taster nicht gedrckt, LOW wenn  gedrckt
// Zum Simulieren des nicht gedrckten Tasters drhte Kurzschlieen



//  Buttons & Modes

int modeAuto = 1;     // 0=Auto, 1= Manual
int button  = 0;       // Status der IR RC Knpfe
#define threshold 35  // Schwellenwert fr  den Auto-Mode wird festgelegt.
#define unlockTime 8    // Die Automatik ffnet  die Klappe nur, wenn Uhrzeit erreich ist

// Light Sensor

int sensorPin  = A0;
int sensorValue = 0;
int sensorAvg1;
int sensorAvg2;
int sensorAvg3;
int  sensorAvg;
unsigned long counterStart = millis();
int pass = 1;

//  Remote

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results  results;

// Display
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include  <LCD.h>
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);

// Clock
#include  "RTClib.h"
RTC_DS3231 rtc;
char daysOfTheWeek[7][12] = {"Sunday", "Monday",  "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};



char  buffer[30];

/*---------------------------------------------------------------------------------------------------------*/
  
void setup() {

// Only for Testing: Remove for Production
// Serial.begin(9600);


//  Display initial beschreiben

  lcd.begin(16,2);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("L: ");
  lcd.setCursor(0,1);
  lcd.print("M:");
  lcd.setCursor(2,1);
  lcd.print("Mn");
  lcd.setCursor(6,1);
  lcd.print("D:");
  lcd.setCursor(8,1);
  lcd.print ("Mn");  

  // Remote einschalten
 
  irrecv.enableIRIn();  

  // Motor und Endlagen PINs zuweisen

  pinMode(CW, OUTPUT); //Set  CW as an output//
  pinMode(CCW, OUTPUT); //Set CCW as an output// 
 
  digitalWrite(CW, HIGH); //Motor stops// 
  digitalWrite(CCW, HIGH); //Motor  stops// 
  
  pinMode(endDownPin, INPUT); // Endlagenschalter fr unten
  pinMode(endUpPin, INPUT); // Endlagenschalterfr oben
  

// Initiate  RTC

 if (! rtc.begin()) {
     lcd.setCursor(0,1);
    lcd.print("Couldn't  find RTC");
    while (1);
  }


  if (rtc.lostPower()) {
    lcd.setCursor(0,1);
    lcd.print("RTC lost power!");
    // following line sets the RTC to the  date & time this sketch was compiled
    // rtc.adjust(DateTime(F(__DATE__),  F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for  example to set
  //   rtc.adjust(DateTime(2020, 8, 1, 14, 30, 0));
  }

  // Uhr stellen
  // rtc.adjust(DateTime(2020, 4, 20, 17, 18, 0));
  // Uhr  beim kompilieren stellen
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  
  DateTime now = rtc.now();

}

/* --------------------------------------------------------------------------------------*/
          
void loop() {

// Lesen des Lichtsensors und schreiben des Ergebnisses

sensorValue  = analogRead(sensorPin);
lcd.setCursor(2,0);
sprintf(buffer,"%04d", sensorValue);
lcd.print(buffer);

//  Display Clock 

  DateTime now = rtc.now();

  lcd.setCursor(11,12);
  sprintf(buffer,"%02d",now.hour());
  lcd.print(buffer);
  lcd.print(":");
  sprintf(buffer,"%02d",now.minute());
  lcd.print(buffer);




//  Lesen und bersetzen der IR Fernbedienung

  if (irrecv.decode(&results))          //Wenn  ein IR-Signal erkannt wurde,
  {
      if (results.value == 16720605)  {               //  Wenn der Schalter <<< gedrckt wurde
        button = 1;
        if (modeAuto  == 1) {                           // uns der Modus "manuell" ist         
          motorCounter = millis();                     // Motorzhler auf jetzt.
          
          while ((millis()-motorCounter < lift) && (digitalRead(endDownPin)  == HIGH)){  // Solange die Zeit "lift" nicht erreicht                                                                          
            digitalWrite(CW,LOW);                                                   //  und der Endlagenschalter nicht gedrckt ist.
          }                                                                         //  fhrt die Klappe runter
          digitalWrite(CW, HIGH);                                                   //  und schaltet wieder ab.  
          
        }            
      }
      else if (results.value == 16712445)  {            // Wenn der Schalter >>>  gedrckt wurde
        button = 2;
        // statusKlappe=0;
        if  (modeAuto == 1) {                            // uns der Modus "manuell" ist
          motorCounter = millis();                                      
          while  ((millis()-motorCounter < lift) && (digitalRead(endUpPin) == HIGH )){                 
            digitalWrite(CCW,LOW);                         
          }                                           
          digitalWrite(CCW, HIGH);                       
        }    
      }
      else if (results.value == 16761405)  {            // Wenn der "Modus" Knopf  >|| gedrckt wurde schalte den Modus um
        button = 3;
        // statusKlappe=0;
        if (modeAuto == 0) {
          modeAuto= 1;
          lcd.setCursor(2,1);
          lcd.print("Mn  ");
        }
        else if (modeAuto == 1) {
          modeAuto=0;
          lcd.setCursor(2,1);
          lcd.print("Au  ");
          if (now.hour() < unlockTime) { // Wenn die unlockTime nicht  erreicht ist, wird ein Sternchen angezeigt
            lcd.setCursor(4,1);            
            lcd.print ("*");  
          }
          if (statusKlappe ==  1) {
            lcd.setCursor(8,1);
            lcd.print ("Dn");  
          }
          else if (statusKlappe == 2) {
            lcd.setCursor(8,1);
            lcd.print ("Up  ");  
          }
        }  
      }
      else if (results.value == 16769055)  {            // Knopf - schaltet Backlight  ab
        button = 4;
        lcd.noBacklight();
      }
      else  if (results.value == 16754775)  {            // Knopf + schaltet Backlight an
        button = 5;
        lcd.backlight();
      }
      else {
        button  =0;
      }

    irrecv.resume();
  }
  else
     {
      button  =0;
     }



// Drei Messdurchgnge werden durchgefhrt

  if  (millis() - counterStart >= 3000) {
    
       counterStart = millis();
       lcd.setCursor(12,0);
       lcd.print("P:");
       lcd.print (pass);
  //      sensorAvg[pass] = sensorValue; // Sensorwert wird in Array geschrieben
      if (pass == 1) {
        sensorAvg1 = sensorValue;
      }
      else  if (pass == 2) {
        sensorAvg2 = sensorValue;
      }
      else if  (pass == 3) {
        sensorAvg3 = sensorValue;
      }

       // Hochzhlen  bis 3 


       
       if (pass < 3) { 
        pass++;
       }

      // Beim dritten Durchgang wird der Klappenstatus gesetzt.
       
       else  {

        sensorAvg = (sensorAvg1 + sensorAvg2 + sensorAvg3)/3; 
        lcd.setCursor(7,0);
        sprintf(buffer,"%04d", sensorAvg);
        lcd.print(buffer);

//  Wenn es dunkel ist und die Klappe oben, dann fhrt sie runter

        if ((modeAuto  == 0) && (sensorAvg < threshold) && (statusKlappe == 2)) { 
          statusKlappe=1;   
          
          motorCounter = millis();                                                  //  Motorzhler auf jetzt.
          while ((millis()- motorCounter < liftDown) &&  (digitalRead(endDownPin) == HIGH )){  // Solange die Zeit "lift" nicht erreicht  
            digitalWrite(CW,LOW);                 
          } 
          digitalWrite(CW,  HIGH);                     // und schaltet wieder ab        
        }

//  Wenn es vor Unlocktime ist und die Klappe oben, dann fhrt sie runter

        else  if ((modeAuto == 0) && (now.hour() < unlockTime) && (statusKlappe == 2) ) { 
          statusKlappe=1;   
          
          motorCounter = millis();                                                      // Motorzhler auf jetzt.
          while ((millis()-motorCounter < liftDown) && (digitalRead(endDownPin)  == HIGH )){  // Solange die Zeit "lift" nicht erreicht           
            digitalWrite(CW,LOW);                         
          }
          digitalWrite(CW, HIGH);                            
        }

// Wenn es hell ist und die Klappen unten und die Unlcktime erreicht,  fhrt sie hoch
        
        else if ((modeAuto == 0) && (sensorAvg >= threshold)  && (statusKlappe == 1) && (now.hour() >= unlockTime)) {
          statusKlappe=2;
          motorCounter = millis();                                                      //  Motorzhler auf jetzt.
          while ((millis()-motorCounter < liftUp) && (digitalRead(endUpPin)  == HIGH )){  // Solange die Zeit "lift" nicht erreicht             
            digitalWrite(CCW,LOW);                        // Relais schaltet 
          }
          digitalWrite(CCW,  HIGH);                      // und schaltet wieder ab          
        }

        pass =1;
       }
  }


// Status korrekt schreiben

if  (modeAuto == 1) {
  lcd.setCursor(8,1);
  lcd.print ("Mn");  
}
else  if (statusKlappe == 1) {
  lcd.setCursor(8,1);
  lcd.print ("Dn");  
}
else  if (statusKlappe == 2) {
  lcd.setCursor(8,1);
  lcd.print ("Up");  
}

}

Downloadable files

Schematic

Comments

Only logged in users can leave comments

hobooeconomicus

0 Followers

•

0 Projects

Intro