Verständnis frage --> pinMode

Hallo miteinander,

ich habe da mal eine Verständnis frage zu dem Befehl "pinMode"

bisher mache ich im void setup() alle Definitionen von den
PINS also ob es ein Eingang oder ein Ausgang ist.

kann / darf ich den Befehl auch in meinem void loop () verwenden?
oder ist das so nicht vorgesehen und es könnte zu Probleme führen?
oder ist das Jake wie Hosse? wo ich das mache Hauptsache ich mache es bevor ich den PIN benutze?

Gruß
Mücke

Das geht überall. Es gibt Anwendung wo man Pins von Eingang auf Ausgang umschalten muss. Aber man muss aufpassen dass man da keinen Kurzschluss fabriziert.

Danke,

Dann kann ich das überall verwenden. Wie du sagst aufpassen das ich nichts Kaputt mache dabei (Kurzschluss) wobei ich das echt gut kann ;-).

Danke.

Man kann, wie gesagt, jederzeit ein Pin als Eingang oder Ausgang definieren. Dies wird zB bei Chalieplexing intensiv gemacht. ( ein Pin ist H ein anderes L und alle anderen Eingang (hochohmig). Charlieplexing - Wikipedia auch bei I2C Bus auf der Datenleitung wird das praktiziert.

Es muß ein Kurzschluß verhindert werden (ein PIN HIGH und ein mt ihm verbundenes LOW) Es könenn Widerstände in Serie zu den Pins notwendig sein um einen etwaigen Kurzschlußstrom auf ungefährliche Werte zu begrenzen ( zB die 500 bzw 1000 Ohm Widerstände zwischen RX und TX des USB Adapters und dem Atmega-Controller).

Grüße Uwe

Muecke:
bisher mache ich im void setup() alle Definitionen von den
PINS also ob es ein Eingang oder ein Ausgang ist.

kann / darf ich den Befehl auch in meinem void loop () verwenden?
oder ist das so nicht vorgesehen und es könnte zu Probleme führen?

Du kannst das machen, wie es im Programm für die Schaltung "passt" und "notwendig ist".

Insbesondere durch das Setzen von "OUTPUT" mit falscher Beschaltung kannst Du allerdings auch fette Kurzschlüsse in Deiner Schaltung produzieren, die ohne eine entsprechende Schutzbeschaltung zur Zerstörung des Controllers führen können.

Kleines Beispiel:
Du hast eine Drahtverbindung zwischen einem INPUT und einem OUTPUT Pin. Jetzt kannst Du den OUTPUT wahlweise HIGH oder LOW setzen und am INPUT den Pegelwechsel messen. Schaltung OK, alles paletti.

Wenn Du jetzt aber den INPUT auch auf OUTPUT setzt, dann ist es nur noch paletti, wenn beide Pins auf denselben Pegel geschaltet sind. Also entweder beide OUTPUT auf LOW oder beide auf HIGH.

Falls sich die Pegel unterscheiden und ein OUTPUT auf LOW gesetzt ist und der andere auf HIGH während diese querverbunden sind, dann versucht der eine, so viel Strom wie möglich zu schlucken, um den Pegel auf LOW zu ziehen, und der andere versucht gleichzeitig, so viel Strom abzugeben, bis der Pegel auf HIGH wechselt. Die klassische Kurzschlußsituation.

Also:
Ohne jegliche äußere Beschaltung des Controllers ist es Jacke wie Hose, wie Du die Eingänge und Ausgänge setzt.

Aber mit Vorhandensein äußerer Beschaltung besteht beim falschen Setzen von OUTPUT die Gefahr eines Kurzschlusses in der Schaltung.

LEDs als Fotodiode zu verwenden ist auch ein gutes Beispiel:
http://www.mikrocontroller.net/articles/Lichtsensor_/_Helligkeitssensor#LED

Man setzt den Pin erst auf Ausgang, High um die Sperrschicht aufzuladen. Dann setzt man ihn auf Eingang und misst die Zeit bis der Pin als Low erkannt wird. Die Zeit ist dann proportional zum Lichteinfall.

Es gibt Projekte die das mit normalen 8x8 LED Matrizen machen.

OK, danke für die Ausführung,

bei mir geht es nicht so Tief in die mattierte ;-), habe heute meine 4 Weiteren Schieblehren erhalten, und habe ie heute auch gleich verlötet (Babel angebracht) leider sind das alles unterschiedliche :frowning:
und ich möchte alle 5 Schieblehren auslesen lassen, da wir das ja schon in einem Anderen Thema besprochen haben, möchte ich das jetzt für mich Übersichtlicher gestellten.

Sprich alles was für die Schieblehre_1 an Code da ist in eine Funktion packen und nur den Wert zurück geben, in der Funktion möchte ich dann auch die Pins Definieren für die Schieblehre.

Das mache ich dann 5 mal und wenn ich dann meine Dehnungsmessstreifen endlich mal verstanden habe kommt der auch mit in eine Funktion.

Ja man könnte die Funktion auch so machen das ich sie Öffners aufrufen kann und alle Schieber aus lesen lassen könnte, ja das geht, ich bekomme das nur nicht hin :-(. daher der weg so, das müsste ich eigentlich schon hin bekommen.

dafür habe ich das nachgefragt, nicht das ich was machen möchte was später zu Problemen führt.

Daher Danke für die Hinweise und die Erklärungen, so weit hatte ich noch gar nicht gedacht :slight_smile:
Danke.

setup() ist auch nicht viel mehr als eine normale Funktion. Die musst du halt haben und sie wird am Anfang einmal ausgeführt. Das macht die IDE im Hintergrund. Aber das ist nichts wirklich besonderes.

Jetzt habe ich nicht verstanden warum Du die Pins nur in der Funktion zum Auslesen einer Schieblehre brauchst und diese nicht standartmäßig definierst.
Grüße Uwe

Das ist so, ich habe da einmal die PIN Nr. Selber und dann auch noch das Register das direkt abgefragt wird von dem PIN, da ich das Register (mir nicht bekamt) in die Funktion übergeben muss ich für jede Schieblehre eine extra Funktion mir erstellen, da ich das Schöner finde möchte ich dann auch die Pin Nr. dort mit rein Schreiben, und ich in meine Sketch vorne, sonnst komm ich noch auf die Doofe ide das ich einfach nur die Nr. ändern muss und den Schieber wo anderes anschließen kann.

Ich habe aber jetzt ein Problem:

meine Datei: Funktionstest.ino

#include "Funktion.h"

int TasterPin = 2;                                                          // Taster zum Daten auslesen

void setup() 
  {
    Serial.begin(9600);                                                     // Serielen Monitor Einstellung
    pinMode(TasterPin, INPUT);                                              // Pin für Taster Definiren (Eingang) 
  }

void loop ()
  {
    Serial.println(Schieber5());

    while (digitalRead(TasterPin) == LOW) {}                                // Warten bis der taster zustand sich ändert
  }  // ENDE --> void loop

Meine Datei: Funktion.h

unsigned long temp_millis;


// ***********************************************************************************************
//                             Schieblehre 5 auslesen und Wert zurück geben 
// ***********************************************************************************************
int Schieber5()
  {
    int Schieber_5_ClockPin = 24;  // Pin 24 das 2. Bit vom Port A (PINA PA2)
    int Schieber_5_DataPin  = 25;  // Pin 25 das 3. Bit vom Port A (PINA PA3)


    pinMode(Schieber_5_ClockPin, INPUT);
    pinMode(Schieber_5_DataPin,  INPUT);

    while (digitalRead(Schieber_5_ClockPin) == LOW) {}    // wenn CLOCK auf LOW, dann warten bis wieder HIGH
    temp_millis = millis();                               // aktuelle Zeitnahme
    while (digitalRead(Schieber_5_ClockPin) == HIGH) {}   // wenn CLOCK auf HIGH, warten bis wieder LOW
    if ((millis() - temp_millis) > 100)                   // wenn High-Pegel länger wie 100ms war, springe in 'decode' Funktion
      {

        long value = 0;
        byte SIGN_Bit = 0;                          // Vorzeichen Bit 21
      
          for (int i=0;i<24;i++)                    // 24 Durchläufe, 0 bis 23
            {           
              if ( PINA & ( 1 << PA3 ))             // wenn Data (Port.A Bit.3) HIGH ist, 
                {                                   // eine 1 in die Variable 'value' an Bitnummer i
                  value |= 1UL << i;                // Syntax Hinweis aus dem Forum, wegen default 16 bit int Arithmetik
                }
                while ( !(PINA & (1 << PA2)))  { }  // solange warten bis Clock (Port.A Bit.2) wieder HIGH ist
                while (   PINA & (1 << PA2 ))  { }  // solange warten bis Clock (Port.A Bit.2) wieder LOW ist
            }  // for Schleifenende
    
           SIGN_Bit = (value >> 21) & B01;          // Vorzeichen Bit 21 separieren
           value = value & 0xFFFF;                  // nur Bit 0 bis Bit 15 behalten, den Rest davor nullen
           value = value >> 1;                      // und alles um ein Bit nach rechts schieben, Startsignal wird entfernt
           if (SIGN_Bit == 1)                       // wenn Vorzeichen-Bit gesetzt war, alles mit -1 multiplizieren
            { value = value * -1; }
           Serial.println((float)value / 100);      // Kommastelle setzen und man erhält den endgültigen Meßwert
//         return (float)value / 100;               // Kommastelle setzen und man erhält den endgültigen Meßwert  (Rückgabe wert)

//    int result;                                // Rückgabe wert Deklariren
//    result = 10 * 30;                          // Rückgabe berechnen 
//    return result;                             // Rückgabe zurückgeben 
  }

jetzt bekomme ich eine Fehlermeldung!!!

In file included from Funktionstest.ino:13:
Funktion.h: In function 'int Schieber5()':
Funktion.h:13: error: 'INPUT' was not declared in this scope
Funktion.h:13: error: 'pinMode' was not declared in this scope
Funktion.h:16: error: 'digitalRead' was not declared in this scope
Funktion.h:16: error: 'LOW' was not declared in this scope
Funktion.h:17: error: 'millis' was not declared in this scope
Funktion.h:18: error: 'digitalRead' was not declared in this scope
Funktion.h:18: error: 'HIGH' was not declared in this scope
Funktion.h:23: error: 'byte' was not declared in this scope
Funktion.h:23: error: expected ;' before 'SIGN_Bit' Funktion.h:27: error: 'PINA' was not declared in this scope Funktion.h:27: error: 'PA3' was not declared in this scope Funktion.h:31: error: 'PINA' was not declared in this scope Funktion.h:31: error: 'PA2' was not declared in this scope Funktion.h:32: error: 'PINA' was not declared in this scope Funktion.h:32: error: 'PA2' was not declared in this scope Funktion.h:35: error: 'SIGN_Bit' was not declared in this scope Funktion.h:35: error: 'B01' was not declared in this scope Funktion.h:40: error: 'Serial' was not declared in this scope In file included from /Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Arduino.h:23, from Funktionstest.ino:15: /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/include/stdlib.h:54: error: expected unqualified-id before string constant Funktionstest:29: error: expected }' at end of input

verstehe ich nicht,

ich habe den gesamten Text vorher im void loop () gehabt da hat es funktioniert.

jetzt wollte ich das in eine Funktion packen damit es aufgeräumter ausschaut, und dann der Fehler :frowning:

Da solltest du aber noch was ändern! Das ist keinesfalls flexibel oder übersichtlich. Besser ist es, eine allgemeine Funktion zu schreiben. Dann die Pins mitteilen.

void func(int clkPin, int dataPin)
{
pinMode(clkPin, INPUT);
pinMode(dataPin, INPUT);
}

Nutzte anstatt eine *.h Datei die *.ino Endung. Hier ist die IDE etwas komisch im Verhalten.
Gibt der Messschieber den Clk vor? Wenn nein, warum clkPin als INPUT? Müsste dann OUTPUT sein. Des weiteren sollte in *.h Dateien nur die Funktionsrümpfe

void func(int clkPin, int dataPin);

stehen.

Dazu brauchst du dann noch eine *.c

#include "*.h"

void func(int clkPin, int dataPin)
{
// do
}

Das liegt einfach dran dass du in einem Header bist und dort die Arduino Definitionen nicht inkludiert sind. Dann kennt er selbstverständlich das Makro nicht.

Lösung:
#include <Arduino.h>

Siehe x:\Arduino\hardware\arduino\avr\cores\arduino\Arduino.h

Da stehe am Anfang Dinge wie:

#define HIGH 0x1
#define LOW  0x0

#define INPUT 0x0
#define OUTPUT 0x1
#define INPUT_PULLUP 0x2

@sschultewolter: so wollte ich das zu beginn machen, jedoch wird weiter unten nicht mehr mit den Pin Nr. gearbeitet sondern mit den Registern selbst und die kann ich schlecht ableiten oder übergeben, dafür habe ich keine Lösung gefunden. :frowning:

was ist ein "Clk" ist kenne das Auto CLK doch das meinst du glaube ich nicht :wink:

das mit dem Auslesen des Schiebers 5 haben wir schon hier geklärt.

LÖSUNG??
#include <Arduino.h>

!!! Das hatte ich auch gedacht doch wenn ich das mache (in der Datei Funktion.h) dann bekomme ich Fehlermeldungen in meiner Funktionstest.ino

EDIT: das mit der Endung .INO habe ich gerade probiert da bekomme ich aber eine Fehler beim der include dann, ...

mit clk meine ich einfach die ClockLeitung. Was meinst du mit deinem letzten Satz?

Wenn du die ino erstellt ist der #include nicht nötig. Das Problem wird sein, dass er dann die h-Datei mehrmals nutzen möchte :wink:

ich kann mir ganz grob vorstellen was eine "ClockLeitung" sein könnte, doch das ist da nicht vorhanden :frowning:

das mit dem "letzten Satz" du meinst mein EDIT. ja ich habe irgend was zerschossen, ... muss erst schauen und es wider auf Anfang Sätzen.

Wenn du die ino erstellt ist der #include nicht nötig. Das Problem wird sein, dass er dann die h-Datei mehrmals nutzen möchte :wink:

Ach so du meinst ich soll die Funktion in der INO Datei drin lassen und in in eine Gesonderte Datei packen.

@sschultewolter: das ist gemein wenn du ein EDIT oben machst und ich das übersehe, ... :wink:
Das mit den Input und Output verstehe ich jetzt nicht, jedoch klapt das mit dem Lesen der Werte des Schiebers.

Habe ich das richtig verstanden. die Datei *.h beinhaltet die Deklaration der Funktionen und die Datei *.c hat die Funktion dann selber?
das sollte das auch gehen was ich vorhabe?

ps. ja du hast recht Flexibel ist das überhaupt nicht, da ich aber keine Ahnung habe wie ich den Code Flexibel bekomme, schaue ich das ich so eine Lösung finde ;-).

Hab mir noch mal den Sketch oben angeschaut. CLK auf INPUT scheint richtig zu sein, wenn der Messschieber den Master spielt, was er hier ja scheinbar macht.

Bleib am besten bei der ino allgemein. Ich habe kein Plan, wie der Aufbau genau verunstaltet wird.

void setup()
{

}

void loop()
{

}

ist in AVR GCC nichts anderes als

#include <Arduino.h>

void setup(void)
{
//
}

void loop()
{
//
}




int main(void)
{
setup();

while(1)
{
loop();
}
return 0;
}
[code]

OK, ich packe das alles in die .INO Datei rein.

Hoffe das klappt dann. :wink:

Muecke:
Habe ich das richtig verstanden. die Datei *.h beinhaltet die Deklaration der Funktionen und die Datei *.c hat die Funktion dann selber?

Korrekt.

Mehrfach-Inkludierungen sollte eigentlich durch Include-Guards verhindert werden, aber dadurch dass die Arduino Software da viel von sich aus im Hintergrund macht kann man da irgendwo reingelegt werden.

Probier mal in deiner .c/.cpp Datei deinen Header und Arduino.h zu inkludieren und dann inkludierst du deinen Header in der .ino Datei. Das ist der normale Weg.

Alles in .ino Datei zu packen geht bei Arduino natürlich auch. Dann übernimmt die IDE das zusammenkopieren der verschieden Dateien vor dem Kompilieren.

Also ich versuche das jetzt alle in der INO Datei.

Doch ich bekomme das nicht hin :frowning:

  1. versuch

Schieber 5 auslesen alles in (Loop) --> Klappt richtig :slight_smile: Heppy

also alles aus dem (Loop) nehmen und in die Funktion int Schiber5() packen
und in Loop dann Seriel.Print Schieber5() aufrufen.

jetzt klappt es nicht mehr, ich bekomme immer 0 angezeigt ab und an ist mal ein wert dabei.

Was zum Henker mache ich da Falsch?
ich versuche das jetzt erst mal nicht in eine Externe Datei zu packen sondern bleibe in der INO Datei.

Code wie es Richtig Klappt:

unsigned long temp_millis;

void setup() 
  {
    Serial.begin(9600);
  }

void loop ()
  {
    int Schieber_5_ClockPin = 24;  // Pin 24 das 2. Bit vom Port A (PINA PA2)
    int Schieber_5_DataPin  = 25;  // Pin 25 das 3. Bit vom Port A (PINA PA3)


    pinMode(Schieber_5_ClockPin, INPUT);
    pinMode(Schieber_5_DataPin,  INPUT);

    while (digitalRead(Schieber_5_ClockPin) == LOW) {}    // wenn CLOCK auf LOW, dann warten bis wieder HIGH
    temp_millis = millis();                               // aktuelle Zeitnahme
    while (digitalRead(Schieber_5_ClockPin) == HIGH) {}   // wenn CLOCK auf HIGH, warten bis wieder LOW
    if ((millis() - temp_millis) > 100)                   // wenn High-Pegel länger wie 100ms war, springe in 'decode' Funktion
      {

        long value = 0;
        byte SIGN_Bit = 0;                          // Vorzeichen Bit 21
      
          for (int i=0;i<24;i++)                    // 24 Durchläufe, 0 bis 23
            {           
              if ( PINA & ( 1 << PA3 ))             // wenn Data (Port.A Bit.3) HIGH ist, 
                {                                   // eine 1 in die Variable 'value' an Bitnummer i
                  value |= 1UL << i;                // Syntax Hinweis aus dem Forum, wegen default 16 bit int Arithmetik
                }
                while ( !(PINA & (1 << PA2)))  { }  // solange warten bis Clock (Port.A Bit.2) wieder HIGH ist
                while (   PINA & (1 << PA2 ))  { }  // solange warten bis Clock (Port.A Bit.2) wieder LOW ist
            }  // for Schleifenende
    
           SIGN_Bit = (value >> 21) & B01;          // Vorzeichen Bit 21 separieren
           value = value & 0xFFFF;                  // nur Bit 0 bis Bit 15 behalten, den Rest davor nullen
           value = value >> 1;                      // und alles um ein Bit nach rechts schieben, Startsignal wird entfernt
           if (SIGN_Bit == 1)                       // wenn Vorzeichen-Bit gesetzt war, alles mit -1 multiplizieren
            { value = value * -1; }
           Serial.println((float)value / 100);      // Kommastelle setzen und man erhält den endgültigen Meßwert
//         return (float)value / 100;               // Kommastelle setzen und man erhält den endgültigen Meßwert  (Rückgabe wert)
      }
  }  // ENDE --> void loop

Code wie ich es gerne hätte, doch nicht klappt

unsigned long temp_millis;

void setup() 
  {
    Serial.begin(9600);
  }

void loop ()
  {
    Serial.println(Schieber5());
  }  // ENDE --> void loop







int Schieber5()
  {
    int Schieber_5_ClockPin = 24;  // Pin 24 das 2. Bit vom Port A (PINA PA2)
    int Schieber_5_DataPin  = 25;  // Pin 25 das 3. Bit vom Port A (PINA PA3)


    pinMode(Schieber_5_ClockPin, INPUT);
    pinMode(Schieber_5_DataPin,  INPUT);

    while (digitalRead(Schieber_5_ClockPin) == LOW) {}    // wenn CLOCK auf LOW, dann warten bis wieder HIGH
    temp_millis = millis();                               // aktuelle Zeitnahme
    while (digitalRead(Schieber_5_ClockPin) == HIGH) {}   // wenn CLOCK auf HIGH, warten bis wieder LOW
    if ((millis() - temp_millis) > 100)                   // wenn High-Pegel länger wie 100ms war, springe in 'decode' Funktion
      {

        long value = 0;
        byte SIGN_Bit = 0;                          // Vorzeichen Bit 21
      
          for (int i=0;i<24;i++)                    // 24 Durchläufe, 0 bis 23
            {           
              if ( PINA & ( 1 << PA3 ))             // wenn Data (Port.A Bit.3) HIGH ist, 
                {                                   // eine 1 in die Variable 'value' an Bitnummer i
                  value |= 1UL << i;                // Syntax Hinweis aus dem Forum, wegen default 16 bit int Arithmetik
                }
                while ( !(PINA & (1 << PA2)))  { }  // solange warten bis Clock (Port.A Bit.2) wieder HIGH ist
                while (   PINA & (1 << PA2 ))  { }  // solange warten bis Clock (Port.A Bit.2) wieder LOW ist
            }  // for Schleifenende
    
           SIGN_Bit = (value >> 21) & B01;          // Vorzeichen Bit 21 separieren
           value = value & 0xFFFF;                  // nur Bit 0 bis Bit 15 behalten, den Rest davor nullen
           value = value >> 1;                      // und alles um ein Bit nach rechts schieben, Startsignal wird entfernt
           if (SIGN_Bit == 1)                       // wenn Vorzeichen-Bit gesetzt war, alles mit -1 multiplizieren
            { value = value * -1; }
//           Serial.println((float)value / 100);      // Kommastelle setzen und man erhält den endgültigen Meßwert
         return (float)value / 100;               // Kommastelle setzen und man erhält den endgültigen Meßwert  (Rückgabe wert)
        }
  }  // ENDE --> Schieber5

kann das sein das das an dem int liegt?
int Schieber5()

Nennt mich was Ihr wollt, doch für mich ist das nicht Logisch.

so klappt es jetzt, das der Auslese Code unten Extra in einer Funktion steht.

ich habe das jetzt so abgerufen:

    float Ergebnis; 
    Ergebnis = Schieber5(); 
    Serial.println(Ergebnis);
unsigned long temp_millis;

void setup() 
  {
    Serial.begin(9600);
  }

void loop ()
  {
    float Ergebnis; 
    Ergebnis = Schieber5(); 
    Serial.println(Ergebnis);
  }  // ENDE --> void loop



float Schieber5()
  {
    int Schieber_5_ClockPin = 24;  // Pin 24 das 2. Bit vom Port A (PINA PA2)
    int Schieber_5_DataPin  = 25;  // Pin 25 das 3. Bit vom Port A (PINA PA3)


    pinMode(Schieber_5_ClockPin, INPUT);
    pinMode(Schieber_5_DataPin,  INPUT);

    while (digitalRead(Schieber_5_ClockPin) == LOW) {}    // wenn CLOCK auf LOW, dann warten bis wieder HIGH
    temp_millis = millis();                               // aktuelle Zeitnahme
    while (digitalRead(Schieber_5_ClockPin) == HIGH) {}   // wenn CLOCK auf HIGH, warten bis wieder LOW
    if ((millis() - temp_millis) > 100)                   // wenn High-Pegel länger wie 100ms war, springe in 'decode' Funktion
      {

        long value = 0;
        byte SIGN_Bit = 0;                          // Vorzeichen Bit 21
      
          for (int i=0;i<24;i++)                    // 24 Durchläufe, 0 bis 23
            {           
              if ( PINA & ( 1 << PA3 ))             // wenn Data (Port.A Bit.3) HIGH ist, 
                {                                   // eine 1 in die Variable 'value' an Bitnummer i
                  value |= 1UL << i;                // Syntax Hinweis aus dem Forum, wegen default 16 bit int Arithmetik
                }
                while ( !(PINA & (1 << PA2)))  { }  // solange warten bis Clock (Port.A Bit.2) wieder HIGH ist
                while (   PINA & (1 << PA2 ))  { }  // solange warten bis Clock (Port.A Bit.2) wieder LOW ist
            }  // for Schleifenende
    
           SIGN_Bit = (value >> 21) & B01;          // Vorzeichen Bit 21 separieren
           value = value & 0xFFFF;                  // nur Bit 0 bis Bit 15 behalten, den Rest davor nullen
           value = value >> 1;                      // und alles um ein Bit nach rechts schieben, Startsignal wird entfernt
           if (SIGN_Bit == 1)                       // wenn Vorzeichen-Bit gesetzt war, alles mit -1 multiplizieren
            { value = value * -1; }
         return (float)value / 100;               // Kommastelle setzen und man erhält den endgültigen Meßwert  (Rückgabe wert)
        }
  }  // ENDE --> Schieber5

vorher war das ja so:

void loop ()
  {
    Serial.println(Schieber5());
  }  // ENDE --> void loop

wie gesagt Logisch ist das für mich nicht, aber gut. es tut jetzt :-).

jetzt mal schauen ob ich es schaffe das Teil in eine Extra Datei zu packen.