doggie-door/doggie-door.ino

306 lines
10 KiB
Arduino
Raw Normal View History

/*
Open and close a dog door with a servo and limit switches via the web
*/
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <ArduinoMDNS.h>
#include <Servo.h>
#include <AsyncTimer.h>
EthernetUDP udp;
MDNS mdns(udp);
byte mac[] = {
0xD0, 0x99, 0x1E, 0xD0, 0x99, 0x1E
};
//IPAddress ip(192, 168, 10, 99);
EthernetServer server(80);
bool USE_SERIAL=false; // ideally don't use serial during normal operation so it doesn't hang
bool USE_ETHERNET=true;
int SAFETY_STOP_TIME_MS=10000; // how many milliseconds to turn the servo before giving up
int SERVO_DEBOUNCE_TIME_MS=200; // how many milliseconds to wait before checking the limit switch status again
bool DETACH_SERVO_WHEN_DONE=true; // detaching lets the servo rotate semi-freely, remaining attached holds the servo at "stop"
Servo myservo;
AsyncTimer t;
int limitUpPin = 2;
int limitDownPin = 3;
int servoPin = 9;
int ethernetPin = 10;
int downward = 100; // lower to lessen down speed, max 180
int upward = 0; // raise to lessen up speed, min 0
int stop = 90; // adjust in case 90 isn't "stop" for your servo, but if you experience jitter probably adjust the servo potentiometer
bool isMaxUp = false;
bool isMaxDown = false;
// const unsigned long TIMER0_COUNT = 500; // 500 msec timer interval
/*
// TIMER0 interrupt handler
ISR( TIMER0_COMPA_vect ) {
// recheck the sensors periodically just in case
handleSensor();
}
*/
// the setup routine runs once when you press reset:
void setup() {
// give ethernet a bit of time to stabilize power on startup before init
if (USE_ETHERNET) delay(5000);
// initialize serial communication at 9600 bits per second:
if (USE_SERIAL) Serial.begin(9600);
pinMode(limitUpPin, INPUT_PULLUP);
pinMode(limitDownPin, INPUT_PULLUP);
/*
// *** TIMER0 initialization ***
cli(); // turn off all interrupts
TIMSK0 = 0; // turn off timer0 for lower jitter
OCR0A = 0xBB; // arbitrary interrupt count
TIMSK0 |= _BV( OCIE0A ); // piggy back onto interrupt
sei(); // turn interrupts back on
*/
attachInterrupt(digitalPinToInterrupt(limitUpPin), handleSensor, CHANGE);
attachInterrupt(digitalPinToInterrupt(limitDownPin), handleSensor, CHANGE);
// initialize the ethernet shield
if (USE_ETHERNET) Ethernet.init(ethernetPin);
// start the Ethernet connection via DHCP:
if (USE_ETHERNET && Ethernet.begin(mac) == 0) {
if (USE_SERIAL) Serial.println("Failed to configure Ethernet using DHCP");
}
if (USE_ETHERNET && Ethernet.hardwareStatus() == EthernetNoHardware) {
if (USE_SERIAL) Serial.println("Ethernet shield was not found!");
//while (true) {
// delay(1); // do nothing, no point running without Ethernet hardware
//}
}
if (USE_ETHERNET && Ethernet.linkStatus() == LinkOFF) {
if (USE_SERIAL) Serial.println("Ethernet cable is not connected!");
}
// start the server
if (USE_ETHERNET) server.begin();
if (USE_SERIAL) Serial.print("IP: ");
if (USE_SERIAL) Serial.println(Ethernet.localIP());
// start mDNS
mdns.begin(Ethernet.localIP(), "doggie-door");
if (USE_SERIAL) Serial.println("or doggie-door.local");
// Currently the mDNS library addServiceRecord function is buggy and causes reliability issues
/*mdns.addServiceRecord("Doggie Door Control._http",
80,
MDNSServiceTCP);*/
}
void stopServo() {
myservo.write(stop);
if (DETACH_SERVO_WHEN_DONE) myservo.detach();
}
void handleSensor(){
// the limit switches are pulled up but attached as Normally Closed and shorted to ground,
// which means true is unpressed and false is pressed. this allows "unplugged" to read as
// "pressed" aka fail-secure.
delay(SERVO_DEBOUNCE_TIME_MS); // debounce a bit and let the flag solidly contact the switch (there's a lot of bounce going up)
// only update state and continue if there's a change
bool changed = false;
if ((bool)digitalRead(limitUpPin) != isMaxUp) {
isMaxUp = !isMaxUp;
changed = true;
}
if ((bool)digitalRead(limitDownPin) != isMaxDown) {
isMaxDown = !isMaxDown;
changed = true;
}
if (changed) {
if (isMaxUp && myservo.read() == upward) {
stopServo();
}
if (isMaxDown && myservo.read() == downward) {
stopServo();
}
// String out = "interrupt: maxup: ";
// out = out + (isMaxUp ? "y" : "n")+" maxdown: "+(isMaxDown ? "y" : "n");
// if (USE_SERIAL) Serial.println(out);
}
}
void handleInput(char input, EthernetClient client){
// must be d,u,s,q
if (input == 'd') {
if (isMaxDown) {
if (USE_SERIAL) Serial.println("can't go more down!");
if (USE_ETHERNET) client.print("can't go more down");
return;
}
if (USE_SERIAL) Serial.println("down...");
if (USE_ETHERNET) client.print("going down");
myservo.attach(servoPin);
myservo.write(downward);
t.setTimeout([]() { // asynctimer
if (myservo.read() == downward) {
stopServo();
if (USE_SERIAL) Serial.println("safety stop.");
}
}, SAFETY_STOP_TIME_MS);
} else if (input == 'u') {
if (isMaxUp) {
if (USE_SERIAL) Serial.println("can't go more up!");
if (USE_ETHERNET) client.print("can't go more up");
return;
}
if (USE_SERIAL) Serial.println("up...");
if (USE_ETHERNET) client.print("going up");
myservo.attach(servoPin);
myservo.write(upward);
t.setTimeout([]() { // asynctimer
if (myservo.read() == upward) {
stopServo();
if (USE_SERIAL) Serial.println("safety stop.");
}
}, SAFETY_STOP_TIME_MS);
} else if (input == 's') {
stopServo();
if (USE_SERIAL) Serial.println("stop.");
if (USE_ETHERNET) client.print("stopped.");
} else if (input == 'q') {
if (USE_SERIAL) Serial.println("status via ethernet only");
if (USE_ETHERNET) {
client.print("{\"maxup\":");
client.print(isMaxUp ? "1" : "0");
client.print(",\"maxdown\":");
client.print(isMaxDown ? "1" : "0");
client.print("}");
}
// if (USE_SERIAL) Serial.println(out);
// if (USE_ETHERNET) client.print(out);
} else {
if (USE_SERIAL) Serial.println("inv:");
if (USE_SERIAL) Serial.println(input);
if (USE_ETHERNET) client.print("inv: ");
if (USE_ETHERNET) client.print(input);
}
}
// the loop routine runs over and over again forever:
void loop() {
t.handle(); //asynctimer
mdns.run(); // handle mDNS requests/responses
// ideally don't use serial during normal operation so it doesn't hang
if (!USE_ETHERNET && USE_SERIAL) {
while (Serial.available() > 0) {
String input = Serial.readStringUntil('\n');
handleInput(input[0], NULL);
}
}
// listen for incoming clients
else if (USE_ETHERNET) {
EthernetClient client = server.available();
if (client) {
if (USE_SERIAL) Serial.println("new client");
// an HTTP request ends with a blank line
bool currentLineIsBlank = true;
String clientBuf = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
if (USE_SERIAL) Serial.write(c);
//read char by char HTTP request up to 300 chars
if (clientBuf.length() < 300) {
//store characters to string
clientBuf += c;
}
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the HTTP request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
long len = clientBuf.length();
long idx = clientBuf.indexOf("?");
long idxj = clientBuf.indexOf("json");
const char* cc = "Connection: close";
const char* cth = "Content-Type: text/html";
if (len > 0 && idx > 0) {
char cmd = clientBuf[idx+1];
// must be d,u,s,q
if (cmd == 'd' || cmd == 'u' || cmd == 's' || cmd == 'q') {
client.println("HTTP/1.1 200 OK");
} else {
client.println("HTTP/1.1 400 Bad Request");
}
if (idxj > 0 || len > 20) { // junk 123 logic to always go here despite compiler
client.println("Content-Type: application/json");
client.println(cc);
client.println();
handleInput(cmd, client);
} else {
client.println(cth);
client.println(cc);
client.println();
// client.print("<pre>");
handleInput(cmd, client);
// client.print("</pre><br><a href=/>Back</a>");
// client.print(clientBuf);
// client.print("-->");
}
} else {
const char* its = "<input type=submit name=";
// send a standard HTTP response header
client.println("HTTP/1.1 200 OK");
client.println(cth);
client.println(cc); // the connection will be closed after completion of the response
client.println("Refresh: 5"); // refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
handleInput('q', client);
client.print("<br><form action=/ method=GET>");
client.print(its);
client.print("u value=Up />");
client.print(its);
client.print("d value=Down />");
client.print(its);
client.print("s value=Stop /></form></html>");
}
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
} else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
if (USE_SERIAL) Serial.println("client disconnected");
}
}
}