Einfacher Code für automatische Bewässerung

Hallo.

Ich bin neu hier im Forum und auch in der Arduino-Welt. Mich hat der Basteldrang gepackt und ich habe vor eine automatische Bewässerungsanlage für unser Tomatenhaus zu bauen, bzw. diese zu verbessern.
Aktuell stehen 4 große Pflanzkübel im Tomatenhaus. In einem der Kübel ist ein kapazitiver Feuchtigkeitssensor versenkt. Meine Arduino Nano Kopie liest die feuchte der Erde aus und wenn diese zu trocken ist schaltet er die Pumper per für 30 Sekunden ein. Danach wartet er 15 Minuten.

Das ganze läuft über eine Autobatterie mit einer 12V 1.5A mini China-Pumpe. Der Code macht was er soll. Es hat sich aber herausgestellt dass die Pumpe zu wenig Druck hat um alle Pflanzen gleichmäßig zu bewässern. Immerhin muss sie vier Schläuche bzw Ausgänge mit genug Druck versorgen und sowieso müssen sich alle Pflanzen nach dem Wasserbedarf des einen Kübels richten. Das möchte ich gerne ändern.

Die Anlage wird aufgerüstet und bekommt dazu ein 5 Wege Magnetventil und einen Sensor pro Kübel. In festen Abständen einen Sensorwert im Pflanzkübel abgefragt werden. Ist die Erde zu trocken soll ein Ventil öffnen und eine Pumpe einschalten. Danach soll der Sensorwert im Intervall solange überprüft werden bis die Erde feucht genug ist. Erst dann soll die Pumpe wieder abschalten und das Ventil schließen. Danach geht das ganze mit dem nächsten Kübel weiter.

Dafür habe ich folgenen Sketch geschrieben:

int ventil1 = 1;  // Namen für Digitalpins 1-5
int ventil2 = 2;
int ventil3 = 3;
int ventil4 = 4;
int pumpe = 5;
int sens1 = A1;  // Namen für Analogpins 1-4
int sens2 = A2;
int sens3 = A3;
int sens4 = A4;
int senswert1;  // Name für Sensorwert
int senswert2;
int senswert3;
int senswert4;


void setup() {
  pinMode(1, OUTPUT);  // Digitale Pins 1-5 werden auf OUTPUT gestellt
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
}

void loop() {
  senswert1 = analogRead(sens1);  // Wert von Sensor wird ausgelesen
  if (senswert1 > 600)            // Wenn Sensorwert größer 600 dann nachfolgende Anweisungen ausführen
  {
    digitalWrite(ventil1, HIGH);  // Ventil öffnen
    delay(3000);                  // 3 Sekunden warten
    digitalWrite(pumpe, HIGH);    // Pumpe an
    delay(5000);                  // 5 Sekunden warten
    while (senswert1 > 475)       // Solange Sensorwert größer 475 ist nachfolgende Anweisungen ausführen
    {
      delay(2000);                    // 2 Sekunden Warten
      senswert1 = analogRead(sens1);  // Sensorwert auslesen. Zurück zu "while"
    }
    digitalWrite(pumpe, LOW);    // Pumpe aus
    delay(3000);                 // 3 Sekunden warten
    digitalWrite(ventil1, LOW);  // Ventil 1 schließen
    delay(3000);                 // 3 Sekunden warten
  }
  senswert2 = analogRead(sens2);
  if (senswert2 > 600) {
    digitalWrite(ventil2, HIGH);
    delay(3000);
    digitalWrite(pumpe, HIGH);
    delay(5000);
    while (senswert2 > 475) {
      delay(2000);
      senswert2 = analogRead(sens2);
    }
    digitalWrite(pumpe, LOW);
    delay(3000);
    digitalWrite(ventil2, LOW);
    delay(3000);
  }
  senswert3 = analogRead(sens3);
  if (senswert3 > 600) {
    digitalWrite(ventil3, HIGH);
    delay(3000);
    digitalWrite(pumpe, HIGH);
    delay(5000);
    while (senswert3 > 475) {
      delay(2000);
      senswert3 = analogRead(sens3);
    }
    digitalWrite(pumpe, LOW);
    delay(3000);
    digitalWrite(ventil3, LOW);
    delay(3000);
  }
  senswert4 = analogRead(sens4);
  if (senswert4 > 600) {
    digitalWrite(ventil4, HIGH);
    delay(3000);
    digitalWrite(pumpe, HIGH);
    delay(5000);
    while (senswert4 > 475) {
      delay(2000);
      senswert4 = analogRead(sens4);
    }
    digitalWrite(pumpe, LOW);
    delay(3000);
    digitalWrite(ventil4, LOW);
  }
  delay(900000);
}

Das ist mein zweiter Code den ich selber erstellt habe. Man verzeihe mir bitte meine mangelnden Vorkenntnisse :upside_down_face: Ich warte noch auf die Ventile und die Sensoren aber ich dachte mir man kann die Profis ja schon mal drüber schauen lassen :grin:
Wird der Code denn so funktionieren und passt die while Schleife so?
Ich habe es so verstanden dass alles was in den {} nach "while" kommt solange ausgeführt wird bis die Bedingung von while nicht mehr erfüllt wird?
In diesem Fall wenn der Wert vom Sensor unter 475 fällt dann wird der Teil nach den {} von "while" ausgeführt (Pumpe aus, Ventil zu).


    while (senswert2 > 475) {
      delay(2000);
      senswert2 = analogRead(sens2);
    }
    digitalWrite(pumpe, LOW);
    delay(3000);
    digitalWrite(ventil2, LOW);
    delay(3000);

Es wird wohl empfohlen nicht mit "delay()" sondern mit "millis()" zu arbeiten. Ist das hier unbedingt nötig? Die delays werde ich evtl noch umstellen. Ich will nur vermeiden dass die Ventile geschlossen sind wärend die Pumpe läuft.

Vielen Dank schon mal für die Antworten.

Relak

Hallo,

ich würde nicht solange sturr gießen bis der Wert vom Sensor stimmt. Es gibt in der Erde eine gewisse Verzögerung der Durchfeuchtung. Auch kommt es darauf an wie tief der Sensor in der Erde steckt. Ich würde immer nur etwas gießen, warten, messen. Ggf. Zyklus solange wiederholen bis mir die Feuchtigkeit gefällt. Während der eine Kübel auf seine verzögerte Messung wartet kann der andere etwas gegossen werden usw.
Du merkst hier ganz schnell das blockierende Schleifen Mist sind. Beschäftige dich mit millis, denke an deine Armbanduhr o.ä. wie du damit tagtäglich eher unbewusst Differenzzeiten bildest. Genauso funktioniert das mit millis.

Schön, Herzlich willkommen!
Sieht ja schon nicht so ganz falsch aus.
Kurzhinweise:

Du bezeichnest die Pins so wunderschön, nutzt die Bezeichnungen aber nicht.

Der PIN 1 (und PIN 0) ist bei einem UNO / NANO / MEGA.... mit dem USB-Port verbunden.
Das wird Dir evtl. auf die Füsse fallen.

Du hast eigentlich 4 inhaltlich gleichlautende Funktionen.
Du könntest mit Arrays und ggfls. mit struct arbeiten um das übersichtlicher zu machen - und Schreibarbeit zu sparen.

Na denne....

Darf ich als Hobbyprogrammierer auch mitspielen?

Die Pins 0 und 1 sind beim Nano für USB reserviert und dürfen nicht als digitale Pins verwendet werden.

Die Pinnummern sind konstant:

const uint8_t ventil1 = 2;
const uint8_t ventil2 = 3;
const uint8_t ventil3 = 4;
const uint8_t ventil4 = 5;
const uint8_t pumpe = 6;
const uint8_t sens1 = A1;  // Namen für Analogpins 1-4
const uint8_t sens2 = A2;
const uint8_t sens3 = A3;
const uint8_t sens4 = A4;

Namen solltest Du konsequent verwenden:

  pinMode(ventil1, OUTPUT);
  pinMode(ventil2, OUTPUT);
  pinMode(ventil3, OUTPUT);
  pinMode(ventil4, OUTPUT);
  pinMode(pumpe, OUTPUT);

Zahlenkonstanten kann man benennen, dann braucht man sie nur an einer Stelle zu ändern:

const int SENS_TROCKEN = 600;
const int SENS_FEUCHT = 475;
...
  if (senswert1 > SENS_TROCKEN)   // Wenn Sensorwert größer SENS_TROCKEN dann bewässern
...
    while (senswert1 > SENS_FEUCHT)   // Solange Sensorwert größer SENS_FEUCHT weiter bewässern

Das gilt auch für die Zeiten:

const uint16_t SCHALTZEIT_PUMPE = 3000;
const uint16_t MINBEWÄSSERUNGSZEIT = 2000;
...
  senswert1 = analogRead(sens1);      // Wert von Sensor wird ausgelesen
  if (senswert1 > SENS_TROCKEN)       // Wenn Sensorwert größer SENS_TROCKEN dann nachfolgende Anweisungen ausführen
  {
    digitalWrite(ventil1, HIGH);      // Ventil öffnen
    delay(SCHALTZEIT_PUMPE);          // warten
    digitalWrite(pumpe, HIGH);        // Pumpe an
    while (senswert1 > SENS_FEUCHT)   // Solange Sensorwert größer SENS_FEUCHT ist nachfolgende Anweisungen ausführen
    {
      delay(MINBEWÄSSERUNGSZEIT);     // warten
      senswert1 = analogRead(sens1);  // Sensorwert auslesen. Zurück zu "while"
    }
    digitalWrite(pumpe, LOW);         // Pumpe aus
    delay(SCHALTZEIT_PUMPE);          // warten
    digitalWrite(ventil1, LOW);       // Ventil 1 schließen
  }
... // Sensor 2 bis 4 machst Du bitte selbst

Ich war nicht so schnell wie die Kollegen, daher wiederholen sich manche Hinweise, schadet ja nicht :crazy_face:

1 Like

dafür ausführlicher...

1 Like

Das wäre mein "Einsteigercode"

const byte pflanzenNum = 4;          // Anzahl der Kübel - darauf basiert dann die Ventile etc...
const byte pumpePin = 2;
const byte ventilPin[pflanzenNum] = {3, 4, 5, 6}; // Namen für Digitalpins 1-5
const byte sensorPin[pflanzenNum] = {A1, A2, A3, A4};
unsigned int sensorWert;
const unsigned int trocken = 600;
const unsigned int nass = 475;

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  for (byte b = 0; b < pflanzenNum; b++)
  {
    pinMode(ventilPin[b], OUTPUT);
  }
  pinMode(pumpePin, OUTPUT);
}

void loop()
{
  for (byte b = 0; b < pflanzenNum; b++)
  {
    sensorWert = analogRead(sensorPin[b]);     // Wert von Sensor wird ausgelesen
    if (sensorWert > trocken)
    {
      digitalWrite(ventilPin[b], HIGH);        // Ventil öffnen
      Serial.print(F("Ventil"));
      Serial.print(b);
      Serial.println(F(": geht auf!"));
      delay(3000);                             // 3 Sekunden warten
      digitalWrite(pumpePin, HIGH);            // Pumpe an
      Serial.println(F("Pumpe ist an"));
      delay(5000);                             // 5 Sekunden warten
      while (sensorWert > nass)                // Solange Sensorwert größer 475 ist nachfolgende Anweisungen ausführen
      {
        delay(2000);                           // 2 Sekunden Warten
        sensorWert = analogRead(sensorPin[b]); // Sensorwert auslesen. Zurück zu "while"
      }
      digitalWrite(pumpePin, LOW);             // Pumpe aus
      Serial.println(F("Pumpe ist aus"));
      // delay(3000);                          // 3 Sekunden warten
      digitalWrite(ventilPin[b], LOW);            // Ventil 1 schließen
      Serial.print(F("Ventil"));
      Serial.print(b);
      Serial.println(F(": geht zu!"));
      delay(3000);                             // 3 Sekunden warten
    }
  }
  // delay(900000);
}

Ich habe deine zwei delays auskommentiert, weil nicht nötig.
Bitte beachte ich hab die Pins umsortiert.
Zudem arbeite ich mit dem dem seriellen Monitor.
In der Standardeinstellung steht der auf 9600 - das ist mir zu langsam :wink:

So läuft es im aktuellen Programm. Da werde ich aber nochmal rumprobieren müssen da es aktuell nicht so gut läuft. Ich kann es ja jederzeit ändern. Danke :slightly_smiling_face:

Das habe ich vor. Ich war mir nur nicht Sicher ob ich millis wirklich brauche. Ich werd mich da mal rein arbeiten.

Ich werde es ändern.

Kein Problem. Dann nehm ich 4-8. Danke für den Hinweis. Gibt es bei den analogen Pins auch solche Dinge auf die ich achten muss?

Da werde ich mich gerne mal einlesen. Aktuell sollte der Code ja so reichen für das was ich wirklich brauche. Der ganze Spass soll nach und nach verbessert werden. Später ist das Messen des Wasserstandes im Fass noch geplant. Irgendwann soll auf Wireless umgestellt werden und und und. Da werde ich solche Sachen sowieso benötigen. Danke dir.

Für mich ist jeder Hobbyprogrammierer der mehr weiß als ich ein Profi :smiley:

Auf die Idee bin ich gar nicht gekommen. Das werd ich so übernehmen. Danke für die ausführliche Antwort.

Hui. Da sind Sachen dabei die ich noch nicht verstehe :smiley: Mit "for" hab ich mich z.B. noch gar nicht beschäftigt.

for (byte b = 0; b < pflanzenNum; b++)

byte b ist 0.
Dann wird geprüft ob b kleiner als 4 ist.
Dann wird mit ++ hinter B einfach +1 dazugezählt.
Wenn er bei 4 angekommen ist fängt er von vorne an.

Habe ich das richtig verstanden?
Muss man mit dem Seriellen Monitor arbeiten? Wird später sicher auch nötig sein...

Vielen Dank an alle.

Relak

... wird die Schleife verlassen. 0 bis 3 wird bearbeitet, 4 dann nicht mehr.

Nein, ja, hilft bei der Fehlersuche.

Dann mal eine Gute Nacht Lektüre. Dort das pdf runterladen. Geschrieben von einem Arduino-Nutzer und dementsprechend auch einfach zu lesen.
Jeden Abend ein paar Seiten - nicht auswendig lernen, nur wissen, das da was drin steht. Später kommt dann ganz automatisch ein Buch....

1 Like

Ja.
Beim Uno und Nano liegt I2C auf A4 und A5 (siehe Wire).

Du möchtest "einfachen Code", aber was ist "einfach"?

Als objektorientierte Programmierung (OOP) angeboten wurde, empfand ich das als vollständig überflüssig. In diesem Forum gibt es Menschen, die meine Meinung ins Wanken gebracht haben. Ist also eine OOP-Variante von #6 "einfacherer Code"? Siehe selbst:

const uint8_t pumpePin = 2;
const uint16_t SCHALTZEIT_PUMPE = 3000;
const uint16_t MINBEWAESSERUNGSZEIT = 2000;

const uint16_t TROCKEN = 600;
const uint16_t NASS = 475;

class Tomate
{
    const byte ventilPin;
    const byte sensorPin;
  public:
    Tomate(const byte ventilPin, const byte sensorPin) : ventilPin(ventilPin), sensorPin(sensorPin)
    {}
    void init()
    {
      pinMode(ventilPin, OUTPUT);
    }

    void bewaessern()
    {
      uint16_t sensorWert = analogRead(sensorPin);      // Wert von Sensor wird gelesen
      if (sensorWert > TROCKEN)
      {
        digitalWrite(ventilPin, HIGH);           // Ventil öffnen
        Serial.print(F("ventilPin "));
        Serial.print(ventilPin);
        Serial.println(F(" geht auf!"));
        delay(SCHALTZEIT_PUMPE);                 // warten
        digitalWrite(pumpePin, HIGH);            // Pumpe an
        Serial.println(F("Pumpe ist an"));
        while (sensorWert > NASS)                // Solange nicht naß genug nachfolgende Anweisungen ausführen
        {
          delay(MINBEWAESSERUNGSZEIT);           // warten
          sensorWert = analogRead(sensorPin);    // Sensorwert auslesen. Zurück zu "while"
          Serial.print(F("sensorWert "));
          Serial.println(sensorWert);
        }
        digitalWrite(pumpePin, LOW);             // Pumpe aus
        Serial.println(F("Pumpe ist aus"));
        delay(SCHALTZEIT_PUMPE);                 // warten
        digitalWrite(ventilPin, LOW);            // Ventil schließen
        Serial.print(F("ventilPin "));
        Serial.print(ventilPin);
        Serial.println(F(" geht zu!"));
        delay(SCHALTZEIT_PUMPE);                 // warten
      }
    }
};

Tomate tomate[] =
{ // ventilPin, sensorPin
  {3, A0},
  {4, A1},
  {5, A2},
  {6, A3},
};


void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  pinMode(pumpePin, OUTPUT);
  for (auto &t : tomate) t.init();
}

void loop()
{
  for (auto &t : tomate) t.bewaessern();
}

Ich habe ganz bewußt die Logik unverändert gelassen, um einen Vergleich einfacher zu gestalten.

Wenn man in relativ kurzen Zeitintervallen mißt, dürfte auch ein Grenzwert genügen:

const uint8_t pumpePin = 2;
const uint16_t SCHALTZEIT_PUMPE = 3000;
const uint16_t MINBEWAESSERUNGSZEIT = 2000;

const uint16_t TROCKEN = 600;

class Tomate
{
    const byte ventilPin;
    const byte sensorPin;
  public:
    Tomate(const byte ventilPin, const byte sensorPin) : ventilPin(ventilPin), sensorPin(sensorPin)
    {}
    void init()
    {
      pinMode(ventilPin, OUTPUT);
    }

    void bewaessern()
    {
      uint16_t sensorWert = analogRead(sensorPin);      // Wert von Sensor wird gelesen
      Serial.print(F("sensorWert "));
      Serial.println(sensorWert);
      if (sensorWert > TROCKEN)
      {
        digitalWrite(ventilPin, HIGH);           // Ventil öffnen
        Serial.print(F("ventilPin "));
        Serial.print(ventilPin);
        Serial.println(F(" geht auf!"));
        delay(SCHALTZEIT_PUMPE);                 // warten
        digitalWrite(pumpePin, HIGH);            // Pumpe an
        Serial.println(F("Pumpe ist an"));
        delay(MINBEWAESSERUNGSZEIT);             // warten
        digitalWrite(pumpePin, LOW);             // Pumpe aus
        Serial.println(F("Pumpe ist aus"));
        delay(SCHALTZEIT_PUMPE);                 // warten
        digitalWrite(ventilPin, LOW);            // Ventil schließen
        Serial.print(F("ventilPin "));
        Serial.print(ventilPin);
        Serial.println(F(" geht zu!"));
        delay(SCHALTZEIT_PUMPE);                 // warten
      } else {
        delay( 3 * SCHALTZEIT_PUMPE + MINBEWAESSERUNGSZEIT );
      }
    }
};

Tomate tomate[] =
{ // ventilPin, sensorPin
  {3, A0},
  {4, A1},
  {5, A2},
  {6, A3},
};


void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  pinMode(pumpePin, OUTPUT);
  for (auto &t : tomate) t.init();
}

void loop()
{
  for (auto &t : tomate) t.bewaessern();
}

Hallo relak
Mir hat die Idee von Doc_Arduino saugut gefallen. Mir kam sofort die Idee einen Wasser-Demuliplexer zu bauen.

Hier kommt auch noch ein "klassenloses" Beispiel in objektorientierte Programmierung (OOP) zum Lernen.

Das Objekt ist eine Datenstruktur in der alle Variablen mit den entsprechenden Datentypen deklariert werden:

struct WATERING
{
  String name_;        // name of sensor
  byte sensor;         // port pin address for moisture sensor
  byte pump;           // port pin address for water pump
  byte ventil;         // port pin address for water ventil
  int  dryValue;       // value for measured moisture
  unsigned long time_; // time window for watering
  unsigned long stamp; // currentTime value,
};

und als struktuiertes Array initialisiert:

WATERING waterings[]
{
  {"Tomate 1", A0, 8, 9, 600, 5000, 0},  // Irrigation branch 1
  {"Tomate 2", A1, 8, 10, 600, 5000, 0}, // Irrigation branch 2
  {"Tomate 3", A2, 8, 11, 600, 5000, 0}, // Irrigation branch 3
  {"Tomate 4", A3, 8, 12, 600, 5000, 0}, // Irrigation branch 4
};

Ein Service, Methode oder wie auch immer man das nennt, nimmt die Daten aus dem struktuiertes Array und realisiert so den Wasser-Demuliplexer.
Viel Spass beim Spielen und Lernen. Die OOP erleichert das Arbeiten ungemein, dann wenn man viele identische Elemente hat ohne dabei den Code (n+1) mal zu kopieren. So entsteht ein Einfacher Code für automatische Bewässerung.

/* BLOCK COMMENT
  ATTENTION: This Sketch contains elements of C++.
  https://www.learncpp.com/cpp-tutorial/
  https://forum.arduino.cc/t/einfacher-code-fur-automatische-bewasserung/1007872
  Tested with Arduino: Mega[X] - UNO [ ] - Nano [ ]
*/
#define ProjectName "Einfacher Code für automatische Bewässerung"
#define OutPutTest
constexpr  unsigned long OutPutTestTime {1000};
// VARIABLE DECLARATION AND DEFINITION
unsigned long currentTime;

// -- object -----------------------------------------
struct WATERING
{
  String name_;        // name of sensor
  byte sensor;         // port pin address for moisture sensor
  byte pump;           // port pin address for water pump
  byte ventil;         // port pin address for water ventil
  int  dryValue;       // limit value for measured moisture
  unsigned long time_; // time window for watering
  unsigned long stamp; // currentTime value,
};

WATERING waterings[]
{
  {"Tomate 1", A0, 8, 9, 600, 5000, 0},  // Irrigation branch 1
  {"Tomate 2", A1, 8, 10, 600, 5000, 0}, // Irrigation branch 2
  {"Tomate 3", A2, 8, 11, 600, 5000, 0}, // Irrigation branch 3
  {"Tomate 4", A3, 8, 12, 600, 5000, 0}, // Irrigation branch 4
};
// -------------------------------------------------------------------

void setup() 
{
  Serial.begin(9600);
  Serial.println(F("."));
  Serial.print(F("File   : ")), Serial.println(__FILE__);
  Serial.print(F("Date   : ")), Serial.println(__DATE__);
  Serial.print(F("Project: ")), Serial.println(ProjectName);
  pinMode (LED_BUILTIN, OUTPUT);  // used as heartbeat indicator
  //  https://www.learncpp.com/cpp-tutorial/for-each-loops/

  for (auto watering : waterings) pinMode(watering.ventil, OUTPUT), pinMode(watering.pump, OUTPUT);
#ifdef OutPutTest
  // check outputs
  for (auto watering : waterings) digitalWrite(watering.ventil, HIGH), digitalWrite(watering.pump, HIGH), delay(OutPutTestTime);
  for (auto watering : waterings) digitalWrite(watering.ventil, LOW), digitalWrite(watering.pump, LOW), delay(OutPutTestTime);
#endif
}

void loop ()
{
  currentTime = millis();
  digitalWrite(LED_BUILTIN, (currentTime / 500) % 2);
  for (auto &watering : waterings)
  {
    if ((analogRead(watering.sensor) > watering.dryValue) && !digitalRead(watering.pump)) {
      digitalWrite(watering.pump, HIGH) ;
      digitalWrite(watering.ventil, HIGH);
      watering.stamp = currentTime;
      Serial.print(watering.name_), Serial.print(F(" Feuchtigkeit ")),Serial.print(analogRead(watering.sensor));
    }
    if ( currentTime - watering.stamp >= watering.time_ && digitalRead(watering.ventil)) 
    {
      digitalWrite(watering.pump, LOW);
      digitalWrite(watering.ventil, LOW);
      Serial.print(F(" : ")),Serial.println(analogRead(watering.sensor));
    }
  }
}

Ich wünsche einen geschmeidigen Abend und viel Spass beim Programmieren in C++ und Lernen.

wenn ich da einen Vorschlag machen darf:

struct WATERING
{
  const char *name_;   // name of sensor
  const byte sensor;   // port pin address for moisture sensor
  const byte pump;     // port pin address for water pump
  const byte ventil;   // port pin address for water ventil
  int  dryValue;       // limit value for measured moisture
  unsigned long time_; // time window for watering
  unsigned long stamp; // currentTime value,
};

bringt den Sketch runter von Flash 4948/SRAM 446 auf Flash 3234/SRAM 420.

1 Like

Hallo noiasca
Merci, nur so kann man lernen.
:+1: :+1: :+1:

Vielen lieben Dank @agmue und @paulpaulson.

das klingt nach einer guten Beschäftigung für die nächsten freien Abende. Wird sicher etwas dauern bis ich eure Codes komplett verstanden habe :sweat_smile:.
In der erwähnten Lekürte von my_xy_projekt habe ich auch schon etwas gelesen.

Relak

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.