Windmesser mit Reedkontakt

    • Windmesser mit Reedkontakt

      Hallo und Frohe Ostern

      Ich habe vor einen Windmesser mit Reedkontakt (eine Umdrehung gleich ein Impuls)
      an SHC zu betreiben.
      Im Internet gibt es ja einiges zufinden. Es gibt da einen Taktgenerator oder eine
      Flip Flop Schaltung.
      Nur weiss ich nicht was da so in Frage kommt.
      Vieleicht hat hier schon jemand so etwas in Betrieb.

      Überwachen möchte ich damit eine Selbstbau Markise 8x4 m auf dem Wintergarten.
      Wenn es zu stürmisch wird, dann soll die vorhandene an SHC angemeldete Steckdose
      für Auf/Ab auf AUF schalten.
      Kann besser Hardware als Software !
    • Danke für die Antwort.
      Eventuell in Frage kommen würde das von Didi.
      Anemometer_Schaltplan.png

      Da der Ausgang vom Reed an D3 (PWM) vom Arduino liegt,
      müsste es doch auch am RPi Gpio18 möglich sein.
      Nur dann müsste der Sketch verändert werden, aber das
      bekomme ich nicht in den Griff.

      C Source Code

      1. /*
      2. Copyright (C) 2011 Mario Keller. All rights reserved.
      3. This programm is free software; you can redistribute it and/or
      4. modify it under the terms of the GNU Lesser General Public
      5. License as published by the Free Software Foundation; either
      6. version 2.1 of the License, or (at your option) any later version.
      7. See file LICENSE.txt for further informations on licensing terms.
      8. */
      9. // http://www.ichbinzustaendig.de/2011/11/16/anemometer-eigenbau-fur-arduino-wetterstation.html
      10. // LCD5110_ViewFont (C)2011 Henning Karlsen
      11. // web: http://www.henningkarlsen.com/electronics
      12. // This program requires a Nokia 5110 LCD module.
      13. // It is assumed that the LCD module is connected to
      14. // the following pins using a levelshifter to get the
      15. // correct voltage to the module.
      16. // SCK - Pin 8 //Clock input
      17. // MOSI - Pin 9 //Serial input
      18. // DC - Pin 10 //Data/Comand
      19. // RST - Pin 11 //Reset(low)
      20. // CS - Pin 12 //Chip enable (low)
      21. //einbinden der notwendigen Libraries
      22. #include <LCD5110_Basic.h>
      23. // festlegen der Pins fŸr das LCD panel
      24. LCD5110 myGLCD(8,9,10,11,12);
      25. extern uint8_t SmallFont[];
      26. extern uint8_t MediumNumbers[];
      27. extern uint8_t BigNumbers[];
      28. // einige konstanten
      29. const int windPin = 3; // anschluss des reedkontaktes
      30. const float windFactor = 2.4; // umrechnungsfaktor von umdrehungen in geschwindigkeit
      31. //Das Datenblatt zum “Kauf-Anemometer” gibt einen Umrechungsfaktor von 2.4 an. Also eine Umdrehung pro Sekunde entspricht ca. 2.4 km/h Windgeschwindigkeit.
      32. const int measureTime = 10; // messzeitraum in sekunden
      33. int measureCount = 0;
      34. // variablrn
      35. volatile unsigned int windCounter = 0; //interner zaehler fŸr umdrehungen
      36. float windSpeed = 0.0;
      37. //zwischenspeicher für 15 minuten und 6 messungen pro minute
      38. unsigned int gustmax[15*6];
      39. //initialisieren der variablen fŸr messwerte und die zeitmessung
      40. unsigned long time = 0;
      41. //interrupt service routine fŸr das zaehlen der umdrehungen
      42. void countWind() {
      43. windCounter ++;
      44. }
      45. // lcd anzeige
      46. void show_values() {
      47. //erste Zeile - anzahl der gezaehlten umdrehungen im messzeitraum
      48. myGLCD.clrScr(); // LCD löschen
      49. myGLCD.setFont(SmallFont);
      50. myGLCD.print("Böen : ", LEFT, 0);
      51. myGLCD.printNumF(max15gust(),0, RIGHT, 0); ////////////////////////////////////////////////
      52. myGLCD.setFont(BigNumbers);
      53. myGLCD.printNumF(float(windSpeed),1, LEFT, 16); ////////////////////////////////////////////////
      54. myGLCD.setFont(SmallFont);
      55. myGLCD.print("km/h", RIGHT, 32);
      56. }
      57. //gehe durch die letzten 15 maximalwerte und liefere die
      58. //geschwindigkeit des höchsten wertes zurück
      59. float max15gust() {
      60. unsigned int gmax = 0;
      61. for(byte i=0; i<(15*6);i++) {
      62. if(gustmax[i] > gmax) gmax = gustmax[i];
      63. }
      64. return (float)gmax / (float)measureTime * windFactor;
      65. }
      66. //////////////////////////////////////////////////////////////////////
      67. //////////////////////////////////////////////////////////////////////
      68. // MAIN
      69. //////////////////////////////////////////////////////////////////////
      70. //////////////////////////////////////////////////////////////////////
      71. //initialisierung
      72. void setup()
      73. {
      74. myGLCD.InitLCD();
      75. //startzeit bestimmen
      76. time = millis();
      77. //zwischenspeicher für 15 minuten initialisieren
      78. for(int i=0;i<(15*6);i++) gustmax[i]=0;
      79. }
      80. //hauptschleife
      81. void loop()
      82. {
      83. //starten des messzeitraums
      84. //zaehler auf 0 stellen
      85. windCounter = 0;
      86. time = millis();
      87. //zaehl-interrupt aktivieren
      88. attachInterrupt(1,countWind,RISING);
      89. //abwarten des messzeitraums
      90. delay(1000 * measureTime);
      91. //zaehl-interrupt deaktivieren
      92. detachInterrupt(1);
      93. //zeit bestimmen
      94. time = (millis() - time) / 1000;
      95. //aktuellen wert im zwischenspeicher merken
      96. gustmax[measureCount] = windCounter;
      97. measureCount = (measureCount + 1) % (15*6) ;
      98. //berechnen der geschwindigkeit
      99. windSpeed = (float)windCounter / (float)measureTime * windFactor;
      100. //lcs ausgabe aktualisieren
      101. show_values();
      102. }
      Display All
      Kann besser Hardware als Software !
    • Hab jetzt mal was anderes gefunden.

      Gpio Pin in Python als Eingang programmieren
      Raspbian: GPIO-Pin in Python als Eingang programmieren - Good to Know Database

      Habe den WS mal nach dieses Belegung am Gpio 8 angeklemmt
      Anemometer_Schaltplan.png


      Mit putty und dem Befehl "sudo ./input.py" erscheint diese Meldung
      Windsensor.JPG


      Es wird ein High nach low angezeigt wenn der WS sich dreht. Dieses müsste jetzt umgesetzt
      werden, aber wie.
      In SHC ist ein Eingang angelegt, der schaltet von Rot nach Grün und wechselt je nachdem wie der
      Reed geschaltet wird.
      Kann besser Hardware als Software !

      The post was edited 2 times, last by premo ().

    • premo wrote:

      Raspbian: GPIO-Pin in Python als Eingang programmieren - Good to Know Database
      Hier wird Polling betrieben, so das u.U. Signale verloren gehen.

      Schau doch mal unter volkszaehler.org - home da wird beschrieben, wie man Strom oder Gaszähler auslesen kann. Das ist vom Prinzip das gleiche.
      SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.
    • Hallo Premo,

      da ich gerade nach Möglichkeiten suche den Energieverbrauch mittels S0 Pulse zu messen, habe ich mir Gedanken über Deinen Windmesser gemacht.

      Ich habe nach Impulszähler Arduino und Impulszähler Raspberry, sowie nach Energie Erfassung etc. gesucht.

      Die Ansätze, Sketche und Programme, die ich gefunden habe sind immer sehr ähnlich. Es muss eine interruptfähige GPIO verwendet werden. Dies wäre z.B. GPIO3 = Pin 5

      Das Program startet einen Timer von z.B. (in Deinem Fall vielleicht 1 sec.) und während dieser Zeit werden alle Impulse per Interrupt an der GPIO gezählt und aufaddiert (RPS=n+1). Jetzt musst Du wissen, wie viele Impulse bei starkem Wind zu erwarten sind. Sind dies z.B. 20 kommt am Ende der Periode ein Vergleich
      if RPS => 20 GPIO XY high Schalten der Markise
      RPS = 0 Zähler zurück setzen
      Schleife Das ganze beginnt von vorne

      Bei der Interruptabfrage müsstest Du wahrscheinlich noch eine bounce Time einbauen, un zu verhindern, das beim prellen des Kontaktes zu viele Pulse gezählt werden.

      Hier mal ein Link mit code für den Raspi. Vielleicht kannst Du Teile davon verwenden.

      Stromzähler mit S0-Schnittstelle vom Raspberry Pi auswerten | Blog Webernetz.net

      Ein anderer Ansatz wäre, da es bei Deinem Vorhaben ja nicht auf Genauigkeit so ankommt, dass Du über ein RC Glied mit den Pulsen ein Kondensator lädst, und mit einem Timer diesen Kondensator nach z.B. 1 oder 2 sec. wieder entlädst. Über den Widerstand R kann man bestimmen, wieviele Pulse nötig sind um auf einen bestimmten Level zu laden. Dann einen Schmitt- Trigger nachgeschaltet, der ab einer bestimmten Ladung schaltet.

      Das wäre die Hardware Möglichkeit. Softwaremäßig wäre aber eleganter.
      SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.
    • Den Interrupt brauchst Du doch nicht in diesem Fall. Du kannst doch irgendeinen GPIO im SHC als Eingang nehmen. Wenn der Schmitt- Trigger bei einer bestimmten Drehzahl schaltet, wird ein Ereignis im SHC ausgelöst. Damit schaltest Du die Markise.

      Folgendes würde passieren: Schmitt- Trigger schaltet von low auf high. Positive Flanke löst Ereignis aus, welches einen countdown (z.B. 30 sec.) triggert. Markise fährt ein, bis zum Endabschalter.

      Relais fällt nach 30 sec. wieder ab. Wind wird weniger. > Schmitt- Trigger schaltet von high nach low. Nichts passiert, da Du auf die positive Flanke triggerst.

      Wind wird wieder stärker, Relais zieht wieder an, aber Markise steht bereits auf der Endstellung. Der Endabschalter muss schon zuverlässig sein.

      Übrigens, habe gestern mit dem Zählen der S0 Impulse meines Stromzählers begonnen. Anbindung der S0 Schnittstelle an den Raspi absolut problemlos. Ausser einem Kondensator zum Entprellen keine zusätzlichen Bauelemente.

      Bezüglich der Auswertung der Daten, werde ich in den nächsten Tagen noch etwas damit herumspielen. Vom Prinzip her, könntest Du das Programm 1 zu 1 übernehmen. Es zählt die Impulse immer in der letzten Minute und schreibt die Anzahl in eine Datei.

      Da wären vermutlich nur 2 Zeilen Code nötig um eine Bedingung zu erstellen und etwas zu schalten. Wenn Du Interesse hast, schicke ich dir den Code.
      SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.
    • Hallo premo,

      habe hier auch noch was gefunden: Anemometer Eigenbau für Arduino Wetterstation - Ich bin zuständig!

      Den Sketch solltest Du nehmen können. Das LCD Display kannst Du ja weglassen.

      Am Ende nach:
      //lcs ausgabe aktualisieren
      show_values();

      müsste noch der Vergleich und das schalten der GPIO eingesetzt werden.

      Also: if windSpeed => z.B. 20 write gpio xy high Den genauen Syntax müsstest Du noch googlen.

      Oder es findet sich hier jemand, der das aus dem "Ärmel schüttelt".

      Den Sketch hänge ich dir als .txt File an. Ich würde aber dann den originalen verwenden, da beim Umwandeln Fehler entstanden sein können.

      Nachtrag: Hier könntest Du den Sytax finden: C-Programmierung: Einfache Ein- und Ausgabe – Wikibooks, Sammlung freier Lehr-, Sach- und Fachbücher
      Files
      SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.

      The post was edited 1 time, last by rmjspa ().

    • @premo

      Hallo Premo,

      ich habe mir ja den Stromzähler gebastelt, welcher die Impulse auf dem Raspi mit Interrupt zählt. Das läuft, bzw. lief auch ganz gut. Nachdem ich das aber auf meinem SHC Master installiert habe, werden nicht mehr alle Lampen bei Sonnenuntergang bzw. Sonnenaufgang geschaltet. Generell läuft das Zusammenspiel zwischen Master und Slave nicht mehr rund. Auch vermehrt Abstürze des Shedulers.
      Jetzt habe ich den Zähler auf dem Master wieder angehalten und alles geht wieder. Was ich damit sagen will ist, dass die, Prozesse vom SHC nicht mehr richtig zum Zuge durch die Interrupts kommen. Ohne das großartig Verbraucher eingeschaltet sind werden etwa 10 bis 12 Impulse (=Interrupts) pro Minute gezählt. Wenn ein paar Kochplatten an sind, sind es etwa 50 bis 70 pro Minute. Dies fällt zur Zeit eben auch in die Zeit des Sonnenuntergangs.

      Entweder nutzt man einen eigenen Pi nur um Impulse per Interrupt zu zählen, oder macht das besser mit einem hierfür abgestellten Arduino.

      Einen Stromzähler habe ich direkt neben einem Slave, da werde ich es noch mal probieren. Hier könnte ich mir vorstellen, dass das parallel laufen kann, da ja hier kein Sheduler aus dem Tritt gebracht werden kann.

      Vielleicht wird das ja auch mit dem SHC 3 besser. Jetzt geht es auf jedem Fall nicht am Master.

      Möchte dir das nur mitteilen, so dass Du nicht in die falsche Richtung suchst für Deine Windanlage.
      SHC Master B2+ WLAN sowie 1 Slave B2+, 2 Slave B+ und 2 Slave Raspi B. 5x Pi Cam; Imac mit OSX El Capitan; Iphone 6 plus; Ipad mini; Lenovo Android Tablet.
    • Danke für die Info.
      Habe mir jetzt mal eine Platine aus den 3 Schaltbildern
      vom Beitrag #13 erstellt. Am Ausgang der Platine wird
      nach Angabe der Ersteller ein sauberer Impuls ausgegeben.
      Bei der Eingangsspannung von 5 Volt wird bei Reed AUF
      2 Volt und bei Reed ZU 4,8 Volt ausgegeben.
      Prüfen kann ich es nur mit einem Digi Multimeter.
      Dieser Impuls müsste jetzt noch in eine Schaltung wo ein
      Transistor oder ähnlich von Low nach High schaltet.

      Gefunden habe in sowas

      NE555.JPG
      Beschreibung der Schaltung:

      Source Code

      1. Die dargestellte Schaltung ist die Grundschaltung des Timer NE555 als monostabile Kippstufe, auch Monoflop genannt. Der Name kommt daher, weil diese Kippstufe nur einmal einen Impuls am Ausgang (A) abgibt, wenn ein Impuls von etwa 0 V am Eingang (E) anliegt. Dieser Triggerimpuls muss kleiner als 1/3 von VCC sein.
      2. Die Bauteile R1 und C1 sind für die Funktionsweise dieser Schaltung verantwortlich. Die Dauer des Ausgangsimpulses wird durch die Bauteile R1 und C1 vorgegeben. Der Widerstand R2 ist ein Pullup-Widerstand, der den Eingang der Schaltung auf einen festen Pegel (+VCC) legt. Der Kondensator C2 sorgt dafür, dass die Schaltung nicht schwingt.
      3. In der dargestellten Schaltung wurde auf einen Stützkondensator für die Versorgungsspannung direkt am Timer verzichtet. In einer aufgebauten Schaltung sollte er berücksichtigt werden. 100 nF sollten es schon sein. Ein einfacher Wickelkondensator reicht aus.


      Files
      • Windsensor 2.JPG

        (47.45 kB, downloaded 17 times, last: )
      Kann besser Hardware als Software !