witam czy jest mi w stanie ktos pomoc w powieleniu tego skechu na dwie rolety. juz nic mi do głowy nie przychodzi.// Enable debug prints to serial monitor
Dodano po 41 [sekundy]:
// Enable debug prints to serial monitor
#define MY_DEBUG
#define MY_GATEWAY_SERIAL
// Enable and select radio type attached
//#define MY_RADIO_NRF24
//#define MY_RF24_PA_LEVEL RF24_PA_LOW
//#define MY_REPEATER_FEATURE
// uncomment if we want to manually assign an ID/////////////////////////////////////////////////////////////
//#define MY_NODE_ID 1
// Define a lower baud rate for Arduino's running on 8 MHz (Arduino Pro Mini 3.3V & SenseBender)
//#if F_CPU == 8000000L
//#define MY_BAUD_RATE 38400
//#endif
// Flash leds on rx/tx/err
// #define MY_LEDS_BLINKING_FEATURE
// Set blinking period
// #define MY_DEFAULT_LED_BLINK_PERIOD 300
// Inverses the behavior of leds
// #define MY_WITH_LEDS_BLINKING_INVERSE
// Enable inclusion mode
#define MY_INCLUSION_MODE_FEATURE
// Enable Inclusion mode button on gateway
#define MY_INCLUSION_BUTTON_FEATURE
// Inverses behavior of inclusion button (if using external pullup)
//#define MY_INCLUSION_BUTTON_EXTERNAL_PULLUP
// Set inclusion mode duration (in seconds)
#define MY_INCLUSION_MODE_DURATION 60
// Digital pin used for inclusion mode button
#define MY_INCLUSION_MODE_BUTTON_PIN 3
// Uncomment to override default HW configurations
//#define MY_DEFAULT_ERR_LED_PIN 4 // Error led pin
//#define MY_DEFAULT_RX_LED_PIN 6 // Receive led pin
//#define MY_DEFAULT_TX_LED_PIN 5 // the PCB, on board LED
#include <Bounce2.h>
#include <MySensors.h>
#include <SPI.h>
#define BUTTON_UP 54// Arduino Digital I/O pin number for up button
#define BUTTON_DOWN 55 // Arduino Digital I/O pin number for down button
//#define BUTTON_STOP_PIN 5 // Arduino Digital I/O pin number for stop button
//#define RELAY_DIR_PIN 6 // Arduino Digital I/O pin number for direction relay
//#define RELAY_POWER_PIN 7 // Arduino Digital I/O pin number for power relay
#define RELAY_UP 22
#define RELAY_DOWN 23
#define NUMBER_OF_RELAYS 2
#define RELAY_ON 1
#define RELAY_OFF 0
//#define RELAY_DOWN 1
//#define RELAY_UP 0
#define DIRECTION_DOWN 0
#define DIRECTION_UP 1
#define SKETCH_NAME "Cover by Marek"
#define SKETCH_VER "1.0"
#define CHILD_ID_COVER 0 // sensor Id of the sensor child
#define STATE_UP 100 // 100 is open - up
#define STATE_DOWN 0 // 0 is closed - down
//#define CHILD_ID_CALIBRATE 1 // sensor Id of the sensor child to calibrate
#define CHILD_ID_SET 1 // sensor Id of the sensor child to init the roll time
#define PRESENT_MESSAGE "Cover sensor for hass"
const int LEVELS = 100; //the number of levels
float rollTime = 10.0; //the overall rolling time of the shutter
const bool IS_ACK = false; //is to acknowlage
static bool initial_state_sent = false;//for hass we need at list one state send at begining
// debouncing parameters
int value = 0;
int oldValueUp = 0;
int oldValueDown = 0;
int oldValueStop = 0;
//static unsigned long last_interrupt_time_up = 0;
//static unsigned long last_interrupt_time_down = 0;
//static unsigned long debounce_time = 200;
Bounce debouncerUp = Bounce();
Bounce debouncerDown = Bounce();
Bounce debouncerStop = Bounce();
// shutter position parameters
float timeOneLevel = rollTime / LEVELS;
int requestedShutterLevel = 0;
int currentShutterLevel = 0;
unsigned long lastLevelTime = 0;
bool isMoving = false;
int directionUpDown;
enum CoverState {
STOP,
UP, // Window covering. Up.
DOWN, // Window covering. Down.
};
static int coverState = STOP;
MyMessage msgUp(CHILD_ID_COVER, V_UP);
MyMessage msgDown(CHILD_ID_COVER, V_DOWN);
MyMessage msgStop(CHILD_ID_COVER, V_STOP);
MyMessage msgPercentage(CHILD_ID_COVER, V_PERCENTAGE);
//MyMessage msgCode(CHILD_ID_SET, V_IR_SEND);
void sendState() {
// Send current state and status to gateway.
send(msgUp.set(coverState == UP));
send(msgDown.set(coverState == DOWN));
send(msgStop.set(coverState == STOP));
send(msgPercentage.set(currentShutterLevel));
}
void shuttersUp(void) {
#ifdef MY_DEBUG
Serial.println("Shutters going up");
#endif
if (digitalRead(RELAY_DOWN) == RELAY_ON) {
digitalWrite(RELAY_DOWN, RELAY_OFF);
wait(50);
}
digitalWrite(RELAY_UP, RELAY_ON);
directionUpDown = DIRECTION_UP;
isMoving = true;
coverState = UP;
sendState();
}
void shuttersDown(void) {
#ifdef MY_DEBUG
Serial.println("Shutters going down");
#endif
if (digitalRead(RELAY_UP) == RELAY_ON) {
digitalWrite(RELAY_UP, RELAY_OFF);
wait(50);
}
digitalWrite(RELAY_DOWN, RELAY_ON);
directionUpDown = DIRECTION_DOWN;
isMoving = true;
coverState = DOWN;
sendState();
}
void shuttersHalt(void) {
#ifdef MY_DEBUG
Serial.println("Shutters halted");
#endif
digitalWrite(RELAY_UP, RELAY_OFF);
digitalWrite(RELAY_DOWN, RELAY_OFF);
isMoving = false;
requestedShutterLevel = currentShutterLevel;
#ifdef MY_DEBUG
Serial.println("saving state to: ");
Serial.println(String(currentShutterLevel));
#endif
saveState(CHILD_ID_COVER, currentShutterLevel);
coverState = STOP;
sendState();
}
void changeShuttersLevel(int level) {
int dir = (level > currentShutterLevel) ? DIRECTION_UP : DIRECTION_DOWN;
if (isMoving && dir != directionUpDown) {
shuttersHalt();
}
requestedShutterLevel = level;
}
void initShutters() {
#ifdef MY_DEBUG
Serial.println("Init Cover");
#endif
shuttersUp();
wait((rollTime + timeOneLevel * LEVELS) * 1000);
currentShutterLevel = STATE_UP;
requestedShutterLevel = currentShutterLevel;
}
void receive(const MyMessage &message) {
#ifdef MY_DEBUG
Serial.println("recieved incomming message");
Serial.println("Recieved message for sensor: ");
Serial.println(String(message.sensor));
Serial.println("Recieved message with type: ");
Serial.println(String(message.type));
#endif
if (message.sensor == CHILD_ID_COVER) {
switch (message.type) {
case V_UP:
//Serial.println(", New status: V_UP");
changeShuttersLevel(STATE_UP);
//state = UP;
//sendState();
break;
case V_DOWN:
//Serial.println(", New status: V_DOWN");
changeShuttersLevel(STATE_DOWN);
//state = DOWN;
//sendState();
break;
case V_STOP:
//Serial.println(", New status: V_STOP");
shuttersHalt();
//state = IDLE;
//sendState();
break;
case V_PERCENTAGE:
//Serial.println(", New status: V_PERCENTAGE");
// if (!initial_state_sent) {
// #ifdef MY_DEBUG
// Serial.println("Receiving initial value from controller");
// #endif
// initial_state_sent = true;
// }
int per = message.getInt();
if (per > STATE_UP) {
per = STATE_UP;
}
changeShuttersLevel(per);
//InitShutters(message.getInt());//send value < 0 or > 100 to calibrate
//sendState();
break;
}
}
else if (message.sensor == CHILD_ID_SET) {
if (message.type == V_VAR1) {
#ifdef MY_DEBUG
Serial.println(", New status: V_VAR1, with payload: ");
#endif
String strRollTime = message.getString();
rollTime = strRollTime.toFloat();
#ifdef MY_DEBUG
Serial.println("rolltime value: ");
Serial.println(String(rollTime));
#endif
saveState(CHILD_ID_SET, rollTime);
}
}
#ifdef MY_DEBUG
Serial.println("exiting incoming message");
#endif
return;
}
void before() {
// Setup the button
pinMode(BUTTON_UP, INPUT_PULLUP);
// Activate internal pull-up
// digitalWrite(BUTTON_UP_PIN, HIGH);
// attachInterrupt(digitalPinToInterrupt(BUTTON_UP_PIN), upButtonPress, FALLING);
pinMode(BUTTON_DOWN, INPUT_PULLUP);
// Activate internal pull-up
// digitalWrite(BUTTON_DOWN_PIN, HIGH);
// attachInterrupt(digitalPinToInterrupt(BUTTON_DOWN_PIN), downButtonPress, FALLING);
// pinMode(BUTTON_STOP_PIN, INPUT_PULLUP);
// Activate internal pull-up
// digitalWrite(BUTTON_STOP_PIN, HIGH);
// After setting up the button, setup debouncer
debouncerUp.attach(BUTTON_UP);
debouncerUp.interval(5);
// After setting up the button, setup debouncer
debouncerDown.attach(BUTTON_DOWN);
debouncerDown.interval(5);
// After setting up the button, setup debouncer
// debouncerStop.attach(BUTTON_STOP_PIN);
// debouncerStop.interval(5);
// Make sure relays are off when starting up
digitalWrite(RELAY_UP, RELAY_OFF);
// Then set relay pins in output mode
pinMode(RELAY_UP, OUTPUT);
// Make sure relays are off when starting up
digitalWrite(RELAY_DOWN, RELAY_OFF);
// Then set relay pins in output mode
pinMode(RELAY_DOWN, OUTPUT);
}
void presentation() {
// Send the sketch version information to the gateway and Controller
sendSketchInfo(SKETCH_NAME, SKETCH_VER);
// Register all sensors to gw (they will be created as child devices)
present(CHILD_ID_COVER, S_COVER, PRESENT_MESSAGE, IS_ACK);
// present(CHILD_ID_SET, S_CUSTOM);
}
void setup(void) {
//set up roll time if the saved value is not 255
#ifdef MY_DEBUG
Serial.println("getting rolltime from eeprom: ");
#endif
float tmpRollTime = loadState(CHILD_ID_SET);
if (tmpRollTime != 0xff) {
rollTime = tmpRollTime;
}
#ifdef MY_DEBUG
Serial.println(String(rollTime));
#endif
int state = loadState(CHILD_ID_COVER);
#ifdef MY_DEBUG
Serial.println("getting state from eeprom: ");
Serial.println(String(state));
#endif
if (state == 0xff) {
initShutters();
} else {
changeShuttersLevel(state);
}
}
void loop(void) {
if (!initial_state_sent) {
#ifdef MY_DEBUG
Serial.println("Sending initial value");
#endif
sendState();
// send(msgCode.set('20.0'));
// #ifdef MY_DEBUG
// Serial.println("Requesting initial value from controller");
// #endif
// request(CHILD_ID_COVER, V_PERCENTAGE);
// wait(2000, C_SET, V_PERCENTAGE);
initial_state_sent = true;
}
debouncerUp.update();
value = debouncerUp.read();
if (value == 0 && value != oldValueUp) {
if(isMoving){
shuttersHalt();
}
else{
changeShuttersLevel(STATE_UP);
}
//state = UP;
//sendState();
}
oldValueUp = value;
debouncerDown.update();
value = debouncerDown.read();
if (value == 0 && value != oldValueDown) {
if(isMoving){
shuttersHalt();
}
else{
changeShuttersLevel(STATE_DOWN);
}
//state = DOWN;
//sendState();
}
oldValueDown = value;
/* debouncerStop.update();
value = debouncerStop.read();
if (value == 0 && value != oldValueStop) {
shuttersHalt();
//state = IDLE;
//sendState();
}
oldValueStop = value;
*/
if (isMoving) {
unsigned long _now = millis();
if (_now - lastLevelTime >= timeOneLevel * 1000) {
if (directionUpDown == DIRECTION_UP) {
currentShutterLevel += 1;
} else {
currentShutterLevel -= 1;
}
#ifdef MY_DEBUG
Serial.println(String(requestedShutterLevel));
Serial.println(String(currentShutterLevel));
#endif
lastLevelTime = millis();
send(msgPercentage.set(currentShutterLevel));
}
if (currentShutterLevel == requestedShutterLevel) {
shuttersHalt();
}
}
else if (requestedShutterLevel != currentShutterLevel) {
if (requestedShutterLevel > currentShutterLevel) {
shuttersUp();
}
else {
shuttersDown();
}
lastLevelTime = millis();
}
}
Jest to poniekąd logiczne, ale nie wspomniałem o tym. Co do zmian w arduino - owszem masz rację że program może się zawiesić, ale lepiej dopisać to wyłączenie. Z praktyki - od 2 lat używam różnych kombinacji sprzętowych i jeszcze się nie zdarzyło żeby się program zawiesił - no ale zawsze może się zdarzyć.