Unterprogramme wie?

Moin moin,

ich bin etwas auf dem Schlauch, newbee Frage. Es geht um die Verwendung von Unterprogrammen. Totzdem, dass ich einige Tutorials gelesen habe komme ich da irgendwie nicht wirklich weiter.

Was habe ich:

  • Ich habe 5 "2 Wege" Taster. Diese Taster steuern 5 Aktuatoren. (Die Position, hoch und runter)
  • Solange der Taster gedrückt bleibt zählt er hoch oder runter. (Geht nur so, da neben der Eingabe über Taster auch eine Eingabe über eine Tastatur später erfolgt) von 0-255. Der Aktuator fährt dann gemütlich die Pos an.

Hier der Code, der Taster, die Serial.print sind zum visualisieren:

  if(!digitalRead(SW2))  //hochzählen
  {
    if(volt_s1<255)volt_s1++; 
    
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(volt_s1);  //nur zur Visualisierung 
    Serial.println("IST: ");
    Serial.println(volt_i1);
    
    delay(80);
  }
  

  if(!digitalRead(SW1))
  {
    if(volt_s1!=130)volt_s1--;   //Min 130  Anppassung des Pots, in meinem Model kann ich nur bis 130 runter drehen, Anschlag 
 
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(volt_s1); //nur zur Visualisierung
    Serial.println("IST: ");
    Serial.println(volt_i1);
    
    delay(80);
    
  }

Ich will aber diesen Codeblock ja nicht 5 mal in meinem loop haben und daher möchte ich eine unterfkt haben, in der das einmal steht:

void taster(int up, int dw, int volt_s)

{}

Mein Problem ist jetzt, dass ich nicht ganz checke, wie ich das dem Programm verklicker:

Also SW1 (Switch1 hoch), SW2 (Switch2 runter)---Rechne in Sub aus--> volt_s1, Serialprintln("volt_s1") Serial.print("volt_s1)
SW3 (Switch2 hoch) SW3 (Switch2 runter)---Rechne in Sub aus--> volt_s2, Serialprintln("volt_s2") Serial.print("volt_s2)
usw....
Das selbe Spiel habe ich dann ja nochmal für die Aktuatoren, wäre ja auch 5 mal der Fall.
Egal was ich mach es funktioniert nicht... :frowning:

vielen dank!

Im Anhang nochmal der gesammt Code mit Int, Setup und Aktoren:

// Aktuator

int count=0;


// TASTER PINS  BEGIN

int SW1=22;  //MOTOR   Taster UP
int SW2=23;  //        Taster Down

int SW3=24;  //hinten links
int SW4=25;

int SW5=25;  // hinten rechts
int SW6=26;

int SW7=27;  // vorn links
int SW8=28;

int SW9=29;  // vorn rechts
int SW10=30;

// TASTER INT END


// AKTUATOR VAR

// VOLT SOLL -> vom System/User vorgegebene Stellung der Akt

int volt_s1 = 0;  // MOTOR
int volt_s2 = 0;  // HL
int volt_s3 = 0;  // HR
int volt_s4 = 0;  // VL
int volt_s5 = 0;  // VR

// VOLT SOLL ENDE

// AKTUATOR PINS

// VOLT IST -> vom Aktuator gemeldete Poition, Analog IN

int volt_i1 = 0;  // Motor
int volt_i2 = 0;  // HL
int volt_i3 = 0;  // HR
int volt_i4 = 0;  // VL
int volt_i5 = 0;  // VR

// VOLT IST END


// Verfahrgeschwindigkeit der Aktuatoren ANSCHLUSS PINS

int speed1 = 2; // MOTOR PWM Ausgang (2-6) 
int speed2 = 3; // HL
int speed3 = 4; // HR
int speed4 = 5; // VL
int speed5 = 6; // VR


// Drehrichtung der Aktuatoren
 
int M_up = 34;
int M_dw = 35;

int VR_up = 36;
int VR_dw = 37;

int VL_up = 38;
int VL_dw = 39;

int HR_up = 40;
int HR_dw = 41;

int HL_up = 42;
int HL_dw = 43;



 
 
void setup()

{
  // TASTER SETUP
  
  pinMode(SW1, INPUT);
  digitalWrite(SW1, HIGH);
  
  pinMode(SW2, INPUT);
  digitalWrite(SW2, HIGH);
  
  pinMode(SW3,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW4,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW5,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW6,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW7,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW8,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW9,INPUT);
  digitalWrite(SW1,HIGH);  
   
  pinMode(SW10,INPUT);
  digitalWrite(SW1,HIGH);  
  
  
// AKTUATOR MOTOR UP/DOWN PIN SETUP 
  
  
  pinMode(M_up, OUTPUT);
  digitalWrite(M_up, HIGH);
  pinMode(M_dw, OUTPUT);
  digitalWrite(M_dw, HIGH);
     
  pinMode(VR_up,OUTPUT);
  digitalWrite(VR_up, HIGH);
  pinMode(VR_dw,OUTPUT);
  digitalWrite(VR_dw, HIGH);
   
  pinMode(VL_up,OUTPUT);
  digitalWrite(VL_up, HIGH);
  pinMode(VL_dw,OUTPUT);
  digitalWrite(VL_dw, HIGH);
   
  pinMode(HR_up,OUTPUT);
  digitalWrite(HR_up, HIGH);
  pinMode(HR_dw,OUTPUT);
  digitalWrite(HR_dw, HIGH);
   
  pinMode(HL_up,OUTPUT);
  digitalWrite(HL_up, HIGH);
  pinMode(HL_dw,OUTPUT);
  digitalWrite(HL_dw, HIGH);
  
  

  
  
  
  Serial.begin(9600);
  
  volt_s1 = 180;  // Startwert des Akts. In meinem Model kann ich nur bis 130 runter drehen, Anschlag!
  volt_s2 = 180;
  volt_s3 = 180;
  volt_s4 = 180;
  volt_s5 = 180;

}

void taster(int up, int dw, int volt_s)

{}










void loop()

{
 volt_i1 = map(analogRead(A0) , 0, 1023, 0, 255); 
 

// Code für die Taster volt_s (Volt soll)
 
  
  if(!digitalRead(SW2))
  {
    if(volt_s1<255)volt_s1++; 
    
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(volt_s1);  //nur zur Visualisierung 
    Serial.println("IST: ");
    Serial.println(volt_i1);
    
    delay(80);
  }
  

  if(!digitalRead(SW1))
  {
    if(volt_s1!=130)volt_s1--;   //Min 130  Anppassung des Pots, in meinem Model kann ich nur bis 130 runter drehen, Anschlag 
 
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(volt_s1); //nur zur Visualisierung
    Serial.println("IST: ");
    Serial.println(volt_i1);
    
    delay(80);
    
  }
// Taster Ende 
 
 
 
    

    
    analogWrite(speed1, 255); //Speed manuell
    const int intervall = 2;
 
  int error = volt_s1 - volt_i1 ;   
  // Error --> ist SOLL ueber IST -> Error positiv --> Up Schleife
  //           ist SOLL unter IST -> Error negativ --> Down Schleife
  
  if (error > 0 && error > intervall)  //Up Schleife
  {
  digitalWrite (M_up, LOW); // An H-Brücke, LOW -> Motor läuft
  digitalWrite (M_dw, HIGH);
  
  }

    if (error == 0 )
    {
      digitalWrite(M_up, HIGH);  
    }
  
  
  
  if (error < 0 && error < intervall)  //Down Schleife
  {
    digitalWrite(M_dw, LOW); // An H-Brücke, LOW -> Motor läuft
    digitalWrite(M_up, HIGH);
  }

   
    if (error == 0)
    {
      digitalWrite(M_dw, HIGH);
      
    }
   
 }

Unterprogramme werden in C meist Funktionen genannt.

am besten du liest dich hier mal ein: Prozeduren und Funktionen

Bezogen auf dein Beispiel würde ich das so machen:
zunächst würde ich deine Taster und "volt" variable als array deklarieren, das erleichtert den Zugriff.
Dann die Funktion "taster()" mit dem übergabeparametern up, down, und volt aufrufen.

die Crux liegt hier in dem kleinen "&" vor _volt im Funktionskopf.
damit wird nicht der Wert and die Funktion übergeben, sondern ein Pointer auf die Variable. Sonst könnte der Wert von volt_s in der Funktion nicht geändert werden. (Siehe "call-by-value" und "call-by-reference" in der oben verlinkten Seite)

int volt_s[5] = {0,0,0,0,0};
int SW_up[5] = {22,24,26,28,30};
int SW_dw[5] = {23,25,27,29,31};
int kanal = 0;

void taster(int _up, int _dw, int &_volt){  
  if(!digitalRead(_up)) {    //hochzählen
    if(_volt<255)_volt++;     
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(_volt);  //nur zur Visualisierung 
    Serial.println("IST: ");
    Serial.println(_volt);
    delay(80);
  }
  if(!digitalRead(_dw)){
    if(_volt>=130)_volt--;   //Min 130  Anppassung des Pots, in meinem Model kann ich nur bis 130 runter drehen, Anschlag 
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(_volt); //nur zur Visualisierung
    Serial.println("IST: ");
    Serial.println(_volt);    
    delay(80);    
  }
} // end function taster


void setup(){}
void loop(){
  if (++kanal >= 5) kanal = 0; 
  taster(SW_up[kanal], SW_dw[kanal], volt_s[kanal]);  
}

In dieser form wird die Funktion "taster()" bei jedem durch lauf der loop() einmal aufgerufen und fragt jeweils ein Tasterpaar ab, beim nächsten Durchlauf das nächste Tasterpaar.

Hallo,
probiere das doch einmal:
Case
http://arduino.cc/de/Reference/SwitchCase
Gruß und Spaß
Andreas

Vielen Dank für eure Antworten!

@SkobyMobil:
Mir ist nicht ganz klar, was die SwitchCase mit meiner Frage zum Thema Aufbau von Funktionen zu tun hat?

Mir hat man mal gesagt, dass man nur die nötigen Dinge in den Loop packen soll. Und alles was nicht drin sein muss, raus! Hollywood Prinzip nannte er das. Da mein Programm später noch viel mehr machen soll, will ich das gleich so gut wie möglich machen.

Kurze Projektbeschreibung: (Uni Projekt)
Die 4+1 Aktuatoren werden in einem Test-Fahrzeug eingebaut um die Fahreigenschaften zu ändern. Neben der Akt.-Steuerung sollen dann noch die Stellwerte der Akts, die Werte eines GPS, Gyro, Accel, etwa 4-8 Sonars, auf eine SD Card geschrieben werden, sowie über einen Monitor an board ausgegeben werden. Jeder Programteil für sich läuft schon.
-Also ansprechen des Bildschirms (4d Systemas, mit genieArduino)
-Sensoren auslesen
-Speicher
-Aktuatoren steuern
-----> Die gesamten Messdaten sollen dann später in einem Regelkreis verwurstelt werden, (nicht meine Aufgabe), dass man die Akt nicht mehr manuell Steuern muss, sondern geregelt werden. Quasi ein "aktives Fahrwerk" (gibts ja schon bei den Premium Herstellern)

@guntherb

das mit dem & muss man natürlich wissen....

Leider funktioniert es noch nicht, irgendwie hab ich da noch Fehler irgendwo.

Dazu ein paar Fragen zum Verständnis:

  • bei der Initalisierung der Pins:
int SW_up[5] = {22,24,26,28,30};  // <-- So kann man auch die Pins intitalisieren? Also das sind jetzt keine Werte sondern Pins? Das sind doch jetzt einfach Werte im Array.   (Ich benutzde das MEGA)
  • Pinmodes (Das muss ich ja auch anderes schreiben):
 pinMode(SW_up[5], INPUT);
  digitalWrite(SW_up[5], HIGH);
  
  pinMode(SW_dw[5], INPUT);
  digitalWrite(SW_dw[5], HIGH);  // <-- ist das dann so möglich, bzw Richtig?

-Startwert:
Wie setze ich, dass alles volt_s[5] = 180 sind? Weil = {180, 180, 180,180, 180} geht nicht in void setup(), da macht er einen Fehler.

  • Wenn ich dann z.b den 3 Wert später weiter verwenden will, z.b hier:
 int error = volt_s[3] - volt_i1 ;

ist das so korrekt?

Last but not least, bei meinem Code hat er nur auf serial geschrieben, wenn ich den Taster gedrückt HALTE, jetzt macht ers die ganze Zeit.... Warum weiß ich auch nicht.

Nach ausführlichen Test weiß ich jetzt, dass

 pinMode(SW_up[5], INPUT);
  digitalWrite(SW_up[5], HIGH);
  
  pinMode(SW_dw[5], INPUT);
  digitalWrite(SW_dw[5], HIGH);  // <-- ist das dann so möglich, bzw Richtig?

so nicht geht...

So gehts:

pinMode(22, INPUT);
  digitalWrite(22, HIGH);
  
  pinMode(23, INPUT);
  digitalWrite(23, HIGH);

(Für einen Schalter) aber das ist nicht sehr hübsch... da es auch wieder für jeden Pin einzeln gemacht werden muss und bei Änderung des Pins 2x geändert werden muss.... Elegant ist etwas anderes... :frowning:

TEC_MICHL:
Dazu ein paar Fragen zum Verständnis:

  • bei der Initalisierung der Pins:
int SW_up[5] = {22,24,26,28,30};  // <-- So kann man auch die Pins intitalisieren? Also das sind jetzt keine Werte sondern Pins? Das sind doch jetzt einfach Werte im Array.   (Ich benutzde das MEGA)

Richtig erkannt, das sind jetzt einfach nur Werte im Array, mit denen du dann die Pins initialisieren kannst.

TEC_MICHL:

  • Pinmodes (Das muss ich ja auch anderes schreiben):
 pinMode(SW_up[5], INPUT);

digitalWrite(SW_up[5], HIGH);
 
 pinMode(SW_dw[5], INPUT);
 digitalWrite(SW_dw[5], HIGH);  // <-- ist das dann so möglich, bzw Richtig?

ist richtig, du kannst aber auch schreiben:

for (int i=0; i<5;i++){
  pinMode(SW_up[i],  INPUT_PULLUP);
  pinMode(SW_dw[i],  INPUT_PULLUP);
}

TEC_MICHL:
-Startwert:
Wie setze ich, dass alles volt_s[5] = 180 sind? Weil = {180, 180, 180,180, 180} geht nicht in void setup(), da macht er einen Fehler.

Am besten gleich bei der initialisierung:
anstatt int volt_s[5] = {0,0,0,0,0};
schreibst du int volt_s[5] = {180,180,180,180,180};

Wenn du im laufenden Program Werte zuweisen willst, mußt du das einzeln machen:

volt_s[0] = 180;
volt_s[1] = 180;
volt_s[2] = 180;
volt_s[3] = 180;
volt_s[4] = 180;  // Achtung! 5 Elemente im Array bedeuten Zählen von 0-4!

oder, eleganter:
for (int i=0; i<5;i++) volt_s[i] = 180;

TEC_MICHL:

  • Wenn ich dann z.b den 3 Wert später weiter verwenden will, z.b hier:
 int error = volt_s[1] - volt_i1 ;

ist das so korrekt?

Wenn du den 3.Wert willst, dann mußt du schreiben

 int error = volt_s[b][2][/b] - volt_i1 ;

TEC_MICHL:
Last but not least, bei meinem Code hat er nur auf serial geschrieben, wenn ich den Taster gedrückt HALTE, jetzt macht ers die ganze Zeit.... Warum weiß ich auch nicht.

Ohne den ganzen Code zu kennen, ist das schwierig.
Sind denn alle Taster auf HIGH?

Da kannst du z.B. so prüfen:

Serial.println("Taster Stati");
Serial.print("Kanal:         ");
for (int i=0; i<5;i++){
  Serial.print(i);
  Serial.print(char(9));
}

Serial.println();
Serial.print("Taster up:     ");
for (int i=0; i<5;i++){
  Serial.print(digitalRead(SW_up[i]));
  Serial.print(char(9));
}
Serial.println();
Serial.print("Taster down:   ");
for (int i=0; i<5;i++){
  Serial.print(digitalRead(SW_dw[i]));
  Serial.print(char(9));
}
Serial.println();
}

Unsere Posts haben sich überschnitten.

TEC_MICHL:
Nach ausführlichen Test weiß ich jetzt, dass

 pinMode(SW_up[5], INPUT);

digitalWrite(SW_up[5], HIGH);
 
  pinMode(SW_dw[5], INPUT);
  digitalWrite(SW_dw[5], HIGH);  // <-- ist das dann so möglich, bzw Richtig?




so nicht geht...

Das kann auch nicht gehen, weil "SW_up[5]" nicht definiert ist.

mit "int SW_up[5]" hast du ein Array definiert mit 5 Plätzen, die von 0 -4 durchnummeriert werden.

Lieber Gunther,

vielen Dank, für Deine ausführliche Antwort und dass Du jeden Punkt mir erklärt hast!! Hammer!! Langsam dämmerst mir, wie das mit den Array genau geht. Das war bisher etwas "nebulös". :-)))

  • Mit dem Serial.print hattes Du recht. Durch meine fehlerhaftes Pin Setup waren sie nicht auf High. Deine Variante mit der For Schleife ist wirklich sehr elegant und klein, das heb die Übersichtlichkeit doch enorm! Klappt Perfekt.

-Auch das setzten der volt_s[5] klappt. An der Stelle noch eine total blöde Frage, die mich da plagt. Woher weiß der Compiler in dem Fall, was es ist: Denn beides sieht ja gleich aus: Einmal sind es Werte, die sich ja änderen im Loop, einmal sind es Pins...
Wenn jetzt mein volt_s[2] ={22, 23} sein soll, woher weiß er dann, dass ich keinen Pin meine sondern einen Wert meine?? Oder check er das dann, wenn man die Pinmode zuordung macht, und es ist dann eindeutig?

int SW_up[5] = {22,24,26,28,30};
int volt_s[5] = {180,180,180,180,180};

Ich nehme mal [ b ] und [ / b ] hier sollten nur die Zahl dick machen und haben im code kein Bedeutung?

int error = volt_s[b][2][/b] - volt_i1 ;

Auf jeden Fall klapp jetzt alles!! Vielen Dank nochmal!!
Anhand deines Beispiel werd ich jetzt versuchen, das gleiche für die Aktuatoren umzusetzten.

Ach ja, eine Frage noch:
Was sind die Vor, bzw Nachteile, dass die Taster abwechlend bei jedem Loop abgefragt werden und nicht alle gleichzeitig.... Es kann ja auch mal sein, dass man 2 oder mehr gleichzeitig drückt. Hat vermutlich keine großen Einfluß auf das gleichmäßige Verfahren, der Akts?

TEC_MICHL:
An der Stelle noch eine total blöde Frage, die mich da plagt. Woher weiß der Compiler in dem Fall, was es ist: Denn beides sieht ja gleich aus: Einmal sind es Werte, die sich ja änderen im Loop, einmal sind es Pins...
Wenn jetzt mein volt_s[2] ={22, 23} sein soll, woher weiß er dann, dass ich keinen Pin meine sondern einen Wert meine?? Oder check er das dann, wenn man die Pinmode zuordung macht, und es ist dann eindeutig?

int SW_up[5] = {22,24,26,28,30};

int volt_s[5] = {180,180,180,180,180};

Dem compiler ist es völig wurschd, was du meinst.

Es werden einfach in einem Array Zahlen gespeichert. Wofür du die verwendest, ist dir überlassen.

Ganz anders ist der Befehl: "Pinmode()".
Dieser Befehl verlangt eine Pinnummer. Wenn du also hier eine Zahl reinschreibst, dann ist eine bleibige Zahl, die vorher in einer Variable gespeichert wurde, eine Pinnummer.

Sauberer ist es, wenn du die Pinnummer-arrays gleich als Konstante definierst:

const int SW_up[5] = {22,24,26,28,30};

Dann kannst du nicht aus versehen im Programm überschreiben.

TEC_MICHL:
Ich nehme mal [ b ] und [ / b ] hier sollten nur die Zahl dick machen und haben im code kein Bedeutung?

int error = volt_s[b][2][/b] - volt_i1 ;

ja, sorry, Klickfehler von mir.

TEC_MICHL:
Ach ja, eine Frage noch:
Was sind die Vor, bzw Nachteile, dass die Taster abwechlend bei jedem Loop abgefragt werden und nicht alle gleichzeitig.... Es kann ja auch mal sein, dass man 2 oder mehr gleichzeitig drückt. Hat vermutlich keine großen Einfluß auf das gleichmäßige Verfahren, der Akts?

Das ist letztlich eine Philosophie-Frage und was du letztlich machen willst.

die vielen Serial.print in den Tasterabfragen kosten sehr viel Zeit, deshalb erschien es mir sinniger, sie nacheinander abzufragen.
Tastendrücken ist im Vergleich zu SW-Laufzeiten meist recht langsam.
Wenn es deine Funktionen aber verlangen, gleichzeitig gedrückte Tasten abzufragen, dann solltest du alle abfragen.

Es ist keine klare technische Präferenz, eher die Frage, wie möchte ich, dass das System auf Eingaben reagiert.

(Es wäre auch kein Schaden, die Baudrate für der Seriellen Monitor auf 115200 oder 57600baud zu erhöhen)

Juhuu!! Ich konnte nun, anhand Deines Beispiel ebenfalls ein Unterprogramm schreiben für die Steuerung der Aktuatoren, und tatsächlich, es funktioniert!! :slight_smile:

Eine kleines Problem habe ich leider noch.

Hier der gesammte Code:

// Aktuator


int kanal = 0;

const int intervall = 2; // Intervall in dem der Akt nicht nachregelt

// TASTER PINS INT  BEGIN

const int SW_up[5] = {22,24,26,28,30};
const int SW_dw[5] = {23,25,27,29,31};

// TASTER PINS INT END



// AKTUATOR VAR

// VOLT SOLL -> vom System/User vorgegebene Stellung der Akt

int volt_s[5] = {180,180,180,180,180}; // Startposition der Aktuatoren

// VOLT SOLL ENDE



// AKTUATOR PINS

// VOLT IST -> vom Aktuator gemeldete Poition, Analog IN

int volt_i[5] = {A0,A1,A2,A3,A4};   // Akt Motor, HL, HR, VL, VR



// VOLT IST END


// Verfahrgeschwindigkeit der Aktuatoren ANSCHLUSS PINS

int speed1 = 2; // MOTOR PWM Ausgang (2-6) 
int speed2 = 3; // HL
int speed3 = 4; // HR
int speed4 = 5; // VL
int speed5 = 6; // VR




// Drehrichtung der Aktuatoren
 
const int akt_up[5] = {34,36,38,40,42};
const int akt_dw[5] = {35,37,39,41,43};



 
 
void setup()

{
  // PINMODE TASTER SETUP
  
for (int i=0; i<5;i++)

{
  pinMode(SW_up[i],  INPUT_PULLUP);
  pinMode(SW_dw[i],  INPUT_PULLUP);
}
  
  // PINMODE TASTER SETUP END
  
  
// AKTUATOR MOTOR UP/DOWN PIN SETUP 
 

for (int j=0; j<5;j++)
{
  pinMode(akt_up[j], OUTPUT);
  digitalWrite(akt_up[j], HIGH);
  pinMode(akt_dw[j], OUTPUT);
  digitalWrite(akt_dw[j], HIGH);
}

// AKTUATOR MOTOR UP/DOWN PIN SETUP   

  
  
  
  Serial.begin(9600);
  
}

//SETUP END



// FUNCTIONS

// FUNCTION TASTER
void taster(int _up, int _dw, int &_volt){  
  if(!digitalRead(_dw)) {    //hochzählen
    if(_volt<255)_volt++; 
     
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(_volt);  //nur zur Visualisierung 

    delay(20);
    return;
    
    }
  if(!digitalRead(_up)){
    if(_volt>=130)_volt--;   //Min 130  Anppassung des Pots, in meinem Model kann ich nur bis 130 runter drehen, Anschlag 
 
    Serial.println("-------");
    Serial.println("SOLL: ");
    Serial.println(_volt); //nur zur Visualisierung

    delay(20);    
    return;   
  }
} // END FUNCTION TASTER






// FUNCTION AKTUATOR
void aktuator (int _up, int _dw, int volt_s, int kanal)

{ 
  int volt_i = map(analogRead(A0) , 0, 1023, 0, 255); 
  int error = volt_s - volt_i;
  
  if (error > 0 && error > intervall)  //Up Schleife
  {
  digitalWrite (akt_up[kanal], LOW); // An H-Brücke, LOW -> Motor läuft
  digitalWrite (akt_dw[kanal], HIGH);
  }
  
  if (error < 0 && error < intervall)  //Down Schleife
  {
    digitalWrite(akt_dw[kanal], LOW); // An H-Brücke, LOW -> Motor läuft
    digitalWrite(akt_up[kanal], HIGH);
  }
    
  if (error == 0 ) // STOP 
    {
      digitalWrite(akt_up[kanal], HIGH);
      digitalWrite(akt_dw[kanal], HIGH);
    }
    
}

// END FUNCTION AKTUATOR  


void loop()

{
 analogWrite(speed1, 255); //Speed manuell
 

  if (++kanal >= 5) kanal = 0; 
  taster(SW_up[kanal], SW_dw[kanal], volt_s[kanal]);  
 
    
  if (++kanal >= 5) kanal = 0; 
  aktuator(akt_up[kanal], akt_dw[kanal], volt_s[kanal], kanal); 
 
 }

Und hier mein Problem, in meiner Fuktion Aktuator:

void aktuator (int _up, int _dw, int volt_s, int kanal)

{ 
  int volt_i = map(analogRead(A0) , 0, 1023, 0, 255);

Ich habe eben versucht, die Analogen Ports ebenfalls so auszulesen:

Oben steht

int volt_i[5] = {A0,A1,A2,A3,A4};  //beim Mega heißen dieAnalogen Ports A0, A1 usw...

in Fkt, dachte ich das könnte klappen, aber leider nicht

analogRead(volt_i[kanal])

Ich vermute mal, das liegt daran, dass ich hier keinen pinMode habe, was bei nem ausschließlichen "Analog In Pin" ja wenig Sinn machen würde.
noch einen Tip? Vielen Dank! So macht das richtig Spaß! :smiley:

zunächst fällt mir auf, dass du verschiedene "volt_i" verwendest,
da solltest du aufpassen, das führt ganz schnell zu bösen Fehlern!

Bei mir führt dieser Sketch:

const int volt_i[5] = { A0, A1, A2, A3, A4};
void setup() {
  Serial.begin(57600);
  Serial.print("Kanal:         ");
  for (int i=0; i<5;i++){    Serial.print(i);    Serial.print(char(9));  }
  Serial.println(); 
  Serial.print("AD_pin:       ");
  for (int i=0; i<5;i++){    Serial.print(volt_i[i]);    Serial.print(char(9));  }
  Serial.println(); 
  Serial.print("AD Wert:      ");
  for (int i=0; i<5;i++){    Serial.print(analogRead(volt_i[i]));    Serial.print(char(9));  }
} // end setup
void loop() {}

zu dieser Ausgabe:

Kanal:         0	1	2	3	4	
AD_pin:       54	55	56	57	58	
AD Wert:      389	400	361	333	315

Offensichtlich übersetzt die Arduino IDE den String "A0" in die Pinnummer "54".

Es funktioniert jedenfalls.

Du meinst das globale volt_i und das volt _i in der Fkt?

Ich habs jetzt geändert.

Also wenn ich

int volt = map(analogRead(A0) , 0, 1023, 0, 255);

ersetzte, durch

int volt = map(analogRead(volt_i[kanal]) , 0, 1023, 0, 255);

dann sagt er sowas, und bricht beim kompilieren ab..

c:/program files (x86)/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr6/crtm2560.o: In function `__vector_default':
(.vectors+0xd0): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_52' defined in .text.__vector_52 section in core.a(HardwareSerial.cpp.o)

=(

Übrigens klasse Beispiel zum debuggen... Ich hab heut mehr gelernt, als aus 3 Büchern zusammen...

TEC_MICHL:
Übrigens klasse Beispiel zum debuggen... Ich hab heut mehr gelernt, als aus 3 Büchern zusammen...

Na, dann hat sich das ja schon gelohnt... :slight_smile:

Aber zu deinem Problem: bei mir funktioniert das:

const int volt_i[5] = { A0, A1, A2, A3, A4};

void aktuator (int _up, int _dw, int volt_s, int kanal){ 
  int volt = map(analogRead(volt_i[kanal]) , 0, 1023, 0, 255); 
}
void setup() {
  Serial.begin(57600);
  aktuator(1,2,3,0);
} // end setup

void loop() {}

vielleicht hast du ja woander einen Bug im Code?

Probier doch auch mal die kritischen Codeteile mal in einen extra Sketch zu kopieren, ob der Code an sich funktioniert.

Sorry, aber du mußt jetzt ohne mich weitermachen, ich muß weg.
Viel Glück!

Gunther

Danke nochmal und schönen Abend:

Ist ein Ding!

Ich hatte die

#include <genieArduino.h>

um mir die Werte auf meinem TFT anzusehen.

Ist die nicht drin, dann läuft Dein Code. Seltsam seltsam.... :wink: