rgb sketch doet geen rood meer?

Arduino specifieke Software
Berichten: 47
Geregistreerd: 24 Nov 2014, 19:47

Re: rgb sketch doet geen rood meer?

Berichtdoor corolla_g6 » 24 Jul 2017, 20:20

oke, ik begin het een beetje te begrijpen., ik heb nu 255 vervangen voor 254 en dat werkt! maar nu heb ik nog een arduino mega voor mijn tuinverlichting en daar gebruik ik 4x hetzelfde soort trucje om 4 0-10 volt dimmers aan te sturen. hiervoor heb ik een printje gemaakt welke pwm omzet naar 0-10 volt.

hierbij werken de eerste 3 wel maar de laatste doet ook weer raar... en hier werkt het van 254 niet.... het wordt er zelfs slechter op..

hieronder de volledige sketch.

cpp code
#include <SPI.h>
#include <Ethernet.h>
#include <LiquidCrystal_I2C.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <OneWire.h>

//-----------------------------------------------------uitgangen----------------------------------------------------//

#define outAlgemeen 47 //verlichting aan het huis, zodra donker dan aan
#define outVoorTuin 45 //voortuin verlichting in de plantenbakken
#define outZijkantPad 43 //2x staande armatuur naast het pad
#define outGarageDeur 41 //verlichting boven de deur van de garage
#define outSpots 46 //spots bij de bomen van de zijtuin
#define outReserve2 44 //reserve uitgang
#define outSchutting 42 // spotje aan de schutting
#define outReserve1 40 // reserve uitgang

#define outOverkapping 3
#define outBbq 4
#define outJacuzzi 5
#define outLounge 6


#define OnlineStatus 7

#define vorstGrens 5


OneWire ds(8);

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address

byte addrTempSensor1[] = {0x28, 0x75, 0x31, 0x5C, 0x6, 0x0, 0x0, 0x3F}; //buitentemperatuur
//byte addrTempSensor1[] = {0x28, 0xFF, 0xC4, 0x57, 0xB2, 0x15, 0x3, 0x29}; //testbord



unsigned long time1;
unsigned long time2;

byte mqtt[8] =
{
B00000,
B00000,
B01110,
B01010,
B01110,
B00000,
B00000,
};

int blinkState = LOW;
const long interval = 1000;
unsigned long previousMillis = 0;

uint32_t timer = 0;
boolean timerLoopt = false;
const uint32_t WACHTTIJD = 5000;


byte i;
byte present = 0;
byte type_s;
byte data[12];
float celsius;
float temp_buiten;
boolean vorstStatus = 0;
boolean oldVorstStatus = 0;

//------------------------------------------------------LDR standen--------------------------------------------------//

#define LdrGroep1LichtGrens 2500
#define LdrGroep1DonkerGrens 2000
//-------------------------------------------------------------------------------------------------------------------//
boolean oldLdrStatus = 0;
boolean LdrStatus = 0;


boolean mqttstatusvoortuin = 1;
boolean voortuinUpdateFlag = 1;

boolean mqttstatuszijkantpad = 1;
boolean zijkantpadUpdateFlag = 1;

boolean mqttstatusgaragedeur = 1;
boolean garagedeurUpdateFlag = 1;

boolean mqttstatusspots = 0;
boolean spotsUpdateFlag = 1;

boolean mqttstatusschutting = 1;
boolean schuttingUpdateFlag = 1;

boolean mqttstatusornament = 0;
boolean ornamentUpdateFlag = 1;


boolean mqttstatuslounge = 0;
boolean loungeUpdateFlag = 1;

boolean mqttstatusbbq = 0;
boolean bbqUpdateFlag = 1;

boolean mqttstatusjacuzzi = 0;
boolean jacuzziUpdateFlag = 1;

boolean mqttstatusoverkapping = 1;
boolean overkappingUpdateFlag = 1;



// byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xDE }; //testbord
// IPAddress ip(192, 168, 2, 85);


boolean Retained = true;

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x48, 0x05 };
IPAddress ip(192, 168, 2, 147);


IPAddress server(192, 168, 2, 140);

EthernetClient ethClient;
PubSubClient client(ethClient);

//----------------------------------------------------------einde define's-------------------------------------------------//

const int inLdr = A5;

int inLdrValue = 0;
long outLdrValue = 0;
long LdrValue2 = 0;
long LdrValue1 = 0;

void setup()
{
Wire.begin();
lcd.begin(20, 4);
Serial.begin(9600);

pinMode(inLdr, INPUT);


pinMode(outAlgemeen, OUTPUT);
pinMode(outVoorTuin, OUTPUT);
pinMode(outZijkantPad, OUTPUT);
pinMode(outGarageDeur, OUTPUT);
pinMode(outSpots, OUTPUT);
pinMode(outSchutting, OUTPUT);
pinMode(outReserve1, OUTPUT);
pinMode(outReserve2, OUTPUT);

pinMode(OnlineStatus, OUTPUT);


digitalWrite(outAlgemeen, HIGH);
digitalWrite(outVoorTuin, HIGH);
digitalWrite(outZijkantPad, HIGH);
digitalWrite(outGarageDeur, HIGH);
digitalWrite(outSpots, HIGH);
digitalWrite(outSchutting, HIGH);
digitalWrite(outReserve1, HIGH);
digitalWrite(outReserve2, HIGH);

digitalWrite(OnlineStatus, LOW);


for (int i = 0; i < 3; i++)
{
lcd.backlight();
delay(250);
lcd.noBacklight();
delay(250);
}
lcd.backlight(); // finish with backlight on


lcd.createChar(4, mqtt);

client.setServer(server, 1883);
client.setCallback(callback);

Ethernet.begin(mac, ip);
// Allow the hardware to sort itself out
delay(1500);

}

void callback(char* topic, byte* payload, unsigned int length)
{
byte* p = (byte*)malloc(length);
// Copy the payload to the new buffer
memcpy(p, payload, length);

if (strcmp(topic, "/tuinverlichting/callstatus") == 0)
{
switch ((int)(p[0] - '0'))
{
case 1:
voortuinUpdateFlag = 1;
zijkantpadUpdateFlag = 1;
garagedeurUpdateFlag = 1;
spotsUpdateFlag = 1;
schuttingUpdateFlag = 1;
ornamentUpdateFlag = 1;
loungeUpdateFlag = 1;
bbqUpdateFlag = 1;
jacuzziUpdateFlag = 1;
overkappingUpdateFlag = 1;
break;
}
}


//----------------------------------------------------------signaal vanaf een topic---------------------------------------//


if (strcmp(topic, "/tuinverlichting/voortuin") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusvoortuin = 0;
break;
case 1:
mqttstatusvoortuin = 1;
break;
default:
break;
}
voortuinUpdateFlag = true;
}

if (strcmp(topic, "/tuinverlichting/zijkantpad") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatuszijkantpad = 0;
break;
case 1:
mqttstatuszijkantpad = 1;
break;
default:
break;
}
zijkantpadUpdateFlag = true;
}


if (strcmp(topic, "/tuinverlichting/garagedeur") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusgaragedeur = 0;
break;
case 1:
mqttstatusgaragedeur = 1;
break;
default:
break;
}
garagedeurUpdateFlag = true;
}

if (strcmp(topic, "/tuinverlichting/spots") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusspots = 0;
break;
case 1:
mqttstatusspots = 1;
break;
default:
break;
}
spotsUpdateFlag = true;
}


if (strcmp(topic, "/tuinverlichting/schutting") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusschutting = 0;
break;
case 1:
mqttstatusschutting = 1;
break;
default:
break;
}
schuttingUpdateFlag = true;
}


if (strcmp(topic, "/tuinverlichting/ornament") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusornament = 0;
break;
case 1:
mqttstatusornament = 1;
break;
default:
break;
}
ornamentUpdateFlag = true;
}

//--------------------------------------------------overkapping overbrugging voor savonds----------------------------------//


if (strcmp(topic, "/tuinverlichting/overkapping") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusoverkapping = 0;
break;
case 1:
mqttstatusoverkapping = 1;
break;
default:
break;
}
overkappingUpdateFlag = true;
}

if (strcmp(topic, "/tuinverlichting/lounge") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatuslounge = 0;
break;
case 1:
mqttstatuslounge = 1;
break;
default:
break;
}
loungeUpdateFlag = true;
}

if (strcmp(topic, "/tuinverlichting/bbq") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusbbq = 0;
break;
case 1:
mqttstatusbbq = 1;
break;
default:
break;
}
bbqUpdateFlag = true;
}

if (strcmp(topic, "/tuinverlichting/jacuzzi") == 0)
{
switch ((int)(p[0] - '0'))
{
case 0:
mqttstatusjacuzzi = 0;
break;
case 1:
mqttstatusjacuzzi = 1;
break;
default:
break;
}
jacuzziUpdateFlag = true;
}


//------------------------------------------status request arduino online------------------------------------------------------//

if (strcmp(topic, "/arduinos/ping") == 0)
{
switch ((int)(p[0] - '0'))
{
case 1:
client.publish("/arduinos/ping", "Tuinverlichting Online");
client.publish("/tuinverlichting/status", "ONLINE");
break;
default:
break;
}
}

free(p);// Free the memory
//----------------------------------------------------overkapping 0-10volt--------------------------------------//


if (String(topic) == "/tuinverlichting/lounge/dimmer")
{
String valueLounge = String((char*)payload);
int valLounge = map(valueLounge.toInt(), -0, 100, 254, 25);
analogWrite(outLounge, valLounge);
}



if (String(topic) == "/tuinverlichting/bbq/dimmer")
{
String valueBbq = String((char*)payload);
int valBbq = map(valueBbq.toInt(), -0, 100, 254, 25);
analogWrite(outBbq, valBbq);
}



if (String(topic) == "/tuinverlichting/jacuzzi/dimmer")
{
String valueJacuzzi = String((char*)payload);
int valJacuzzi = map(valueJacuzzi.toInt(), -0, 100, 254, 25);
analogWrite(outJacuzzi, valJacuzzi);
}



if (String(topic) == "/tuinverlichting/overkapping/dimmer")
{
String valueOverkapping = String((char*)payload);
int valOverkapping = map(valueOverkapping.toInt(), -0, 100, 254, 25);
analogWrite(outOverkapping, valOverkapping);
}


}


void reconnect() {

Serial.print("Attempting MQTT connection...");
lcd.setCursor(0, 3);
lcd.print("MQTT Check ");


// Attempt to connect
if (client.connect("Tuinverlichting"))
{
lcd.setCursor(0, 3);
lcd.print("MQTT Online");
Serial.println("connected");
Serial.print("rc=");
Serial.println(client.state());
digitalWrite (OnlineStatus, HIGH);

// Once connected, publish an announcement...
client.publish("/arduino/message", "Tuinverlichting Online");
// ... and resubscribe

//--------------------------------------------------hieronder de gebruikte topics zetten----------------------------------------//

client.subscribe("/tuinverlichting/voortuin");
// client.subscribe("/tuinverlichting/voortuin/status");
client.subscribe("/tuinverlichting/zijkantpad");
// client.subscribe("/tuinverlichting/zijkantpad/status");
client.subscribe("/tuinverlichting/garagedeur");
// client.subscribe("/tuinverlichting/garagedeur/status");
client.subscribe("/tuinverlichting/spots");
// client.subscribe("/tuinverlichting/spots/status");
client.subscribe("/tuinverlichting/schutting");
// client.subscribe("/tuinverlichting/schutting/status");
client.subscribe("/tuinverlichting/ornament");
// client.subscribe("/tuinverlichting/ornament/status");

client.subscribe("/tuinverlichting/lounge");
// client.subscribe("/tuinverlichting/lounge/status");
client.subscribe("/tuinverlichting/lounge/dimmer");
// client.subscribe("/tuinverlichting/lounge/dimmer/status");

client.subscribe("/tuinverlichting/bbq");
// client.subscribe("/tuinverlichting/bbq/status");
client.subscribe("/tuinverlichting/bbq/dimmer");
// client.subscribe("/tuinverlichting/bbq/dimmer/status");

client.subscribe("/tuinverlichting/jacuzzi");
// client.subscribe("/tuinverlichting/jacuzzi/status");
client.subscribe("/tuinverlichting/jacuzzi/dimmer");
// client.subscribe("/tuinverlichting/jacuzzi/dimmer/status");

client.subscribe("/tuinverlichting/overkapping");
// client.subscribe("/tuinverlichting/overkapping/status");
client.subscribe("/tuinverlichting/overkapping/dimmer");
// client.subscribe("/tuinverlichting/overkapping/dimmer/status");

client.subscribe("/tuinverlichting/temperatuurbuiten");
client.subscribe("/tuinverlichting/callstatus");
client.subscribe("/tuinverlichting/ldr/status");
client.subscribe("/tuinverlichting/vorst/status");
client.subscribe("/tuinverlichting/status");
client.subscribe("/arduino/message");
client.subscribe("/arduinos/ping");
client.subscribe("/tuinverlichting/ping");


//------------------------------------------------------------------------------------------------------------------------------//
}
else
{
digitalWrite (OnlineStatus, LOW);
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
lcd.setCursor(0, 3);
lcd.print("MQTT Fail ");
}
}


void loop()
{
if (!client.connected())
{
if (!timerLoopt)
{
timer = millis();
timerLoopt = true;
}
else
{
if ((millis() - timer) > WACHTTIJD)
{
reconnect();
timerLoopt = false;
}
}
}

else
{
client.loop();
}

regeling();

unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) {

previousMillis = currentMillis;

if (blinkState == LOW)
{
blinkState = HIGH;
lcd.setCursor(11, 3);
lcd.write(byte(4));
}
else
{
blinkState = LOW;
lcd.setCursor(11, 3);
lcd.write(" ");
}
}


}

void regeling()
{
if (millis() > (time1 + 10000))
{
time1 = millis();
char buffer[10];
temp_buiten = (float)tempsensorReadout(addrTempSensor1);

dtostrf(temp_buiten, 0, 2, buffer);
client.publish("/tuinverlichting/temperatuurbuiten", buffer, Retained);

lcd.setCursor(0, 0);
lcd.print("BuitenTemp:");
lcd.setCursor(11, 0);
lcd.print(" ");
lcd.setCursor(11, 0);
lcd.print(temp_buiten);
lcd.print(" C ");
}


if (millis() > (time2 + 1000))
{
time2 = millis();

inLdrValue = analogRead(inLdr);
LdrValue2 = LdrValue1;
LdrValue1 = map(inLdrValue, 0, 1023, 0, 5000);
outLdrValue = (LdrValue2 + LdrValue1) / 2;

lcd.setCursor(0, 1);
lcd.print("LDR waarde:");
lcd.setCursor(10, 1);
lcd.print(" ");
lcd.setCursor(10, 1);
lcd.print(outLdrValue);
lcd.setCursor(14, 1);
lcd.print("mV");
}


//--------------------------------------donker of licht?---------------------------------------
//oldLdrStatus=LdrStatus;
if (outLdrValue < LdrGroep1DonkerGrens)
{
LdrStatus = 1; // donker
digitalWrite(outAlgemeen, LOW);
}
else if (outLdrValue > LdrGroep1LichtGrens)
{
digitalWrite(outAlgemeen, HIGH);
LdrStatus = 0; //licht
}
//--------------------------------------------------------------------------------------------


//--------------------------------------vorst---------------------------------------

if (temp_buiten < vorstGrens)
{
vorstStatus = 0; // vorst
}
else if (temp_buiten > vorstGrens)
{
vorstStatus = 1; //geenvorst
}
//--------------------------------------------------------------------------------------------//

if (oldLdrStatus != LdrStatus) {

if (LdrStatus)
{
client.publish("/tuinverlichting/ldr/status", "1", Retained);
client.publish("/trap/dimmer", "1");

}
else
{
client.publish("/tuinverlichting/ldr/status", "0", Retained);
client.publish("/trap/dimmer", "0");
}
}

if (oldVorstStatus != vorstStatus) {
if (vorstStatus)
{
client.publish("/tuinverlichting/vorst/status", "1", Retained);


}
else
{
client.publish("/tuinverlichting/vorst/status", "0", Retained);
}
}




// outOrnament
if (ornamentUpdateFlag | (oldVorstStatus != vorstStatus)) {
ornamentUpdateFlag = false;

if (mqttstatusornament)
{
if (vorstStatus)
{
client.publish("/blokhut/ornament/", "1");
client.publish("/tuinverlichting/ornament/status", "ACTIVE", Retained);
}
else
{
client.publish("/blokhut/ornament/", "0");
client.publish("/tuinverlichting/ornament/status", "VORST", Retained);
}
}
else
{
client.publish("/blokhut/ornament/", "0");
client.publish("/tuinverlichting/ornament/status", "INACTIVE", Retained);
}
}

oldVorstStatus = vorstStatus;


//--------------------------------------als er een nieuw mqtt bericht binnen is gekomen of als het licht/donker is geworden---------------------------------------

// outVoorTuin
if (voortuinUpdateFlag | (oldLdrStatus != LdrStatus))
{
voortuinUpdateFlag = false;

if (mqttstatusvoortuin)
{
if (LdrStatus)
{
digitalWrite(outVoorTuin, LOW);
client.publish("/tuinverlichting/voortuin/status", "ACTIVE", Retained);
}
else
{
digitalWrite(outVoorTuin, HIGH);
client.publish("/tuinverlichting/voortuin/status", "STANDBY", Retained);
}
}
else
{
digitalWrite(outVoorTuin, HIGH);
client.publish("/tuinverlichting/voortuin/status", "INACTIVE", Retained);
}
}

// outZijkantPad
if (zijkantpadUpdateFlag | (oldLdrStatus != LdrStatus))
{
zijkantpadUpdateFlag = false;

if (mqttstatuszijkantpad)
{
if (LdrStatus)
{
digitalWrite(outZijkantPad, LOW);
client.publish("/tuinverlichting/zijkantpad/status", "ACTIVE", Retained);
}
else
{
digitalWrite(outZijkantPad, HIGH);
client.publish("/tuinverlichting/zijkantpad/status", "STANDBY", Retained);
}
}
else
{
digitalWrite(outZijkantPad, HIGH);
client.publish("/tuinverlichting/zijkantpad/status", "INACTIVE", Retained);
}
}

// outGarageDeur
if (garagedeurUpdateFlag | (oldLdrStatus != LdrStatus))
{
garagedeurUpdateFlag = false;

if (mqttstatusgaragedeur)
{
if (LdrStatus)
{
digitalWrite(outGarageDeur, LOW);
client.publish("/tuinverlichting/garagedeur/status", "ACTIVE", Retained);
}
else
{
digitalWrite(outGarageDeur, HIGH);
client.publish("/tuinverlichting/garagedeur/status", "STANDBY", Retained);
}
}
else
{
digitalWrite(outGarageDeur, HIGH);
client.publish("/tuinverlichting/garagedeur/status", "INACTIVE", Retained);
}
}

// outSpots
if (spotsUpdateFlag | (oldLdrStatus != LdrStatus))
{
spotsUpdateFlag = false;

if (mqttstatusspots)
{
if (LdrStatus)
{
digitalWrite(outSpots, LOW);
client.publish("/tuinverlichting/spots/status", "ACTIVE", Retained);
}
else
{
digitalWrite(outSpots, HIGH);
client.publish("/tuinverlichting/spots/status", "STANDBY", Retained);
}
}
else
{
digitalWrite(outSpots, HIGH);
client.publish("/tuinverlichting/spots/status", "INACTIVE", Retained);
}
}

// outSchutting
if (schuttingUpdateFlag | (oldLdrStatus != LdrStatus))
{
schuttingUpdateFlag = false;

if (mqttstatusschutting)
{
if (LdrStatus)
{
digitalWrite(outSchutting, LOW);
client.publish("/tuinverlichting/schutting/status", "ACTIVE", Retained);
}
else
{
digitalWrite(outSchutting, HIGH);
client.publish("/tuinverlichting/schutting/status", "STANDBY", Retained);
}
}
else
{
digitalWrite(outSchutting, HIGH);
client.publish("/tuinverlichting/schutting/status", "INACTIVE", Retained);
}
}

oldLdrStatus = LdrStatus;



}
//--------------------------------------------------------------------------------------------

float tempsensorReadout(byte addr[8])
{
ds.reset();
ds.select(addr);
ds.write(0x44);

present = ds.reset();
ds.select(addr);
ds.write(0xBE);

for ( i = 0; i < 9; i++)
{
data[i] = ds.read();
}
OneWire::crc8(data, 8);

int16_t raw = (data[1] << 8) | data[0];
if (type_s)
{
raw = raw << 3;
if (data[7] == 0x10)
{
raw = (raw & 0xFFF0) + 12 - data[6];
}
}
else
{
byte cfg = (data[4] & 0x60);
if (cfg == 0x00) raw = raw & ~7;
else if (cfg == 0x20) raw = raw & ~3;
else if (cfg == 0x40) raw = raw & ~1;
}
celsius = (float)raw / 16.0;
return celsius;

}

Advertisement

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: rgb sketch doet geen rood meer?

Berichtdoor Koepel » 24 Jul 2017, 23:29

Dat is een beetje teveel en ik wordt afgeleid door allerlei dingen die ik zie.
Kun je een minimale sketch maken waarin het probleem voorkomt ? Als je zo'n minimale sketch hebt gemaakt, dan kun je zelf de invoer in de sketch zetten om droog te zwemmen. Dan zou je zelf al kunnen zien wat er gebeurt.


Je mag geen tijd in de toekomst berekenen: if (millis() > (time1 + 10000)).
Dan onstaat het rollover probleem. Doe altijd de huidige millis minus de vorige millis: if (millis() - time1 >= 10000)).

Anderen gebruiken de DallasTemperature library. Dan hoef je niet zelf die berekening van de DS18B20 te doen.

Vorige

Terug naar Arduino software

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 20 gasten