Zeitautomatik für Hydroponikanlage

karlshorster · May 19, 2022, 4:06pm

Hallo und guten Tag,

ich hoffe ich bin mit meinem Anliegen richtig hier.

ich bin neu hier und auch neu mit Mikrocontrollern beschäftigt und interessiert. Ich habe ein Projekt vor Augen, dass ich realisieren möchte. Ich bin Hobbygärtner und möchte eine Intervallbewässerung für meine Hydroponikanlage (Gemüse) bauen. Ich wollte das erst mit dem Timer-IC NE555 realisieren. Jedoch sind die Zeiten die ich wünsche schwer genau zu realisieren, da das R-C-Glied mit Festwiederständen zu ungenau ist. Potenziometer bei Zeiten von bis zu einer Stunde anzuwenden und einzustellen ist einfach nur eine Ätzende Geduldsprobe. Dann habe ich nach alternativen gesucht und bin über den Attiny85 gestolpert. Hört sich erstmal super an was man mit dem Ding so anstellen kann. Ich habe mir dann mal so einen Programmer gekauft (USBtinyISP AVR). Das Einrichten desselben hat ohne Schwierigkeiten geklappt. Dann mal den Anfänger Blink-Sketch auf den Attiny gespielt und mich gefreut wie das so Funktioniert. Die Freude hielt leider nicht lange an. Das Interesse aber schon. Der Blink-Sketch ist eigentlich schon fast was ich gesucht habe. Der Test mit einem Zeitintervall von 2 Minuten Einschaltzeit und 60 Minuten Ausschaltzeit hat super funktioniert. Ich habe die Zeit gestoppt und bin bei der Ausschaltzeit auf 60 Minuten und 15 Sekunden gekommen. Das ist eine Zeitabweichung von unter 0,5%. Für mich sehr zufriedenstellend.
Jetzt wollte ich den Blink-Sketch einfach mal erweitern, so dass alle 5 Beinchen des Attiny’s ihren eigenen Zeitintervall bekommen. Und nu, alles Mist. Geht nicht. Doch nicht so einfach wie ich dachte.

Nun wollte ich euch fragen ob ihr mir bei meinem Problem weitehelfen könnt. Vielleicht gibt es ja schon einen Sketch den ich anpassen könnte. Da ich neu bin wüsste ich nicht einmal wonach ich suchen sollte.

Ich sag jetzt mal was meine Automatik tun soll.

Ich brauche 5 Zeitintervalle mit frei wählbaren An-und-Auszeiten wie im Blink-Sketch. Auf jedem der 5 verfügbaren Ausgänge des Attiny einen Zeitintervall den ich per Drehschalter anwählen kann. Bei der Hardware brauche ich keine Hilfe, nur bei der Software. Das wäre ganz toll und ich würde mich riesig freuen wenn ich Hilfe bekommen würde. Sich die Programmiererei anzueignen ist auch nicht mal in null Komma nichts erledigt. Da bewundere ich jeden der das drauf hat.

Anbei noch eine Skizze zur Veranschaulichung.

Grüße aus Berlin

my_xy_projekt · May 19, 2022, 4:42pm

Dein Ansatz ist falsch.

Der Drehschalter gibt die Zeit vor - das auf einem PIN, der analog eingelesen wird.
Dein Drehschalter ist ein veränderlicher Spannungsteiler.
Braucht ganze zwei PIN.

Tommy56 · May 19, 2022, 4:43pm

Zeige uns doch mal, was Du schon programmiert hast. Setze den Code bitte in Codetags. Wie das geht, steht hier.

Ich selbst würde den Weg wohl anders herum gehen. Das SSR fest an einen Ausgang und über verschiedene Eingänge die Schaltzeiten für diesen Ausgang festlegen.

Gruß Tommy

agmue · May 19, 2022, 4:44pm

Gute Beschreibung, schöne Skizze

Das ist tatsächlich der Erwähnung wert!

In der IDE gibt es ein Beispiel BlinkWithoutDelay, das genau für Dich paßt.

In der Praxis bezweifle ich, daß Du mit dem ATtiny85 glücklich wirst. Es könnte auf einen Nano oder ProMini hinauslaufen.

combie · May 19, 2022, 4:51pm

Nöö.

karlshorster · May 19, 2022, 5:46pm

So wie unten hatte ich mir das gedacht. Ich dachte die Schleife wird immer und immer wieder durchgerannt und was drinnen steht an die Pins gesendet. Das war leider nicht so. Bitte nicht Lachen!!!
Habe dann gelesen das beim delay-Befehl das ganze Programm für die angegebene Zeit im delay-Befehl Stopt. So kann das ganze natürlich nicht funktionieren. Schon Blöd gedacht. Hatte das ganze erst mit kurzen Zeiten probiert und mich gewundert, dass die Zeiten nicht stimmten.
Also braucht man was das die Pins gleichzeitig ansteuern kann. Hatte mir mal dazu in einem anderen Forum mal den Sketch belebtes Haus angesehen.
Da werden mehrere Pins gleichzeitig angesteuert. Ich glaube das ist eine Nummer zu groß für einen Anfänger.


void setup() {
  pinMode(0, OUTPUT);
  pinMode(1, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
}
void loop() {
  digitalWrite(0, HIGH);   
  delay(120000); // 2 Minuten ein                    
  digitalWrite(0, LOW);    
  delay(600000); // 10 Minuten aus
  
  digitalWrite(1, HIGH);   
  delay(120000); // 2 Minuten ein                   
  digitalWrite(1, LOW);    
  delay(1200000); // 20 Minuten aus
  
  digitalWrite(2, HIGH);   
  delay(120000); // 2 Minuten ein                     
  digitalWrite(2, LOW);    
  delay(1200000); // 20 Minuten aus
  
  digitalWrite(3, HIGH);   
  delay(120000); // 2 Minuten ein                     
  digitalWrite(3, LOW);    
  delay(2400000); // 40 Minuten aus
  
  digitalWrite(4, HIGH);   
  delay(120000); // 2 Minuten ein                     
  digitalWrite(4, LOW);    
  delay(3600000); // 60 Minuten aus         
}

karlshorster · May 19, 2022, 5:56pm

Wie könnte das Praktisch aussehen?

karlshorster · May 19, 2022, 5:59pm

Schaue ich mir Morgen mal an. Muß morgen um 4 Uhr raus zur Arbeit. heute ist Feierabend.

danke erstmal an alle für das Interesse

Tommy56 · May 19, 2022, 6:04pm

Die Eingänge abfragen. Sobald einer als aktiv erkannt wurde, die Variablen für Pause und aktive Zeit auf die entsprechenden Wert setzen und den Zeitabluf aktivieren.
Ich weiß jetzt nicht aus dem Kopf, ob der 85 interne PullUp-Widerstände hat, wenn ja, dann diese aktivieren und den Schalter nach GND.
Da ist LOW dann der aktiv-Zustand.

Gruß Tommy

combie · May 19, 2022, 6:19pm

Bei mir würde das in etwa so aussehen:

#include <CombieTimer.h>
#include <CombiePin.h>
#include <CombieTypeMangling.h>

using namespace Combie::Pin;
using namespace Combie::Timer;
using namespace Combie::Millis;

class Task 
{
  public:
  virtual void init() = 0;
  virtual void run() = 0;
};

template<byte pin>
class Bewaesserung : Task
{
  private:
  OutputPin<pin> out;
  PpmGenerator ppm; // Generator fuer Puls/Pause Modulation
  
  public:
  Bewaesserung(Millis onTime,Millis offTime)
  {
    ppm.setOnInterval(onTime);
    ppm.setOnInterval(offTime);
  }
  virtual void init() override
  {
    out.init();
  }
  virtual void run() override
  {
    out = ppm;
  }
};

Task *alle[] 
{ 
  (Task*)(new Bewaesserung<0>( 2_Minuten, 10_Minuten)),
  (Task*)(new Bewaesserung<1>( 2_Minuten, 20_Minuten)),
  (Task*)(new Bewaesserung<2>( 2_Minuten, 1_Stunde)),
};



void setup() 
{
  for(Task *t:alle) t->init();
}

void loop() 
{  
  for(Task *t:alle) t->run();
}

Die CombieLib.zip findet man mit der Forensuche.
Kann sein, dass es mit dem Tiny nicht funktioniert.
Der sollte zwar schon drin sein, ist aber noch nicht wirklich getestet.

my_xy_projekt · May 19, 2022, 8:01pm

Jedes delay() sorgt dafür, das da eine Pause drin ist, bis das delay() abgelaufen ist.
Wenn Du hier startest:

geht das nach 2 Minuten ein und nach 10 Minuten aus.
Dann ist aber die Wartezeit 2Minuten + 20Minuten + 2Minuten + 20Minuten + 2Minuten + 40Minuten + 2Minuten + 60Minuten = 148 Minuten. Erst dann kommst Du wieder oben an....

Wenn Du den Drehschalter in einen Spannungsteiler baust, ist das noch immer mit nur 2 Pins abzuhandeln und die Unterscheidung - wenn es schon delay sein muss - nur auf genau diesem Zweig aktiv.
Das macht Dich aber weiterhin blind für die Zeit, wo der einzelne Zweig aktiv ist.
Ich hab einen digistump mal angetackert - die Pin musst Du auf Dich umschreiben.
Kommentar ist drin.
Die R's sind mit 2,5K ausreichend
Wenn Du später auf die Idee kommst zusätzliche Zeiten mit einem 6:1 oder 7:1 switch einzufügen, einfach die R's anpassen und einen zusätzlichen case einbauen. Braucht auch weiterhin keinen weiteren Pin.

         ___     ___     ___     ___     
+5V --+-|___|-+-|___|-+-|___|-+-|___|-+--GND
       \       \      |      /       /
        \       \     |     /       / 
         \       \    |    /       /
                  Drehswitch 5:1
                      |
                      |
AVR-PIN --------------+

Ich hab die Zeiten für mich kurz gestellt.

unsigned long lastswitch;
const byte analogPin = 1; // P2
const byte outputPin = 1; // P1
void setup()
{
  pinMode(outputPin, OUTPUT);
}
unsigned int switchtime;

void loop()
{
  switchtime = analogRead(analogPin);
  switch (switchtime)
  {
    case 0 ... 204:
      bewaessere(120, 600);
      //bewaessere(120000, 600000);
      break;
    case 205 ... 409:
      bewaessere(120, 1200);
      //bewaessere(120000, 1200000);
      break;
    case 410 ... 615:
      bewaessere(120, 1200);
      //bewaessere(120000, 1200000);
      break;
    case 616 ... 820:
      bewaessere(120, 2400);
      // bewaessere(120000, 2400000);
      break;
    case 821 ... 1024:
      bewaessere(120, 3600);
      //  bewaessere(120000, 3600000);
  }
}

void bewaessere(const unsigned long einZeit, unsigned long ausZeit)
{
  static unsigned long startZeit = 0;
  if (digitalRead(outputPin) == LOW) // ist aus?
  {
    if (millis() - startZeit >= ausZeit)
    {
      digitalWrite(outputPin, HIGH);
      startZeit = millis();
    }
  }
  else   // ist an?
  {
    if (millis() - startZeit >= einZeit)
    {
      digitalWrite(outputPin, LOW);
      startZeit = millis();
    }
  }
}

agmue · May 20, 2022, 10:46am

Bezogen auf Deine ursprüngliche Idee, den NE555 zu ersetzen, habe ich mal das Beispiel BlinkWithoutDelay auf fünf Ausgänge aufgebohrt. Getestet mit ATtiny85:

// ATMEL ATtiny45/85
//
//                +-\/-+
//        Reset  1|    |8  Vcc
// A3 (D 3) PB3  2|    |7  PB2 (D 2) A1 SCL
// A2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//          GND  4|    |5  PB0 (D 0) pwm0 SDA
//                +----+

const uint8_t ANZAHL       = 5;
const uint8_t PIN[ANZAHL]  = {PB0, PB1, PB2, PB3, PB4};  // ATtiny-Pin
const uint32_t EIN[ANZAHL] = {1, 2, 3, 4, 5};            // Einzeit in Minuten
const uint32_t AUS[ANZAHL] = {1, 1, 1, 1, 1};            // Auszeit in Minuten
uint32_t vorhin[ANZAHL]    = {0, 0, 0, 0, 0};            // gemerkter Zeitpunkt seit letztem Umschalten
const uint32_t min2ms      = 60 * 1000UL;                // Umrechnung Minuten nach Millisekunden

void setup()
{
  for (uint8_t j = 0; j < ANZAHL; j++)
  {
    pinMode(PIN[j], OUTPUT);
    digitalWrite(PIN[j], HIGH);
  }
}

void loop()
{
  uint32_t jetzt = millis();
  static uint8_t pin = 0;

  if (digitalRead(PIN[pin]))
  {
    if (jetzt - vorhin[pin] >= min2ms * EIN[pin])
    {
      vorhin[pin] = jetzt;
      digitalWrite(PIN[pin], LOW);
    }
  } else {
    if (jetzt - vorhin[pin] >= min2ms * AUS[pin])
    {
      vorhin[pin] = jetzt;
      digitalWrite(PIN[pin], HIGH);
    }
  }

  if (++pin >= ANZAHL) pin = 0;
}

Möglicherweise macht dieses Programm nicht genau das, was Du brauchst, aber es ist, was Du beschrieben hast. Die vorangegangenen Beiträge geben daher gute Hinweise. Ich bin gespannt

karlshorster · May 23, 2022, 8:20pm

Hallo und guten Abend,
ich habe euch nicht vergessen, hatte nur keine Zeit. Ich kenne das schon aus anderen Foren mit den neuen die sich nicht mehr melden (nicht bei mir ).
Erstmal bin ich echt Platt von der Hilfsbereitschaft hier. Ich danke jedem einzelnen beteiligten ganz herzlich für die Hilfestellung. Leider bin ich nur der Fragende und nicht auch der Gebende.

Deine Spannung kannst du jetzt abbauen. Volltreffer!!! Funktioniert bestens.

Dein Vorschlag hört sich ebenfalls Super an. Mangels Material noch nicht getestet. Etwas aufwändiger beim bauen , aber sparsamen Schaltkreiseinsatz. Werde ich auf jeden Fall auch aufbauen wenn ich alles da habe.

Auch dir meinen Dank. Das ist für einen Einsteiger wie mich leider zu hoch. Da traue ich mich nicht ran. Bitte nicht sauer sein.

Damit werde ich mich etwas später wenn ich mal wieder mehr Zeit auch beschäftigen. Da ich mich gerne mit der für mich neuen Technik "Mikrocontroller" auseinander setzen möchte.

Im übrigen hatte ich auch einen Plan B in der Tasche. Der ist für die Vollanfänger wie mich und ohne fremde Hilfe möglich. Da hätte einfach der Blink-Sketch auf jedem Attiny gereicht. Habe ich mir so ausgedacht, ist jedoch sehr Materialfressend. Die Mikrocontroller werden außerdem in letzter Zeit auch immer teurer.
Bitte nicht die Hände über dem Kopf zusammenschlagen.
Jetzt kommts,

Ich würde gerne noch von euch wissen ob Ihr Beruflich mit der Programmiererei zu tun habt, oder ob auch Hobby-Programmierer unter euch sind. Von einem Hobby-Programmierer hätte ich gern gewußt wie er bei null angefangen hat. Bestimmt gibt es auch eine für Anfänger brauchbare Literatur die Ihr mir empfehlen könnt.

Gute Nacht allen
ich bleibe am Ball und habe noch ein paar Fragen die nächsten Tage
alles gute
Grüße aus Berlin

combie · May 23, 2022, 8:56pm

Warum sollte ich sauer sein?

agmue · May 23, 2022, 9:12pm

Freut mich!

Über meine Anfänge mit Z80 in Assembler willst Du bestimmt nichts wissen, das hilft Dir nicht

Zum Arduino ATtiny85 bin ich durch einen befreundeten Modellbahner gekommen, der bei einer Ausstellung "das belebte Haus" zeigte. Ich habe mit einem ATtiny85 und zwei Schieberegistern für mehrere Zimmer eines größeren Hauses angefangen. Beim Einschaltflackern einer Neonröhre kam ich zunächst an meine Grenzen. Mein Erstlingswerk funktioniert erstaunlicherweise immer noch. Seitdem programmiere ich Arduinos als Hobby.

Bei neuen µCs lasse ich zuerst eine LED blinken, um die Pinzuordnung zu überprüfen. Andere Hardware teste ich und hebe mir die funktionierenden Testprogramme auf, um ggf. darauf zurückfallen zu können. Kleine Schritte bringen mich letztlich zum Ziel.

Manchmal "verbessere" ich auch fremde funktionierende Programme solange, bis sie nicht mehr funktionieren, um daran zu lernen. Diese Vorgehensweise ist in diesem Forum umstritten, aber mir hilft sie. Andere lesen tausendseitige Bücher, das ist nicht so mein Ding. Du mußt also selbst herausfinden, wie Du am besten lernst und dabei Spaß hast.

Zum Nachschlagen nutze ich cplusplus, die Beispiele sind aber weder für Arduino, noch ist es ein Lehrbuch.

karlshorster · May 25, 2022, 1:08pm

Hallo my_xy_projekt

ich bin jetzt dabei Deine Idee umzusetzen. Jetzt brauch ich noch etwas Verständnishilfe.

Was passiert am Attinyeingang und was wird da gemessen, Spannung, Widerstand?
Was sagen mir die Werte die unter "case 0 ... 204:" eingetragen sind, und sind diese ermittelbar?
Sind die Widerstandswerte z.B. für 12 Bewässerungszeiten (Du sagtest es ist erweiterbar) ermittelbar?
Gibt es einen Widerstandshöchstwert in Summe der Kette womit der Attiny überfordert ist oder den er nicht mehr verarbeiten kann?
Würde das mit 12 Zeiten überhaupt sicher funktionieren?

Ja ich weiß, viele Fragen. Aber ich will Deinen Aufbau für mich verstehen und nicht nur wild rumprobieren.
Wenn Du mir bei deiner Idee die ich ebanfalls sehr vielversprechend finde weiterhelfen könntest wäre ich Dir sehr Dankbar. Den Pflanzen soll es ja gut gehen .

Vielen Dank im Voraus
Viele Grüße aus Berlin
Ingolf

agmue · May 25, 2022, 1:38pm

Am analogen Eingang wird Spannung gemessen.

Der ADC setzt die Spannung in Zahlenwerte 0 bis 1023 um.

I = 5 V / R_gesamt
U_R = I * R = 5 V * R / R_gesamt
Wert_ADC = U * 1023 / 5 V = 1023 * R / R_gesamt

Das ist der Wert für den ersten Widerstand, der auf der einen Seite mit GND verbunden ist. Alle weiteren Werte sind ein Vilefaches davon. Da die gemessenen Werte schwanken, gibt man einen Wertebereich als gültig an.

Irgendwann wird der Strom zu klein und der Kondesator des ADC wird nicht mehr schnell genug geladen. Ich würde, über den Daumen gepeilt, nicht über 10 kΩ gehen.

Probiere es aus

Den ADC eines ATtiny habe ich noch nie benutzt, bitte schreibe mir, was Du rausfindest!

my_xy_projekt · May 25, 2022, 2:01pm

Da wird Spannung gemessen.
Die Schaltung ist ein fester Spannungsteiler.
Nachbilden kannst das mit einem Potentiometer.
Die maximale Spannung am Pin ergibt sich aus dem Datenblatt.
(Meisst VCC+0,5V)

Der AnalogEingang hat eine 10Bit Auflösung.
Bei 0V also 0 und bei 5V 1023
Die Auflösung in 5 Schalterstellungen bei gleichen R's (2K) ergibt:

0V  -  x  -  x  -  x  -  5V 
    1,25V   2,5V  3,75V

0 .. 256 .. 511 .. 767 .. 1023

Und nu lässt Du den Mittelwert nochmals pendeln.
Also in dem Fall 0..125, 126..380,381..636, ... usw.

Na einfach nachrechnen.
Der obere Wert ist 5V der untere Wert ist 0V
In der Mitte fehlen jetzt noch 11 Werte. Nu kannst jeweils 1K ansetzen, kommste auf 11K - passt. Bis 15K passiert nichts.
Die 1023 aufteilen

Der Attiny ist nicht damit überfordert - es fehlt dann nur die Möglichkeit das sinnvoll auszuwerten.

Na sicher.

agmue · May 25, 2022, 8:40pm

Wie Du sicherlich inzwischen weißt, schaue ich mir manche Dinge nochmal mit etwas Abstand an, in diesem Fall #11.

Mir geht es um die von Dir gewählten Toleranzbereiche (nur einzelne Programmzeilen):

Du hast fünf Bereiche gleicher Breite festgelegt, was m. E. für den obersten und untersten nicht zutrifft. Nehmen wir mal den Punkt zwischen erstem und zweiten Widerstand, der müßte dann ungefähr um 300 mit plus/minus 100 schwanken. Das würde bedeuten, der Punkt an GND würde um den Sollwert 100 mit plus/minus 100 schwanken. Das kann aber nicht stimmen!

Theoretisch müßte der Punkt an GND zwischen -100 und +100 schwanken, ebenso wie der Punkt an 5 V zwischen 923 und 1123. Das tun sie nicht, weil der ADC nur Werte zwischen 0 und 1023 azsgeben kann. Dennoch liegen die Sollwerte nicht bei
102, 307, 512, 718 und 922.

Meine Bereiche liegen bei 0 - 127, 128 - 383, 384 - 639, 640 - 895 und 896 - 1023.

Für die ~~zwölf~~ dreizehn dann: 0 - 42, 43 - 127, 128 - 213, 214 - 298, 299 - 383, 384 - 468, 469 - 554, 555 - 639, 640 - 724, 725 - 809, 810 - 895, 896 - 980 und 981 - 1023

Mit der freundlichen Bitte um Nachrechnung!

karlshorster · May 25, 2022, 8:41pm

agmue
my_xy_projekt

Ihr seid alle einfach nur SPITZE!!!!!
rauf

Da habe ich ja was zu tun.
Herrentag wird Basteltag

Topic		Replies	Views
Mehrere Schaltvorgänge realisieren. Brauche Hilfe... Deutsch	8	903	May 6, 2021
Hilfe für mein Projekt Deutsch	16	1860	May 6, 2021
LED treppenlicht Deutsch	30	2558	June 3, 2021
Schrittmotor: nur ein paar Schritte zum Glück Deutsch	7	417	February 7, 2023
Schilderung: meine allerersten Arduino Erfahrungen Deutsch	6	3015	May 6, 2021

Zeitautomatik für Hydroponikanlage

Related topics