cogliostrio

Web server is ready for config at http://192.168.4.1/
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[E][Parsing.cpp:283] _parseArguments(): arg missing value: 0
[E][WebServer.cpp:633] _handleRequest(): request handler not found
[DEBUG] Serving /index.html over http...

/*
**  .:A4988 Poulo Stepper Driver:.
**  MS1 MS2 MS3 Microstep resolution
**  L   L   L   Full step
**  H   L   L   Half step
**  L   H   L   Quarter step
**  H   H   L   Eighth step
**  H   H   H   Sixteenth step
*/

// version: twist motor with end stops

//#define MY_TRANSPORT_WAIT_READY_MS 1

#define MY_DEBUG
#define MY_RADIO_RF24
#define MY_NODE_ID 3
#define MY_REPEATER_FEATURE

#include <MySensors.h>
#include <SPI.h>
#include <Stepper.h>

#define SN "Lameller"
#define SV "1.3"
#define CHILD_CURTAIN 1

boolean pinCurtainOpenState ;
boolean pinCurtainShutState ;
boolean pinTwistOpenState ;
boolean pinTwistShutState ;

// defines pins numbers for sliding
const int dirPin = 14;                  // analog pin 0
const int stepPin = 15;                 // analog pin 1
const int enablePin = 16;               // analog pin 2
const int halfSpeed = 19;               // analog pin 5

// define pin numbers for twisting motor (28BYJ-48)
const int in1Pin = 3;
const int in2Pin = 4;
const int in3Pin = 5;
const int in4Pin = 6;

// curtain open or closed
#define pinCurtainShut 17               // analog pin 3
#define pinCurtainOpen 18               // analog pin 4
#define pinTwistOpen 8                  // D8
#define pinTwistShut 7                  // D7

#define stepsPerRevolution 768          // steps for one revolution. 768
int motorSpeed = 40;                    // RPM. 40
Stepper myStepper(stepsPerRevolution, in1Pin, in2Pin, in3Pin, in4Pin);

MyMessage curtainState(CHILD_CURTAIN, S_COVER);

void setup()
{
  Serial.begin(115200);
  Serial.print("");
  Serial.print("curtainState.type: ");
  Serial.println(curtainState.type);

  //initalize sliding motor (A4988)
  Serial.println("initalize sliding motor (A4988)");
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(halfSpeed, OUTPUT);
  pinMode(enablePin, OUTPUT);
  digitalWrite(halfSpeed, HIGH);               // set A4988 to run at half speed
  digitalWrite(enablePin, HIGH);               // A4988 disable

  //initalize twisting motor (Stepper.h)
  Serial.println("initalize twisting motor (Stepper.h)");
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);
  myStepper.setSpeed(motorSpeed);              // set the stepper speed
  powerOffTwistmotor();                        // power off twisting motor

  //initalize curtain status
  Serial.println("initalize curtain status");
  pinMode(pinCurtainOpen, INPUT_PULLUP);       // curtain not covering window
  pinMode(pinCurtainShut, INPUT_PULLUP);       // curtain covering window
  pinMode(pinTwistOpen, INPUT_PULLUP);         // twist to open position
  pinMode(pinTwistShut, INPUT_PULLUP);         // twist to closed position

  pinCurtainOpenState = digitalRead(pinCurtainOpen);
  pinCurtainShutState = digitalRead(pinCurtainShut);
  pinTwistOpenState = digitalRead(pinTwistOpen);
  pinTwistShutState = digitalRead(pinTwistShut);
  Serial.print("pinCurtainOpenState :");
  Serial.println(pinCurtainOpenState);
  Serial.print("pinCurtainShutState :");
  Serial.println(pinCurtainShutState);
  Serial.print("pinTwistOpenState: ");
  Serial.println(pinTwistOpenState);
  Serial.print("pinTwistShutState: ");
  Serial.println(pinTwistShutState);
  Serial.println("");

  Serial.println("calibrate curtain to open position after power loss");
  Serial.println("Running openSequence(), to set curtain open");
  openSequence();                              // calibrate curtain to open position after power loss

  request(CHILD_CURTAIN, S_COVER);             //request last state
}

void presentation()
{
  sendSketchInfo(SN, SV);                      // Sending sketch name and version
  present(CHILD_CURTAIN, S_COVER);             // Window cover sub-type, commands V_UP, V_DOWN
}

void loop()
{
}

/************************************
   Change state of curtain
   when signal received.
 ***********************************/
void receive(const MyMessage &curtainState)
{
  Serial.print("curtainState.type: ");
  Serial.println(curtainState.type);
  if (curtainState.type == V_DOWN)             // curtain is open, this starts the closing sequence
  {
    Serial.print("V_DOWN: ");
    Serial.println(V_DOWN);
    Serial.print("pinCurtainShut value above: ");
    Serial.println(pinCurtainShutState);
    if ((pinCurtainShutState = (digitalRead(pinCurtainShut)) == true))
    {
      Serial.print("pinCurtainShut value: ");
      Serial.println(pinCurtainShutState);
      Serial.println("---------------");
      Serial.println("");
      shutSequence();
      Serial.print("pinCurtainShutState value after open sequence done: ");
      Serial.print(pinCurtainShutState);
    }
  }

  if (curtainState.type == V_UP)               // curtain is closed, this starts the opening sequence
  {
    Serial.print("V_UP: ");
    Serial.println(V_UP);
    Serial.print("pinCurtainOpen value above: ");
    Serial.println(pinCurtainOpenState);
    if ((pinCurtainOpenState = (digitalRead(pinCurtainOpen)) == true))
    {
      Serial.print("pinCurtainOpenState value: ");
      Serial.println(pinCurtainOpenState);
      Serial.println("---------------");
      Serial.println("");
      openSequence();
      Serial.print("pinCurtainOpenState value after open sequence done: ");
      Serial.println(pinCurtainOpenState);
      Serial.println("");
    }
  }
}

/************************************
   sequence to twist open,
   then slide curtain open.
 ***********************************/
void openSequence()
{
  Serial.println("open sequence started");

  Serial.println("twist open started");
  powerOnTwistmotor();                         //Run twist motor until pinTwistOpen is true, then stop motor.
  Serial.print("pinTwistOpenState: ");
  Serial.println(pinTwistOpenState);
  while (digitalRead(pinTwistOpen))
  {
    myStepper.step(1);
  }
  powerOffTwistmotor();
  Serial.println("twist open completed");

  Serial.println("sliding to open position started");
  digitalWrite(enablePin, LOW);                // A4988 enable
  Serial.println("digitalWrite(enablePin, LOW)");
  delay(1000);
  while (digitalRead(pinCurtainOpen))          // Run until sliding motor until pinCurtainOpen is activated
  {
    digitalWrite(dirPin, LOW);                 // LOW => UP. (HIGH = anti-clockwise / LOW = clockwise)
    digitalWrite(stepPin, HIGH);               // Makes pulses for ratation
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  digitalWrite(enablePin, HIGH);               // A4988 disable
  Serial.println("sliding to open position completed");
  Serial.println("---------------");
  Serial.println("");
  delay(1000);
}

/************************************
   sequence to slide curtain shut,
   then twist shut.
 ***********************************/
void shutSequence()
{
  Serial.println("shut sequence started");
  Serial.println("sliding to shut position started");
  digitalWrite(enablePin, LOW);                // A4988 enable
  delay(100);
  while (digitalRead(pinCurtainShut))          // Run sliding motor until pinCurtainShut is activated
  {
    digitalWrite(dirPin, HIGH);                // HIGH => DOWN. (HIGH = anti-clockwise / LOW = clockwise)
    digitalWrite(stepPin, HIGH);               // Makes pulses for rotation
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  Serial.println("sliding to shut position completed");

  digitalWrite(enablePin, HIGH);               // A4988 disable
  Serial.println("sliding to shut position completed");
  Serial.println("---------------");
  Serial.println("");
  delay(1000);

  Serial.println("twisting shut started");
  powerOnTwistmotor();                           //Run twist motor until pinTwistOpen is closed, then stop motor.
  while (digitalRead(pinTwistShut))
  {
    myStepper.step(-1);
  }
  powerOffTwistmotor();
  Serial.println("twist shut completed");
}

/************************************
   enable all outputs on twisting motor.
 ***********************************/
void powerOnTwistmotor()
{
  digitalWrite(in1Pin, HIGH);
  digitalWrite(in2Pin, HIGH);
  digitalWrite(in3Pin, HIGH);
  digitalWrite(in4Pin, HIGH);
}

/************************************
   disable all outputs on twisting motor.
 ***********************************/
void powerOffTwistmotor()
{
  digitalWrite(in1Pin, LOW);
  digitalWrite(in2Pin, LOW);
  digitalWrite(in3Pin, LOW);
  digitalWrite(in4Pin, LOW);
}