outdoor I

[Rabenauge]

Echtes Multitasking funktioniert mit nem Single-Core nicht.
Meine Lösung dürfte aber ein ziemlich guter Kompromiss sein, weil alles zeitkritische in separaten Tasks "am Stück" erledigt werden kann. Insofern lautet die halbe Antwort: ja.
Es ist egal, wie lange ein einzelner Task braucht.

Danach hat loop() wieder die Kontrolle-die läuft inzwischen _nicht_ weiter!
Die Schaltuhr aber schon....
timer() wird ja _nur_ in loop() aufgerufen, wenn also irgendein anderer Task läuft (und mal länger dauert) dann nicht.
Dadurch ist es auch möglich, dass mal Ereignisse überhaupt nicht ausgeführt werden (weil die Schaltuhr schon drüber gerasselt ist in der Zwischenzeit).

Aber bei vielem ist das egal: ein Akku stirbt nicht, wenn er mal erst nach 40 Sekunden abgefragt wird, statt alle 20.
PWM läuft auch, wenn sie einmal gestartet ist, weiter (das ist schon sowas wie Multitasking), also geht das meistens so schon.

[inka]

Echtes Multitasking funktioniert mit nem Single-Core nicht. Meine Lösung dürfte aber ein ziemlich guter Kompromiss sein, weil alles zeitkritische in separaten Tasks "am Stück" erledigt werden kann. Insofern lautet die halbe Antwort: ja.
Es ist egal, wie lange ein einzelner Task braucht.

bei der umstellung vom FB betrieb auf selbständiges fahren gibts probleme. Und zwar fährt der roboter "abschnittsweise", also stotternd. Der verursacher sind die aufrufe für die entfernungsmessung, ohne die pingabfragen fährt der ganz ok... Die frequenz des "stotterns" ist abhängig von der grösse des ping-intervalls...
---------------------------------------------------------------
@rabenauge: Kann ich solche programmabschnitte mit dem "timer-system" kombinieren, oder muss ich völlig umdenken? Es müsste z.b. noch die bewegung des Servos dazukommen..., da geht ja richtung kontinuierliche bewegung wahrscheinlich garnix...
Wie fragst Du die US module ab? nach der lib, oder anders?
---------------------------------------------------------------
das hier ist der haupt-fahrt-code welches aus der loop() aufgerufen wird:

void alle_motoren_vorwaerts_hindernis(void)
{
  currentMillis = millis();
  dauer_fahrt = 200;
  if (currentMillis - previousMillis > dauer_fahrt)
  {
    if (start_ping_rechts || start_ping_links == true)
    {
      aktuelle_ping_millis = millis();
      if (aktuelle_ping_millis - vergangene_ping_millis > interval_ping)
      {
        vergangene_ping_millis = aktuelle_ping_millis;
        ping_distanz_rechts();
        ping_distanz_links();
      }
    }
    //servo_und_ping();

    if (hindernis_rechts == true)
    {
      ausweichen_hindernis_rechts();
      hindernis_rechts = false;
    }
    if (hindernis_links == true)
    {
      ausweichen_hindernis_links();
      hindernis_links = false;
    }
    else
    {
      hindernis_rechts = false;
      hindernis_links = false;
      Serial.println("alle motoren vorwaerts_hindernis");

      vorwaerts();
    }
  }
}

vor dem start frage ich noch die US-module ab, der roboter soll ja nicht nach vorne anfahren, wenn er vor einer wand steht, die abfrage ist "entprellt", damit es nicht mehrere ergebnisse gibt, es wird für rechts und links abgefragt:

void hindernis_vorh_rechts_entprellt(void)
{
  if (start_ping_rechts == false)


    aktuelle_ping_millis = millis();
    if (aktuelle_ping_millis - vergangene_ping_millis > interval_ping)
    {
      vergangene_ping_millis = aktuelle_ping_millis; 
      ping_distanz_rechts();
    }

    if (uS_rechts != NO_ECHO)
    {
      if (((uS_rechts / US_ROUNDTRIP_CM) <= 25) && mehrfach_zaehler_rechts == 0)
      {
        hindernis_rechts = true;
        mehrfach_zaehler_rechts = 1;
      }
      else if (((uS_rechts / US_ROUNDTRIP_CM) <= 25) && mehrfach_zaehler_rechts == 1)
      {
        mehrfach_zaehler_rechts = 0;
      }
    }
    else
    {
      if (((uS_rechts / US_ROUNDTRIP_CM) <= 25) && mehrfach_zaehler_rechts == 1)
      {
        hindernis_rechts = false;
        mehrfach_zaehler_rechts = 0;
      }
      else if (((uS_rechts / US_ROUNDTRIP_CM) <= 25) && mehrfach_zaehler_rechts == 0)
      {
        mehrfach_zaehler_rechts = 1;
      }
    }
}

die eigentliche entfernung wird hiermit gemessen, auch wieder für rechts und links ausgelegt:

void ping_distanz_rechts(void)
{
  uS_rechts = sonar_rechts.ping();

  Serial1.print("Ping: ");
  Serial1.print(uS_rechts / US_ROUNDTRIP_CM);
  Serial1.println(" cm");
  Serial.print("Ping: ");
  Serial.print(uS_rechts / US_ROUNDTRIP_CM);
  Serial.println(" cm");

  delay(100); // hinzugefügt am 30.1.17 wg. doppelausweichen
  start_ping_rechts = true;
}

die ganzen prints habe ich auch schon mal auskommentiert, es ändert nichts an meinem problem...

[Rabenauge]

Ich benutze keine Bibliothek für das bisschen Ultraschall- das kann man zu Fuss auch machen:

void pingVorne()// ******************** Vorn nach Hindernissen suchen **************************************
{
  delay(100);                            // ggf, alte Echos abklingen lassen, die halbe Zeit reicht auch
  digitalWrite(triggerVorne, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerVorne, HIGH);     //Trigger Impuls 10 µs
  delayMicroseconds(10);
  digitalWrite(triggerVorne, LOW);      //Messung starten
  long laufZeit = pulseIn(echoVorne, HIGH,maxEntfernung); // Echo-Zeit messen, aber nicht zu lange warten
  float messung=laufZeit/ 58.2;         //Laufzeit in cm umrechnen
  entfernungVorne = ((entfernungVorneAlt*0.2)+(messung*0.8)); // Ergebnis glätten
  if(entfernungVorne==0)                // das gibts nicht, also muss die Bahn frei sein
    {
      entfernungVorne=120;
    } 
  entfernungVorneAlt=entfernungVorne;
  Serial.print("Vorne: ");
  Serial.print(entfernungVorne);
  Serial.println(" cm");
}

Wie steuerst du deine Motoren an- mit PWM?
Die läuft nämlich weiter, auch wenn in der Zwischenzeit andere Dinge erledigt werden.
Wenn du an einen Pin PWM(soundso) schickst, läuft die dort so lange, bis was anderes gesagt wird...

Ebenso Servo-Impulse- du kannst einem Servo ne Soll-Position senden, und schon andere Dinge tun, bevor es die erreicht-das funktioniert.
Man muss aber aufpassen: die Servo-Bibliothek verträgt sich nich unbedingt mit jeder anderen- beispielsweise gibt es Probleme mit programmierbaren LED's..das hängt mit den Timern zusammen.

In meinem (unfertigen) Test-Unterprogramm läuft das so ab:
-es wird vorn und hinten "gepingt"
-anhand der zurückgelieferten Distanzen wird die mögliche Geschwindigkeit festgelegt (je näher Hindernis, desto langsamer), und dann wird der berechnete Wert für die Geschwindigkeit ans eigetliche Fahrprogramm übergeben, also ungefähr so:

SpeedVorgabe=255;
fahreGeradeaus(); // das ist das eigentliche Fahrprogramm

Das Fahrprogramm nutzt dann diese Speed-Vorgabe als "Sollwert"- regelt aber nach Bedarf da noch selber dran herum.
Anschliessend schickt es die berechneten PWM-Werte an den Motortreiber.
Da sich die PWM nicht ändert (bis sie, beim nächsten Aufruf des Fahrprogrammes ggf, geändert _wird), fährt der locker und flüssig vor sich hin...
Hier gehts von vorne los:
Hauptprogramm ruft
Test-Unterprogramm, das ruft
Ping-Unterprogramm, berechnet anhand dessen Antwort die Soll-Geschwindigkeit, und schickt die zum
Fahrprogramm
und so weiter.

Das Ganze läuft _nicht_ über die Timer-Funktion einige Beiträge weiter oben, aber der läuft trotzdem im Hintergrund (wird im Hauptprogramm bei jedem Zyklus aufgerufen), der löst dann Zusatzaufgaben aus wie ab und an den Akku-Füllstand überprüfen usw.

Du kannst das ausprobieren: schick mal eine PWM an irgendeinen geeigneten Pin (an den du _irgendwas_ hängst, was dir auch anzeigt, dass die PWM weiter läuft, es geht schon mit ner LED+Vorwiderstand), und lass den Rechner danach mit delay(1000) einfach warten.
Du wirst sehen: das delay() beeinflusst die PWM _nicht!
Genauso kannst du in der Zeit irgendwelche Sensoren abfragen oder so- das juckt die PWM nicht, die läuft und läuft...

[Moppi]

Ja, das mit PWM ist wohl die einzige Möglichkeit, einen sauberen Gleichlauf der Stepper hinzubekommen.

Ansonsten ist doch ein ESP32 vorhanden: https://www.elektormagazine.de/magaz...ktor-138/56969

Sind immer dieselben Probleme, unter Nutzung nur einer CPU.


Für die Steuerung des Fahrgestells kann auch ein Arduino NANO verwendet werden. Kommandos kann dem per serieller Schnittstelle schicken (oder andere, die frei sind). Ultraschall und andere Sachen können mit dem ESP32 oder dem MEGA parallel zum NANO abgearbeitet werden.



MfG

[inka]

hallo Rabenauge,
ich wollte mal ausprobieren ob Deine pingversion schneller ist als die mit der ping-lib...

Ich benutze keine Bibliothek für das bisschen Ultraschall- das kann man zu Fuss auch machen:

void pingVorne()// ******************** Vorn nach Hindernissen suchen **************************************
{
  delay(100);                            // ggf, alte Echos abklingen lassen, die halbe Zeit reicht auch
  digitalWrite(triggerVorne, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerVorne, HIGH);     //Trigger Impuls 10 µs
  delayMicroseconds(10);
  digitalWrite(triggerVorne, LOW);      //Messung starten
  long laufZeit = pulseIn(echoVorne, HIGH,maxEntfernung); // Echo-Zeit messen, aber nicht zu lange warten
  float messung=laufZeit/ 58.2;         //Laufzeit in cm umrechnen
  entfernungVorne = ((entfernungVorneAlt*0.2)+(messung*0.8)); // Ergebnis glätten
  if(entfernungVorne==0)                // das gibts nicht, also muss die Bahn frei sein
    {
      entfernungVorne=120;
    } 
  entfernungVorneAlt=entfernungVorne;
  Serial.print("Vorne: ");
  Serial.print(entfernungVorne);
  Serial.println(" cm");
}

habe es an meine hardwareverhältnisse angepasst, das sieht dann so aus:

#include "Arduino.h"


#define TRIGGER_PIN_RECHTS  2
#define ECHO_PIN_RECHTS   3
#define MAX_DISTANCE_RECHTS 200 //400

uint16_t distanz_rechts;
uint16_t distanz_rechts_alt;

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

}

void loop()
{
  ping_rechts();

}


void ping_rechts()// ******************** rechts nach hindernissen suchen **************************************
{
  delay(100);                            // ggf, alte Echos abklingen lassen, die halbe Zeit reicht auch
  digitalWrite(TRIGGER_PIN_RECHTS, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGER_PIN_RECHTS, HIGH);     //Trigger Impuls 10 µs
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN_RECHTS, LOW);      //Messung starten
  long lauf_zeit = pulseIn(ECHO_PIN_RECHTS, HIGH, MAX_DISTANCE_RECHTS); // Echo-Zeit messen, aber nicht zu lange warten
  float messung = lauf_zeit / 58.2;      //Laufzeit in cm umrechnen
  distanz_rechts = ((distanz_rechts_alt * 0.2) + (messung * 0.8)); // Ergebnis glätten
  if (distanz_rechts == 0)             // das gibts nicht, also muss die Bahn frei sein
  {
    distanz_rechts = 120;
  }
  distanz_rechts_alt = distanz_rechts;
  Serial.print("distanz rechts: ");
  Serial.print(distanz_rechts);
  Serial.println(" cm");
}

die printausgabe ist: 120 / 24 / 4 und das wiederholt sich....

[inka]

habe unter den beispielen in der ping-lib etwas durchaus interessantes gefunden. Ein beispiel für drei sensoren, macht einen recht einfachen eindruck:

#include <NewPing.h>

#define SONAR_NUM 3      // Number of sensors.
#define MAX_DISTANCE 200 // Maximum distance (in cm) to ping.

NewPing sonar[SONAR_NUM] = {   // Sensor object array.
  NewPing(2, 3, MAX_DISTANCE), // Each sensor's trigger pin, echo pin, and max distance to ping. 
  NewPing(4, 5, MAX_DISTANCE), 
  NewPing(8, 9, MAX_DISTANCE)
};

void setup() {
  Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
}

void loop() { 
  for (uint8_t i = 0; i < SONAR_NUM; i++) { // Loop through each sensor and display results.
    delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
    Serial.print(i);
    Serial.print(" = ");
    Serial.print(sonar[i].ping_cm());
    Serial.print(" cm ");
  }
  Serial.println();
}

[Rabenauge]

Hm- wenns funktioniert....ich hatte mal bei anderer Gelegenheit die NewPing probiert, war aber keineswegs von begeistert.
Aber ich weiss nicht mehr genau, was war....

Mein Code ist _nicht_ auf Speed optimert: du kannst z.B. das anfängliche delay noch deutlich runtersetzen (musst du mal rechnen, wie weit die Dinger maximal kommen können, dann kommst du mit der Schallgeschwindigkeit auf den Wert, den du evtl brauchst)- oder du lässt es ganz weg- im Freien wirst du eher keine solchen wilden Echos haben.
Die Ansteuerung muss so-laut Datenblatt.
Man könnte versuchen, den Triger auch kürzer anzusteuern- vielleicht klappts, vieleicht nicht.
Auch die maxDistance kann man an die konkreten Anforderungen anpassen, wenn man die verkürzt, spart man auch Zeit, da pulseIn() blockierend ist (das wartet einfach bis entweder das Timeout abgelaufen ist oder was rein kommt).

Den letzten Rest kann man bei der Umrechnung rausholen, indem man auf die Fliesskomma-Berechnung verzichtet, und das so umbaut, dass die nicht mehr nötig ist.

[Moppi]

Guten Morgen,

welche Abfragezeit wird denn benötigt, wie schnell wird das Ergebnis benötigt, wie sicher soll es sein? Danach sollte sich dann die Sensor-Auswahl richten. So einen US-Wandler kann man nur in bestimmten Intervallen abfragen, nicht unendlich schnell. Beim SRF05 habe ich eine Angabe von min. 50ms im Netz gefunden, als Zeit zwischen den einzelnen Messungen. An anderer Stelle ist die Rede von 65ms.


MfG

[Klebwax]

Echtes Multitasking funktioniert mit nem Single-Core nicht.

Das ist natürlich Unsinn. Das klassische Multitasking System UNIX wurde auf und für eine PDP8 bzw PDP11 geschrieben. Und das waren Single-Core CPUs. Linux wurde zuerst auf einem 386 gebaut, ebenfalls Single Core. Und das erste preemptive Windows, Windows NT, lief auch auf einem Single Core.

Ja, das mit PWM ist wohl die einzige Möglichkeit, einen sauberen Gleichlauf der Stepper hinzubekommen.

Sicher nicht. Du hast ja schon mal mit AccelStepper() rumgespielt. Die kann das. Ebenso wie alle 3D-Drucker oder Lasergravierer mit grbl. Aus der Doku zu AccelStepper:

You can have multiple simultaneous steppers, all moving at different speeds and accelerations, provided you call their run() functions at frequent enough intervals.

Die Arduino SW ist ja Open Source. Man kann also sowohl in die PWM Library als auch in AccelStepper reinschauen und sehen, wie das da gemacht wird.

Sind immer dieselben Probleme, unter Nutzung nur einer CPU.

Dazu benutzt man Interrupte. Dafür sind sie da. Oder man macht es kooperativ, wie AccelStepper es mit seiner run()-Funktion tut.

MfG Klebwax

[HaWe]

Dazu benutzt man Interrupte. Dafür sind sie da.
MfG Klebwax

oder man verwendet wie ich grundsätzlich Multithreading, per Due Scheduler, pthread oder std::thread samt mutexes und thread-prios.