-         
Seite 35 von 38 ErsteErste ... 253334353637 ... LetzteLetzte
Ergebnis 341 bis 350 von 375

Thema: outdoor I

  1. #341
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.758
    Blog-Einträge
    9
    Anzeige

    Das gibt es wohl öfters, bin auch schon mehrmals darüber gestolpert, wo User das in den 3D-Drucker-Foren schrieben. Ich selbst habe auch Filament auch noch nie so lange gelagert, dass es irgendwann in mehrere Teile zerbrochen wäre. Man kann ja dann kleinere Mengen kaufen. Umgewickelt habe ich aber auch noch nie, ich stelle einfach die großen Rollen neben den Drucker.

    MfG

  2. #342
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.706
    ich bin auch etwas weitergekommen, die SR04 Sensoren sind - beweglich - am rahmen angebracht, zu sehen hier ...
    gruß inka

  3. #343
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    51
    Beiträge
    1.604
    Sieht cool aus, wie der sich den Weg frei schielt...
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  4. #344
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.706
    hab es unüberlegter weise in ein bereits erledigtes thema gepostet, hier , wohin es eigentlich hingehört, noch einmal zusammengefasst...
    ----------------------------------------------------------------------------------------------------------------------------------------------------------------

    Zitat Zitat von Rabenauge Beitrag anzeigen
    Ich mach alles in Zeitscheiben: es läuft ein simpler Timer (nach dem Beispielprogramm BlinkWithoutDelay), der mir, beispielsweise, jede Sekunde einen Tick gibt. Diese Ticks werden gezählt, so lange, wie ich halt Aufgaben zu vergeben habe, und bei jeder Tick-Zahl wird eine Aufgabe erledigt.
    Danach wird der Tick-Zähler zurückgesetzt, und der ganze Zyklus geht von vorne los.
    Auf diese Weise schafft so ein kleiner Arduino erstaunlich viel.....es ist z.B. vollkommen unnötig, den Akku alle paar Millisekunden abzufragen, im XPlorer mache ich das nur alle 20 Sekunden, das genügt völlig, und ich hab 19 Sekunden, auf die ich andere Aufgaben verteilen kann.
    Diesen Timer kann man beliebig langsam (oder schnell, der könnte auch Zehntelsekunden oder hundertstel) ticken lassen, so kann man z.B. auch sicherstellen, dass US-Sensoren sich nie gegenseitig in die Quere kommen (Echos abklingen lassen) usw.
    Unglaublich einfach und unglaublich flexibel.
    Da steht natürlich in Wirklichkeit noch bisschen Kleinkram drin (man sollte sicherstellen, dass der Arduino beim "Lies Akkustand-Tick" nicht 152x den Akku ausliest, usw. aber das Prinzip ist ganz einfach.
    Hi Sly,
    ich lerne neue sachen (auch simple timer ) gerne aus der kombination von beschreibung und beispiel und der "blink without delay" code ist nun ein zu simples beispiel. Würde Dir das was ausmachen hier Deinen code öffentlich zu machen? Eine PM geht natürlich auch, aber vielleicht gibt's noch andere die lernen wollen?

    wäre super, dann könnte ich endlich meine loop für den outdoor fertigschreiben ohne ständig verzweifeln zu müssen...

    antwort zusammengebastelt:
    -----------------------------------------
    Aber gern doch.
    Hier mal ein paar Auszüge aus dem Code des XPlorer1, da wird das auch so gehandhabt.

    Zuerst bauen wir und nen Timner zusammen, der anhand von den millis() bei Bedarf "Ticks" erzeugt:



    Code:
    void timer()               //***************** mehrere Sekundenticks erzeugen **********************************
    {
    
    unsigned long aktuelleMillis = millis();
    
      if (aktuelleMillis - vergangeneMillis >= interval)  // Sekunde um
      {
        vergangeneMillis = aktuelleMillis;
         halbeTick ++;                                // 500ms sind um
       if(halbeTick>2)                                // hier ist eine volle Sekunde vorbei
       {
        halbeTick=1;                                  // wechselt alle halbe Sekunde
        sekundenTick++;                               // wechselt jede volle Sekunde
        gemachtFlag=0;                                //  Aufgabe-erledigt-Flag zurücksetzen
       }
       if(sekundenTick==5)                            // mehr brauchen wir nicht
       {
        sekundenTick=0;
       }
    
      }
    }


    Der hier erzeugt jede halbe Sekunde nen Tick, und zusätzlich zählt er die Sekunden jedesmal bis fünf hoch.
    Im Grunde ein umgeschriebenes "blink_without_delay"...
    Im Hauptprogramm muss dieser Timer natürlich auch "hin und wieder" aufgerufen werden (immer, wenn Zeit ist), das Stück Code ist tatsächlich das _komplette_ Hauptprogramm:

    Code:
     
    void loop() 
    {
     timer();
     manageLichter();
     sekundenAufgaben();                          // je nachdem, was der Timer grade hat...
     delay(2);                                           // Zeit lassen für Anfragen vom NodeMCU
    }

    Im Unterprogramm "sekundenAufgaben" wird nun aufgedröselt, je nachdem, welchen Wert der Timer gerade hat:



    Code:
    void sekundenAufgaben()
    {
      if((sekundenTick==0)&&(gemachtFlag==0))     //wenns nicht schon erledigt wurde...
      {
        messeAkku();
      }
    
      if((sekundenTick==1)&&(gemachtFlag==0))
        {
          berechneLichtstaerke();
          gemachtFlag=1;
        }
    }


    Die gewünschten Intervalle (in denen der Timer halt "tickt") stellt man dann einfach mit passenden Konstanten ein:

    Code:
              unsigned long vergangeneMillis = 0;  // hier der letzte Tick
    const long interval = 500;           // Intervall, 500 Millisekunden
    Die Variable "gemachtFlag" verhindert, dass die jeweilige Aufgabe innerhalb des einen Intervalls ...zigmal erledigt wird- nur wenn die auch 0 ist, wird die Aufgabe abgearbeitet, und nachdem sie erledigt wurde, wird das Flag auf 1 gesetzt.

    Im Code zum XP2 hab ich inzwischen fünf oder sechs solche Flags-der hat einiges mehr zu tun, hehe.
    Der zählt aber auch die Sekunden bis 20 hoch....das Beispiel ist in alle möglichen Richtungen anpassbar, man kann den Timer schneller oder langsamer ticken lassen, man kann ihn weiter oder weniger weit hochzählen lassen, ganz wie man es gerade braucht.
    Das ist natürlich keine Atomuhr- da der nur abgefragt wird, wenn keine anderen Aufgaben zu erledigen sind (hier z.B. kommt noch das manageLichter() dazwischen), geht er nicht supergenau, aber wen jucken Abweichungen von nen paar Millisekunden denn- meistens ist das Wurst.

    Falls du noch Fragen dazu hast- frag einfach.
    ---------------------------------------------------------------------

    mache ich, muss es mir erstmal genauer anschauen....
    gleich die erste frage:
    und das ist jetzt wirklich so, dass die in der loop aufgerufenen task's laufen, unabhängig davon, wie lange sie dauern, während die loop weiter abgearbeitet wird?
    gruß inka

  5. #345
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    51
    Beiträge
    1.604
    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.
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  6. #346
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.971
    Zitat Zitat von Rabenauge Beitrag anzeigen
    Echtes Multitasking funktioniert mit nem Single-Core nicht.
    Man muss zwischen Multitasking und Multithreading unterscheiden, oft wird das nicht scharf getrennt.
    Auf kleinen MCUs ist es Multithreading (time slice scheduling, round-robin), und hier stimmt das so nicht mit Single- vs. Multicores: der Due (M3 SAM) ist z.B. ein Singlecore, der mit der Scheduler Lib recht gutes kooperatives Multithreading kann, dieselbe Lib läuft auch z.B. mit einem M0/Zero (SAMD).
    Auch die neuen SAMD M4 (ebenfalls Singlecores) beherrschen laut Arduino Multithreading.
    Die Scheduler Lib wurde zwischenzeitlich auch für AVRs portiert, erfordert aber deutich mehr Justierungen für das Speichermanagement.
    Hier werden vom Thread Scheduler jedem Thread je eine eigene Zeitscheibe zugeteilt, und bei Wechsel zur nächsten alle Variablen und Register gesichert - ist er wieder dran, werden alle wieder zurückgelesen und dort weitergemacht, wo vorher aufgehört wurde.

    Doch auf Multicores läuft es deutlich besser, wie z.B. auf dem ESP32: der kann sogar preemptives Multithreading (ähnlich POSIX pthread und C++ std::thread), wobei jeder seiner beiden Cores genau so time-slice scheduling macht mit sehr vielen Parallel-Threads wie ein Singlecore - grundsätzlich nicht anders, aber hier können eben z.B. 20 Threads auf 2 "Schultern" verteilt werden.
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  7. #347
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.706
    Zitat Zitat von Rabenauge Beitrag anzeigen
    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:

    Code:
    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:

    Code:
    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:

    Code:
    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...
    gruß inka

  8. #348
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    51
    Beiträge
    1.604
    Ich benutze keine Bibliothek für das bisschen Ultraschall- das kann man zu Fuss auch machen:
    Code:
    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...
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  9. #349
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.758
    Blog-Einträge
    9
    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
    Geändert von Moppi (27.03.2020 um 13:28 Uhr)

  10. #350
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.706
    danke erstmal, das braucht ein bischen...

    ein "zwischen"problem:

    - der timer läuft, da werden die sekundenaufgaben aufgerufen, in denen die pingroutine:

    Code:
    if ((sekunden_tick == 1) && (gemacht_ping_links_flag == 0))
      {
        ping_distanz_links();
    
        Serial.print("Ping: ");
        Serial.print(uS_links / US_ROUNDTRIP_CM);
        Serial.println(" cm");
      }
    gestartet wird.

    in der pingroutine

    Code:
    void ping_distanz_links(void)
    {
      uS_links = sonar_links.ping();
    
      gemacht_ping_links_flag = 1;
      start_ping_links = true;
    }
    wird aber das pingergebnis trotz des ping-flags auf 1 "100mal" ausgedruckt. Wieso? Wo muss die flagänderung denn hin? In der loop wird sie ja zuerst auf "0" gesetzt, dann in den sekundenaufgaben abgefragt und letztendlich in der pingroutine wieder auf 1 gesetzt...
    gruß inka

Seite 35 von 38 ErsteErste ... 253334353637 ... LetzteLetzte

Ähnliche Themen

  1. Abstandsmessung Outdoor bis 3m
    Von robo218 im Forum Sensoren / Sensorik
    Antworten: 4
    Letzter Beitrag: 14.12.2017, 06:56
  2. outdoor spy robot
    Von jancrombach im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 7
    Letzter Beitrag: 14.08.2010, 13:09
  3. Outdoor Roboter
    Von OsramLED im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 3
    Letzter Beitrag: 07.08.2006, 09:34
  4. Outdoor-Robo
    Von RobotrixerP im Forum Mechanik
    Antworten: 3
    Letzter Beitrag: 16.04.2006, 18:38
  5. [ERLEDIGT] Outdoor - Navigation
    Von Quaio im Forum Sensoren / Sensorik
    Antworten: 37
    Letzter Beitrag: 21.04.2005, 12:31

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •