[GELÖST] GPIO weg vom Raspi --> Arduino --> Jeelink --> keyValueProtocol

[Marlen]

Soo .... jetzt schaut es so aus, was sagst du dazu?

Code Auswählen Erweitern


#include <Bounce2.h>

// Stromzähler PIN's
#define BUTTON_PIN_1 4
#define BUTTON_PIN_2 5
#define BUTTON_PIN_3 6
Bounce debouncer1 = Bounce();
Bounce debouncer2 = Bounce();
Bounce debouncer3 = Bounce();
// Wasser PIN
#define BUTTON_PIN_w 7
Bounce debouncerw = Bounce();
// Gas PIN
#define BUTTON_PIN_g 8
Bounce debouncerg = Bounce();
// Variablen
int Wasser_Counter = 0;
int merkerw = 0;
int Gas_Counter = 0;
int merkerg = 0;
int merker = 0; // 1=vor 2=gez 3=rueck 4=erl
// fuer Timer
const unsigned long INTERVAL = 1000L*60* 1; // ############## 1 Minuten
unsigned long lastRun = 0 ;

// #########################             Enable debug prints to serial monitor
//#define MY_DEBUG
//##########################

void setup() {

  pinMode(BUTTON_PIN_1,INPUT_PULLUP);
  debouncer1.attach(BUTTON_PIN_1);
  debouncer1.interval(100); // interval in ms

  pinMode(BUTTON_PIN_2,INPUT_PULLUP);
  debouncer2.attach(BUTTON_PIN_2);
  debouncer2.interval(100); // interval in ms
 
    pinMode(BUTTON_PIN_3,INPUT_PULLUP);
  debouncer3.attach(BUTTON_PIN_3);
  debouncer3.interval(100); // interval in ms

    pinMode(BUTTON_PIN_w,INPUT_PULLUP);
  debouncerw.attach(BUTTON_PIN_w);
  debouncerw.interval(100); // interval in ms

     pinMode(BUTTON_PIN_g,INPUT_PULLUP);
  debouncerg.attach(BUTTON_PIN_g);
  debouncerg.interval(100); // interval in ms

  Serial.begin(38400);
}

void loop() {
Strom();
Wasser();
Gas();
if ( millis() - lastRun >= INTERVAL ) {
   senden();
   lastRun += INTERVAL;
}}
void senden(){
  if (Wasser_Counter != 0) {
    Serial.print("OK VALUES ARDU 1 Wasser1Min=");
        Serial.println(Wasser_Counter);
        Wasser_Counter = 0;
  }
   if (Gas_Counter != 0) {
    Serial.print("OK VALUES ARDU 1 Gas1Min=");
        Serial.println(Gas_Counter);
        Gas_Counter = 0;
  }}

void Wasser(){
  debouncerw.update();
  int valuew = debouncerw.read();
  if ( valuew == LOW) {
    if (merkerw == 0) {
    Wasser_Counter++;
    merkerw = 1;
    #ifdef MY_DEBUG
    Serial.print("Wasser =");
    Serial.println(Wasser_Counter);
    #endif
    }
  }else{
    merkerw = 0;
  }}

void Gas(){
  debouncerg.update();
  int valueg = debouncerg.read();
  if ( valueg == LOW) {
    if (merkerg == 0) {
    Gas_Counter++;
    merkerg = 1;
    #ifdef MY_DEBUG
    Serial.print("Gas =");
    Serial.println(Gas_Counter);
    #endif
    }
  }else{
    merkerg = 0;
  }}

void Strom() {
  // Update the Bounce instances :
  debouncer1.update();
  debouncer2.update();
  debouncer3.update();
// Get the updated value :
  int value1 = debouncer1.read();
  int value2 = debouncer2.read();
  int value3 = debouncer3.read();

  // ################# 1. Eingang ##################### START ######################
   if ( value1 == HIGH) {
    if (merker != 2 && merker != 1) { // 1=vor 2=gez 3=rueck 4=erl
      merker = 1; // 1=vor 2=gez 3=rueck 4=erl
      #ifdef MY_DEBUG
      Serial.println("PIN1 on");
      Serial.println(merker);
      #endif
  }
    if (merker == 2 ) {
    merker = 4; // 1=vor 2=gez 3=rueck 4=erl
    }}
 
  // ################# 2. Eingang ##################### START ######################
if ( value2 == HIGH && value1 == LOW && value3 == LOW && merker != 2) {
// ###################### dreht VOR ###########################
      if (merker == 1) { // 1=vor 2=gez 3=rueck 4=erl
        merker = 2; // 1=vor 2=gez 3=rueck 4=erl
        Serial.print("OK VALUES ARDU 1 StromUm=");
        Serial.println("+1");
        #ifdef MY_DEBUG
        Serial.println("-->");
        #endif
      }
// ###################### dreht ZURUECK ###########################
      if (merker == 3) { // 1=vor 2=gez 3=rueck 4=erl
        merker = 2; // 1=vor 2=gez 3=rueck 4=erl
        Serial.print("OK VALUES ARDU 1 StromUm=");
        Serial.println("-1");
        #ifdef MY_DEBUG
        Serial.println("<--");
        #endif
      }
      #ifdef MY_DEBUG
      Serial.println("PIN2 on");
      Serial.println(merker);
      #endif
    }
  // ################# 3. Eingang ##################### START ######################
   if ( value3 == HIGH) {
    if (merker != 2 && merker != 3) { // 1=vor 2=gez 3=rueck 4=erl
      merker = 3; // 1=vor 2=gez 3=rueck 4=erl
      #ifdef MY_DEBUG
      Serial.println("PIN3 on");
      Serial.println(merker);
      #endif
    }
    if (merker == 2 ) {
      merker = 4; // 1=vor 2=gez 3=rueck 4=erl
  }
}
}


Beim Stromzähler ist das genau andersherum als beim Wasser- bzw. Gaszähler.
Beim Stomzähler reflektiert die Scheibe ja immer, bis die rote Markierung kommt!

LG
  Marlen

[Marlen]

Es gibt übrigens Schwestermodule zu dem von dir genannten . Und für einen "Alarm: Wasserrohrbruch" müßtest du eben ein eigenes notify erfinden

Ja, weiß ich schon, ...den Gascalculator....werd ich wohl auch nehmen. Den kann man auch für Wasser nehmen.
Alarm für Wasserrohrbruch hatte ich jetzt auch schon, muss dann nur das NOTIFY anpassen!

LG
Marlen

[Beta-User]

Soo .... jetzt schaut es so aus, was sagst du dazu?

WOW! Da hast du große Fortschritte gemacht !

Bei zwei Sachen bin ich mir nicht so ganz sicher:
Das erste verbirgt sich hinter den Stichwort "rollover". Das scheint aber zu klappen, wie du das hast. (Sollte nach 50 Tagen nicht mehr alles gesendet werden, suche nach "millis rollover" und baue es entsprechend um.)
Das andere ist das "L" bei der Berechnung der Sendefrequenz. Damit machst du sie von der Prozessorfrequenz abhängig, was m.E. nicht erforderlich ist, da ja keine wirklich zeitkritische Timing-Berechnung gemacht wird (wäre beim Senden von RF oder IR-Codes was anderes). Und ich kenne das eigentlich nur als Kombination von "UL", habe mich damit aber auch noch nicht intensiver beschäftigt...

Nur für den Fall, dass du noch einen Bewegungsmelder da dranhängen willst: Nutze wenigstens dafür einen interrupt-PIN ...
Und man kann mit einem Arduino auch 1-Wire-Devices auslesen (hat dann aber nichts mehr mit OWX&Co zu tun) und eine ganze Menge anderer Dinge mehr (auf der MySensors-Seite findet sich ja einiges an Sensorik, das man recht einfach auf das keyValueProtocol umbauen kann).

Deine Meinung würde mich jetzt noch interessieren: War für dich das Einarbeiten in die Thematik und das Programmieren des Arduino gefühlt wesentlich schwieriger als das Einarbeiten in Wiring-PI und die Auswertung auf dem PI?
(Klar, es ist "anders", und der Vergleich hinkt immer, da die Vorkenntnisse aus Wiring-PI natürlich auch hier helfen...)

Danke, dass du da dran geblieben bist und das wirklich verstehen wolltest .

Eine Bitte noch: neben dem "Gelöst" wäre noch der Hinweis auf das keyValueProtocol im thread-Titel hilfreich. Dann findet ihn ggf. jemand, der ein ähnliches Problem hat, später mal wieder.
Dazu noch eine Frage: Es dürfte reichen, den Arduino als Jeelink einzubinden und dann autocreate anzuschalten, oder?

Gruß, Beta-User

[Marlen]

Ja, bin ganz schön schnell ziemlich weit gekommen!

Was mich als nächstes interessiet:
- wie kann ich einen Ausgang von FHEM aus schalten.
- wie kann ich den arduino per Ethernet bzw. WLAN verbinden.

Deine Meinung würde mich jetzt noch interessieren: War für dich das Einarbeiten in die Thematik und das Programmieren des Arduino gefühlt wesentlich schwieriger als das Einarbeiten in Wiring-PI und die Auswertung auf dem PI?
(Klar, es ist "anders", und der Vergleich hinkt immer, da die Vorkenntnisse aus Wiring-PI natürlich auch hier helfen...)

Naja, wenn man mal berücksichtigt, das ich diesen Thread vor 3 Tagen eröffnet habe und mich seit dem erst damit beschaffe.....und durch deiner Unterstützung....ging die Einarbeitung schon, hat sich auf jeden Fall geleohnt!

Bin schon auf der suche, wo ich noch einen Arduino einsetzten kann.....aber jetzt muss ich erst mal den Hardwareseitig installieren und dann FHEM umbauen ....

Eine Bitte noch: neben dem "Gelöst" wäre noch der Hinweis auf das keyValueProtocol im thread-Titel hilfreich. Dann findet ihn ggf. jemand, der ein ähnliches Problem hat, später mal wieder.
Dazu noch eine Frage: Es dürfte reichen, den Arduino als Jeelink einzubinden und dann autocreate anzuschalten, oder?

Ja, fand es schon komisch, das es keine Schritt-für-Schritt Anleitung dafür gibt, wie man die Verbindung zu FHEM herstellt!
autocreate muss ich mal testen..

LG und vielen Dank nochmal
   Marlen 

[Beta-User]

Was mich als nächstes interessiet:
- wie kann ich einen Ausgang von FHEM aus schalten.
- wie kann ich den arduino per Ethernet bzw. WLAN verbinden.

keyValueProtocol ist "one-way" (jedenfalls nach meiner Kenntnis, es gibt aber irgendwo hier auch eine modifizierte Netzwerkversion). ERGO: Schalten mit kvp von FHEM aus geht nicht, Alternativen dann etwas weiter unten...

Eine Darstellung zu Arduino und ähnlichen mcu's (Microcontroller Units) gibt es im Wiki. Hier mal eine etwas "gefärbte Version":

1. M.E. ist es eher eine Notlösung, wenn man einen Arduino (oder ESP8266 etc.) mit einem echten Netzwerkprotokoll in ein Steuerungssystem wie FHEM einbindet. Das bedeutet einen entsprechenden Overhead für die Kommunikation sowie die Abhängigkeit von weiteren Komponenten (Router etc.).
Wenn man das trotzdem unbedingt will:
a) Ethernet: Es gibt entsprechende Shields, damit kann man auch eine serielle Kommunikation innerhalb des Netzwerkprotokolls kapseln.
b) WLAN: auch hier gibt es shields, allerdings ist es in der Regel einfacher, andere mcu's zu nehmen, wobei der ESP8266 die verbreitetste Variante ist. Ich mag diese mcu persönlich überhaupt nicht, und es gibt auch einige technische Gründe, warum man besser die Finger davon läßt. Aber wenn, dann nimmt man z.B. ein Wemos oder eine NodeMCU-Board, damit ist wenigstens das Flashen einfach (sofern man die SW entsprechend vorbereitet hat). WLAN und Batteriebetrieb schließen sich praktisch aus (es gibt einige Spezialisten, die es trotzdem möglich machen, aber da muß man sehr genau wissen, was man tut).

2. Für die Kommunikationsebene finde ich andere Varianten besser:
Dabei wird das, was wir jetzt auf einem Arduino gemacht haben, in der Regel auf zwei verteilt: Einer macht die Kommunikation zum Controller (bei dir: PI mit FHEM, das nennt sich dann Gateway), der andere die eigentliche Meßaufgabe. Dann brauchen beide noch passende Transceiver-Hardware und eine gemeinsame Sprache, um die Daten zu übertragen (Protokoll).
Daher mal ein kurzer Abriss, was da so alles an Protokollen und Transceivern rumschwirrt (ohne Anspruch auf Vollständigkeit):

a) MySensors:
Mögliche Transceiver: nRF24 (2,4 GHz), RFM69 (433&868MHz, Rest ist wohl in D nicht zulässig) und (kabelgebunden, benötigt 2 Adern) RS485
Mein Favorit, einfach auch in der Einbindung in FHEM; nRF und RS485-Tranceiver sind unglaublich billig (ab 40ct pro Stück), allerdings muß man bei Funk ggf. etwas in eine abgesicherte Kommunikation investieren.
Und nochmal zur Klarstellung: Das GW kann auch ein einfacher Arduino Nano mit einer USB-Verbindung sein!

b) AskSin++ - Homematic-Protokoll mit CC1101
Kann auch mit anderen HM-Komponenten sprechen und ist entsprechend abgesichert, erfordert allerdings für die Einbindung in FHEM ein sehr formalisiertes Vorgehen (mein persönlicher Eindruck)
Dafür kann z.B. ein CUL die GW-Aufgabe mit übernehmen...

c) Homebrew-Wired: HM mit RS485 (wie AskSin++, vermutlich etwas einfacher in der Programmierung der Arduinos und  was die Einbindung in FHEM angeht; das GW ist ein fertiger Baustein. Es gibt dazu einen - mindestens vom Lesen her - guten Workshop von T. Pferdekaemper hier im Forum)

d) 433-MHz-Projekte, die die Daten in gängige Protolle kapseln

e) Firmata (USB oder auch über (W)LAN möglich): läßt die direkte Steuerung der IO's von FHEM aus zu, man kann aber praktisch nichts auf der mcu programmieren, aber dafür dann z.B. I2C von FHEM aus steuern (mache ich persönlich lieber mit dem Programm auf den Arduino). Ist etwas "zickig", FHEM mag nicht alle Versionen (insbesondere die neueren nicht). Ist also sowas ähnliches wie der ältere Bruder von ESPEasy.

Mehr fällt mir im Moment nicht ein, aber die Welt da draußen ist groß...

Hoffe, das ist nachvollziehbar.

Gruß, Beta-User

[Marlen]

JETZT weiß ich endlich was du mit kvp meinst! 

Also wenn ich dich richtig verstanden habe, gibt es derzeit keine Möglichkeit in meinen Fall (Arduino per USB am Raspberry) einen Ausgang am Arduino zu schalten??

b) AskSin++ - Homematic-Protokoll mit CC1101
Kann auch mit anderen HM-Komponenten sprechen und ist entsprechend abgesichert, erfordert allerdings für die Einbindung in FHEM ein sehr formalisiertes Vorgehen (mein persönlicher Eindruck)
Dafür kann z.B. ein CUL die GW-Aufgabe mit übernehmen...

Das hab ich ja schon im Einsatz, dann bräuchte ich praktisch nur noch einen Arduino mit Funkmodul!?

Für was nutzt du eigentlich den Arduino???

LG
  Marlen

[Beta-User]

Also wenn ich dich richtig verstanden habe, gibt es derzeit keine Möglichkeit in meinen Fall (Arduino per USB am Raspberry) einen Ausgang am Arduino zu schalten??

Jein...

keyValueProtocol ist "one-way" (jedenfalls nach meiner Kenntnis, es gibt aber irgendwo hier auch eine modifizierte Netzwerkversion). ERGO: Schalten mit kvp von FHEM aus geht nicht, Alternativen dann etwas weiter unten...

Schalten geht schon, nur eben nach meiner Kenntnis nicht mit diesem Protokoll!
Zum einen z.B. mit firmata, was aber den Nachteil hat, dass du Pulse zwar weiterreichen kannst, dafür aber nicht auf dem Arduino selbst irgend eine andere Auswertung machen (also nicht mit dem Sketch aus den 3 Zuständen einen Zählerimpuls ableiten).
Auch als MySensors-GW könntest du PINS ein- und ausschalten, allerdings klappt das Kompilieren mit MySensors nur, wenn auch ein Transceiver definiert ist (angeschlossen muß er nicht sein). Aber damit könntest du dann auch weiter rechnen, kein Problem (warum mag ich MySensors?!?)
Allerdings müßtest du bei einem anderen IO/Protokoll immer auch FHEM-seitig die Dinge anders definieren (bei MySensors würden z.B. 3 Zähler als je eigene ChildID präsentiert, bitte im Wiki den Starter-Guide dazu suchen und lesen, bevor du Fragen dazu stellst). In praktisch jedem anderen Fall  wären die Impulse bzw. Zählerwerte  in einem anderen Reading eines  anderen Device zu finden als jetzt .

Zu AskSin++:
Ja, ein Arduino+Funkmodul würde reichen, ABER:
Die Doku dazu ist - ohne intensive Nachforschung behauptet - in etwa so wie die zum kvp  . Was wann wie zu "verpacken" ist, müsstest du aus vorhandenen Beispielen zusammensuchen, genauso wie die Frage, welche Vorarbeit im FHEM erforderlich ist, um das dann hier einzubinden. Im Ergebnis: Mir persönlich ist das zu viel Einarbeitungsaufwand. Mach' ich vielleicht mal, wenn ich mit anderen Dingen soweit bin...
Ich würde das an deiner Stelle im Auge behalten, wenn die direkte Zusammenarbeit (peering) mit anderen HM Komponenten wichtig wäre und mir vielleicht  mal fertige Projekte ansehen (Fensterkontakt oder Wetterstation). Da siehst du dann auch, wie die Sketche aussehen und welche Chance du hast, da selbst was zu entwickeln.

Für was nutzt du eigentlich den Arduino???

Interfaces lt. Signatur: Signalduino, 2xMySensors-GW (dazu zwei weitere mcu's: ESP8266 als MiLight-GW und einen Maple-CUN; das ist ein STM32-Arm-Prozessor)
Alle anderen Arduinos sind MySensors-Nodes, an denen eine Vielzahl von Zeugs hängt (in der Regel Multi-Child-Nodes, also mehrere Funktionalitäten pro Arduino), mal auf die Schnelle, was mir so einfällt:
- BME280 (früher mal BMP180)
- 20+ x DS18B20
- Bewegungsmelder bzw. Schwimmerschalter für das Hauswasserwerk bei Tank leer
- Infrarot-Dekoder und Transmitter für den Hifi-Bereich
- Gaszähler (Wasserzähler muß ich die Hardware noch auf Rotlicht umbauen, SW ist aber schon auf der Node)
- Relays bzw. MOSFETS (die On-Zeit für diverse Lichter läßt sich in der Regel von FHEM aus einstellen bzw. teilweise entscheidet der jweilige Arduino, wann ein- und auszuschalten ist (z.B. die Umwälzpumpe für das Warmwasser, wenn eine einstellbare Rücklauftemperatur erreicht ist))
- Servo-Motor (zur Steuerung der 3-stufigen Heizungspumpe, diese Anwendung ist nicht zur Nachahmung empfohlen)

Testweise in Betrieb hatte ich auch schon:
- Lichtsensor (BH1750)
- Digitale Widerstände etc. (MCP4131, MCP4132)

Pipeline:
- Solarbasierte Wetterstation (aus einer China-LED-Lampe) mit
-- BH1750
-- UV (VEML6075)
-- Windgeschw. + -richtung
-- Regenwippe
- Digitale Einbindung meiner Junkers-Therme. Die spricht ein älteres HT3-Protokoll. Ist was "größeres", dafür habe ich daliegen
-- STM32-Platinen, da der Code vermutlich nicht auf einen Nano passen wird
-- CAN-Module (MCP2515)

Bestimmt habe ich noch was vergessen ....

Gruß, Beta-User

Nachtrag: Vergessene Themen:
- Statusdisplay
- RFID

[Marlen]

Sooo, Arduino ist jetzt, auch wenn nur provisorisch im Betrieb und scheint auch gut zu zählen!
Jetzt warte ich mal ein paar Tage, dann vergleiche ich mal die Hardware-Zähler mit den FHEM-Zählern, dann wird sich herausstellen wie gut das ist.

LG
  Marlen

[Marlen]

Guten Morgen,

heute war mein Arduino plötzlich DISCONNECTED.......

Ein "set ..... reset" hat auch nix gebracht.

Sogar ein kompletter Neustart des System's hat nix gebracht......

Wie kann man herausfinden was das war und wie verhindern?

LG
  Marlen

[Beta-User]

Klingt nicht gut.

Kannst du ihn mal an ein Laptop anschließen und z.B. über den seriellen Monitor der Arduino-IDE nachschauen, ob da was ausgespuckt wird?
Oft gibt es sowas wie einen "Startbildschirm", an dem man erkennen kann, ob der Sketch ordentlich startet.

[Marlen]

Hab ihn jetzt mal vom RasPi getrennt und wieder eingesteckt, dann war er wieder connected.

[Marlen]

Du hast doch mal geschrieben:

Bei zwei Sachen bin ich mir nicht so ganz sicher:
Das erste verbirgt sich hinter den Stichwort "rollover". Das scheint aber zu klappen, wie du das hast. (Sollte nach 50 Tagen nicht mehr alles gesendet werden, suche nach "millis rollover" und baue es entsprechend um.)

Meinst du das hatte damit was zu tun?

LG
  Marlen

[Beta-User]

Meinst du das hatte damit was zu tun?

Schwierig zu beantworten, weil meine Arduinos da eben anderen Code verwenden, von dem ich weiß, dass er funktioniert. Aber nachdem die Zeit bis zum Ausfall ziemlich genau 49.7 Tagen zu entsprechend scheint: Schaden würde es nicht, wenn du den code umbaust.

Aber bei "Disconnected" hätte ich eher an ein anderes Problem gedacht (irgendwas mit dem USB-seriell-Wandler).

Material zum Einlesen: https://arduino.stackexchange.com/questions/12587/how-can-i-handle-the-millis-rollover. Beachte: der Auszug aus dem code dort kommt von http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay (das "Umfeld" dazu muß auch passen).

Viel Erfolg,

Beta-User

[Frank_Huber]

Sorry für den Post hier jetzt,

Aber worin liegt jetzt der Vorteil die GPIOs des RasPi durch externe Hardware am RasPi zu ersetzen?
Habe den Sinn von Anfang an nicht verstanden. wofür hat der RPI die GPIOs denn wenn nicht zum benutzen...

just my 2cent....

[Beta-User]

Vorteile nochmal in Kurzfassung:

- 5V statt 3.3V
- Abschirmung des Prozessors vor eventuellen Nutzerfehlern (PI-GPIO sind prozessornah => Zerstörungsgefahr)
- Trennung der Steuerungsschichten, keine spezielle Konfiguration der HW erforderlich => kein Stress mit OS- oder library-updates
- GPIO-Abfragen können den PI (zeitweise) blockieren
- Man braucht als Zentrale nicht zwingend einen PI oder sonst einen SBC=> zukunftssicherer

Etwas weiter gedacht:
Bei "weiter entfernten" Systemen/GPIOs braucht man keinen (wartungsbedürftigen) Rechner für FHEM2FHEM oä., sondern kann mit einfachen Mitteln weitere HW dezentral mit einbinden (MySensors&Co), wenn man "Arduino" uä. mal verstanden hat. Diese Infrastruktur ist zum einen im wesentlichen wartungsfrei und (v.a.) man kann das auch unabhängig von LAN u. WLAN aufbauen. Insbesondere WLAN ist für zentrale Steuerungsaufgaben suboptimal... Zu WLAN allg. und ESP8266 im besonderen im besonderen hat Hexenmeister jüngst hier noch was nettes aufgegabelt.

Auch nur my2ct...