Contrôleur de Garage Arduino (6 / 8 étapes)

Étape 6: Le Code de l’Arduino

/*
Contrôleur de garage
Rédigé par Aram Perez
Une licence sous GPLv2, disponible à http://www.gnu.org/licenses/gpl-2.0.txt
*/

#define LOG_SERIAL

#include < SPI.h >
#include < Ethernet.h >
#include < Wire.h >

#define NO_PORTA_PINCHANGES
#define NO_PORTC_PINCHANGES
#include < PinChangeInt.h >

#define IOPORT 23 //Normal telnet port
#define NBR_OF_RELAYS 4

Bouton poussoir & capteurs de porte de garage
#define GARAGE_CLOSED_SENSOR 2 //Connect à la borne NC, active haute
#define GARAGE_PARTIALLY_OPEN_SENSOR 3 //Connect à aucune borne, active haute

#define RELAY0 4
#define GARAGE_RELAY RELAY0 //Relay pour le bouton de porte de garage
#define relais 1 5
#define relais 2 6
#define RELAY3 7

#define CR ((char) 13)
#define LF ((char) 10)

Entrez une adresse MAC et l’adresse IP de votre contrôleur ci-dessous.
L’adresse IP sera tributaire de votre réseau local.
porte d’entrée et de sous-réseau sont facultatifs :
public static byte mac = {}
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
public static IPAddress ip (192 168 1, 170) ;
public static IPAddress passerelle (192, 168, 1, 1) ;
public static IPAddress sous-réseau (255, 255, 255, 0) ;

public static EthernetServer server(IOPORT) ;
public static EthernetClient client ;

public static char relayState [NBR_OF_RELAYS] ;

classe passerelle
{
bool closedState, partiallyOpenState ;
public :
GarageDoor() ;
void Init() ;
void SetClosedState(bool st) {}
closedState = m ;
}
void SetPartiallyOpenState(bool st) {}
partiallyOpenState = m ;
}
char State() const ;
void PushButton() ;
};

public static passerelle passerelle ;

Cela devrait être une fonction privée dans la classe passerelle
p. ex. GarageDoor::StateChangedISR(void),
mais le compilateur donne une erreur si elle est:-(
public static void StateChangedISR(void)
{
Si (PCintPort::arduinoPin == GARAGE_CLOSED_SENSOR) {}
garageDoor.SetClosedState(PCintPort::pinState) ;
}
else {}
Doit avoir été la GARAGE_PARTIALLY_OPEN_SENSOR :
garageDoor.SetPartiallyOpenState(PCintPort::pinState) ;
}
}

GarageDoor::GarageDoor()
{
}

Sub GarageDoor::Init()
{
pinMode (GARAGE_CLOSED_SENSOR, INPUT_PULLUP) ;
PCintPort::attachInterrupt (GARAGE_CLOSED_SENSOR, & StateChangedISR, changement) ;
pinMode (GARAGE_PARTIALLY_OPEN_SENSOR, INPUT_PULLUP) ;
PCintPort::attachInterrupt (GARAGE_PARTIALLY_OPEN_SENSOR, & StateChangedISR, changement) ;
closedState = digitalRead(GARAGE_CLOSED_SENSOR) ;
partiallyOpenState = digitalRead(GARAGE_PARTIALLY_OPEN_SENSOR) ;
}

Sub GarageDoor::PushButton()
{
digitalWrite (GARAGE_RELAY, basse) ;
Delay(400) ;  Retard.4 secs
digitalWrite (GARAGE_RELAY, élevé) ;
}

char GarageDoor::State() const
{
Si (closedState) retour "c" ;
retour partiallyOpenState ? 'p' : 'o';
}

void setup() {}
#ifdef LOG_SERIAL
Serial.Begin(56700) ;
#endif
initialiser le périphérique ethernet
Ethernet.Begin (mac, ip, passerelle, sous-réseau) ;
démarrer l’écoute des clients
Server.Begin() ;
garageDoor.Init() ;
pour (int i = 0; i < NBR_OF_RELAYS; i ++) {}
pinMode (RELAY0 + i, sortie) ;  Zone 1
digitalWrite (RELAY0 + i, HIGH) ; Logique d’utilisation inversée les relais, élevée = Off
relayState [i] = « 0 » ;  Utiliser la logique normale
}
Si {(client.connected())
client.Flush() ;
}
#ifdef LOG_SERIAL
Serial.println("\r\nOK") ;
#endif
}

char ReadNext()
{
char ch = client.read() ;
#ifdef LOG_SERIAL
Serial.Print(ch) ;
#endif
retour de ch ;
}

//
Commandes :
//  g? -retourner l’actuel état de porte de garage
c - la porte est fermée
o - la porte est complètement ouverte
p - porte est entrouverte
GB - bouton de porte de garage « push »
RX ? -Relais retour x État
rxy - relais set x à y (0 ou 1)
//
void loop() {}
public static char lastGarageDoorState = « c » ;
char ch, SRAC ;
Si (! client.connected()) {}
Si le client n’est pas connecté, attendez un nouveau client :
client = server.available() ;
}
Si (client.available() > 0) {}
int rNdx ;
bool err = false ;
tandis que (client.available() > 0) {}
Switch (ReadNext()) {}
case « g » :
Switch (ReadNext()) {}
cas '?' :
ch = garageDoor.State() ;
client.Print('g') ;
client.println(ch) ;
#ifdef LOG_SERIAL
Serial.Print (« > g ") ;
Serial.println(ch) ;
#endif
rupture ;
case « b » :
garageDoor.PushButton() ;
rupture ;
par défaut :
ERR = true ;
}
rupture ;
case « r » :
ch = ReadNext() ;
commutateur (ch) {}
affaire « 1 » :
affaire « 2 » :
affaire « 3 » :
SRAC = ch ;
rNdx = ch - « 1 » ;
ch = ReadNext() ;
commutateur (ch) {}
cas '?' :
ch = relayState [rNdx] ;
rupture ;
affaire « 0 » :
digitalWrite (relais 1 + rNdx, HIGH) ;  Logique inversée
relayState [rNdx] = ch ;
rupture ;
affaire « 1 » :
digitalWrite (relais 1 + rNdx, faible) ;  Logique inversée
relayState [rNdx] = ch ;
rupture ;
par défaut :
ERR = true ;
}
Si (! err) {}
client.Print('r') ;
client.Print(rAsc) ;
client.println(ch) ;
#ifdef LOG_SERIAL
Serial.Print('>') ;
Serial.println(ch) ;
#endif
}
rupture ;
par défaut :
ERR = true ;
}
rupture ;
boitier CR :
cas LF :
rupture ;    Ignorer les CR et LF
par défaut :
ERR = true ;
}
}
Si {(err)
client.println('?') ;
#ifdef LOG_SERIAL
Serial.println ("> Say what?") ;
#endif
}
}
ch = garageDoor.State() ;
Si (ch! = lastGarageDoorState) {}
lastGarageDoorState = ch ;
client.Print('g') ;
client.println(ch) ;
#ifdef LOG_SERIAL
Serial.Print (« > g ") ;
Serial.println(ch) ;
#endif
}
}