So da habe ich mir den Code mal angesehen und der Unterschied ist lediglich diese Zeile beim dem MAX: my_sensor.light = lux/4;
Aber ich scheine wohl meinen Sensor wie auch immer gegrillt zu haben, da mit der Zeile logischerweise meine 2937 Lux nunmehr durch 4 geteilt, also maximal 734 angezeigt werden. Dann werde ich mal einen Ersatzsensor ordern, wenn der Code bei Dir verlässliche Werte anzeigt.
thehackisback.
Sorry, habe ich gamz vergessen das ich den LUX Wert künstlich am Arduino verringere, da ich Probleme mit den hohen Werten und der ZWave Übertragung hatte.
Das der echte Luxwert ist 4* höher als dieser Code auswirft.
Den Wert habe ich in der HC2 auf W/m2 umgerechnet.
Bei Sonnenschein habe ich 17.000 (68.000 in echt)
Ok, dann lag es zum Glück nicht an meinem Code sondern wohl am Sensor. Ich werde berichten, sobald der neue Sensor da ist. Bis dahin drucke ich mal die Wetterhütte für die Wetterstation weiter. Vielleicht kann ich bis dahin den nächsten Prototyp präsentieren.
Abend, so ich habe die letzten Tage mal wieder ein wenig Luft zum Basteln gehabt, dabei habe ich auch den Fehler bezüglich des VEML gefunden. Ich hatte diesen im Setup per I2C angesprochen und danach nur noch im Loop die Werte abgegriffen. Sobald ich aber alles in den Loop verlagere hat dieser die richtigen Werte. Dein Problem mit den hohen Werten hatte ich noch nicht. Könntest du mir noch einen Denkanstoß geben, wie ich den UV-Wert an Wunderground übermittelt bekomme?
–[[ UV_OUT–]]v2[11]={11,‚UV‘,‚‘}
–[[ UV_OUT–]]v3[WS][11]={‚UV‘,‚‘,‚‘,‚‘}
`
Ansonsten habe ich noch ein wenig an den Prototypen der Gehäuse gebastelt. Das blaue ist die zu große Variante als Vogelhaus und die weiße ist die Variante 2, als Wetterhütte mit geringerem Platz innen.
Bild
WOW,
das sieht ja richtig Professionell aus.
Bezüglich UV Wert solltest bei der Webservice Konfiguration folgendes eingeben. (1. Zeile ist nur Bsp. für Format)
--[[ Pressure_IN--]]v3[WS][13]={'baromin','hpa2inch','AVG',''}
--[[ UV--]]v3[WS][13]={'UV','','AVG',''}
Nur die Werte in einer unkonfigurierten Zeile ändern.
Und dann natürlich die Szene einmal starten.
Hier ist das Wunderground Protokol:
https://feedback.weather.com/customer/en/portal/articles/2924682-pws-upload-protocol?b_id=17298
Was hast denn für einen UV Sensor verwendet?
Danke für das Lob und den Denkanstoß. Mit dem 3D Programm komme ich deutlich besser klar, als mit Lua. Muss echt mal überlegen, ob ich nicht mal das System gegen z.B. Homey austausche. Der UV Sensor ist ein Veml6070 per i2c. Code kann ich gerne posten, wenn du ihn einsetzen willst.
Der UV Sensor ist recht günstig, ja bitte teile den Code, wird eh mal Zeit weiterzubasteln.
Mach ich am Wochenende. Ich hätte noch ein paar rumliegen, bestelle immer 5 in China. Bei einem ist die Chance des Defektes mir zu groß.
Ich habe diesse Libary hier verwendet:
und lediglich den UV-Index hinzugefügt, sodass hieraus folgendes wurde:
Bis jetzt ist der Wire-Aufruf noch im Setup und funktioniert. Ich wollte aber noch beobachten, ob es nicht wie beim Luxsensor in den Loop wandert.
Ansonsten habe ich große Probleme mit meiner 0815 Raingauge. Funktioniert deine Davis problemlos? Ich bin am überlegen, ob ich noch einen Regensensor Regensensor verbaue, da ich sonst keine Scene bezüglich der Dachfenster und des Regens bauen kann.
#define DEBUG
#include <Wire.h>
#include <math.h>
#include "EEPROM.h"
#define EEPROM_ADDR 0x800 // EEPROM address
#define EEPROM_UPDATE_INTERVAL 120000 // Delayed EEPROM writing to minimize writting attempts
#include "ZUNO_BME280.h"
BME280 bme; //BME
#define Addr 0x4A //M44009
#define I2C_ADDR 0x38 //VEML6070
//Integration Time
#define IT_1_2 0x0 //1/2T
#define IT_1 0x1 //1T
#define IT_2 0x2 //2T
#define IT_4 0x3 //4T
#define wind2_factor 1.22 //m/s per pulse in 2 seconds
#define rain_factor 0.40894 //mm per pulse
ZUNO_SETUP_ISR_INT0(int0_handler);
ZUNO_SETUP_ISR_INT1(int1_handler);
ZUNO_SETUP_ISR_GPTIMER(gpt_handler); // 2" Timer (2" & 1 Minute measurements)
struct meter_data {
dword rain_total;
byte crc8;
};
meter_data my_meter_data;
struct sensor_data {
int temperature = 0;
unsigned int humidity = 0;
float pressure = 0;
unsigned int wind_speed = 0;
unsigned int wind_gust = 0;
unsigned int wind_direction = 0;
unsigned int rain_rate = 0;
dword light = 5000;
byte UVIndex;
};
sensor_data my_sensor;
long last_write_EEPROM_millis = 0;
unsigned int wind_pulses = 0;
unsigned int wind_pulses60 = 0;
unsigned int wind_boe60 = 0;
unsigned int rain_pulses = 0;
unsigned int rain_pulses300 = 0;
byte data_updated = FALSE;
byte GPT_2sec = 0;
byte count_2sec = 0;
byte minute_Count = 0;
byte hour_Count = 0;
byte RR[12];
ZUNO_SETUP_CHANNELS(// set up channels
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE,
SENSOR_MULTILEVEL_SCALE_CELSIUS,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterTemperature),
ZUNO_SENSOR_MULTILEVEL_HUMIDITY(getterHumidity),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_VELOCITY,
SENSOR_MULTILEVEL_SCALE_METERS_PER_SECOND,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterVelocity),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_VELOCITY,
SENSOR_MULTILEVEL_SCALE_METERS_PER_SECOND,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterVelocityBoe),
ZUNO_SENSOR_MULTILEVEL_ANGLE_POSITION (getterDirection),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_RAIN_RATE,
SENSOR_MULTILEVEL_SCALE_MILLIMETERS_PER_HOUR,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_ONE_DECIMAL,
getterRainRate),
ZUNO_METER(ZUNO_METER_TYPE_WATER,
METER_RESET_ENABLE,
ZUNO_METER_WATER_SCALE_PULSECOUNT,
METER_SIZE_FOUR_BYTES,
METER_PRECISION_ONE_DECIMAL,
getterRain,
resetterRain),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_LUMINANCE,
SENSOR_MULTILEVEL_SCALE_LUX,
SENSOR_MULTILEVEL_SIZE_FOUR_BYTES,
SENSOR_MULTILEVEL_PRECISION_ZERO_DECIMALS,
GetterLightLux),
ZUNO_SENSOR_MULTILEVEL_ANGLE_POSITION (getterCount),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_BAROMETRIC_PRESSURE,
SENSOR_MULTILEVEL_SCALE_KILOPASCAL,
SENSOR_MULTILEVEL_SIZE_FOUR_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterPressure),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_ULTRAVIOLET,
SENSOR_MULTILEVEL_SCALE_ULTRAVIOLET_INDEX,
SENSOR_MULTILEVEL_SIZE_ONE_BYTE,
SENSOR_MULTILEVEL_PRECISION_ZERO_DECIMALS,
getterUV)
);
void setup() {
Serial.begin(9600);
zunoExtIntMode(ZUNO_EXT_INT0, RISING);
zunoExtIntMode(ZUNO_EXT_INT1, RISING);
zunoGPTInit(ZUNO_GPT_SCALE1024 | ZUNO_GPT_CYCLIC);
zunoGPTSet(62500); // 2 Sekunden Timer
zunoGPTEnable(1);
EEPROM.get(EEPROM_ADDR, &my_meter_data, sizeof(meter_data));
if (my_crc8((byte*)&my_meter_data, sizeof(meter_data) - 1) != my_meter_data.crc8) {
my_meter_data.rain_total = 0;
update_meter_data();
}
//VEML6070
Wire.begin();
Wire.beginTransmission(I2C_ADDR);
Wire.write((IT_1 << 2) | 0x02);
Wire.endTransmission();
delay(500);
}
void int0_handler() // PIN17-wind sensor interupt
{
wind_pulses++;
}
void int1_handler() // PIN18-rain sensor interupt
{
rain_pulses++;
}
void gpt_handler() // 2" Timer
{
GPT_2sec++;
}
byte ReadandDebugUVIndex() {
byte msb = 0, lsb = 0;
uint16_t uv;
int UV1 = 0;
Wire.requestFrom(I2C_ADDR + 1, 1); //MSB
delay(1);
if (Wire.available())
msb = Wire.read();
Wire.requestFrom(I2C_ADDR + 0, 1); //LSB
delay(1);
if (Wire.available())
lsb = Wire.read();
uv = (msb << 8) | lsb;
Serial.println("----------");
Serial.println("Sensor Type Max44009");
Serial.print("sensor voltage = ");
Serial.println(uv);
UV1 = uv;
if (UV1 < 50) return 0;
if (UV1 <= 227) return 1;
if (UV1 <= 318) return 2;
if (UV1 <= 408) return 3;
if (UV1 <= 503) return 4;
if (UV1 <= 606) return 5;
if (UV1 <= 696) return 6;
if (UV1 <= 795) return 7;
if (UV1 <= 881) return 8;
if (UV1 <= 976) return 9;
if (UV1 <= 1079) return 10;
return 11;
}
void readanddebugM44009() {
unsigned int dataL[2];
Wire.begin();
// Start I2C Transmission
Wire.beginTransmission(Addr);
// Select data register
Wire.write(0x03);
// Stop I2C transmission
Wire.endTransmission();
// Request 2 bytes of data
Wire.requestFrom(Addr, 2);
// Read 2 bytes of data
// luminance msb, luminance lsb
if (Wire.available() == 2)
{
dataL[0] = Wire.read();
dataL[1] = Wire.read();
}
// Convert the data to lux
int exponent = (dataL[0] & 0xF0) >> 4;
int mantissa = ((dataL[0] & 0x0F) << 4) | (dataL[1] & 0x0F);
float lux = pow(2, exponent) * mantissa * 0.045 ;
my_sensor.light = lux;
delay(300);
#ifdef DEBUG
Serial.print("Helligkeit ");
Serial.print("\t");
Serial.print(my_sensor.light);
Serial.println(" Lux");
#endif
}
void readanddebugBME280() {
bme.begin();
bme.setOversampling(4);
char result = bme.startMeasurement();
my_sensor.temperature = (bme.getTemperature100());
my_sensor.humidity = (bme.getHum());
my_sensor.pressure = bme.getPressure100();
Serial.println("----------");
Serial.print("Sensor Type");
if (bme.chip_id == 96) Serial.println("BME 280");
else Serial.println("BMP 280");
Serial.print("Temperature ");
Serial.print(my_sensor.temperature / 100.00); Serial.println(" C");
Serial.print("Pressure ");
Serial.print(bme.getPressure100() / 100);
Serial.println(" hPa");
if (bme.chip_id == 96) {
Serial.print("Humidity ");
Serial.print(my_sensor.humidity); Serial.println(" %");
}
Serial.println("----------");
delay(5000);
}
void loop() {
if (count_2sec != GPT_2sec) {
count_2sec = GPT_2sec;
if (wind_pulses > wind_boe60) {
my_sensor.wind_direction = map(analogRead(A1), 0, 1024, 0, 100); //PIN4- wind direction 0-100 in 3.6° steps 100=N
Serial.print("Windrichtung2 ");
Serial.println(my_sensor.wind_direction);
wind_boe60 = wind_pulses ;
}
wind_pulses60 = (wind_pulses60 + wind_pulses);
wind_pulses = 0;
if (rain_pulses > 0) {
my_meter_data.rain_total = my_meter_data.rain_total + 1; //Debounce 2 would be 180-360mm/h
rain_pulses300 = rain_pulses300 + 1;
rain_pulses = 0;
data_updated = true;
}
if (count_2sec > 29) {
minute_Count++;
if (minute_Count > 4) {
minute_Count = 0;
hour_Count++;
if (hour_Count > 11) {
hour_Count = 0;
}
RR[hour_Count] = rain_pulses300;
rain_pulses300 = 0;
for (byte i = 0; i < 12; i++) {
rain_pulses300 = rain_pulses300 + RR[i] ;
}
my_sensor.rain_rate = rain_pulses300 ;
rain_pulses300 = 0;
}
my_sensor.wind_speed = wind_pulses60 * wind2_factor / 30 * 100; //Measurement in m/s
my_sensor.wind_gust = wind_boe60 * wind2_factor * 100; //Measurement in m/s
#ifdef DEBUG
Serial.print("Windspeed ");
Serial.print("\t");
Serial.println(my_sensor.wind_speed);
Serial.print("Regenrate(Clicks) ");
Serial.print("\t");
Serial.println(my_sensor.rain_rate);
Serial.println("----------");
#endif
wind_boe60 = 0;
wind_pulses60 = 0;
GPT_2sec = 0;
readSensor();
}
}
if (data_updated && (millis() - last_write_EEPROM_millis) > EEPROM_UPDATE_INTERVAL) { // To save EEPROM from a lot of r/w operation write it once in EEPROM_UPDATE_INTERVAL if data was updated
update_meter_data();
data_updated = false;
last_write_EEPROM_millis = millis();
}
delay(100);
/*
// TEST-SENSOREN-OHNE-1-MINUTE-WARTEZEIT
readSensor();
my_sensor.UVIndex = ReadandDebugUVIndex();
delay(1000);
#ifdef DEBUG
Serial.print("UV-INDEX = ");
Serial.print("\t");
Serial.println(my_sensor.UVIndex);
Serial.println("----------");
#endif
*/
}
void readSensor () {
readanddebugM44009();
readanddebugBME280();
my_sensor.UVIndex = ReadandDebugUVIndex();
delay(1000);
#ifdef DEBUG
Serial.print("UV-INDEX = ");
Serial.print("\t");
Serial.println(my_sensor.UVIndex);
Serial.println("----------");
#endif
zunoSendReport(1);
zunoSendReport(2);
zunoSendReport(3);
zunoSendReport(4);
zunoSendReport(5);
zunoSendReport(6);
zunoSendReport(7);
zunoSendReport(8);
zunoSendReport(9);
zunoSendReport(10);
zunoSendReport(11);
zunoSendReport(12);
}
byte my_crc8(byte * data, byte count) {
byte result = 0xDF;
while (count--) {
result ^= *data;
data++;
}
return result;
}
void update_meter_data() {
my_meter_data.crc8 = my_crc8((byte*)&my_meter_data, sizeof(meter_data) - 1);
EEPROM.put(EEPROM_ADDR, &my_meter_data, sizeof(meter_data));
}
word getterTemperature() {
return my_sensor.temperature;
}
word getterHumidity() {
return my_sensor.humidity;
}
word getterVelocity() {
return my_sensor.wind_speed;
}
word getterVelocityBoe() {
return my_sensor.wind_gust;
}
word getterDirection() {
return my_sensor.wind_direction;
}
word getterRainRate() {
return my_sensor.rain_rate * rain_factor * 10;
}
word getterCount() {
return minute_Count;
}
void resetterRain(byte v) {
my_meter_data.rain_total = 0;
update_meter_data();
}
dword getterRain(void) {
return my_meter_data.rain_total * rain_factor * 10;
}
dword GetterLightLux() {
return my_sensor.light;
}
dword getterPressure() {
return my_sensor.pressure;
}
byte getterUV() {
return my_sensor.UVIndex;
}
Danke,
der Davis Regenmesser funktioniert bis jetzt ohne Probleme.
Ist halt Riesengroß.
Falls du Deine Dachfenster bei Regen schließen willst wäre wahrscheinlich ein beheizter Regenmelder besser.
https://www.reichelt.com/ch/de/regenmelder-hyg-regen-24v-p117274.html?CTYPE=0&MWSTFREE=0&PROVID=2788&wt_gacha=55399629803_272998727678&PROVID=2788&gclid=CjwKCAjw36DpBRAYEiwAmVVDMFHzTGrsOFEJU16U4YGYK6VZ754mpbSK3ou5cC3FBfR3tyGGSIJlgRoCkBEQAvD_BwE&&r=1
Der sollte beim ersten Tropfen ansprechen und nicht erst nach 0,2mm.
Kann dir aber nichts zur Zuverlässigkeit sagen.
Sieht gut aus, wobei bei allem über 5v beim Arduino/Zuno mein Latein am Ende ist. Da muss ich mich erstmal einlesen, bevor ich den Arduino und den Sensor brate.
Der Sensor bräuchte eine eigenständige Stromversorgung. Der Arduino käme an den potentialfreien Kontakt. Somit keine Grillgefahr. Wegen Heizung wirds ähnliche Sensoren kaum mit 5V geben.
Wie gesagt, ich muss mich da mal einlesen. Habe aktuell z.B. 5V Heizfolien da, die wollte ich kommenden Winter mal in der Regengauge testen. Solche hier z.B. Heizfolie
Danke,der Davis Regenmesser funktioniert bis jetzt ohne Probleme.
Ist halt Riesengroß.
Falls du Deine Dachfenster bei Regen schließen willst wäre wahrscheinlich ein beheizter Regenmelder besser.Der sollte beim ersten Tropfen ansprechen und nicht erst nach 0,2mm.
Kann dir aber nichts zur Zuverlässigkeit sagen.
Den hab ich seit einem halben Jahr installiert (24V Typ mit UBS). Bisher eher enttäuschend. Zu Anfangs Wackelkontakt am Stecker Sensor-Baugruppe -> Mit Heißkleber fixiert. Festgestellt dass die Heizung recht ordentlich warm ist. Im Winter ok aber bei Nieselregen bleibt tatsächlich der Sensor trocken. Habe jetzt mal die Heizung mittels Jumper ausgestellt. Funktionierte scheinbar besser. Gerade prasselt es wieder runter: Ich schaue ins HC, kein Regen angezeigt 
Raus und nachschauen… Der Kamm des Sensors ist mit Regentropfen überbrückt. Geht man kurz mit dem Finger drauf, spricht er sofort an. Vermutlich ist der Regen zu sauber. Ich mach jetzt noch einen Versuch mit dem Empfindlichkeitspoti bevor ich mich nach was anderem umschaue.
Mahlzeit,
da gerade sowohl mein 5V Regensensor als auch die 5V Heizmatte für den Zuno gekommen sind, will ich mich heute oder morgen Abend mal an den Code dafür machen.
Ich könnte mit dem Sensor wenige Tropfen von viel Regen über den Analogwert unterscheiden. Oder lieber nur Regen oder kein Regen anzeigen lassen? Welchen Sensortyp würdet ihr nehmen?
Ich habe mir darüber auch schon Gedanken gemacht.
Mein Ansatz wäre dass ich den Sensor nicht extra im HC2 anzeigen lasse, sondern folgende Logik zur Anwendung bringen würde.
Wenn letzter Niederschlag länger als 1 Stunde her ist, dann zähle ich die Regenmenge um 0,1mm nach oben und übertrage den Wert.
Sollte innerhalb der nächsten Stunde der Regenmesser einen Wert liefern, dann übertrage ich nur 0,1mm von diesem Wert.
Alle weiteren Werte werden normal übertragen.
Damit hättest Du ein sofortiges Ansprechen des Regenmessers und nur Werte unter 0,2mm haben eine gewisse Ungenauigkeit von 0,1mm max.
Du brauchst nur einen Timer welcher von 3600 Sekunden runterzählt sobald ein Regenereignis eintritt.
Jeder neue Messwert setzt den Zähler wieder auf 3600 rauf.
Wenn der Regensensor Regen erkennt, prüfst Du ob Zähler auf 0 und wenn ja dann überträgst du 0,1mm.
Wenn du 0,1mm übertragen hast, dann setzte eine Variable welche bei Zähler 0 oder bei erstmaliger Erkennung von Regen über den normalen Sensor zurückgesetzt wird.
Hallo,
Mal eine dumme Frage zwischendurch - welchen Regenmesser verwendet Ihr denn, der 0,1mm Auflösung hat?
Ist der relativ zuverlässig?
Was die anderen Regenmelder betrifft, da habe ich festgestellt, dass bei „sauberem“ Regen die Sensoren nicht ansprechen.
Habt Ihr da etwas stabiles gefunden, was bei wenigen Tropfen schon eine Anzeige bringt?
Gruss
Micha
@mdietinger: zufälligerweiße Softwarteentwickler von Beruf?
Ich dachte eher an sowas simples wie, wenn der Sensor für 30 Sekunden ausgelöst wird, dann meldet er per Zwave Regen, also wie bei einem Türsensor offen/zu. Deine Überlegung muss ich mal sacken lassen, denn sie klingt sehr interessant.
@micha_pr
Ich habe richtig tief in die Tasche gegriffen und den hier bestellt 
https://www.ebay.de/itm/Schnee-Regen-Tropfen-Erkennungs-Sensor-Modul-Regen-Wetter-Modul-Luft-Feuc-X6Q9/223615992094?hash=item34108d411e:g:T6AAAOSwn-pdTUp5
Ich habe keine Ahnung, ob er diese Auflösung hat, jedoch erkennt er jeden Tropfen, sogar den angefeuchteten Finger. Das mit dem sauberen Regen kann ich dir erst sagen, wenn ich den Code habe und mein Testaufbau ans Balkongeländer gehängt habe.
@thehackisback: das ist einer der Sensoren, die bei mir schlecht funktionierten (mit sauberem Regenwasser)
Das mit den 0,1mm bezog sich auf:
@mdietinger: „…dann zähle ich die Regenmenge um 0,1mm nach oben und übertrage den Wert.“
Michael