Zeigt her eure geilen Projekte !

Einen Kreativpreis hast Du auf jeden Fall verdient! Bei der Ökonomie, na ja ;)

Du könntest auch einen Mega 2560 pro auf eine von Dir zu entwickelnde Platine als UNO-Shield setzen, wo Du dann zusätzliche Pins unterbringen könntest. Den gibt es auch ohne USB-Anschluß.

Weiter geht's mit der Kreativität :)

Jo .. das teil habe ich zu erst versucht. Aber es passt ja nicht auf einen Uno. Da müsste ich noch einen Adapter machen. Dann gibt es ja noch die Begrenzung der Ströme. Die bei einem 2560 einfach nur 20 mA pro pin sind. Und 250 Maximal auf alle Pins auf dauer. Das bedeutet das man sehr vorsichtig damit umgehen muss. Der 328 packt 40 mA Dauerstrom auf allen 16 Pins locker. Ausserdem liebe ich diese Bauform DIL28. Lassen sich locker Sockeln und wer braucht schon so fiele pins.....

fiele wege führen nach Rom :-)

temucin: ääää nicht hauen . Aber welche Links ? woher soll ich wissen wo die Bilder Abgespeichert sind? Bei Insert a Link muss ich eine url eingeben.

Na die, die unter #561 stehen.

Gruß Tommy

temucin:
… Dann gibt es ja noch die Begrenzung der Ströme. Die bei einem 2560 einfach nur 20 mA pro pin sind. Und 250 Maximal auf alle Pins auf dauer. Das bedeutet das man sehr vorsichtig damit umgehen muss. Der 328 packt 40 mA Dauerstrom auf allen 16 Pins locker. …

Hallo,

die Aussage animiert mich dem zu widersprechen. Nicht zum ärgern, sondern weil ich das für wichtig halte und viel Mist im Internetz die Runde macht.

328P, absolute maximum ratings all pins 200mA.
Insgesamt hat der Uno 20 pins, die Hardware Serielle lässt man meistens frei, bleiben noch 18 Pins. 200mA durch 18 macht pro Pin 11,1mA.

2560, auch hier steht - absolute maximum ratings all pins 200mA. wenn man von den 70 Pins beim Mega auch 2 der Seriellen frei lässt, muss man 200mA durch 68 teilen. Macht pro Pin 2,9mA.

Betreibt man den µC dauerhaft mit dieser Last an allen Pins geht er kaputt bzw. nimmt Schaden. Die besagten maximalen 40mA pro Pin gelten auch nicht dauerhaft. Auch unter Beachtung des maximal zulässigen Summenstroms nicht. Dauerhaft mit dieser Last geht er kaputt bzw. nimmt Schaden. Steht im Datenblatt.

Note: Stresses beyond those listed under “Absolute Maximum Ratings” may cause permanent damage
to the device. This is a stress rating only and functional operation of the device at these or other conditions beyond those indicated in the operational sections of this specification is not implied. Exposure to absolute maximum rating conditions for extended periods may affect device reliability.

Worums gehts dann eigentlich? Es geht um die Einhaltung der garantierten Spannungspegel am Ausgang jeweils für Low und High Pegel. Maximal 0,9V und minimal 4,2V. Genau diese Pegel werden garantiert wenn ein Pin mit <= 20mA belastet wird. Daher rühren die viel zitierten 20mA pro Pin. Leider wird der maximale Summenstrom dabei vergessen zu erwähnen.

Man kann einen Pin meinetwegen auch mit 30mA belasten, nur muss man dann selbst dafür Sorge tragen das die nachfolgende Schaltung mit den nicht garantierten Signalpegeln klar kommt. Man muss nachmessen wenn es wichtig ist.

Hallo,

danke für deine Ausführung, die natürlich grundsätzlich nicht falsch ist und meiner Grundaussage ja nicht widerspricht. Ich habe mir nicht die Mühe gemacht exakte Zahlen zu recherchieren, da mein Englisch eine Katastrophe ist. Mir ging es um die Sache mit dem Strom. Und wollte darlegen das es mir lieber ist 2 oder 3 Atmege328 zu verwenden wenn ich mehr Pins benötige, da der Atmege2560 einfach Leistungsmässig derart beschränkt ist. Wenn man die anzahl Pins berücksichtigt. Für Bastler einfach ungeeignet. Daher habe ich auch diese Bauart mit der beschränkung an Pins beibehalten. Ein Labor Techniker würde natürlich andere Mittel anwende um alle 60 Pins zu verwenden wenn es nötig wäre. Bei Gleichstrom kann man ja alle Pins durch Impuls Ansteuerung entlasten. Solange man Induktive Lasten wie Relais ansteuern will. Auf jeden fall danke an alle für den guten zusprüch was mein Projekt anbelangt. Und sollte jemand einen Bausatz haben wollen. Darf er sich gerne bei mir melden. Ich habe immer einige übrig.

Gruss Temucin alias TFT

Vorstellung: Autorange-Ohmmeter

Ich wollte ein kleines Messgerät aufbauen, mit dem man Kondensatoren und Widerstände messen kann.
Es sollte ein praktisches Open-Frame Gerät werden, das möglichst einfach aufgebaut ist, über USB zu benutzen ist,
und im Rahmen der verwendeten Hardware möglichst genau messen sollte. Dazu gekommen sind dann noch
andere Messbereiche, die aber eher Spielerei sind (Flussspannung von Dioden & LEDs, Sperrstrom Dioden).
Nach einigen Vorversuchen auf dem Steckbrett wurde dann alles auf einer 6x4cm Lochrasterplatte aufgebaut.
Die Kosten sind Peanuts, ich komme auf ca. 3,60€ plus einem Arduino NANO-Clone (ab 3€ im 5er Pack).

Angefangen hatte ich eigentlich mit dem Kondensator-Messgerät, funktioniert mit gleicher Hardware, aber
das genaue einmessen des Widerstandsbereiches ist eigentlich die Grundlage dafür. Also habe ich das Projekt
gesplittet, und mich erstmal ausschließlich um das Autorange-Ohmmeter gekümmert.
Deshalb geht es ab hier auch nur um dieses!

Was braucht man sonst noch:
Für die genaue Kalibrierung braucht man Präzisionswiderstände (0.1%) für ca. 3€ (www.Reichelt.de), die werden
aber nicht verbaut, sondern nur zum Abgleich benutzt, und können später anderweitig Verwendung finden.
Die Stückelung sollte die gleiche sein, wie die einzelnen Messbereiche des Autorange-Ohmmeters.
Für die Kalibrierung des 2 MΩ-Bereiches sollte man ein paar hochohmige Widerstände haben.
Bei mir waren es 4x 10 MΩ, die ich in Reihe verlötet habe, aber noch einzeln messbar sind. (Foto)
Ein Messgerät braucht man nur, wenn man den Messbereich kleiner 1 Ω nutzen möchte, sonst nicht!
Und natürlich Kram zum Löten, Kabel zur Verdrahtung, Abstandshalter (als Füße), Anschlussklemmen, ansonsten
erkennt man eigentlich alles im Schaltplan und auf dem Foto, sowie auf dem "Bestückungsplan" ...

Was kann das Teil:
Naja, in erster Linie nur Widerstände messen, mit gleicher Hardware, anderem Sketch geht aber mehr, s.o.
Der gesteckte / angeschraubte Widerstand wird automatisch gemessen, und alle 2s das Ergebnis seriell ausgegeben.
Der Messbereich erstreckt sich von 0,000 Ω bis 200.0 MΩ, Ergebniss darüber werden ausgeblendet.
Ich erhalte zwischen 0,5 Ω und 40 MΩ Messergebnisse mit einem Fehler < 0,5%, typisch sind 0,2% bis 0,4% Fehler.
Wird der Sub-Ohm-Bereich ordentlich eingemessen, kann man bis etwa 20 mΩ Ergebnisse erhalten, die
einen Fehler kleiner 3% haben können! Dafür muss aber viel Aufwand beim Kalibrieren betrieben werden!

Wie wird gemessen:
Es gibt 6 dekadisch aufgeteilte Messbereiche - 20 Ω, 200 Ω, 2 kΩ, 20 kΩ, 200 kΩ, 2 MΩ, weitere Zwischenwerte
sind nicht notwendig! Im äußeren Bereich ist der theoretische Fehler nur 0,15% größer als im Sweet-Spot,
also in der Mitte des jeweiligen Messbereiches.
Der 20 Ω-Bereich wird über einen PNP-Transistor geschalten, der Rest jeweils über DigitalPins.
Im 20 kΩ-Messbereich wird eine Vorqualifizierung durchgeführt, danach wird entschieden, welcher Messbereich
sich den Testwiderstand nochmal greift und nochmals misst, falls erforderlich.
Das ist ganz grob das Konzept, um sicherzustellen, daß nur der Sweet-Spot des jeweiligen Messbereiches
verwendet wird. Was im 200 Ω-Messbereich landet, kann nach der Messung nochmals in den 20 Ω-Messbereich
weitergereicht werden, falls der Widerstand eher diesem Messbereich zuzuordnen ist (kleiner 63 Ω). (siehe PAP!)

Für die Genauigkeit wurde berücksichtigt:
Bauelemente Auswahl --> Metallschicht-Widerstände mit TK 50, Transistor mit geringem Reststrom
im gesperrten Zustand (10x besser als MOSFET!), geringe Vce(sat)
Ratiometrische Widerstandsmessung --> die genaue Höhe der Versorgungsspannung ist unwichtig,
solange sie während der Messung stabil ist (außer im Bereich kleiner 1 Ω).
Kalibrierung über Messwiderstände (0.1%) --> es wird der Innenwiderstand (Ri) des jeweiligen
verwendeten DigitalPin mit berücksichtigt (ca. 25 Ω).
Beim 200 Ω-Messbereich wird der Spannungsverlust durch den Innenwiderstand Ri des DigitalPins
mit gemessen und ratiometrisch rausgerechnet.
Beim 20 Ω-Messbereich wird der Spannungsverlust durch den PNP-Transistor ebenfalls gemessen
und ratiometrisch rausgerechnet.
Multiple Messung für Oversampling und Mittelwertbildung zur Auflösungserhöhung und Stabilisierung
des Messergebnisses.
Im 2MΩ-Messbereich wird der >> wirksame<< Eingangswiderstand des AnalogPins via Formel eines
belasteten Spannungsteilers herausgerechnet (Aber nicht der Messfehler zum Rand des Messbereiches!)

Hinweise zum Abgleich:
ALLE Messbereiche (s.o.) mit Messwiderständen (0,1%) durch messen selbiger im Gerät abgleichen.
Also den Wert des verbauten Messbereichswiderstand ermitteln und korrigieren bist der externe
Messwiderstand (0,1%) mit seinem Wert angezeigt wird.
Vorher die anzuzeigenden Kommastellen in der Ausgabeformatierung um Eins erhöhen.
Für die Beschreibung der Kalibrierung des 2 MΩ - Messbereiches und des mΩ - Messbereiches müsste
ich hier zu weit ausholen, kann ich aber auf Nachfrage gern nachreichen.

Ansonsten gibt es noch eine REL-Taste, zum eliminieren von Widerständen die durch Messleitungen
verursacht werden (zwischen 0 - 10 Ω wirksam), und wird seriell, sowie über die (LED_BUILTIN) angezeigt.

Gruß André

Autorange-Ohmmeter.V2.2.ino (13.3 KB)

Saubere Arbeit und vor allem sehr gut dokumentiert. Mein Glückwunsch.

Gruß Tommy

Steuerung meiner Zirkulationspumpe

Nicht geil, aber sehr hilfreich, deshalb gebe ich diese Anregung gern weiter.

Entstanden auf Anregung von Franz54, danke Franz.

Die bisherige Steuerung der Pumpe erledigte eine einfache Schaltuhr.
Das sollte sich ändern.

Jetzt übernimmt die Steuerung ein “Atmega328-Standalone”, der die “Vorlauftemperatur” misst.
Dieser schaltet die Pumpe bei 42 Grad ein und bei 56 Grad aus.
Pumpenlaufzeit ca. 3 Min., ca. 45 Min. bis die Pumpe wieder einschaltet.
Die Schaltung arbeitet (Tag) von 7 Uhr bis 23 Uhr.
Eine zusätzliche Bedarfsschaltung misst die Temperatur während der Nacht und schaltet die Pumpe ein, wenn die Temperatur innerhalb von 3 Sek. um 0,5 Grad steigt.

Da meine Heizung keine Legionellenschaltung enthält, habe ich diese durch eine weitere Funktion nachempfunden.
Täglich ab 6:15 Uhr wird die Pumpe für 15 Min. eingeschaltet und spült so den kompletten Kreislauf mit max. Temperatur, ca. 60 Grad.

In der Urlaubszeit kann die Steuerung ausgeschaltet werden.
Dann läuft nur die “Legionellenschaltung”.

Das Netzteil und das Relais zur Schaltung der Pumpe befindet sich in einem extra Gehäuse.
Angeschlossen wird der Controller über eine USB-Mini-Buchse, die auch die Datenleitung zu den zwei Sensoren (DS18B20) führt.
Controller_Innen.JPG
Controller_offen.JPG
Controller_geschlossen.JPG

Da auf der Platine noch reichlich Platz vorhanden ist, kann ich mir noch so einige Erweiterungen ausdenken.

@ Tommy56, danke für die Blumen!

Die Vref 1.1V habe ich übrigens mit Deinem Sketch aus dem Nachbarforum eingemessen.

Gruß André

Das ist doch schön, wenn wir gegenseitig über Forengrenzen hinaus voneinander lernen können.

Gruß Tommy

Die Projekte hier werden immer professioneller, zolle hier mal allgemeinen Respekt!!

Die Erklärungen und Dokumentationen werden immer ausführlicher und verleiten zum Nachbau, macht bitte weiter so!

@Hotsystems: Die Idee die DS18B20 über die freien USB Adern zu versorgen ist schlichtweg genial!

Gruß

Hey Leute,

also mega-geile Projekte hier..

Neben diesem Projekt hier: Wohnwagen Kontroll Zentrum (WKZ) habe ich noch das SMARTE Schlüsselbrett:

Man nehme ein Holzscheit (Brennholz), etwas Schleifpapier, ein NodeMCU, zwei magnetische IButtons inkl. Tags und etwas Zeit...

Fertig... (siehe Bilder) Was passiert: Wenn ich nach Hause komme schickt der Arduino per WLAN an die Rasperry PI, auf der domoticz läuft den Hinweis, dass "Papa" nach Hause gekommen ist. Also macht Domoticz den ArbeitsPC, den Monitor und die Kaffeemaschine per Funkschalter (433MHz) an.

Kommt "Sohn" nach Hause, geht die Stereo-Anlage an und die PlayStation....

Gruß Ralf

PS "Mama" gibt es hier im Haushalt nicht.....

EDIT: Naja und wenn ich gehe: dann Licht im Wohnzimmer aus, Licht im Flur für 5 Minuten an, Fernseher aus, PC runterfahren, Monitor aus, ect pp...

BastelRalf: also mega-geile Projekte hier..

Gut, dass jetzt auch Dein Superschlüsselbrett in diesem Thread gelandet ist. Ist auch megageil, finde ich.

Gruß

Gregor

PS: Dass Mama fehlt, hat auch Vorteile: Ein Schlüssel weniger, über den WAF musst Du Dir keine Gedanken machen.

Hallo,

ja das mit dem Schlüsselbrett ist wirklich super. Lässt du dir die Information ggf im Browser auch anzeigen.

Die ganze sache solltest du noch verfeinern um der Bluetooth Funktion und solche Low Energie karten in wichtige taschen legen. Meine Idee ist alle Schlüssel, Taschen und Portomonais damit aus zustatten, den Wir standen schon einmal am Schwimmbad ja aber das Geld war zuhause. Nun ein Blick ins Smartphone hätte sicher das Suchen und Überlegen ob man es doch bei hat, erleichtert.

Lars

Anstatt in der einen Hosentasche nach dem Handy zu schauen kannst du auch einfach in der anderen nachsehen ob dein Portmonnaie da ist. :o

Mal was von mir:

#include <Servo.h>

int absetzenPin = 2; //absetzen an Pin 2 angeschlossen
int aufnahmePin = 3; //aufnahme an Pin 3 angeschlossen
int sabfragePin = 4; //sabfrage an Pin 4 angeschlossen
int absetzenStatus = 0;
int aufnahmeStatus = 0;
int sabfrageStatus = 0;
Servo pumpe;
Servo klemme;
Servo scherenheber;
Servo sicherungsstangen;
Servo druecker;
Servo fuehrungsstangen;
const int LED1 = 13;
const int LED2 = 12;
const int LED3 = 11;

void setup()
{
  pinMode(absetzenPin, INPUT); //absetzenPin (Pin 2) wird als INPUT definiert
  pinMode(aufnahmePin, INPUT); //aufnahmePin (Pin 3) wird als INPUT definiert
  pinMode(sabfragePin, INPUT); //sabfragePin (Pin 4) wird als INPUT definiert
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pumpe.attach(A0); //Servomotor wurde an Pin A0 bis A5 angeschlosse
  pumpe.write(0); //Dreht nach links
  klemme.attach(A1);
  klemme.write(90);
  scherenheber.attach(A2);
  scherenheber.write(90);
  sicherungsstangen.attach(A3);
  sicherungsstangen.write(90);
  druecker.attach(A4);
  druecker.write(90);
  fuehrungsstangen.attach(A5);
  fuehrungsstangen.write(93);
  delay(50);
}
void loop()
{
  absetzenStatus = digitalRead(absetzenPin);
  if (absetzenStatus == HIGH) {
    digitalWrite(LED1, HIGH);
    pumpe.write(100);
    fuehrungsstangen.write(90);
    klemme.write(130);
    scherenheber.write(60);
    sicherungsstangen.write(60);
    delay(500);
    
  }
  {
    absetzenStatus = digitalRead(absetzenPin);
    if (absetzenStatus == LOW) {
      digitalWrite(LED1, LOW);
      pumpe.write(80);
   } 
   {
      aufnahmeStatus = digitalRead(aufnahmePin);
      if (aufnahmeStatus == HIGH) {
        digitalWrite(LED2, HIGH);
        pumpe.write(150);        
        druecker.write(50);
        delay(1000);
        fuehrungsstangen.write(150);
        delay(1500);
        scherenheber.write(140);
   }
   {
        aufnahmeStatus = digitalRead(aufnahmePin);
        if (aufnahmeStatus == LOW) {
          digitalWrite(LED2, LOW);
          pumpe.write(80);
        }
        {
        sabfrageStatus = digitalRead(sabfragePin);
        if (sabfrageStatus == HIGH) {
          digitalWrite(LED3, HIGH);
          pumpe.write(155);
          fuehrungsstangen.write(20);
          delay(1500);
          druecker.write(135);
          delay(1000);
          sicherungsstangen.write(140);
          klemme.write(30);
          }
          {
        if (sabfrageStatus == LOW) {
          digitalWrite(LED3, LOW);
          sicherungsstangen.write(90);
          klemme.write(90);
          druecker.write(90);
          pumpe.write(80);            
    }}}}}}}

Und noch was:

int ch1;
#include<Servo.h>
Servo myservo;
const int LED1 = 13;
int schalterPin = 10;
int selbststeuern = 0;
int potpin = A7;
int val;
unsigned long duration;
void setup(){
  pinMode(6,INPUT);
  myservo.attach(12);
  pinMode(LED1,OUTPUT);
  }
  void loop(){
    ch1 = pulseIn(6,HIGH);
    ch1 = map(ch1,1030,2003,0,170);
    myservo.write(ch1);
    {
      selbststeuern = digitalRead(schalterPin);
      if (selbststeuern == HIGH);
      digitalWrite(LED1,HIGH);
      val = analogRead(A7);
      val = map(val,0,1030,0,165);
      myservo.write(val);
    delay(25);
    }
    if (selbststeuern == LOW){
      digitalWrite(LED1,LOW);
      myservo.write(duration);
      return;
    }
    }

Und etwas weiteres:

#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>
hd44780_I2Cexp lcd1;
hd44780_I2Cexp lcd2;
hd44780_I2Cexp lcd3;

#define LCD_COLS 20
#define LCD_ROWS 4
int t;
const int schalterPin = 8;
const int LED1 = 13;
const int LED2 = 9;
const int analogInPin = A0;
const int analogOutPin = 9;
int sensorValue = 0;
int outputValue = 0;
int textumschalter = 0;  // Signal Textumschaltung


void setup()
{
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(schalterPin, INPUT);

}

void loop() {

  sensorValue = analogRead(analogInPin);
  outputValue = map(sensorValue, 1290, 0, 5, 240);
  analogWrite(analogOutPin, outputValue);
  textumschalter = digitalRead(schalterPin);
  if (textumschalter == LOW) {

    digitalWrite(LED1, LOW);

    lcd1.begin(LCD_COLS, LCD_ROWS);
    lcd1.begin(20, 4);
    lcd1.print("      Vorsicht");
    lcd1.setCursor(3, 1);
    lcd1.print("Ausnahmekonvoi");
    lcd1.setCursor(8, 2);
    lcd1.print("Lu`s");
    lcd1.setCursor(4, 3);
    lcd1.print("Spezialtrans");

    lcd2.begin(LCD_COLS, LCD_ROWS);

    lcd2.print("      Vorsicht");
    lcd2.setCursor (3, 1);
    lcd2.print("Ausnahmekonvoi");
    lcd2.setCursor(8, 2);
    lcd2.print("Lu`s");
    lcd2.setCursor(4, 3);
    lcd2.print("Spezialtrans");

    lcd3.begin(LCD_COLS, LCD_ROWS);

    lcd3.print("      Vorsicht");
    lcd3.setCursor (3, 1);
    lcd3.print("Ausnahmekonvoi");
    lcd3.setCursor(8, 2);
    lcd3.print("Lu`s");
    lcd3.setCursor(4, 3);
    lcd3.print("Spezialtrans");
    }

    // Umschaltung zum englischen Text

  else if (textumschalter == HIGH) {
    digitalWrite(LED1, HIGH);
    
    lcd1.begin(20, 4);
    lcd1.print("     Attention");
    lcd1.setCursor(0, 1);
    lcd1.print("Convoi  Exceptionnel");
    lcd1.setCursor(8, 2);
    lcd1.print("Lu`s");
    lcd1.setCursor(4, 3);
    lcd1.print("Specialtrans");

    lcd2.begin(LCD_COLS, LCD_ROWS);
    
    lcd2.print("     Attention");
    lcd2.setCursor(0, 1);
    lcd2.print("Convoi  Exceptionnel");
    lcd2.setCursor(8, 2);
    lcd2.print("Lu`s");
    lcd2.setCursor(4, 3);
    lcd2.print("Specialtrans");

    lcd3.begin(LCD_COLS, LCD_ROWS);
   
    lcd3.print("     Attention ");
    lcd3.setCursor(0, 1);
    lcd3.print("Convoi  Exceptionnel");
    lcd3.setCursor(8, 2);
    lcd3.print("Lu`s");
    lcd3.setCursor(4, 3);
    lcd3.print("Specialtrans");
  }}

Und noch was besonderes:

/*Nauticumschalter fuer 4 Nauticmodule
*/

int nauticschalterPin = 2;
int nautic1schalterPin = 3;
int nautic2schalterPin = 4;
int nautic3schalterPin = 5;
int nautic4schalterPin = 6;
int nautic = 0;
int nautic1 = 0;
int nautic2 = 0;
int nautic3 = 0;
int nautic4 = 0;
const int LED1 = 13;
const int LED2 = 12;
const int LED3 = 11;
const int LED4 = A0;
const int LED5 = 10;
const int LED6 = A1;
const int LED7 = 9;
const int LED8 = A2;
const int LED9 = 8;
const int LED10 = A3;

void setup()
{
  pinMode(nautic, INPUT);
  pinMode(nautic1, INPUT);
  pinMode(nautic2, INPUT);
  pinMode(nautic3, INPUT);
  pinMode(nautic4, INPUT);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  pinMode(LED7, OUTPUT);
  pinMode(LED8, OUTPUT);
  pinMode(LED9, OUTPUT);
  pinMode(LED10, OUTPUT);

}

void loop()
{
  nautic = digitalRead(nauticschalterPin);
  nautic1 = digitalRead(nautic1schalterPin);
  nautic2 = digitalRead(nautic2schalterPin);
  nautic3 = digitalRead(nautic3schalterPin);
  nautic4 = digitalRead(nautic4schalterPin);
  digitalWrite(LED1, LOW);
  digitalWrite(LED2, LOW);
  digitalWrite(LED3, LOW);
  digitalWrite(LED4, LOW);
  digitalWrite(LED5, LOW);
  digitalWrite(LED6, LOW);
  digitalWrite(LED7, LOW);
  digitalWrite(LED8, LOW);
  digitalWrite(LED9, LOW);
  digitalWrite(LED10, LOW);
  {
  }
  if (nautic == HIGH) {
    digitalWrite(LED1, HIGH);
    digitalWrite(LED2, HIGH);
  {
    }
  }
  if (nautic1 == HIGH) {
    digitalWrite(LED3, HIGH);
    digitalWrite(LED4, HIGH);
    {
    }
  }
  if (nautic2 == HIGH) {
    digitalWrite(LED5, HIGH);
    digitalWrite(LED6, HIGH);
    {
    }
  }
  if (nautic3 == HIGH) {
    digitalWrite(LED7, HIGH);
    digitalWrite(LED8, HIGH);
   {
   }
 }
 if (nautic4 == HIGH) {
  digitalWrite(LED9, HIGH);
  digitalWrite(LED10, HIGH);
  }
}

@Crazydiver Viele "schöne" Sketch-Zeilen.....nur gibt es da auch eine Beschreibung zu. Oder dürfen wir uns was aussuchen ?

Wäre ja ziemlich witzlos. Also poste eine aussagekräftige Beschreibung, damit alle Wissen, was das soll. Ein paar schöne Bilder, auf denen man was erkennen kann, dazu wären auch angebracht.

Ohne die hat das Ganze aus meiner Sicht hier nichts zu suchen.

Ach, und kennst du die Tastenkombination "STRG+T" in der IDE noch nicht ?