-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 16

Thema: Balancieren auf 1 Rad / Entfleuchen auf 2 Rädern

  1. #1
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.12.2006
    Ort
    Eberbach
    Beiträge
    199

    Balancieren auf 1 Rad / Entfleuchen auf 2 Rädern

    Anzeige

    Beim Durchsuchen meiner Videos vom Asuro fand ich zwei interessante wieder.

    Ich hatte damals einiges über balancierende Roboter/Asuro's gelesen und wollte auch meinem Asuro das Balancieren beibringen. Damit das nicht ein reines Nachmachen war, versuchte ich, ein Rad fixiert zu lassen (mittels BREAK), und somit mit nur einem Rad zu balancieren.

    Das etwas schummerige Licht war notwendig, da der Außenlichtschutz um die IR-FortLED und die Fototransistoren bei einer solchen Neigung des Asuro natürlich unwirksam war. Die Rolle mit Süßstofftabletten ließ sich mit Isolierband gut als Kontergewicht verwenden.

    Hier nun das Video:
    (Video 3gp mpeg)

    Am verblüffendsten fand ich, wie einfach das Programm war, welches dieses Balancieren ermöglichte:
    Code:
    #include <asuro.h>
    
    #define SPEED 0xdF
    
    #define THRESHOLD 231 
    
    int main(void)
    {
      unsigned int sum,data[2];
    
      Init();
    
      FrontLED(ON);   
    
      MotorSpeed(SPEED,SPEED);
      MotorDir(BREAK,BREAK); 
      
      for(;;) {
        LineData(data);
    
        sum=data[LEFT]+data[RIGHT];
    
        if (sum<THRESHOLD)  MotorDir(RWD,BREAK); 
        else  MotorDir(FWD,BREAK); 
      }
    
      while (1);
    
      return 0;
    }
    Ein paar Tage zuvor klappte das mit dem Balncieren noch nicht so ganz. Aber einmal war der Asuro fast dran, entschied sich aber, auf 2 Rädern zu entfleuchen! Wie gut, daß ich ihn gerade noch vor der Tischkante erwischt habe ...
    (Video 3gp mpeg)

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    Hallo Hermann,

    sehr erstaunlich, was man erreichen kann, wenn man unvoreingenommen an eine Sache herangeht. Nicht schlecht !

    Das "entfleuchen"-Video geht bei mir aber leider nicht.

    Gruss,
    stochri

  3. #3
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    16.05.2005
    Beiträge
    734
    Gratuliere Hermann!

    Ich habe bei meinen Versuchen auch so angefangen. War auch erstaunt, dass es mit einem 2 Punkt-Regler schon geht.

    Gruß Waste

  4. #4
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.12.2006
    Ort
    Eberbach
    Beiträge
    199
    Hallo,
    Zitat Zitat von stochri
    Hallo Hermann,

    sehr erstaunlich, was man erreichen kann, wenn man unvoreingenommen an eine Sache herangeht. Nicht schlecht !

    Das "entfleuchen"-Video geht bei mir aber leider nicht.

    Gruss,
    stochri
    ging denn das 1. Video?
    Ich habe beide 3gp-Videos von meinem Fotohandy mittels des Mobile Media Converter 1.2.0 ins mpeg-Format wandeln lassen.

    Da ich das Video aber echt gut finde, habe ich es eben als animated-gif gespeichert, jetzt aber mit 388Kb ohne Ton (gegenüber 61Kb mit Ton für 3gp):
    http://www.stamm-wilbrandt.de/videos...00611_anim.gif
    (Endlosschleife: 8s Video, 1s Pause, nachdem Alles geladen ist)

    [Wie? 3gp-Video in Quicktime Player 7.1.5 mittels Pfeil-Rechts-Taste einzelbildweise abspielen, jedes Bild mittels CTRL-C kopieren, in Irfanview 3.85 mit STRG-V und S als .gif speichern, und die einzelnen gif's mittels gifsicle zu einem animated gif zusammensetzen ... ]


    Angeregt durch dieses nette Entfleuchen habe ich nun aber noch eine große Frage!
    Könnt Ihr Euch vorstellen, daß der Asuro auf 2 Rädern eine Kontour umfahren kann?

    Genauer: Im Bild links oben ist eine schwarz ausgefüllte Kontour dargestellt. Der Asuro soll diese am Rand auf zwei Rädern umfahren. Da innen alles schwarz ist, braucht man für die Randverfolgung nur einen Fototransistor -- dies sei hier der rechte. Der linke schaut immer brav (evtl. mit Schrumpfschlauchfokussierung) in die innere schwarze Fläche. Mittels seiner Helligkeitswerte kann der Asuro balancieren (siehe schematisch rechts unter im Bild, Ausschnitt der zu umfahrenden Kontour und Teil des Asuro mit dargestellten Fototransistoren und FortLED). Nun soll das Balancieren durch eine forcierte leichte "Vorlage" in eine leichte Vorwärtsbewegung gewandelt werden. Der rechte Fototransistor soll für eine Rechts-/Links-Steuerung der Räder beim (langsamen) Vorwärtsfahren sorgen ...


    Ich bin erst dabei, darüber Nachzudenken, habe noch nichts programmiert, und bin dankbar für Kommentare!

  5. #5
    Benutzer Stammmitglied
    Registriert seit
    01.02.2007
    Ort
    Ashausen
    Alter
    59
    Beiträge
    64
    Hi Hermann,

    Du hast mir mit diesem Thread einen angenehmen Abend beschert Es hat mir natürlich keine Ruhe gelassen, dass es mit einem so einfachen Programm möglich sein sollte, auf zwei Rädern zu fahren. Also haben ich meinem ASURO 4 AA Accus auf das Batteriepaket geschnallt und ein wenig an den Parametern in Deinem Programm gespielt.

    Meine Linienfolgeeinheit ist mit einer superhelle LED bestückt und ich habe den Versuch auf weißer Presspappe unter schwacher Taschenlampenbeleuchtung durchgeführt.

    Und - JA, es hat funktioniert!!!! Meine Parameter waren:

    #define SPEED 240
    #define THRESHOLD 53

    Na - jedenfalls hat es mir super Spaß gemacht, auch wenn ich das wohl in ein paar Stunden bereuen werde, wenn ich mich am Schreibtisch zu irgendwas motivieren soll...

    Danke also für Deine Anregung. Als nächstes werde ich mich dann wohl mal mit Regelungstechnik beschäftigen müssen. Frage an Waste: Welches Buch (welche Bücher) kannst Du dafür empfehlen? Ich habe mir schon mal "Einführung in die Regelungstechnik" von Mann/Schiffelgen/Froriep besorgt. War das eine gute Entscheidung?

    Na wie auch immer - ich muss jetzt ins Bett - kann aber jedem das Experiment nur empfehlen...

    Gruß,

    _HP_

  6. #6
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    16.05.2005
    Beiträge
    734
    Zitat Zitat von HermannSW
    Angeregt durch dieses nette Entfleuchen habe ich nun aber noch eine große Frage!
    Könnt Ihr Euch vorstellen, daß der Asuro auf 2 Rädern eine Kontour umfahren kann?
    Ja, das kann ich mir vorstellen.
    Probier mal mit dem rechten Sensor zu balancieren und dem linken Rad eine geringe Geschwindigkeit vorgeben! Dann sollte er eigentlich automatisch der Kontur folgen. Die Schwelle sollte so eingestellt sein, dass der rechte Sensor auf die Mitte der schwarz/weiß Grenze balanciert.

    @_HP_
    Ich selbst habe keine Bücher zur Regelungstechnik, kann dir deshalb auch kein bestimmtes empfehlen. Wenn ich was nachschauen muss, reicht mir das Internet.

    Waste

  7. #7
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.12.2006
    Ort
    Eberbach
    Beiträge
    199
    Hi,
    Zitat Zitat von waste
    Zitat Zitat von HermannSW
    Angeregt durch dieses nette Entfleuchen habe ich nun aber noch eine große Frage!
    Könnt Ihr Euch vorstellen, daß der Asuro auf 2 Rädern eine Kontour umfahren kann?
    Ja, das kann ich mir vorstellen.
    diese Bemerkung hat mich zu ersten Spielereien bzgl. Vorwärtsneigung verleitet ...



    Erstes Video flott (30s, 3gp / mpeg) .
    Zweites Video langsam, aber dafür vor/zurück/vor tänzelnd ... (30s, 3gp / mpeg).


    Vielleicht könnte es ja später mal die Befehle
    • void Go2W ( int distance, int speed)
    • void Turn2W (int degree, int speed)
    als Varianten der Befehle Go() und Turn() in der Asuro-Lib geben (xxx2W = "on 2 wheels") ...


    Falls Ihr jetzt Lust zum Probieren bekommen habt, dann:
    • Einfach ein Kontergewicht hinten aufschnallen (letztes Mal war es eine Süßstofftablettenrolle, diesmal war es ein zusätzlicher 2x2xAA-Batteriepack), sodaß der Asuro einen brauchbaren (?) Gleichgewichtspunkt hat.
    • Dann ein Programm flashen, welches die Fotosensorwerte ausgibt, z.B. dieses:
      Code:
      #include <asuro.h>
      
      int main(void)
      {
        unsigned int data[2];
      
        Init();
      
        FrontLED(ON);
      
        for(;;) {
          LineData(data);
      
          PrintInt(data[LEFT]);
          SerPrint(",");
          PrintInt(data[RIGHT]);
          SerPrint(" / ");
          PrintInt(data[LEFT]-data[RIGHT]);
          SerPrint(",");
          PrintInt(data[LEFT]+data[RIGHT]);
          SerPrint("\r\n");
      
          Msleep(500);
        }
      
        while (1); // unreachable code
      
        return 0;
      }
    • Nun den Asuro im Gleichgewichtszustand halten und die Werte hierfür im Terminalprogramm ablesen.
    • Dann mit diesen Werten im Zweipunktregler weiter oben im Thread experimentieren!
    Viel Spaß!

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    Hallo Herrann,

    wie man aus Deinem Video schön sieht, hat die Einrad-Balance gegenüber der 2Rad-Balance sogar Vorteile: Der Roboter fährt nicht so einfach vom Tisch, wenn er versucht das Gewicht nach vorne Auszubalancieren. Das war bei meinen Experimenten immer das Problem.

    Gruss,
    stochri

  9. #9
    Benutzer Stammmitglied
    Registriert seit
    01.02.2007
    Ort
    Ashausen
    Alter
    59
    Beiträge
    64
    Hi,

    ich habe das Programm von Hermann mal als Vorlage genommen und es etwas "verkompliziert".

    Inhaltlich bleibt es bei dem Zweipunktregler. Allderdings versuche ich den Einfluß des Umgebungslichtes zu unterdrücken (ich meine die Idee dazu mal bei waste gefunden zu haben). Bei meinen Messungen (mit einer superhellen LED am Liniensensor) war es allerdings nötig, eine Wartezeit zwischen den Messungen mit aus- bzw. eingeschalteter LED einzuschieben, da die LED zu träge ist. Das mag mit anderen LEDs anders sein.

    Weiterhin habe ich die Taster dazu verwendet, um "on the fly" die Parameter für Geschwindigkeit und Hell/Dunkelschwelle zu ändern. Dies geht mit schrittweisem Erhöhen oder erniedrigen oder direktem Eingeben über ein Terminalprogramm oder - im Falle der Hell/Dunkelschwelle - auch über das Messen des Wertes, wenn man den Roboter in der austarierten Stellung hält.

    Die Funktionen UartGetc() und ReadInt() schlage ich vor als Erweiterung in die nächste Lib-Version aufzunehmen. Natürlich fehlt dann auch noch ein ReadLong(), dass aber analog zu ReadInt() zu programmieren wäre. Damit hätten die entsprechenden Print-Funktionen dann auch ihr Gegenstück.

    Schaut Euch das mal an, experimentiert damit und sagt eure Meinung...

    Gruß,

    _HP_

    EDIT: Der code wurde leicht verändert.

    Code:
    /****************************************************************************/
    /*!
      \file test.c
    
      \brief
      Programm zum Balancieren von ASURO auf den Hinterrädern.
      
      \par Hinweis:
      Die Regelung erfolgt mittels Zweipunktregler. Bitte auch die Infos zur\n
      Funktion main() beachten.
    
      \author   _HP_
    
      \version  beta - 04.04.2007 - _HP_\n
                first implementation
                
      \version  beta - 05.04.2007 - _HP_\n
                bugfixing in ReadInt und kleine Änderungen im Hauptprogramm
    *****************************************************************************/
    /*****************************************************************************
    *                                                                            *
    *   This program is free software; you can redistribute it and/or modify     *
    *   it under the terms of the GNU General Public License as published by     *
    *   the Free Software Foundation; either version 2 of the License, or        *
    *   any later version.                                                       *
    *                                                                            *
    *****************************************************************************/
    #include <asuro.h>
    #include <stdlib.h> 
    
    #define INI_SPEED     240
    #define INI_THRESHOLD  53
    
    // Tastenwert bitorientiert, K1 = Bit5, K2 = Bit4, K3 = Bit3, K4 = Bit2,
    // K5 = Bit1, K6 = Bit0
    #define K1        (1 << 5) // Schalter an der linken Seite neben der IR-Diode
    #define K2        (1 << 4)
    #define K3        (1 << 3)
    #define K4        (1 << 2)
    #define K5        (1 << 1)
    #define K6        (1 << 0)
    
    
    /****************************************************************************/
    /*                                                                          */
    /* Funktion: UartGetc()                                                     */
    /*                                                                          */
    /*!
      \brief
      Einlesen eines Zeichens von der serielle Schnittstelle. Die Funktion wartet\n
      solange, bis ein Zeichen gelesen wurde!
    
      \param
      keine
    
      \return
      gelesenes Zeichen
    
      \author   _HP_
    
      \version  beta - 04.04.2007 - _HP_\n
                first implementation
    
      \par  Beispiel:
      (Nur zur Demonstration der Parameter/Returnwerte)
      \code
      char c;
      c = UartGetc();
      \endcode
    *****************************************************************************/
    char UartGetc(void)
    {
      unsigned char data = 0x00;                // gelesenen Zeichen 
      
      UCSRB = 0x10;                             // Empfaenger einschalten
      while (data == 0x00)
      {
        if (UCSRA & 0x80) data = UDR;
      }
      return data;
    }
    
    
    /****************************************************************************/
    /*                                                                          */
    /* Funktion: ReadInt()                                                      */
    /*                                                                          */
    /*!
      \brief
      Einlesen einer Zahl im Integerbereich (+/- 32767) von der serielle /n
      Schnittstelle./n
      
      Die Funktion wartet bis entweder 6 erlaubte Zeichen (Ziffern und an erster\n
      Stelle ein Vorzeichen) eingegeben, oder ein Zeichen im Bereich 0x00 - 0x1F\n
      gelesen wurden!
    
      \param
      keine
    
      \return
      Integerwert der eingegebenen Zeichen
    
      \author   _HP_
    
      \version  beta - 04.04.2007 - _HP_\n
                first implementation
                
      \version  beta - 05.04.2007 - _HP_\n
                numbers[] um ein byte vergrößert, um immer ein NULL-Zeichen\n
                am Ende zu haben          
    
      \par  Beispiel:
      (Nur zur Demonstration der Parameter/Returnwerte)
      \code
      int z;
      z = ReadInt();
      \endcode
    *****************************************************************************/
    int ReadInt(void)
    {
      unsigned char c;                          // gelesenes Zeichen
      unsigned char i = 0;                      // Index in numbers
      char          numbers[7] = {0x00};        // Vorzeichen und 5 Ziffern + abschließendes /0
        
      while (i < 6)                             // Es können maximal 5 Ziffern und ein Vorzeichen gelesen werden
      {
        c = UartGetc();
        if ((c > 0x2F) && (c < 0x3A))
        {
          numbers[i++] = c;
        }
    
        if ((i == 0) && ((c == 0x2B) || (c == 0x2D)))  // Vorzeichen an erste Position zulassen
        {
          numbers[i++] = c;
        }
        
        if (c < 0x20)                          // Beenden bei Eingabe eines nichtdruckbaren Zeichens
        {
          i = 10;
        }
      }
      
      return atoi(numbers);  
    }
    
    
    /****************************************************************************/
    /*                                                                          */
    /* Funktion: ReadSensor()                                                   */
    /*                                                                          */
    /*!
      \brief
      Das Licht an den Liniensensoren wird gemessen und die Summe von beiden\n 
      Sensoren wird zurückgegeben.
      
      Die Funktion minimiert den Einfluß des Umgebungslichtes, indem eine Messung\n
      zunächst bei ausgeschaltetem Umgebungslicht durchgeführt wird. Das Ergebnis\n
      dieser Messung wird von der Messung mit eingeschalteter LED abgezogen.\n
      Da die LED eine gewisse Trägheit besitzt, wird nach dem Ein- bzw. Ausschalten\n
      eine kurze Zeit gewartet, bis die Messung erfolgt. Diese Zeit muss evtl. auf\n
      den eigenen ASURO abgestimmt werden.
    
      \param
      keine
    
      \return
      Summe beider Fototransistoren, bereinigt um den Wert des Umgebungslichtes.
    
      \author   _HP_
    
      \version  beta - 04.04.2007 - _HP_\n
                first implementation
    
      \par  Beispiel:
      (Nur zur Demonstration der Parameter/Returnwerte)
      \code
      int Licht;
      Licht = ReadSensor();
      \endcode
    *****************************************************************************/
    int ReadSensor(void)
    {
      unsigned int  FotoTrans[2];               // gemessene Werte der Fototransistoren (FotoTrans[0] ist links)
      int           LightEnv;                   // Summe des gemessen Umgebungslichtes beider Fototransistoren
      unsigned char Delay = 10;                 // Wartezeit in 1/36 ms bis die FrontLED reagiert hat.
     
      FrontLED(OFF);
      Sleep(Delay);
      LineData(FotoTrans);
      LightEnv = FotoTrans[0] + FotoTrans[1];
      FrontLED(ON);
      Sleep(Delay);
      LineData(FotoTrans);
      
      return FotoTrans[0] + FotoTrans[1] - LightEnv;
    }
    
    /****************************************************************************/
    /*                                                                          */
    /* Funktion: main()                                                         */
    /*                                                                          */
    /*!
      \brief
      Programm zum Balancieren des ASURO auf den Hinterrädern.\n
      
      Die Grundidee ist von HermannSW beschrieben im Thread\n
      http://www.roboternetz.de/phpBB2/viewtopic.php?t=29269 .\n
      Es ist notwendig, den ASURO hinten so zu beschweren, dass sich die Nase\n
      nicht zu weit über dem Boden befindet, wenn er sich im Gleichgewicht\n
      befindet.
      
      Mit den Tastern kann man die Parameter für die Helligkeit im \n
      Gleichgewichtszustand und die Geschwindigkeit des linken Motors im\n
      laufenden Betrieb wie folgt ändern:\n
      
      Taster linke Seite ändert die Helligkeitsschwelle der Sensoren im\n
      Gleichgewichtszustand... \n
      K1 gedrückt       : Threshold++; \n
      K2 gedrückt       : Threshold--; \n
      K3 gedrückt       : Threshold über Terminalprogramm vorgeben \n
      K1 und K2 gedrückt: Threshold aktuellen Wert der Sensoren übernehmen \n
          
      Taster rechte Seite ändert die Geschwindigkeit... \n
      K4 gedrückt       : Speed über Terminalprogramm vorgeben \n
      K5 gedrückt       : Speed--; \n
      K6 gedrückt       : Speed++; \n
      
      Bei jedem Betätign der Taster werden die neuen Werte für THRESHOLD \n
      und SPEED über die Infrarotschnittstelle ausgegeben.
    
      \param
      keine
    
      \author   _HP_
    
      \version  beta - 04.04.2007 - _HP_\n
                first implementation
                
      \version  beta - 05.04.2007 - _HP_\n
                Auswerung der Taster verbessert und Umlaute in den Ausgaben entfernt
    *****************************************************************************/
    int main(void) 
    { 
      int           Light;                      // Summe des gemessenen Lichtes der Fototransistoren ohne Umgebungslicht
      int           T1, T2;                     // Werte der Taster bei zwei aufeinanderfolgenden Messungen
      int           Threshold = INI_THRESHOLD;  // Schwellwert des Lichtes für die Fototransistoren, der eingehalten werden soll.
      int           Speed     = INI_SPEED;      // Geschwindikeit der Motoren, wenn der Wert der Fototransistoren vom Sollwert abweicht.
    
      Init(); 
    
      FrontLED(ON);    
    
      MotorSpeed(Speed,0);    // Regelung erfolgt nur über das linke Rad
      MotorDir(BREAK,BREAK); 
      
      for(;;) {
        
        // Ändern der Parameter mit den Tastern:
        T1 = PollSwitch();
        T2 = PollSwitch();
        if (T1 && T2 && T1 == T2)
        {
          // Motor stoppen wenn Werte geänder werden
          StatusLED(RED);
          MotorSpeed(0,0);
          
          // Taster linke Seite ändert die Hell/Dunkel-Schwelle...
          if (T1 == K1)  Threshold++;
          if (T1 == K2)  Threshold--;
          if (T1 == K3)  
          {
            SerPrint("\r\nBitte einen Wert fuer THRESHOLD eingeben: ");
            Threshold = ReadInt();
          }
          if (T1 == (K1 + K2))  //K1 und K2 gedückt
          {
            SerPrint("\r\nAutokalibration von THRESHOLD!");
            Threshold = ReadSensor();
          }
          
          if (Threshold <    0) Threshold =    0;
          if (Threshold > 1023) Threshold = 1023;
          
          // Taster rechte Seite ändert die Geschwindigkeit...
          if (T1 == K4)
          {
            SerPrint("\r\nBitte einen Wert fuer SPEED eingeben: ");
            Speed = ReadInt();
          }
          if (T1 == K5) Speed--;
          if (T1 == K6) Speed++;
          
          if (Speed <   0) Speed =   0;
          if (Speed > 255) Speed = 255;
    
          
          // Ausgabe der aktuellen Werte
          SerPrint("\r\nTHESHOLD: ");
          PrintInt(Threshold);
          SerPrint("    SPEED: ");
          PrintInt(Speed);
          SerPrint("\r\n");
          
          Msleep(200);
          StatusLED(GREEN);
          MotorSpeed(Speed,0); 
          
        }
        
        // Licht an den Liniensensoren messen
        Light = ReadSensor();
    
        // Fahre rückwärts, wenn es zu dunkel und vorwärts wenn es zu hell wird.
        if (Light < Threshold)  MotorDir(RWD,BREAK); 
        else                    MotorDir(FWD,BREAK); 
      } 
    
      return 0; 
    }

  10. #10
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.12.2006
    Ort
    Eberbach
    Beiträge
    199
    Hallo,
    Zitat Zitat von _HP_
    Inhaltlich bleibt es bei dem Zweipunktregler. Allderdings versuche ich den Einfluß des Umgebungslichtes zu unterdrücken (ich meine die Idee dazu mal bei waste gefunden zu haben).
    ...
    Schaut Euch das mal an, experimentiert damit und sagt eure Meinung...
    Habe es heute abend im Zug übersetzt und gleich ausprobiert!
    • Hat auf unterschiedlichsten Untergründen sofort funktioniert, und auch der Wechsel von Sonnenlicht und Schatten hat (wohl Dank Deiner an Waste angelehnten Technik) nicht gestört!
    • Dank der Übernahme der Sensorwerte (K1 & K2 gedrückt) kann man den Asuro mittels darauffolgender Tastendrücke K1/K2 sehr schnell auf einem neuen Untegrund zum Balancieren kriegen.
    • Im fahrenden Zug hat der Zweipunktregler allerdings seine Grenzen gefunden: länger als 3 Sekunden hat er nie das Wackeln des Zuges (RE) ausgleichen können. Ich muß mal den PD-Regler für das Balancieren von Waste ausprobieren (siehe folgenden Thread), vielleicht verkraftet der ja die Stöße im fahrenden Zug ...


    Code:
    ...
      Bei jedem Betätign der Taster werden die neuen Werte für THRESHOLD \n
      und SPEED über die Infratotschnittstelle ausgegeben.
    ...
    Wo kann ich denn die Infratotschnittstelle finden?

    Code:
    ...
      MotorSpeed(Speed,0);    // Regelung erfolgt nur über das linke Rad
      MotorDir(BREAK,BREAK); 
    ...
    Wenn ich BREAK richtig verstehe, dann geschieht das Bremsen durch einen Kurzschluß des Motors im Gegensatz zu FREE, wo das Rad frei laufen kann.
    Allerdings liegt bei MotorSpeed(...,0) wegen PWM keine Spannung auf dem rechten Motor, sodaß sich BREAK dort wie FREE verhält, oder?
    [das Programm funktioniert aber auch so]

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

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