BlinkWithOutDelay Variante hakt jetzt grundsaetzlich, bei kurzem Test Sketch

Koennte ein Internet Meme werden. :upside_down_face:

Hallo Leute,
mein erster Plan war zwei Servos an einem PWM Signal laufen zu lassen. Das klappt auch grundsaetzlich. Leider musste ich feststellen das die Servos Bauraum bedingt nur gespiegelt eingebaut werden koennen, was heisst die Servos muessen gegenlaeufig drehen (und gleichzeitig) . Also komme ich wohl nicht an millis() vorbei

Und jetzt probiere ich hier rum und bin der Meinung das muesste doch so klappen, also jetzt ernsthaft, ich beacker das Thema ja schon eine weile. Aber mein Nano Clon hat Schwierigkeiten dabei meinen Code umzusetzen. Vielleicht ist er damit einfach ueberfordert? :thinking:

Der Serial Monitor ist recht aktiv, aber das Ergebnis laesst mich raetseln.

So wie ich es hier probiert habe, bin ich der Meinung das die for-Schleife 2 Sekunden warten muss bis millis() durchgelaufen ist. (Ich habe millis() auch schon in der for-Schleife platziert) Aber ist halt nicht. Der Monitor rattert einfach durch, die for-Schleife rennt so schnell wie es der Ausgabe moeglich ist.

#include <Servo.h>
int Tor1 = 1;
int Tor2 = 1;
Servo Serv;
unsigned long currentMillis = 0;
unsigned long previousMillis = 0;
unsigned long previousMillis_b = 0;

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

int schalten (int PIN, int soll, int ist, long pause ){
  Serv.attach(PIN);
  if (soll>ist){
    if (currentMillis - previousMillis >= pause) {
      previousMillis = currentMillis;
      for(ist; ist<=soll; ist++){
        Serv.write(ist);
        Serial.print("Ist geht plus: ");
        Serial.println(ist);
        Serial.print("Was ist soll: ");
        Serial.println(soll);
    }
   }
  }
  if (soll<ist){
    if (currentMillis - previousMillis >= pause) {
      previousMillis_b = currentMillis;
      for(ist; ist>=soll; ist--){
        Serv.write(ist);
        Serial.print("Ist geht minus: ");
        Serial.println(ist);
        Serial.print("Was ist soll: ");
        Serial.println(soll);
    }    
  }
  Serv.detach();
  return soll;
  }
}


void loop() {
  currentMillis = millis();

  
  if ((digitalRead(A0)) == HIGH){
    Tor1 = schalten(9, 20, Tor1, 2000);
  }
  else{
    Tor1 = schalten(9, 0, Tor1, 2000);  
  }


//  if ((digitalRead(A0)) == HIGH){
//    Tor2 = schalten(7, 20, Tor2, 1000);
//  }
//  else{
//    Tor2 = schalten(7, 0, Tor2, 1000);  
//  }
}

Und wer mir jetzt aufs Brot schmieren will, er haette es vorher gewusst. Nur zu, und ruhig dick. Das passt schon. :expressionless:

Und schon mal Danke fuer die Hilfe im Voraus.

Gruesse,

gutschy

P.S.
ich hab mir ueberlegt die delay() Variante meines Servo Treibers auf zwei Servos umzuschreiben, :smiley: also zur Not. Aber das muss jetzt oben trotzdem fertig werden, ich mein, das gibts doch nicht.

welche for-schleife?

   if (currentMillis - previousMillis >= pause)
    {
      previousMillis_b = currentMillis;
      for (ist; ist >= soll; ist--)

ist jetzt die Frage, was Du da machen willst.
Wenn Du da vorher auf 2000ms wartest, ist das doch richtig.
Nur darfst Du das nicht jedes mal neu setzen.

Und das hier ist ganz Mist:

    }
    Serv.detach();
    return soll;
  }
}

Du solltest die Warnungen beherzigen:
warning: control reaches end of non-void function [-Wreturn-type]
}
^

Kannst du das mal erleutern?

previousMillis = currentMillis;

habe ich schon mal alleine in die for-Schleife gesestzt, ist aber alles stochern im Nebel. Vielleicht sollte ich die for-Schleife auch komplett ausbauen.
Einfach

ist++

so hochzaehlen, ach man, was ist daran so schwer zu kapieren???

Das weiss ich nicht.
Was soll der Sketch machen?
Jetzt.
ErklÀren.

Sehe ich jetzt zum ersten mal die Warunung??

Der Sketch laesst den Servo langsam laufen. Bei 180 Grad solle jeder Grad nacheinander angefahren werden.

Hier der Sketch mit delay() den ich als Grundlage nehme.

#include <Servo.h>
int Tor1 = 1;
Servo Serv;

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

int schalten (int PIN, int soll, int ist, int Pause){
  Serv.attach(PIN);
  if (soll>ist){
    for(ist; ist<=soll; ist++){
      Serv.write(ist);
      delay(Pause);
      Serial.println(ist);
    }
  }
  if (soll<ist){
    for(ist; ist>=soll; ist--){
      Serv.write(ist);
      delay(Pause);
      Serial.println(ist);
    }    
  }
  Serv.detach();
  return soll;
}


void loop() {
  if ((digitalRead(2)) == HIGH){
    Tor1 = schalten(9, 20, Tor1, 200);
  }
  else{
    Tor1 = schalten(9, 0, Tor1, 200);  
  }
}

Das lÀsst sich Àndern:
DATEI - VOREINSTELLUNGEN - Haken setzen bei AusfĂŒhrliche Ausgabe wĂ€hrend : Kompilierung
Darunter auswÀhlen alle.

Was heisst bei 180Grad soll jeder Grad einzeln angefahren werden? Du willst von 180 bis 200 einen "LangsamlÀufer" - also jedes Degree einzeln anfahren?

Dann ist das komplett falsch.
Du weisst nicht, wo der positioniert ist.
Dein IST ist eine freie Interpretation...
Servo.read() wÀre eine Variante.

Du musst nur Deine SOLL-Position ĂŒbergeben, dann macht der Code eigentlich selbst was Du willst.

Ich schau mal...

Ok, Haken gesetzt, und Danke!

Also die 180 Grad waren jetzt nur da hingesagt, es geht einfach von Null zu irgendwas. Die Null Position findet doch der Servo alleine, oder nicht?

kompiliert fehler- und Warnungsfrei.

Der servo soll sich im sekundentakt bewegen - in die eine Richtung, wenn die Taste gedrĂŒckt - in die andere Richtung wenn nicht.

#include <Servo.h>
int Tor1 = 1;

const byte ServoPin = 9;


Servo Serv;
unsigned long previousMillis = 0;

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

void schalten (const byte PIN,  int sollPosition, const unsigned long pause )
{
  Serv.attach(PIN);
  if (sollPosition != Serv.read()) // feststellen ob ĂŒberhaupt was passieren muss
  {
    if (millis() - previousMillis > 1000) // Zeit abgelaufen?
    {
      if (Serv.read() < sollPosition) // Richtung bestimmen
      {
        Serv.write(Serv.read() + 1);
        Serial.print("Ist geht plus: ");
        Serial.println(Serv.read());
        Serial.print("Was ist soll: ");
        Serial.println(sollPosition);
      }
      else if (Serv.read() > sollPosition) // andere Richtung
      {
        Serv.write(Serv.read() - 1);
        Serial.print("Ist geht minus: ");
        Serial.println(Serv.read());
        Serial.print("Was ist soll: ");
        Serial.println(sollPosition);
      }
      previousMillis = millis(); // Zeit merken
    }
  }
  Serv.detach();
}
void loop()
{
  if ((digitalRead(A0)) == HIGH)
  {
   schalten(ServoPin, 60, 2000);
  }
  else
  {
   schalten(ServoPin, 0,  2000);
  }
}

Sorry, laeuft nicht. Hardware maessig ist alles ok. Mit dem delay() Sketch gehts.

In Zeile 20 sollte wohl Pause statt 1000 stehen, oder? Ich teste mal.

Ja was nicht?
Jeden Quark Dir aus der Nase zu ziehen ist doch Kacke.
Ja und jetzt ich: Du hast A0 als DigitalPin den Du auswerten willst?
Dann musst Du den auch richtig einstellen!

#include <Servo.h>
int Tor1 = 1;

const byte ServoPin = 9;

const byte schaltPin = A0;

Servo Serv;
unsigned long previousMillis = 0;

void setup()
{
  Serial.begin(115200);
  pinMode(schaltPin, INPUT_PULLUP);
}

void schalten (const byte PIN,  int sollPosition, const unsigned long pause )
{
  Serv.attach(PIN);
  if (sollPosition != Serv.read()) // feststellen ob ĂŒberhaupt was passieren muss
  {
    if (millis() - previousMillis > pause) // Zeit abgelaufen?
    {
      if (Serv.read() < sollPosition) // Richtung bestimmen
      {
        Serv.write(Serv.read() + 1);
        Serial.print("Ist geht plus: ");
        Serial.println(Serv.read());
        Serial.print("Was ist soll: ");
        Serial.println(sollPosition);
      }
      else if (Serv.read() > sollPosition) // andere Richtung
      {
        Serv.write(Serv.read() - 1);
        Serial.print("Ist geht minus: ");
        Serial.println(Serv.read());
        Serial.print("Was ist soll: ");
        Serial.println(sollPosition);
      }
      previousMillis = millis(); // Zeit merken
    }
  }
  Serv.detach();
}
void loop()
{
  if ((digitalRead(A0)) == HIGH)
  {
    schalten(ServoPin, 60, 500);
  }
  else
  {
    schalten(ServoPin, 0,  500);
  }
}

Ausgabe:

23:21:24.593 -> Ist geht minus: 74
23:21:24.593 -> Was ist soll: 60
23:21:25.093 -> Ist geht minus: 73
23:21:25.093 -> Was ist soll: 60
23:21:25.590 -> Ist geht minus: 72
23:21:25.590 -> Was ist soll: 60
23:21:26.086 -> Ist geht minus: 71
23:21:26.086 -> Was ist soll: 60
23:21:26.617 -> Ist geht minus: 70
23:21:26.617 -> Was ist soll: 60
23:21:27.114 -> Ist geht minus: 69
23:21:27.114 -> Was ist soll: 60
23:21:27.611 -> Ist geht minus: 68
23:21:27.611 -> Was ist soll: 60
23:21:28.108 -> Ist geht minus: 67
23:21:28.108 -> Was ist soll: 60
23:21:28.605 -> Ist geht minus: 66
23:21:28.605 -> Was ist soll: 60
23:21:29.102 -> Ist geht minus: 65
23:21:29.102 -> Was ist soll: 60
23:21:29.600 -> Ist geht minus: 64
23:21:29.600 -> Was ist soll: 60
23:21:30.097 -> Ist geht minus: 63
23:21:30.097 -> Was ist soll: 60
23:21:30.627 -> Ist geht minus: 62
23:21:30.627 -> Was ist soll: 60
23:21:31.124 -> Ist geht minus: 61
23:21:31.124 -> Was ist soll: 60
23:21:31.622 -> Ist geht minus: 60
23:21:31.622 -> Was ist soll: 60

und zurĂŒck lĂ€ufts gerade:

23:23:19.112 -> Was ist soll: 0
23:23:19.609 -> Ist geht minus: 11
23:23:19.609 -> Was ist soll: 0
23:23:20.106 -> Ist geht minus: 10
23:23:20.106 -> Was ist soll: 0
23:23:20.603 -> Ist geht minus: 9
23:23:20.603 -> Was ist soll: 0
23:23:21.134 -> Ist geht minus: 8
23:23:21.134 -> Was ist soll: 0
23:23:21.631 -> Ist geht minus: 7
23:23:21.631 -> Was ist soll: 0
23:23:22.128 -> Ist geht minus: 6
23:23:22.128 -> Was ist soll: 0
23:23:22.625 -> Ist geht minus: 5
23:23:22.625 -> Was ist soll: 0
23:23:23.122 -> Ist geht minus: 4
23:23:23.122 -> Was ist soll: 0
23:23:23.619 -> Ist geht minus: 3
23:23:23.619 -> Was ist soll: 0
23:23:24.116 -> Ist geht minus: 2
23:23:24.116 -> Was ist soll: 0
23:23:24.613 -> Ist geht minus: 1
23:23:24.613 -> Was ist soll: 0
23:23:25.143 -> Ist geht minus: 0
23:23:25.143 -> Was ist soll: 0

Na herzlichen GlĂŒckwunsch.
Hast ein gutes TEAM.
forum.arduino.cc/t/optimierung-fuer-eine-blinkwithoutdelay-variante-gesucht-ein-servo-mit-4-funtionen-schalten/909922/12

Nein.
Ich ignoriere da die Übergabe - ich habs vorhin mit 500ms gebaut. - das Ding lĂ€uft super durch. - Ohne Servo. Nur mit dem SerMon und der Logik.

Nach 10 Minuten einfach mal umgeschalten:

23:23:24.613 -> Ist geht minus: 1
23:23:24.613 -> Was ist soll: 0
23:23:25.143 -> Ist geht minus: 0
23:23:25.143 -> Was ist soll: 0
23:32:04.202 -> Ist geht plus: 1
23:32:04.202 -> Was ist soll: 60
23:32:04.699 -> Ist geht plus: 2
23:32:04.699 -> Was ist soll: 60
23:32:05.197 -> Ist geht plus: 3
23:32:05.197 -> Was ist soll: 60
23:32:05.694 -> Ist geht plus: 4
23:32:05.694 -> Was ist soll: 60
23:32:06.224 -> Ist geht plus: 5
23:32:06.224 -> Was ist soll: 60
23:32:06.721 -> Ist geht plus: 6
23:32:06.721 -> Was ist soll: 60
23:32:07.219 -> Ist geht plus: 7
23:32:07.219 -> Was ist soll: 60
23:32:07.716 -> Ist geht plus: 8
23:32:07.716 -> Was ist soll: 60
23:32:08.213 -> Ist geht plus: 9
23:32:08.213 -> Was ist soll: 60
23:32:08.710 -> Ist geht plus: 10
23:32:08.710 -> Was ist soll: 60
23:32:09.207 -> Ist geht plus: 11
23:32:09.207 -> Was ist soll: 60
23:32:09.704 -> Ist geht plus: 12
23:32:09.737 -> Was ist soll: 60
23:32:10.234 -> Ist geht plus: 13
23:32:10.234 -> Was ist soll: 60
23:32:10.732 -> Ist geht plus: 14
23:32:10.732 -> Was ist soll: 60
23:32:11.229 -> Ist geht plus: 15
23:32:11.229 -> Was ist soll: 60
23:32:11.726 -> Ist geht plus: 16
23:32:11.726 -> Was ist soll: 60
23:32:12.223 -> Ist geht plus: 17
23:32:12.223 -> Was ist soll: 60
23:32:12.720 -> Ist geht plus: 18
23:32:12.720 -> Was ist soll: 60
23:32:13.217 -> Ist geht plus: 19
23:32:13.217 -> Was ist soll: 60
23:32:13.747 -> Ist geht plus: 20
23:32:13.747 -> Was ist soll: 60
23:32:14.244 -> Ist geht plus: 21
23:32:14.244 -> Was ist soll: 60
23:32:14.741 -> Ist geht plus: 22
23:32:14.741 -> Was ist soll: 60
23:32:15.238 -> Ist geht plus: 23
23:32:15.238 -> Was ist soll: 60
23:32:15.735 -> Ist geht plus: 24
23:32:15.735 -> Was ist soll: 60
23:32:16.232 -> Ist geht plus: 25
23:32:16.232 -> Was ist soll: 60
23:32:16.729 -> Ist geht plus: 26
23:32:16.729 -> Was ist soll: 60
23:32:17.226 -> Ist geht plus: 27
23:32:17.259 -> Was ist soll: 60
23:32:17.756 -> Ist geht plus: 28
23:32:17.756 -> Was ist soll: 60
23:32:18.253 -> Ist geht plus: 29
23:32:18.253 -> Was ist soll: 60
23:32:18.751 -> Ist geht plus: 30
23:32:18.751 -> Was ist soll: 60
23:32:19.248 -> Ist geht plus: 31
23:32:19.248 -> Was ist soll: 60
23:32:19.745 -> Ist geht plus: 32
23:32:19.745 -> Was ist soll: 60
23:32:20.242 -> Ist geht plus: 33
23:32:20.242 -> Was ist soll: 60
23:32:20.739 -> Ist geht plus: 34
23:32:20.739 -> Was ist soll: 60
23:32:21.236 -> Ist geht plus: 35
23:32:21.269 -> Was ist soll: 60
23:32:21.766 -> Ist geht plus: 36
23:32:21.766 -> Was ist soll: 60
23:32:22.263 -> Ist geht plus: 37
23:32:22.263 -> Was ist soll: 60
23:32:22.760 -> Ist geht plus: 38
23:32:22.760 -> Was ist soll: 60
23:32:23.258 -> Ist geht plus: 39
23:32:23.258 -> Was ist soll: 60
23:32:23.755 -> Ist geht plus: 40
23:32:23.755 -> Was ist soll: 60
23:32:24.252 -> Ist geht plus: 41
23:32:24.252 -> Was ist soll: 60
23:32:24.749 -> Ist geht plus: 42
23:32:24.749 -> Was ist soll: 60
23:32:25.279 -> Ist geht plus: 43
23:32:25.279 -> Was ist soll: 60
23:32:25.776 -> Ist geht plus: 44
23:32:25.776 -> Was ist soll: 60
23:32:26.276 -> Ist geht plus: 45
23:32:26.276 -> Was ist soll: 60
23:32:26.773 -> Ist geht plus: 46
23:32:26.773 -> Was ist soll: 60
23:32:27.270 -> Ist geht plus: 47
23:32:27.270 -> Was ist soll: 60
23:32:27.767 -> Ist geht plus: 48
23:32:27.767 -> Was ist soll: 60
23:32:28.265 -> Ist geht plus: 49
23:32:28.265 -> Was ist soll: 60
23:32:28.762 -> Ist geht plus: 50
23:32:28.762 -> Was ist soll: 60
23:32:29.259 -> Ist geht plus: 51
23:32:29.259 -> Was ist soll: 60
23:32:29.790 -> Ist geht plus: 52
23:32:29.790 -> Was ist soll: 60
23:32:30.287 -> Ist geht plus: 53
23:32:30.287 -> Was ist soll: 60
23:32:30.784 -> Ist geht plus: 54
23:32:30.784 -> Was ist soll: 60
23:32:31.281 -> Ist geht plus: 55
23:32:31.281 -> Was ist soll: 60
23:32:31.778 -> Ist geht plus: 56
23:32:31.778 -> Was ist soll: 60
23:32:32.275 -> Ist geht plus: 57
23:32:32.275 -> Was ist soll: 60
23:32:32.772 -> Ist geht plus: 58
23:32:32.772 -> Was ist soll: 60
23:32:33.302 -> Ist geht plus: 59
23:32:33.302 -> Was ist soll: 60
23:32:33.800 -> Ist geht plus: 60
23:32:33.800 -> Was ist soll: 60

Alles schick.
Und nu erklÀre endlich, was Du da bauen willst.

Der Servo macht noch immer keinen Mucks, umschalten im Monitor geht wie gedacht.

Zwei Fenster, ein grosses das Kippen soll. Das soll von zwei (angeblichen) 60Kilo Servos gemacht werden. Mit ein paar 3 Druck Teilen sollte das kein Problem sein, dazu gibt es noch einen Fensterrahmen Ventilator, der steckt im kleinen Fenster. Also, beide Fenster ueber Funk auf, der Ventilator blaesst frische Luft rein. Dafuer die Schalter 1 und 2, sprich Auf und Zu. Und die Schalter 3 und 4, Fenster Auf fuer 30 Minuten oder Fenster Auf fuer 30 Minuten, dann Zu, dann wieder nach 4 Stunden Auf fuer 30 Minuten.

Lueften waehrend man Schlaeft, das ist so mein Plan.

Dann ist Dein Aufbau Murks.
Ich mach hier dann Schluß.
Letztendlich geht es softwareseitig.

Na dann gute Nacht, schaetze ich krieg das noch.

Ach ja und Danke.

Den Vergleich machst du mit previousMillis. Aber previousMillis_b setzt du gleich currentMillis. Damit ist der Vergleich dann immer wahr, solange soll kleiner ist.

Kann da der Fehler liegen.

(Bezieht sich auf den Startpost)

:wink:
Da sind wir schon drĂŒber.
Mittlerweile geht das ja laut SerMon - der Servo bewegt sich blos nicht (nach Aussage...) - allerdings ist das ganze so krude, das ich da nicht mehr weiter helfen kann, wenn ich nicht sehe, was da tatsÀchlich passiert.
Vielleicht ist der Servo auch einfach nicht an dem PIN angetackert.. - keine Ahnung.

Oder dem Servo fehlt die benötigte Betriebsspannung fĂŒr den Motor. So starke Servos benötigen manchmal fĂŒr den Motor eine separate Betriebsspannung, die höher liegen muss , als die Versorgunsspannung fĂŒr die Elektronik. aber um da wirklich helfen zu können, mĂŒssten wir wissen, was das genau fĂŒr ein Servo ist. sprich Link zum Servo oder noch besser Datenblatt vom Servo.

Der Servo hat eine externe Versorgung.