Garage door controller

Garage door controller dead? No worries just go with Arduino.

Oct 17, 2021

•

2221 views

•

0 respects

•

Components and supplies

Relay Module (Generic)

1N4007 – High Voltage, High Current Rated Diode

Arduino UNO

Power MOSFET N-Channel

Tools and machines

Soldering iron (generic)

Mastech MS8217 Autorange Digital Multimeter

Apps and platforms

Arduino IDE

Project description

Code

Garage door controller code

arduino

1
2#include <EEPROM.h>  
3
4int pinI1=5;      // PIN D5 MOTOR UP
5int
6  pinI2=7;     // PIN D7 MOTOR DOWN
7int speedpinA=6;  // PIN D6 PWM
8
9//const
10  int relay_pin=4;
11
12int pwm=150;
13volatile int steps = 0;   // Pulses from
14  Hall Effect sensors
15
16
17const int pinH1=2;      // PIN D2 HALL sensor signal
18
19const
20  int remote_input = 3;     // PIN D3 Remote signal 
21const int init_button = 4;
22      // PIN D4 Door init button
23const int LONG_PRESS_TIME = 2000;
24
25//
26  Variables will change:
27int lastState = HIGH;  // the previous state from the
28  input pin
29int currentState;     // the current reading from the input pin
30unsigned
31  long pressedTime  = 0;
32bool isPressing = false;
33bool isLongDetected = false;
34
35int
36  RemotebuttonState = 0; 
37//int InitbuttonState = 0;  
38
39int door_status =
40  0;          //Door open/closed position 0-closed 1-open 2-interrupted
41int door_position
42  = 0;
43int prev_door_pos = 0;
44bool active = 0;              //Active command
45  check
46int door_open_pos = 0;      //Hall memory of open position
47const int
48  door_closed_pos = 0;      //Closed position default
49int last_dir = 0;             //
50  Last direction of movement 0-up 1-down  
51
52  
53volatile unsigned long  prevTimer
54  = 0;
55
56bool initialized = 0;
57bool alarm = 0;
58int alarm_count=0;
59
60
61void
62  setup() {
63  // put your setup code here, to run once:
64  pinMode(pinI1,OUTPUT);
65  
66  pinMode(pinI2,OUTPUT); 
67  pinMode(speedpinA,OUTPUT); 
68  
69  digitalWrite(pinI1,HIGH);
70  
71  digitalWrite(pinI2,HIGH);
72
73  delay(2000);
74
75
76//  pinMode(relay_pin,OUTPUT);
77
78  
79 
80
81  Serial.begin(9600);
82
83  pinMode(remote_input,INPUT);
84  pinMode(init_button,INPUT_PULLUP);
85
86
87  pinMode(pinH1,INPUT_PULLUP);
88  attachInterrupt(digitalPinToInterrupt(pinH1),
89  countSteps, CHANGE); // HALL sensor interrupt init
90
91
92//EEPROM.write(0,
93  100);
94door_open_pos = EEPROM.read(0);
95// door_closed_pos = EEPROM.read(1);
96
97  
98
99
100/* INIT SEQUENCE */
101
102Serial.print("Door open position set:
103  ");
104Serial.println(door_open_pos);
105Serial.print("Door closed position set:
106  ");
107Serial.println(door_closed_pos);
108Serial.print("Door initialized: ");
109Serial.println(initialized);
110
111
112delay(1000);
113//digitalWrite(relay_pin,
114  HIGH);
115
116  
117  }
118
119void loop() {
120
121  
122  RemotebuttonState =
123  digitalRead(remote_input);                // wait for remote signal or button press
124
125  currentState = digitalRead(init_button);                // wait for remote signal
126  or button press
127
128  
129  if (RemotebuttonState == HIGH && initialized==1)
130              // if remote signal goes HIGH & door is initialized
131  {
132  Serial.println("Remote
133  sigal");
134  Serial.println (active);
135  
136    if (active == 0)                                      //
137  if NO command is active
138      { 
139      switch (door_status)                         
140
141        {
142        case 0:                                           // case  door
143  stautus is closed
144        Serial.println("Door opening");  
145        active=1;
146                                         // set active flag
147        last_dir
148  = 0;                                     // Set last dir of movement UP
149        open();
150                                           // open COMMAND
151        break;
152
153        
154        case 1:                                           // case  door
155  stautus is open
156        Serial.println("Door closing");  
157        active=1;
158  
159        last_dir = 1;                                     
160        close();
161                                       
162        break;
163
164        case 2:
165                                           // case  door stautus is stopped inbetween
166
167        Serial.println("Door resume");  
168        active=1;  
169        if
170  (last_dir == 1){                                     
171          
172          close();
173  
174        }
175        else{
176          
177          open(); 
178        }
179
180        
181        break;
182        }      
183      }
184   }
185    
186  else
187  if (currentState == LOW && initialized == 0){    // Init button long press routine
188
189          
190          Serial.println("Door initialization");
191          active=1;
192
193          initialize_door();
194  }        
195          
196          
197          
198
199          
200//          Serial.println("A press is detected");
201//
202//    pressedTime
203  = millis();
204//    isPressing = true;
205//    isLongDetected = false;
206//    }
207//
208  else if (currentState == HIGH){ 
209//    isPressing = false;
210//    }
211//
212//
213  
214//  if(isPressing == true && isLongDetected == false) {
215//    long pressDuration
216  = millis() - pressedTime;
217//
218//    if( pressDuration > LONG_PRESS_TIME ) {
219//
220      Serial.println("A long press is detected");
221//      isLongDetected =
222  true;
223//      
224      
225
226      
227    
228
229  
230}
231    
232
233
234void
235  open()       // Drive door UP
236{
237  prevTimer = millis();
238  door_status=2;
239
240  analogWrite(speedpinA,pwm); 
241  digitalWrite(pinI2,LOW); 
242  digitalWrite(pinI1,HIGH);
243
244  
245  while(active == 1){
246  
247   if(millis() - prevTimer > 100){                    //
248  Update the Position every 1/10 seconds
249        
250        updatePosition();
251
252        prevTimer = millis();
253      
254       
255        if (door_position
256  >= door_open_pos){
257          stop();
258          //Serial.println("Door opened");
259
260          //Serial.print ("Door Position UP: ");
261          //Serial.println
262  (door_position);
263
264          door_status=1;
265          active = 0;
266
267
268          }
269
270        if (door_position >= door_open_pos-300){
271          analogWrite(speedpinA,30);
272
273          }
274       
275        if (door_position == prev_door_pos){
276          stop();
277
278          alarm=1;
279          Serial.println ("ALARM");
280          active
281  = 0;
282
283        }  
284    
285   }
286 }
287}
288
289
290
291void close()    //
292  Drive door DOWN
293
294{
295  prevTimer = millis();
296  door_status=2;
297  analogWrite(speedpinA,pwm);
298  
299  digitalWrite(pinI2,HIGH); 
300  digitalWrite(pinI1,LOW);
301  
302  while(active
303  == 1){
304
305
306
307  if(millis() - prevTimer > 100){                   
308        updatePosition();
309                            
310        prevTimer = millis();
311        
312        if
313  (door_position <= door_closed_pos){
314          stop();
315          //Serial.println("Door
316  closed");
317          //Serial.print ("Door Position DOWN: ");
318          //Serial.println
319  (door_position);
320          door_status=0;
321          active = 0;
322          }
323
324        if (door_position <= door_closed_pos+300){
325          analogWrite(speedpinA,50);
326
327          }
328        if (door_position == prev_door_pos){
329          stop();
330
331          alarm=1;
332          Serial.println ("ALARM");
333          active
334  = 0;
335        }
336  }
337 }
338}
339 
340 void stop()
341{
342  analogWrite(speedpinA,0);
343
344  digitalWrite(pinI2,HIGH); 
345  digitalWrite(pinI1,HIGH);
346  
347} 
348
349void
350  countSteps() 
351{
352  steps++;
353  
354}
355
356
357void updatePosition()
358{
359
360  if(last_dir == 0){
361    //Serial.print ("door position: ");
362    //Serial.println
363  (door_position);
364    prev_door_pos = door_position;
365    door_position = door_position
366  + steps;
367    steps = 0;
368  } else {
369    //Serial.print ("door position:
370  ");
371    //Serial.println (door_position);
372    prev_door_pos = door_position;
373
374    door_position = door_position - steps;
375    steps = 0;
376  }}
377
378
379void
380  initialize_door()          // Door initialization
381{
382  prevTimer = millis();
383
384  door_status=2;
385  last_dir=1;
386  door_position = 10000;
387
388  
389  while(active
390  == 1){
391  analogWrite(speedpinA,50);  
392  digitalWrite(pinI2,HIGH); 
393  digitalWrite(pinI1,LOW);
394
395
396
397  if(millis() - prevTimer > 80){                   
398        updatePosition();
399                            
400        prevTimer = millis();
401        
402        if
403  (door_position == prev_door_pos){
404          stop();
405          Serial.println
406  ("DETECTED CLOSED");
407          active = 0;
408          door_position = 0;
409
410        }
411  }
412 }
413  delay(3000);
414  active = 1;
415  last_dir=0;
416  prevTimer
417  = millis();
418  
419  while(active == 1){
420  analogWrite(speedpinA,50);  
421
422  digitalWrite(pinI2,LOW); 
423  digitalWrite(pinI1,HIGH);
424
425
426  if(millis()
427  - prevTimer > 80){                   
428        updatePosition();                            
429
430        prevTimer = millis();
431        
432        if (door_position == prev_door_pos){
433
434          stop();
435          Serial.println ("DETECTED OPEN");
436          active
437  = 0;
438          door_position=door_position-100;      //Compensate for belt slack
439
440          door_open_pos = door_position;
441          EEPROM.write(0, door_position);
442
443          //Serial.print("Door open position detected: ");
444          //Serial.println(door_position);
445
446        }
447  }
448 }
449
450  delay(3000);
451  active = 1;
452  last_dir=1; 
453
454  close();
455
456switch (alarm) {
457 
458case 0:
459Serial.println ("Init sucessfull");
460Serial.print("Door
461  open position set: ");
462Serial.println(door_open_pos);
463initialized=1;
464active=0;
465break;
466
467case
468  1:
469Serial.println ("Init failed");
470initialized=0;
471
472break;
473
474
475
476}
477
478  
479  
480}

#include <EEPROM.h>  

int pinI1=5;      // PIN D5 MOTOR UP
int
  pinI2=7;     // PIN D7 MOTOR DOWN
int speedpinA=6;  // PIN D6 PWM

//const
  int relay_pin=4;

int pwm=150;
volatile int steps = 0;   // Pulses from
  Hall Effect sensors


const int pinH1=2;      // PIN D2 HALL sensor signal

const
  int remote_input = 3;     // PIN D3 Remote signal 
const int init_button = 4;
      // PIN D4 Door init button
const int LONG_PRESS_TIME = 2000;

//
  Variables will change:
int lastState = HIGH;  // the previous state from the
  input pin
int currentState;     // the current reading from the input pin
unsigned
  long pressedTime  = 0;
bool isPressing = false;
bool isLongDetected = false;

int
  RemotebuttonState = 0; 
//int InitbuttonState = 0;  

int door_status =
  0;          //Door open/closed position 0-closed 1-open 2-interrupted
int door_position
  = 0;
int prev_door_pos = 0;
bool active = 0;              //Active command
  check
int door_open_pos = 0;      //Hall memory of open position
const int
  door_closed_pos = 0;      //Closed position default
int last_dir = 0;             //
  Last direction of movement 0-up 1-down  

  
volatile unsigned long  prevTimer
  = 0;

bool initialized = 0;
bool alarm = 0;
int alarm_count=0;


void
  setup() {
  // put your setup code here, to run once:
  pinMode(pinI1,OUTPUT);
  
  pinMode(pinI2,OUTPUT); 
  pinMode(speedpinA,OUTPUT); 
  
  digitalWrite(pinI1,HIGH);
  
  digitalWrite(pinI2,HIGH);

  delay(2000);


//  pinMode(relay_pin,OUTPUT);

  
 

  Serial.begin(9600);

  pinMode(remote_input,INPUT);
  pinMode(init_button,INPUT_PULLUP);


  pinMode(pinH1,INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(pinH1),
  countSteps, CHANGE); // HALL sensor interrupt init


//EEPROM.write(0,
  100);
door_open_pos = EEPROM.read(0);
// door_closed_pos = EEPROM.read(1);

  


/* INIT SEQUENCE */

Serial.print("Door open position set:
  ");
Serial.println(door_open_pos);
Serial.print("Door closed position set:
  ");
Serial.println(door_closed_pos);
Serial.print("Door initialized: ");
Serial.println(initialized);


delay(1000);
//digitalWrite(relay_pin,
  HIGH);

  
  }

void loop() {

  
  RemotebuttonState =
  digitalRead(remote_input);                // wait for remote signal or button press

  currentState = digitalRead(init_button);                // wait for remote signal
  or button press

  
  if (RemotebuttonState == HIGH && initialized==1)
              // if remote signal goes HIGH & door is initialized
  {
  Serial.println("Remote
  sigal");
  Serial.println (active);
  
    if (active == 0)                                      //
  if NO command is active
      { 
      switch (door_status)                         

        {
        case 0:                                           // case  door
  stautus is closed
        Serial.println("Door opening");  
        active=1;
                                         // set active flag
        last_dir
  = 0;                                     // Set last dir of movement UP
        open();
                                           // open COMMAND
        break;

        
        case 1:                                           // case  door
  stautus is open
        Serial.println("Door closing");  
        active=1;
  
        last_dir = 1;                                     
        close();
                                       
        break;

        case 2:
                                           // case  door stautus is stopped inbetween

        Serial.println("Door resume");  
        active=1;  
        if
  (last_dir == 1){                                     
          
          close();
  
        }
        else{
          
          open(); 
        }

        
        break;
        }      
      }
   }
    
  else
  if (currentState == LOW && initialized == 0){    // Init button long press routine

          
          Serial.println("Door initialization");
          active=1;

          initialize_door();
  }        
          
          
          

          
//          Serial.println("A press is detected");
//
//    pressedTime
  = millis();
//    isPressing = true;
//    isLongDetected = false;
//    }
//
  else if (currentState == HIGH){ 
//    isPressing = false;
//    }
//
//
  
//  if(isPressing == true && isLongDetected == false) {
//    long pressDuration
  = millis() - pressedTime;
//
//    if( pressDuration > LONG_PRESS_TIME ) {
//
      Serial.println("A long press is detected");
//      isLongDetected =
  true;
//      
      

      
    

  
}
    


void
  open()       // Drive door UP
{
  prevTimer = millis();
  door_status=2;

  analogWrite(speedpinA,pwm); 
  digitalWrite(pinI2,LOW); 
  digitalWrite(pinI1,HIGH);

  
  while(active == 1){
  
   if(millis() - prevTimer > 100){                    //
  Update the Position every 1/10 seconds
        
        updatePosition();

        prevTimer = millis();
      
       
        if (door_position
  >= door_open_pos){
          stop();
          //Serial.println("Door opened");

          //Serial.print ("Door Position UP: ");
          //Serial.println
  (door_position);

          door_status=1;
          active = 0;


          }

        if (door_position >= door_open_pos-300){
          analogWrite(speedpinA,30);

          }
       
        if (door_position == prev_door_pos){
          stop();

          alarm=1;
          Serial.println ("ALARM");
          active
  = 0;

        }  
    
   }
 }
}



void close()    //
  Drive door DOWN

{
  prevTimer = millis();
  door_status=2;
  analogWrite(speedpinA,pwm);
  
  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,LOW);
  
  while(active
  == 1){



  if(millis() - prevTimer > 100){                   
        updatePosition();
                            
        prevTimer = millis();
        
        if
  (door_position <= door_closed_pos){
          stop();
          //Serial.println("Door
  closed");
          //Serial.print ("Door Position DOWN: ");
          //Serial.println
  (door_position);
          door_status=0;
          active = 0;
          }

        if (door_position <= door_closed_pos+300){
          analogWrite(speedpinA,50);

          }
        if (door_position == prev_door_pos){
          stop();

          alarm=1;
          Serial.println ("ALARM");
          active
  = 0;
        }
  }
 }
}
 
 void stop()
{
  analogWrite(speedpinA,0);

  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,HIGH);
  
} 

void
  countSteps() 
{
  steps++;
  
}


void updatePosition()
{

  if(last_dir == 0){
    //Serial.print ("door position: ");
    //Serial.println
  (door_position);
    prev_door_pos = door_position;
    door_position = door_position
  + steps;
    steps = 0;
  } else {
    //Serial.print ("door position:
  ");
    //Serial.println (door_position);
    prev_door_pos = door_position;

    door_position = door_position - steps;
    steps = 0;
  }}


void
  initialize_door()          // Door initialization
{
  prevTimer = millis();

  door_status=2;
  last_dir=1;
  door_position = 10000;

  
  while(active
  == 1){
  analogWrite(speedpinA,50);  
  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,LOW);



  if(millis() - prevTimer > 80){                   
        updatePosition();
                            
        prevTimer = millis();
        
        if
  (door_position == prev_door_pos){
          stop();
          Serial.println
  ("DETECTED CLOSED");
          active = 0;
          door_position = 0;

        }
  }
 }
  delay(3000);
  active = 1;
  last_dir=0;
  prevTimer
  = millis();
  
  while(active == 1){
  analogWrite(speedpinA,50);  

  digitalWrite(pinI2,LOW); 
  digitalWrite(pinI1,HIGH);


  if(millis()
  - prevTimer > 80){                   
        updatePosition();                            

        prevTimer = millis();
        
        if (door_position == prev_door_pos){

          stop();
          Serial.println ("DETECTED OPEN");
          active
  = 0;
          door_position=door_position-100;      //Compensate for belt slack

          door_open_pos = door_position;
          EEPROM.write(0, door_position);

          //Serial.print("Door open position detected: ");
          //Serial.println(door_position);

        }
  }
 }

  delay(3000);
  active = 1;
  last_dir=1; 

  close();

switch (alarm) {
 
case 0:
Serial.println ("Init sucessfull");
Serial.print("Door
  open position set: ");
Serial.println(door_open_pos);
initialized=1;
active=0;
break;

case
  1:
Serial.println ("Init failed");
initialized=0;

break;



}

  
  
}

Garage door controller code

arduino

1
2#include <EEPROM.h>  
3
4int pinI1=5;      // PIN D5 MOTOR UP
5int  pinI2=7;     // PIN D7 MOTOR DOWN
6int speedpinA=6;  // PIN D6 PWM
7
8//const  int relay_pin=4;
9
10int pwm=150;
11volatile int steps = 0;   // Pulses from  Hall Effect sensors
12
13
14const int pinH1=2;      // PIN D2 HALL sensor signal
15
16const  int remote_input = 3;     // PIN D3 Remote signal 
17const int init_button = 4;      // PIN D4 Door init button
18const int LONG_PRESS_TIME = 2000;
19
20//  Variables will change:
21int lastState = HIGH;  // the previous state from the  input pin
22int currentState;     // the current reading from the input pin
23unsigned  long pressedTime  = 0;
24bool isPressing = false;
25bool isLongDetected = false;
26
27int  RemotebuttonState = 0; 
28//int InitbuttonState = 0;  
29
30int door_status =  0;          //Door open/closed position 0-closed 1-open 2-interrupted
31int door_position  = 0;
32int prev_door_pos = 0;
33bool active = 0;              //Active command  check
34int door_open_pos = 0;      //Hall memory of open position
35const int  door_closed_pos = 0;      //Closed position default
36int last_dir = 0;             //  Last direction of movement 0-up 1-down  
37
38  
39volatile unsigned long  prevTimer  = 0;
40
41bool initialized = 0;
42bool alarm = 0;
43int alarm_count=0;
44
45
46void  setup() {
47  // put your setup code here, to run once:
48  pinMode(pinI1,OUTPUT);  
49  pinMode(pinI2,OUTPUT); 
50  pinMode(speedpinA,OUTPUT); 
51  
52  digitalWrite(pinI1,HIGH);  
53  digitalWrite(pinI2,HIGH);
54
55  delay(2000);
56
57
58//  pinMode(relay_pin,OUTPUT);
59  
60 
61
62  Serial.begin(9600);
63
64  pinMode(remote_input,INPUT);
65  pinMode(init_button,INPUT_PULLUP);
66
67  pinMode(pinH1,INPUT_PULLUP);
68  attachInterrupt(digitalPinToInterrupt(pinH1),  countSteps, CHANGE); // HALL sensor interrupt init
69
70
71//EEPROM.write(0,  100);
72door_open_pos = EEPROM.read(0);
73// door_closed_pos = EEPROM.read(1);
74  
75
76
77/* INIT SEQUENCE */
78
79Serial.print("Door open position set:  ");
80Serial.println(door_open_pos);
81Serial.print("Door closed position set:  ");
82Serial.println(door_closed_pos);
83Serial.print("Door initialized: ");
84Serial.println(initialized);
85
86
87delay(1000);
88//digitalWrite(relay_pin,  HIGH);
89
90  
91  }
92
93void loop() {
94
95  
96  RemotebuttonState =  digitalRead(remote_input);                // wait for remote signal or button press
97  currentState = digitalRead(init_button);                // wait for remote signal  or button press
98
99  
100  if (RemotebuttonState == HIGH && initialized==1)              // if remote signal goes HIGH & door is initialized
101  {
102  Serial.println("Remote  sigal");
103  Serial.println (active);
104  
105    if (active == 0)                                      //  if NO command is active
106      { 
107      switch (door_status)                         
108        {
109        case 0:                                           // case  door  stautus is closed
110        Serial.println("Door opening");  
111        active=1;                                         // set active flag
112        last_dir  = 0;                                     // Set last dir of movement UP
113        open();                                           // open COMMAND
114        break;
115        
116        case 1:                                           // case  door  stautus is open
117        Serial.println("Door closing");  
118        active=1;  
119        last_dir = 1;                                     
120        close();                                       
121        break;
122
123        case 2:                                           // case  door stautus is stopped inbetween
124        Serial.println("Door resume");  
125        active=1;  
126        if  (last_dir == 1){                                     
127          
128          close();  
129        }
130        else{
131          
132          open(); 
133        }
134        
135        break;
136        }      
137      }
138   }
139    
140  else  if (currentState == LOW && initialized == 0){    // Init button long press routine
141          
142          Serial.println("Door initialization");
143          active=1;
144          initialize_door();
145  }        
146          
147          
148          
149          
150//          Serial.println("A press is detected");
151//
152//    pressedTime  = millis();
153//    isPressing = true;
154//    isLongDetected = false;
155//    }
156//  else if (currentState == HIGH){ 
157//    isPressing = false;
158//    }
159//
160//  
161//  if(isPressing == true && isLongDetected == false) {
162//    long pressDuration  = millis() - pressedTime;
163//
164//    if( pressDuration > LONG_PRESS_TIME ) {
165//      Serial.println("A long press is detected");
166//      isLongDetected =  true;
167//      
168      
169
170      
171    
172
173  
174}
175    
176
177
178void  open()       // Drive door UP
179{
180  prevTimer = millis();
181  door_status=2;
182  analogWrite(speedpinA,pwm); 
183  digitalWrite(pinI2,LOW); 
184  digitalWrite(pinI1,HIGH);
185  
186  while(active == 1){
187  
188   if(millis() - prevTimer > 100){                    //  Update the Position every 1/10 seconds
189        
190        updatePosition();
191        prevTimer = millis();
192      
193       
194        if (door_position  >= door_open_pos){
195          stop();
196          //Serial.println("Door opened");
197          //Serial.print ("Door Position UP: ");
198          //Serial.println  (door_position);
199
200          door_status=1;
201          active = 0;
202
203          }
204
205        if (door_position >= door_open_pos-300){
206          analogWrite(speedpinA,30);
207          }
208       
209        if (door_position == prev_door_pos){
210          stop();
211          alarm=1;
212          Serial.println ("ALARM");
213          active  = 0;
214
215        }  
216    
217   }
218 }
219}
220
221
222
223void close()    //  Drive door DOWN
224
225{
226  prevTimer = millis();
227  door_status=2;
228  analogWrite(speedpinA,pwm);  
229  digitalWrite(pinI2,HIGH); 
230  digitalWrite(pinI1,LOW);
231  
232  while(active  == 1){
233
234
235
236  if(millis() - prevTimer > 100){                   
237        updatePosition();                            
238        prevTimer = millis();
239        
240        if  (door_position <= door_closed_pos){
241          stop();
242          //Serial.println("Door  closed");
243          //Serial.print ("Door Position DOWN: ");
244          //Serial.println  (door_position);
245          door_status=0;
246          active = 0;
247          }
248        if (door_position <= door_closed_pos+300){
249          analogWrite(speedpinA,50);
250          }
251        if (door_position == prev_door_pos){
252          stop();
253          alarm=1;
254          Serial.println ("ALARM");
255          active  = 0;
256        }
257  }
258 }
259}
260 
261 void stop()
262{
263  analogWrite(speedpinA,0);
264  digitalWrite(pinI2,HIGH); 
265  digitalWrite(pinI1,HIGH);
266  
267} 
268
269void  countSteps() 
270{
271  steps++;
272  
273}
274
275
276void updatePosition()
277{
278  if(last_dir == 0){
279    //Serial.print ("door position: ");
280    //Serial.println  (door_position);
281    prev_door_pos = door_position;
282    door_position = door_position  + steps;
283    steps = 0;
284  } else {
285    //Serial.print ("door position:  ");
286    //Serial.println (door_position);
287    prev_door_pos = door_position;
288    door_position = door_position - steps;
289    steps = 0;
290  }}
291
292
293void  initialize_door()          // Door initialization
294{
295  prevTimer = millis();
296  door_status=2;
297  last_dir=1;
298  door_position = 10000;
299
300  
301  while(active  == 1){
302  analogWrite(speedpinA,50);  
303  digitalWrite(pinI2,HIGH); 
304  digitalWrite(pinI1,LOW);
305
306
307  if(millis() - prevTimer > 80){                   
308        updatePosition();                            
309        prevTimer = millis();
310        
311        if  (door_position == prev_door_pos){
312          stop();
313          Serial.println  ("DETECTED CLOSED");
314          active = 0;
315          door_position = 0;
316        }
317  }
318 }
319  delay(3000);
320  active = 1;
321  last_dir=0;
322  prevTimer  = millis();
323  
324  while(active == 1){
325  analogWrite(speedpinA,50);  
326  digitalWrite(pinI2,LOW); 
327  digitalWrite(pinI1,HIGH);
328
329
330  if(millis()  - prevTimer > 80){                   
331        updatePosition();                            
332        prevTimer = millis();
333        
334        if (door_position == prev_door_pos){
335          stop();
336          Serial.println ("DETECTED OPEN");
337          active  = 0;
338          door_position=door_position-100;      //Compensate for belt slack
339          door_open_pos = door_position;
340          EEPROM.write(0, door_position);
341          //Serial.print("Door open position detected: ");
342          //Serial.println(door_position);
343        }
344  }
345 }
346
347  delay(3000);
348  active = 1;
349  last_dir=1; 
350  close();
351
352switch (alarm) {
353 
354case 0:
355Serial.println ("Init sucessfull");
356Serial.print("Door  open position set: ");
357Serial.println(door_open_pos);
358initialized=1;
359active=0;
360break;
361
362case  1:
363Serial.println ("Init failed");
364initialized=0;
365
366break;
367
368
369
370}
371  
372  
373}

#include <EEPROM.h>  

int pinI1=5;      // PIN D5 MOTOR UP
int  pinI2=7;     // PIN D7 MOTOR DOWN
int speedpinA=6;  // PIN D6 PWM

//const  int relay_pin=4;

int pwm=150;
volatile int steps = 0;   // Pulses from  Hall Effect sensors


const int pinH1=2;      // PIN D2 HALL sensor signal

const  int remote_input = 3;     // PIN D3 Remote signal 
const int init_button = 4;      // PIN D4 Door init button
const int LONG_PRESS_TIME = 2000;

//  Variables will change:
int lastState = HIGH;  // the previous state from the  input pin
int currentState;     // the current reading from the input pin
unsigned  long pressedTime  = 0;
bool isPressing = false;
bool isLongDetected = false;

int  RemotebuttonState = 0; 
//int InitbuttonState = 0;  

int door_status =  0;          //Door open/closed position 0-closed 1-open 2-interrupted
int door_position  = 0;
int prev_door_pos = 0;
bool active = 0;              //Active command  check
int door_open_pos = 0;      //Hall memory of open position
const int  door_closed_pos = 0;      //Closed position default
int last_dir = 0;             //  Last direction of movement 0-up 1-down  

  
volatile unsigned long  prevTimer  = 0;

bool initialized = 0;
bool alarm = 0;
int alarm_count=0;


void  setup() {
  // put your setup code here, to run once:
  pinMode(pinI1,OUTPUT);  
  pinMode(pinI2,OUTPUT); 
  pinMode(speedpinA,OUTPUT); 
  
  digitalWrite(pinI1,HIGH);  
  digitalWrite(pinI2,HIGH);

  delay(2000);


//  pinMode(relay_pin,OUTPUT);
  
 

  Serial.begin(9600);

  pinMode(remote_input,INPUT);
  pinMode(init_button,INPUT_PULLUP);

  pinMode(pinH1,INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(pinH1),  countSteps, CHANGE); // HALL sensor interrupt init


//EEPROM.write(0,  100);
door_open_pos = EEPROM.read(0);
// door_closed_pos = EEPROM.read(1);
  


/* INIT SEQUENCE */

Serial.print("Door open position set:  ");
Serial.println(door_open_pos);
Serial.print("Door closed position set:  ");
Serial.println(door_closed_pos);
Serial.print("Door initialized: ");
Serial.println(initialized);


delay(1000);
//digitalWrite(relay_pin,  HIGH);

  
  }

void loop() {

  
  RemotebuttonState =  digitalRead(remote_input);                // wait for remote signal or button press
  currentState = digitalRead(init_button);                // wait for remote signal  or button press

  
  if (RemotebuttonState == HIGH && initialized==1)              // if remote signal goes HIGH & door is initialized
  {
  Serial.println("Remote  sigal");
  Serial.println (active);
  
    if (active == 0)                                      //  if NO command is active
      { 
      switch (door_status)                         
        {
        case 0:                                           // case  door  stautus is closed
        Serial.println("Door opening");  
        active=1;                                         // set active flag
        last_dir  = 0;                                     // Set last dir of movement UP
        open();                                           // open COMMAND
        break;
        
        case 1:                                           // case  door  stautus is open
        Serial.println("Door closing");  
        active=1;  
        last_dir = 1;                                     
        close();                                       
        break;

        case 2:                                           // case  door stautus is stopped inbetween
        Serial.println("Door resume");  
        active=1;  
        if  (last_dir == 1){                                     
          
          close();  
        }
        else{
          
          open(); 
        }
        
        break;
        }      
      }
   }
    
  else  if (currentState == LOW && initialized == 0){    // Init button long press routine
          
          Serial.println("Door initialization");
          active=1;
          initialize_door();
  }        
          
          
          
          
//          Serial.println("A press is detected");
//
//    pressedTime  = millis();
//    isPressing = true;
//    isLongDetected = false;
//    }
//  else if (currentState == HIGH){ 
//    isPressing = false;
//    }
//
//  
//  if(isPressing == true && isLongDetected == false) {
//    long pressDuration  = millis() - pressedTime;
//
//    if( pressDuration > LONG_PRESS_TIME ) {
//      Serial.println("A long press is detected");
//      isLongDetected =  true;
//      
      

      
    

  
}
    


void  open()       // Drive door UP
{
  prevTimer = millis();
  door_status=2;
  analogWrite(speedpinA,pwm); 
  digitalWrite(pinI2,LOW); 
  digitalWrite(pinI1,HIGH);
  
  while(active == 1){
  
   if(millis() - prevTimer > 100){                    //  Update the Position every 1/10 seconds
        
        updatePosition();
        prevTimer = millis();
      
       
        if (door_position  >= door_open_pos){
          stop();
          //Serial.println("Door opened");
          //Serial.print ("Door Position UP: ");
          //Serial.println  (door_position);

          door_status=1;
          active = 0;

          }

        if (door_position >= door_open_pos-300){
          analogWrite(speedpinA,30);
          }
       
        if (door_position == prev_door_pos){
          stop();
          alarm=1;
          Serial.println ("ALARM");
          active  = 0;

        }  
    
   }
 }
}



void close()    //  Drive door DOWN

{
  prevTimer = millis();
  door_status=2;
  analogWrite(speedpinA,pwm);  
  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,LOW);
  
  while(active  == 1){



  if(millis() - prevTimer > 100){                   
        updatePosition();                            
        prevTimer = millis();
        
        if  (door_position <= door_closed_pos){
          stop();
          //Serial.println("Door  closed");
          //Serial.print ("Door Position DOWN: ");
          //Serial.println  (door_position);
          door_status=0;
          active = 0;
          }
        if (door_position <= door_closed_pos+300){
          analogWrite(speedpinA,50);
          }
        if (door_position == prev_door_pos){
          stop();
          alarm=1;
          Serial.println ("ALARM");
          active  = 0;
        }
  }
 }
}
 
 void stop()
{
  analogWrite(speedpinA,0);
  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,HIGH);
  
} 

void  countSteps() 
{
  steps++;
  
}


void updatePosition()
{
  if(last_dir == 0){
    //Serial.print ("door position: ");
    //Serial.println  (door_position);
    prev_door_pos = door_position;
    door_position = door_position  + steps;
    steps = 0;
  } else {
    //Serial.print ("door position:  ");
    //Serial.println (door_position);
    prev_door_pos = door_position;
    door_position = door_position - steps;
    steps = 0;
  }}


void  initialize_door()          // Door initialization
{
  prevTimer = millis();
  door_status=2;
  last_dir=1;
  door_position = 10000;

  
  while(active  == 1){
  analogWrite(speedpinA,50);  
  digitalWrite(pinI2,HIGH); 
  digitalWrite(pinI1,LOW);


  if(millis() - prevTimer > 80){                   
        updatePosition();                            
        prevTimer = millis();
        
        if  (door_position == prev_door_pos){
          stop();
          Serial.println  ("DETECTED CLOSED");
          active = 0;
          door_position = 0;
        }
  }
 }
  delay(3000);
  active = 1;
  last_dir=0;
  prevTimer  = millis();
  
  while(active == 1){
  analogWrite(speedpinA,50);  
  digitalWrite(pinI2,LOW); 
  digitalWrite(pinI1,HIGH);


  if(millis()  - prevTimer > 80){                   
        updatePosition();                            
        prevTimer = millis();
        
        if (door_position == prev_door_pos){
          stop();
          Serial.println ("DETECTED OPEN");
          active  = 0;
          door_position=door_position-100;      //Compensate for belt slack
          door_open_pos = door_position;
          EEPROM.write(0, door_position);
          //Serial.print("Door open position detected: ");
          //Serial.println(door_position);
        }
  }
 }

  delay(3000);
  active = 1;
  last_dir=1; 
  close();

switch (alarm) {
 
case 0:
Serial.println ("Init sucessfull");
Serial.print("Door  open position set: ");
Serial.println(door_open_pos);
initialized=1;
active=0;
break;

case  1:
Serial.println ("Init failed");
initialized=0;

break;



}
  
  
}

Downloadable files

Garage door controller

https://github.com/pj1976/Arduino-Garage-door-controller

Schematic

Garage door controller

https://github.com/pj1976/Arduino-Garage-door-controller

Comments

Only logged in users can leave comments

Pepisan

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content