Linearmotor Ansteuerung

[c0ntem]

Hallo ins Forum

ich habe ein kleines Problem mit der Ansteuerung von einem Linearmotor mit Hilfe von 2 externen Endschaltern. Rauf / bzw. Runterfahrt wird über eine Relais Schaltung realisiert.

Jetzt habe ich folgendes Problem, dass es im ersten Durchlauf funktioniert, aber nachdem der Motor einmal raufgefahren ist, beim runterfahren der Endschalter ignoriert wird...

Hat hier jemand eine Idee, oder kann mich freundlicherweise auf meinen Fehler aufmerksam machen?

Benutzt wird ein normaler Arduino UNO

Code:

#include <Wire.h>
int relais1 = 11;  //13
int relais2 = 10;  //12

int schalteroben = 6;
int schalterunten = 7;
int mittelschalter = 2; //auf Interrupt pin setzten...
const int wendung = 4; //Hauptschalter Wendung Pullup nötig
bool wendungstaste;

bool obenstatus;  // Statusabfrage oben false
bool untenstatus; // Statusabfrage unten
bool mittelstatus; // Statusabfrage mittel
unsigned long currentMillis;
unsigned long previousMillis = 0;
const long Interval = 60000;  // Wendungsintervall

volatile bool ISR_FLAG_AUF = 0;     // Flag für INTERRUPT_TASTER_AUF
volatile bool ISR_FLAG_ZU = 0;      // Flag für INTERRUPT_TASTER_ZU

int obenflag;  // Flags als Merker
int untenflag;
int mittelflag;


void setup() {
  // put your setup code here, to run once:
// pinMode(kontakt, INPUT);
Serial.begin (9600);

  pinMode (relais1, OUTPUT);          // Relee 1 als Augang
  pinMode (relais2, OUTPUT);           // Relee 2 als Ausgang
  pinMode (schalteroben, INPUT);      // Schalter OBEN Einang
  pinMode (schalterunten, INPUT);     // Schalter UNTEN Eingang
  pinMode (wendung, INPUT_PULLUP);    // Hauptschalter Wendung
  pinMode (mittelschalter, INPUT);    // Schalter für Mittelstellung

  attachInterrupt (0, INTERRUPT_mittelschalter, LOW); // Interrupt für Taster_AUF

}

void loop()
{
currentMillis = millis();                 // Einlesen der Kontake und Status
wendungstaste = digitalRead(wendung);
obenstatus = digitalRead(schalteroben);
untenstatus = digitalRead(schalterunten);
mittelstatus = digitalRead(mittelschalter);



// Start der Bedingung wenn Taster gedrück ist
// HIGH = Auf // LOW = ZU
//if (wendungstaste == HIGH){
//  Motor_stopp();

// Wendungstaster geschlossen, nach Unten/Rechts fahren Schalter oben und unten OFFEN.
if (wendungstaste == LOW && untenflag == false && obenflag == false){   //&& obenstatus == HIGH && untenstatus == HIGH) {
  
   while (untenstatus)
  {
  Motor_ab();
  Serial.println ("Motor faehrt nach Unten/rechts");
  untenstatus = digitalRead(schalterunten);     // Pruefung ob Untenstatus "offen"
  untenflag = true;
  }
  Motor_stopp();
  Serial.println ("Motor ist unten angekommen");
  Serial.println ("Untenflag:");
  Serial.println (untenflag);
  Serial.println ("Obenflag:");
  Serial.println (obenflag);
}

// Motor gestoppt Zeit Interval

if ( untenflag == true && (currentMillis - previousMillis>= Interval)){

  while (obenstatus)
  {
    Motor_auf();
    Serial.println ("Motor faehrt hoch");
    obenstatus = digitalRead(schalteroben);
    obenflag = true;
    untenflag = false;
  }
  Motor_stopp();
    Serial.println (" Motor vom Rauffahren gestoppt");
    previousMillis = currentMillis;
      Serial.println ("Untenflag:");
  Serial.println (untenflag);
  Serial.println ("Obenflag:");
  Serial.println (obenflag);
}
//else?
if (obenflag == true && (currentMillis - previousMillis>=Interval)){
  
    while (untenstatus)
    {    
      Motor_ab();
      Serial.println ("Motor faehrt runter");     // hier läuft das Programm nicht weiter:@
      untenstatus = digitalRead(schalterunten);
      untenstatus = true;
      obenflag = false;
    }
    Motor_stopp();
    Serial.println ("Motor vom runterfahren gestoppt");
    previousMillis = currentMillis;
      Serial.println ("Untenflag:");
  Serial.println (untenflag);
  Serial.println ("Obenflag:");
  Serial.println (obenflag);
  }
/*
  if (ISR_FLAG_ZU ==1 && wendungstaste== HIGH && untenstatus == true){
    Motor_auf();
    Serial.println ("Mitteltaste grdrückt, Motor auf");
    obenstatus = digitalRead(schalteroben);
  }
    else if (ISR_FLAG_ZU ==1 && wendungstaste == HIGH && obenstatus == true)
    {
      Motor_ab();
      Serial.println ("Mitteltaste gedrückt, Motor rauf");
      untenstatus = digitalRead(schalterunten);
  }
    //delay(1000); //Programm Durchlaufzeit?!
*/
}

//################################################
// einzelne Funktionen
//################################################

void INTERRUPT_mittelschalter()
{
  ISR_FLAG_ZU=1;
  Serial.println ("Mittelstellung gedrückt");
}
void Motor_ab()
{
  digitalWrite(relais1,HIGH);
  digitalWrite(relais2,LOW);
}

void Motor_auf()
{
  digitalWrite(relais1,LOW);
  digitalWrite(relais2,HIGH);
}

void Motor_stopp()
{
  digitalWrite(relais1,LOW);
  digitalWrite(relais2,LOW);
}

[MicroBahner]

Code:

untenstatus = digitalRead(schalterunten);
untenstatus = true;

Da kannst Du lesen soviel Du willst, wenn Du den Status gleich wieder zu true setzt, kann der nie false werden ( und die while-Schleife wird auch nie beendet ).

Das mit dem Interrupt würde ich mir auch nochmal überlegen. Ich weis zwar nicht, wozu der 'Mittelschalter' ist, aber einen einfachen Schalter per Interrupt abzufragen ist nie eine gute Idee ( und auch nie notwendig ).

[c0ntem]

...

ja manchmal sind doch viele Bäume im Wald, wenn man jetzt den richtigen Status/ Flag einsetzt klappt es auch sehr gut.

Vielen Dank !

Zurück zum Interrupt,

also gedacht ist wenn ich einen Schalter/ Taster drücke, dass der Motor entsprechend hoch/ runter fährt um in die Mittelstellung zu kommen.
Die Mittelstellung ist nötig, wird aber nur bei Bedarf ausgelöst, Problem ist das das Interval hinterher bei ca. 2h liegt, und ich daher an einen Interrupt gedacht.

Gibt es hier vielleicht doch noch eine elegantere Lösung?

[MicroBahner]

(28.01.2021 18:33)c0ntem schrieb:  Problem ist das das Interval hinterher bei ca. 2h liegt, und ich daher an einen Interrupt gedacht.

Interrupts sind genau für das Gegenteil gedacht: bei extrem kurzen Intervallen und wenn es extrem schnell gehen muss.
Bei langen Intervallen kann man das bequem im loop abfragen. Schalter prellen, und Interrupts sind so schnell, die lösen bei jedem einzelnen Prellen des Schalters aus.

[c0ntem]

ah okay, vielen Dank für den Hinweis.

So wie ich die Suche hier im Forum und Google verstanden habe, läuft Millis eh normal weiter, daher würde die Mögichkeit bestehen den Taster ganz normal im Loop abzufragen, auch wenn grade ein "Warteintervall" läuft?!

[MicroBahner]

Ja den Taster kann man immer im loop() abfragen.
Ganz grundsätzlich sollte man 'blockadefrei' programmieren, also den loop nie anhalten, auch während Warteintervallen nicht ( also keine längeren while-Schleifen oder delay() im loop ). Dann kann man jederzeit auf externe Ereignisse reagieren.

[Franz54]

"auch wenn grade ein "Warteintervall" läuft?! "

Was ist ein Warteintervall ? Ich nehme mal an, das ist das, was es bei brauchbarer Programmierung nicht gibt?

Franz

[c0ntem]

Die While Schleife, habe ich bisher nur für das Verfahren des Linearmotors genuzt, danach wäre ja die IF Abfrage über die Millis die der UNO hochzählt.

Zitat:"auch wenn grade ein "Warteintervall" läuft?! "

Was ist ein Warteintervall ? Ich nehme mal an, das ist das, was es bei brauchbarer Programmierung nicht gibt?

Ja das ist wohl so Da hab ich mich etwas schlecht Ausgedrückt, das ist mein Zeitlicher Ablauf im Programm.. Also:

Motor verfährt, Endpunkt erreicht -> (Warteinvervall = in meinem Fall 2h) -> Motor in andere Richtung bis Endpunkt, wieder Warten usw.

Und das ganze über einen Taster unterbrechen, damit man Manuel den Motor/rauf/runterfahren kann...


Schon mal vielen Dank für diese Einblicke, ich versuch jetzt nochmal die Tasterabfrage zu ändern