Arduino Steuerung für drei Achsige Halterung

[Ron B. (simatic)]

Hallo zusammen,
zuerst einmal zu mir. Ich heiße Ron, bin 19 Jahre alt und lerne im 3. 
Lehrjahr Mechatroniker (Industrie). Im Hobby bereich habe ich mir vor 
kurzem einen Arduino Uno zugelegt, da mich das Thema Mikrocontroller mit 
dem elektrischen drumherum ziemlich interessiert. Für jemanden der sonst 
Automatisierungssysteme wie die S7 gewohnt ist, ist der µC doch eine 
große Umstellung. Nun habe ich mir als Projekt die Low Budget 
Automatisierung einer von mir gebauten Monitorhalterung vorgenommen 
(Nein ich bin kein Nerd, hier ist der Weg das Ziel :) ).
Die drei Achsen sind über 12VDC Motoren rotatorisch verfahrbar. Jede 
Achse hat zwei Endlagen, die über digitale Hall-Sensoren abgefragt 
werden. Die Motoransteuerung ist über jeweils 2 Relais realisiert 
(Relais 1=Ein/Aus, Relais 2= Rechts/Links). Zur Bedienung werden 3 Potis 
verwendet. Für jede Achse eins, sollte aber aus dem Sketch hervorgehen. 
Bei der Grundfahrt (Poti1=1000+, Poti2= Stopp, Poti3= Stopp) sollen alle 
Achsen in die hintere Endlage fahren.

Die Verdrahtung der Sensoren und Aktoren mit dem µC sind kein Problem 
für mich. Ich scheitere nur im Moment an dem Arduino Programm. Wenn ich 
den ganzen Apparat starte ziehen alle Relais an (Motoren sind 
abgeklemmt, sonst Crash). Potistellung ist egal. Ich erwarte hier keinen 
überarbeiteten Sketch, würde mich über das Aufmerksam machen auf 
Logik/Programmierfehler freuen. Ich bin absoluter Neuling auf dem Gebiet 
der µC Programmierung. Ich hoffe ihr habt Verständnis dafür. Im Anhang 
findet ihr den Sketch. Die 3,5s delay am Ende sind für das bessere 
Beobachten der Variablen im seriellen Monitor gedacht.

Vielen Dank schonmal!

Greets
Ron

const int K1_A_0 = 2;         //Wand          0=aus,          1=ein                                                          DO
const int K2_B_0 = 3;         //Scharnier     0=aus,          1=ein                                                          DO
const int K3_C_0 = 4;         //Monitor       0=aus,          1=ein                                                          DO
const int K4_A_1 = 5;         //Wand          0=rechts,       1=links                                                        DO
const int K5_B_1 = 6;         //Scharnier     0=rechts,       1=links                                                        DO
const int K6_C_1 = 7;         //Monitor       0=rechts,       1=links                                                        DO
const int Achse_A_0 = 8;      //Wand                          1=eingefahren                                                  DI
const int Achse_A_1 = 9;      //Wand                          1=ausgefahren                                                  DI
const int Achse_B_0 = 10;     //Scharnier                     1=eingefahren                                                  DI
const int Achse_B_1 = 11;     //Scharnier                     1=ausgefahren                                                  DI
const int Achse_C_0 = 12;     //Monitor                       1=eingefahren                                                  DI
const int Achse_C_1 = 13;     //Monitor                       1=ausgefahren                                                  DI
const int S1 = A0;            //Poti Wand           0-250=rechts, 251-750=Stopp, 751-1000=links, 1001-1024= Grundstellung    AI
const int S2 = A1;            //Poti Scharnier      0-250=rechts, 251-750=Stopp, 751-1000=links                              AI
const int S3 = A2;            //Poti Monitor        0-250=rechts, 251-750=Stopp, 751-1000=links                              AI

int _S1_Value = 0;            //Potiwert Wand
int _S2_Value = 0;            //Potiwert Scharnier
int _S3_Value = 0;            //Potiwert Monitor

int _Achse_A_0_Value = 0;    //Wand eingefahren
int _Achse_A_1_Value = 0;    //Wand ausgefahren
int _Achse_B_0_Value = 0;    //Scharnier eingefahren
int _Achse_B_1_Value = 0;    //Scharnier ausgefahren
int _Achse_C_0_Value = 0;    //Monitor eingefahren
int _Achse_C_1_Value = 0;    //Monitor ausgefahren

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

  pinMode (K1_A_0, OUTPUT);
  pinMode (K2_B_0, OUTPUT);
  pinMode (K3_C_0, OUTPUT);
  pinMode (K4_A_1, OUTPUT);
  pinMode (K5_B_1, OUTPUT);
  pinMode (K6_C_1, OUTPUT);
  pinMode (Achse_A_0, INPUT);
  pinMode (Achse_A_1, INPUT);
  pinMode (Achse_B_0, INPUT);
  pinMode (Achse_B_1, INPUT);
  pinMode (Achse_C_0, INPUT);
  pinMode (Achse_C_1, INPUT);
}

void loop()
{


  {
    
    Serial.print("Achse_A_0     "); 
    Serial.println(digitalRead(Achse_A_0));      
    Serial.print("Achse_A_1     ");
    Serial.println(digitalRead(Achse_A_1));    
    Serial.print("Achse_B_0     ");
    Serial.println(digitalRead(Achse_B_0)); 
    Serial.print("Achse_B_1     ");
    Serial.println(digitalRead(Achse_B_1));
    Serial.print("Achse_C_0     ");
    Serial.println(digitalRead(Achse_C_0));  
    Serial.print("Achse_C_1     ");
    Serial.println(digitalRead(Achse_C_1));   
    Serial.print("Poti 1     ");
    Serial.println(analogRead(_S1_Value));   
    Serial.print("Poti 2     ");
    Serial.println(analogRead(_S2_Value));  
    Serial.print("Poti 3     ");
    Serial.println(analogRead(_S3_Value));   
     Serial.println("  ");
    

  }


  {

    _Achse_A_0_Value = digitalRead(Achse_A_0);
    _Achse_A_1_Value = digitalRead(Achse_A_1);
    _Achse_B_0_Value = digitalRead(Achse_B_0);
    _Achse_B_1_Value = digitalRead(Achse_B_1);
    _Achse_C_0_Value = digitalRead(Achse_C_0);
    _Achse_C_1_Value = digitalRead(Achse_C_1);
    _S1_Value = analogRead(S1);
    _S2_Value = analogRead(S2);
    _S3_Value = analogRead(S3);
  }

  // Achse Wand



  if ((_S1_Value == 0 < 250) && (_Achse_A_1_Value == 0))                         //Achse Wand ausfahren (links)
  {
    digitalWrite(K1_A_0, HIGH);
    digitalWrite(K4_A_1, HIGH);
  }


  if (((_S1_Value == 750 < 1000) && (_Achse_A_0_Value == 0)) || ((_S1_Value > 1001) && (_Achse_A_0_Value == 0)))                     //Achse Wand einfahren (rechts)
  {
    digitalWrite(K1_A_0, HIGH);
    digitalWrite(K4_A_1, LOW);
  }

  if ((_S1_Value == 251 < 749) && (_S1_Value < 1001))                                                                       //Achse Wand Stopp
  {
    digitalWrite(K1_A_0, LOW);
    digitalWrite(K4_A_1, LOW);
  }


  //Achse Scharnier



  if ((_S2_Value == 0 < 250) && (_Achse_B_1_Value == 0))                                                                   //Achse Scharnier ausfahren (auf)
  {
    digitalWrite(K2_B_0, HIGH);
    digitalWrite(K5_B_1, HIGH);
  }


  if (((_S2_Value == 750 < 1025) && (_Achse_B_0_Value == 0)) || ((_S1_Value > 1001) && (_Achse_B_0_Value == 0)))            //Achse Scharnier einfahren (zu)
  {
    digitalWrite(K2_B_0, HIGH);
    digitalWrite(K5_B_1, LOW);
  }

  if ((_S2_Value == 251 < 749) && (_S1_Value < 1001))                                                                      //Achse Scharnier Stopp
  {
    digitalWrite(K2_B_0, LOW);
    digitalWrite(K5_B_1, LOW);
  }


  //Achse Monitor


  if ((_S3_Value == 0 < 250) && (_Achse_C_1_Value == 0))                                                                  //Achse Monitor ausfahren
  {
    digitalWrite(K3_C_0, HIGH);
    digitalWrite(K6_C_1, HIGH);
  }


  if (((_S3_Value == 750 < 1025) && (_Achse_C_0_Value == 0)) || ((_S1_Value > 1001) && (_Achse_C_0_Value == 0)))          //Achse Monitor einfahren
  {
    digitalWrite(K3_C_0, HIGH);
    digitalWrite(K6_C_1, LOW);
  }

  if ((_S3_Value == 251 < 749) && (_S1_Value < 1001))                                                                      //Achse Monitor Stopp
  {
    digitalWrite(K3_C_0, LOW);
    digitalWrite(K6_C_1, LOW);
  }


delay (3500);
  

}

[Alexander S. (alex998)]

Ron B. schrieb:


> const int K1_A_0 = 2;

->  #define K1_A_0 2

Dafür solltest du Makros nutzen.

Ansonsten: Schaltplan wär nicht verkehrt.

[PittyJ (Gast)]

Warum Macros?
Ich verwende const ints auch sehr gerne.
Die machen das gleiche und der Compiler kann sauber damit arbeiten. 
Keine Präprozessor-Ersetzung mit irgendwelchen Nebenwirkungen.

[Alexander S. (alex998)]

@PittyJ: Ja du hast Recht; beim Arduino-C++ hat const Vorteile 
(Casting), war von C ausgegangen.

[Peter (Gast)]

Hast du vll. eine fertige Relaisplatine gekauft. Oft schalten die bei 
0V. Kannst ja mal probieren in dem du beim Einschalten alle Ausgänge 
setzt... Dann sollten alle Relais aus sein.

[Rasputin (Gast)]

hab nur kurz drüber geschaut, aber sowas:

(_S1_Value == 750 < 1000)

funktioniert nicht. Vermutlich meintest du sowas wie:

(_S1_Value > 750 && _S1_Value <= 1000)

[Ron B. (simatic)]

Dann bleibe ich erstmal bei den const_int's.

Ich bin leider kein Experte in E-CAD, im Moment fuchse ich mich in Eagle 
rein. Bis da etwas ordentliches rauskommt dauert es aber noch. Eine 5V 
Relais Karte verwende ich für die Relais, die den Motor Ein/Aus 
schalten. Die Relais für die Pol Wendung werden über einen C547B 
Transistor angesteuert.
Die elektrische Schaltung und ob die Ausgänge die Relais schalten habe 
ich getestet.



Rasputin schrieb:
> hab nur kurz drüber geschaut, aber sowas:
>
>

(_S1_Value == 750 < 1000)

>
> funktioniert nicht. Vermutlich meintest du sowas wie:
>
>

(_S1_Value > 750 && _S1_Value <= 1000)

Danke für den Tipp, Rasputin. Funktion soll sein, dass wenn Poti 1 einen 
Wert zwischen 750 und 1000  hat, Relais K1 anzieht und K4 nicht. Ist 
dies dann eine funktionierende Bedingung?

(((_S1_Value > 750 && _S1_Value <= 1000 ) && (_Achse_A_0_Value == 0)) || ((_S1_Value > 1001) && (_Achse_A_0_Value == 0)))