- LiFePO4 Speicher Test         
Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 18 von 18

Thema: ASURO als GFS

  1. #11

    Erstmal Danke!

    Anzeige

    Powerstation Test
    Erstmal vileen Dank für deine Antwort damaltor.

    Ich denke ich habe es jezt verstanden.

    jezt habe ich es mal auf Level 2 probiert mit zwei Taster, doch ich bin mir nicht wirklich sicher ob es richtig ist.

    Code:
    
                     +5V 
                      | 
                 Widerstand 1000Ω Ohm
                      | 
                      +-----------------+ 
                                        | 
                                        +----------AD-Wandler 
                                        | 
                  +--------+--------+---+----+--------+--------+ 
                  |                                            |
                  |                                            |
                  |                                            |
                  |           4 NICHT gedrückte  Taster        |
                  |                                            |
                  |        |        |        |        |        | 
    Widerstände  2000Ω     4000Ω   8200Ω    16000Ω  33000Ω  60000Ω 
                  |        |        |        |        |        | 
                  +--------+--------+---+----+--------+--------+ 
                                        | 
                                        | 
                                      Masse
    
    
    
                        1                                                 1
    ----------------------------------    ______    ------------------------
            1                      1      ______   1                  1
    --------------  +  ----------------             ---------   +  ----------
    Widerstant1     Widerstand 2               2000Ω        60000Ω
    
    
    Das Ergebnis wäre dann gerundet: 1935Ω
     
    
    Spannung * Widerstand1 / (Widerstand1 + Widerstand2)
    5V * 1935Ω / ( 1935Ω + 1000Ω)
    = 3,2964V
    
    Gemessene Spannung  * 1023 / Spannung
    3,2964V * 1023 / 5V
    =  469 (richtig gerundet)
    
    (1023 / gemessener Wert - 1) * 61 + 0.5
    (1023 / 469 - 1) * 61 + 0.5
    = 72
    Ich hoffe man kann es erkennen ist alles nen bissle verutscht.

    InFaIN

  2. #12
    Moderator Robotik Einstein Avatar von damaltor
    Registriert seit
    28.09.2006
    Ort
    Milda
    Alter
    38
    Beiträge
    4.066
    na gut probeiren wir das mal.
    60000Ω || 2000Ω = 1935 Ω
    U_ADC = 5V * 1935Ω / (1935Ω + 1000Ω) = 3,2964V
    (kleiner fehler in deiner beschreibung, aber richtig gerechnet. U_ADC = VCC * R2 / (R1 + R2), nicht R1 vorne!)
    ADC = 3,2964V * 1023 / 5V = 674 (!! Fehler, du hast 2,2964 eingetippt!)
    POLLSWITCH = (1023 / 674 - 1) * 61 + 0,5 = 32,0

    sollte 33 (=32 + 1) sein.

    also an sich hast du es wohl verstanden, aber dich leider vertippt

    diese fehler am ende könnten evtl darauf zurückzuführen sein, dass VCC nicht genau 5V ist sondern etwas darüber. habe ich aber noch nicht nachgerechnet.

    EDIT:
    Level3: alle atsten gedrückt.
    2000Ω||4000Ω||8200Ω||16000Ω||33000Ω||60000Ω = 1018.9308Ω
    Read... or die.
    ff.mud.de:7600
    Bild hier  

  3. #13
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018

    Re: Danke

    Schön, dass ihr weiterkommt.
    Ich sehe direkt den glühenden Taschenrechner vor meinen Augen

    Tut mir leid, dass ich im Moment nicht so intensiv dabei bin, aber damaltor richtet es ja bestens.


    Zitat Zitat von InFaIN
    .. Doch dann hab ich des proplem(ich hab den beitrag von dir im andern Theard gelesen) dass ich des mit dem AD wandler nich so ganz verstehe. Du hast es ja für den hellichkeitssensor erklärt nur ist mir da nicht so ganz klar wei ich es bei den Tastern machen muss. ..
    Die Sache mit den Helligkeitssensoren und/oder den Tasten ist etwas ganz anderes als der AD-Wandler.
    Du musst hier ganz stark unterscheiden worum es bei den beiden Dingen (AD-Wandler / Sensoren) geht.

    Der AD-Wandler ist 'nur' dafür zuständig, die Analogen Spannungswerte der Sensoren/Taster in eine für den Computer lesbare Digitale Zahl zu 'verwandeln'. (Das hat damaltor gerade erklärt.)

    In dem Thread, in dem ich das mit den Helligkeitssensoren erklärte, habe ich sie so dargestellt, dass man sie einfach als veränderbare Widerstände betrachten kann.
    Nun hast du ja schon selber die Aufgabe von damaltor mit den 2 gedrückten Tastern berechnet. Und??? Was hast du da gemacht??? Du hast die Widerstände an den Tastern nur neu zusammengeschaltet, so dass sich der Gesamtwert da geändert hat. (Parallelschalten von Widerständen mit Tastern)
    Siehst du den Zusammenhang? Licht ändert am Helligkeitsensor den Widerstand. Finger an den Tastern ändert den Widerstand in der Schaltung.
    Und der AD-Wandler muss nur nachsehen, wie groß dann die Spannung ist, um die Zahl zu bestimmen.


    Also schön unterscheiden:
    Sensoren (Licht/Finger/Luftfeuchtigkeit/...) ändern eine Spannung.
    AD-Wandler machen dir 'nur' eine Zahl daraus, damit der Computer damit arbeiten kann.

    Weiterhin viel Erfolg bei der Elektrotechnik
    wünscht dir Sternthaler

    P.S.: Immer schön weiter fragen, wenn noch was unklar ist.
    Lieber Asuro programieren als arbeiten gehen.

  4. #14
    Nun ist es mal wieder so weit, ich brauche euro hilfe. Vornweg die Hilfe sollte schnell sein da ich an diesem Donnerstag meine GFS halten muss.

    Ich habe jezt alle meine Codes verucht in eine Datei zu bekommen da man ja schlecht beim vortrag immer flashen kann. Nun habe ich aber das proplem damit dies nicht funktioniert. Ich hoffe ihr könnt mir helfen. Ich habe den code von der Kolision genommen um das "Menü" zu machen. Hier der Code:

    Code:
    #include "asuro.h" 
    
    
    #define TRIGGERLEVEL 655
    #define HYSTERESIS 10
    #define LOW 0
    #define HIGH 1
    
    
    #define GESCHW   65
    
    
    int main(void) 
    { 
       unsigned int z ,ll ,rr; 
       unsigned char taste1, taste2 ,taste3, taste4; 
       
        unsigned int data[2];
        signed int status[2]={0,0};
        signed int difference=0;
        
        MotorDir(FWD, FWD);
    	
    	
    	int lData[2]; 
    int i, donl, doffl, donr, doffr, l, r; 
    	
       Init(); 
        
      
       while(1) 
       { 
          taste4=PollSwitch(); 
          taste2=PollSwitch(); 
         taste1=PollSwitch(); 
          taste3=PollSwitch();     
          if (taste1 && (taste1==taste2) && (taste3==taste4) && (taste1==taste3) && (taste1==taste4)) 
          { 
            ll=0; 
            rr=0; 
               if (taste1==1) {
    		   //////////////////////////////////////////////
    		   ///// Kolision
    		   //////////////////////////////////////////////
    		   
    		   while(1) 
       { 
          taste4=PollSwitch(); 
          taste2=PollSwitch(); 
         taste1=PollSwitch(); 
          taste3=PollSwitch();     
          if (taste1 && (taste1==taste2) && (taste3==taste4) && (taste1==taste3) && (taste1==taste4)) 
          { 
            l=0; 
            r=0; 
               if (taste1==1) {l=120;r=0;} 
               if (taste1==2) {l=0;r=160;} 
               if (taste1==4) {l=0;r=120;} 
               if (taste1==8) {l=120;r=0;} 
               if (taste1==16) {l=160;r=0;} 
               if (taste1==32) {l=0;r=120;} 
             StatusLED(RED); 
             MotorDir(RWD,RWD); 
             MotorSpeed(l,r); 
           
             for(z=0;z<250;z++) 
             { 
                Sleep(255); 
             } 
          } 
          else 
          { 
             StatusLED(GREEN); 
             MotorDir(FWD,FWD); 
             MotorSpeed(120,120); 
          } 
          taste2=0; 
         taste1=0; 
       } 
       return 0; 
    		   
    		   
    		   //////////////////////////////////////////////
    		   ///// Kolision
    		   //////////////////////////////////////////////
    		   } 
               if (taste1==2) 
    		   {
    		   //////////////////////////////////////////////
    		   ///// Odometer
    		   //////////////////////////////////////////////
    		   
    		   while(1) {
            // Helligkeitswerte der Lichtschranken auslesen
            OdometrieData(data);
            // Wechsel linker Sensor von niedrig auf hoch?
            if ((status[0]==LOW) && (data[0]>TRIGGERLEVEL+HYSTERESIS)) {
                status[0]=HIGH;
                difference++;
            }
            // Wechsel linker Sensor von hoch auf niedrig?
            if ((status[0]==HIGH) && (data[0]<TRIGGERLEVEL-HYSTERESIS)) {
                status[0]=LOW;
                difference++;
            }
            // Wechsel rechter Sensor von niedrig auf hoch?
            if ((status[1]==LOW) && (data[1]>TRIGGERLEVEL+HYSTERESIS)) {
                status[1]=HIGH;
                difference--;
            }
            // Wechsel rechter Sensor von hoch auf niedrig?
            if ((status[1]==HIGH) && (data[1]<TRIGGERLEVEL-HYSTERESIS)) {
                status[1]=LOW;
                difference--;
            }
            // zur Sicherheit: verhindern, dass der Differenzz?ler
            // den erlaubten Wertebereich verl?st
            if (difference<-255) difference=-255;
            if (difference>255) difference=255;
            
            // Status-LED noch entsprechend der erkannten Segmente
            // aufleuchten lassen, grn fr links, rot fr rechts
            StatusLED(status[0]+status[1]*2);
            
            // Z?ldifferenz passend auf die Motoren verteilen
            if (difference>0) MotorSpeed(255-difference-50,255-50);
            else MotorSpeed(255-50,255+difference-50);
            
        }
        return 0;
    		   
    		   //////////////////////////////////////////////
    		   ///// Odometer
    		   //////////////////////////////////////////////
    		   } 
               if (taste1==4) 
    		   {
    		   //////////////////////////////////////////////
    		   ///// Linien
    		   //////////////////////////////////////////////
    		   
    		   while(1) 
       { 
       FrontLED(OFF);      // Umgebungslicht filtern 
       Sleep(10);          // kurz warten bis LED aus 
       LineData(lData);      // 
       LineData(lData);      // 
       doffl = (lData[0]);   // 
       doffr = (lData[1]);   // 
       FrontLED(ON);      // 
       Sleep(10);         // kurz warten bis LED an 
       LineData(lData);      // 
       LineData(lData);      // 
       donl = (lData[0]);   // 
       donr = (lData[1]);   // 
       l = donl - doffl;   // 
       r = donr - doffr;   // r und l sind nun die werte von T9 und T10 mit gefiltertem Umgebungslicht 
       i = (l+r)/2; 
    
       if (l<r) // gegenlenken 
       { 
       MotorSpeed(GESCHW -i+68, GESCHW +i); 
       } 
       else 
       { 
       MotorSpeed(GESCHW +i+68, GESCHW -i); 
       }
    
       } 
       return 0; 
    		   
    		   //////////////////////////////////////////////
    		   ///// linien
    		   //////////////////////////////////////////////
    		   } 
               if (taste1==8) {l=120;r=0;} 
               if (taste1==16) {l=160;r=0;} 
               if (taste1==32) {l=0;r=120;} 
             StatusLED(RED); 
            
          taste2=0; 
         taste1=0; 
     
    } 
       return 0; 
    } 
    }
    Naja wenn ihr mir nicht helfen könnt auch nicht so schlimm dan muss ich eben doch nebenher flashen.

    Vielen Dank im Voraus!

  5. #15
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    02.01.2008
    Alter
    33
    Beiträge
    239
    hallo

    was genau funktionier bei deinem programm nicht?

  6. #16
    Naja wenn ich einen Taster drücke passiert garnix

  7. #17
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    02.01.2008
    Alter
    33
    Beiträge
    239
    allso erst mal vorweg: 4 tasterabfragen sind doch etwas viel, aber sicher nicht das problem. im normalfall genügen immer 2, zb auf diese art:
    Code:
    do{
    taster=PollSwitch();
    }while(taster!=PollSwitch());
    so, und nun zu deinem problem:
    versuch einmal nach dem ersten return 0; noch eine abschließende "}" zu setzen. ich glaube, dass es daran liegen kann.

    ein anderer ansatz wäre es, dein ganzes programm noch einmal zu schreiben, und dann im main() nur die programmanwahl per tasterabfrage zu machen, und die ganzen programme (kollision, odometrie,...) in eigenen funktionen außerhalb von main() auszuführen. dadurch wird der code automatisch übersichtliche, und man kann somit auch leicher fehler suchen/finden.
    mfg hai1991

    P.S.: wer großbuchstaben oder rechtschreibfehler findet darf sie behalten

  8. #18
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    Hallo InFaIN,

    den vorgeschlagenen Ansatz von hai1991 kann ich nur unterstützen.
    Hier ist mal eine formatierte Version. Es ist nichts geändert, sondern nur mal ordentlich eingerückt. Dann wird der Fehler auch sichtbar.
    Code:
    #include "asuro.h"
    
    #define  TRIGGERLEVEL   655
    #define  HYSTERESIS     10
    #define  LOW            0
    #define  HIGH           1
    #define  GESCHW         65
    
                      int   main (void)
    {
             unsigned int   z, ll, rr;
             unsigned char  taste1, taste2 ,taste3, taste4;
             unsigned int   data [2];
             signed   int   status [2] = {0, 0};
             signed   int   difference = 0;
                      int   lData [2];
                      int   i, donl, doffl, donr, doffr, l, r;
    
       MotorDir (FWD, FWD);
    
       Init ();
    
       while (1)
       {
          taste4 = PollSwitch ();
          taste2 = PollSwitch ();
          taste1 = PollSwitch ();
          taste3 = PollSwitch ();
    
          if (taste1           &&
              taste1 == taste2 &&
              taste3 == taste4 &&
              taste1 == taste3 &&
              taste1 == taste4)
          {
             ll = 0;
             rr = 0;
             if (taste1 == 1)
             {
                //////////////////////////////////////////////
                ///// Kolision
                //////////////////////////////////////////////
          
                while (1)
                {
                   taste4 = PollSwitch ();
                   taste2 = PollSwitch ();
                   taste1 = PollSwitch ();
                   taste3 = PollSwitch ();
    
                   if (taste1           &&
                       taste1 == taste2 &&
                       taste3 == taste4 &&
                       taste1 == taste3 &&
                       taste1 == taste4)
                   {
                      l = 0;
                      r = 0;
    
                      if (taste1 ==  1) { l = 120; r =   0; }
                      if (taste1 ==  2) { l =   0; r = 160; }
                      if (taste1 ==  4) { l =   0; r = 120; }
                      if (taste1 ==  8) { l = 120; r =   0; }
                      if (taste1 == 16) { l = 160; r =   0; }
                      if (taste1 == 32) { l =   0; r = 120; }
    
                      StatusLED  (RED);
                      MotorDir   (RWD, RWD);
                      MotorSpeed (l, r);
          
                      for (z = 0; z < 250; z++)
                      {
                         Sleep (255);
                      }
                   }
                   else
                   {
                      StatusLED  (GREEN);
                      MotorDir   (FWD, FWD);
                      MotorSpeed (120, 120);
                   }
                   taste2 = 0;
                   taste1 = 0;
                }
                return 0;
    
                //////////////////////////////////////////////
                ///// Kolision
                //////////////////////////////////////////////
             }
    
             if (taste1 == 2)
             {
                //////////////////////////////////////////////
                ///// Odometer
                //////////////////////////////////////////////
    
                while (1)
                {
                   // Helligkeitswerte der Lichtschranken auslesen
                   OdometrieData (data);
    
                   // Wechsel linker Sensor von niedrig auf hoch?
                   if (status [0] == LOW &&
                       data [0]    > TRIGGERLEVEL + HYSTERESIS)
                   {
                      status [0] = HIGH;
                      difference++;
                   }
                   // Wechsel linker Sensor von hoch auf niedrig?
                   if (status [0] == HIGH &&
                       data [0]    < TRIGGERLEVEL - HYSTERESIS)
                   {
                      status [0] = LOW;
                      difference++;
                   }
    
                   // Wechsel rechter Sensor von niedrig auf hoch?
                   if (status [1] == LOW &&
                       data [1]    > TRIGGERLEVEL + HYSTERESIS)
                   {
                      status [1] = HIGH;
                      difference--;
                   }
    
                   // Wechsel rechter Sensor von hoch auf niedrig?
                   if (status [1] == HIGH &&
                       data [1]    < TRIGGERLEVEL - HYSTERESIS)
                   {
                      status [1] = LOW;
                      difference--;
                   }
    
                   // zur Sicherheit: verhindern, dass der Differenzz?ler
                   // den erlaubten Wertebereich verl?st
                   if (difference <- 255)
                      difference = -255;
                   if (difference > 255)
                      difference = 255;
          
                   // Status-LED noch entsprechend der erkannten Segmente
                   // aufleuchten lassen, grn fr links, rot fr rechts
                   StatusLED (status [0] + status [1] * 2);
    
                   // Zaeldifferenz passend auf die Motoren verteilen
                   if (difference > 0)
                      MotorSpeed (255 - difference - 50, 255 - 50);
                   else
                      MotorSpeed (255 - 50, 255 + difference - 50);
                }
                return 0;
          
                //////////////////////////////////////////////
                ///// Odometer
                //////////////////////////////////////////////
             }
    
             if (taste1 == 4)
             {
                //////////////////////////////////////////////
                ///// Linien
                //////////////////////////////////////////////
          
                while (1)
                {
                   FrontLED (OFF);      // Umgebungslicht filtern
                   Sleep (10);          // kurz warten bis LED aus
                   LineData (lData);    //
                   LineData (lData);    //
                   doffl =  lData [0];  //
                   doffr =  lData [1];  //
                   FrontLED (ON);       //
                   Sleep (10);          // kurz warten bis LED an
                   LineData (lData);    //
                   LineData (lData);    //
                   donl =   lData [0];  //
                   donr =   lData [1];  //
                   l = donl - doffl;    //
                   r = donr - doffr;    // r und l sind nun die werte von T9 und
                                        // T10 mit gefiltertem Umgebungslicht
                   i = (l + r) / 2;
    
                   if (l < r)           // gegenlenken
                   {
                      MotorSpeed (GESCHW - i + 68, GESCHW + i);
                   }
                   else
                   {
                      MotorSpeed (GESCHW + i + 68, GESCHW - i);
                   }
                }
                return 0;
          
                //////////////////////////////////////////////
                ///// linien
                //////////////////////////////////////////////
             }
    
             if (taste1 ==  8) { l = 120; r =   0; }
             if (taste1 == 16) { l = 160; r =   0; }
             if (taste1 == 32) { l =   0; r = 120; }
             StatusLED (RED);
    
             taste2 = 0;
             taste1 = 0;
          }
          return 0;
       }
    }
    Wird jetzt mal alles aus dem ersten if() in der while()-Schleife hinter dem Init() entfernt, bleibt nur noch folgendes übrig:
    Code:
    #include "asuro.h"
    
    #define  TRIGGERLEVEL   655
    #define  HYSTERESIS     10
    #define  LOW            0
    #define  HIGH           1
    #define  GESCHW         65
    
                      int   main (void)
    {
             unsigned int   z, ll, rr;
             unsigned char  taste1, taste2 ,taste3, taste4;
             unsigned int   data [2];
             signed   int   status [2] = {0, 0};
             signed   int   difference = 0;
                      int   lData [2];
                      int   i, donl, doffl, donr, doffr, l, r;
    
       MotorDir (FWD, FWD);
    
       Init ();
    
       while (1)
       {
          taste4 = PollSwitch ();
          taste2 = PollSwitch ();
          taste1 = PollSwitch ();
          taste3 = PollSwitch ();
    
          if (taste1           &&
              taste1 == taste2 &&
              taste3 == taste4 &&
              taste1 == taste3 &&
              taste1 == taste4)
          {
          }
          return 0;
       }
    }
    Das geht zwar durch den Compiler, aber dieses Programm verläßt die main()-Funktion mehr oder weniger sofort nach dem einschalten wieder. Und das ist leider falsch.

    Wenn alle 'return 0'-Zeilen entfernt werden sollte es auf alle Fälle schon mal besser gehen.

    Wird der Asuro eingeschalte, sollte das 'Menü' aktiv sein:
    - Taste1 = 1: Kollision
    - Taste1 = 2: Odometer
    - Taste1 = 4: Linien

    - Taste1 = 8: Variablen l und r setzen, aber nichts weiteres.
    - Taste1 = 16: Sollten hier Motorbewegungen angestoßen werden?
    - Taste1 = 32: Es scheint dann ein MotorSpeed() zu fehlen

    Ob die Funktionen bei Taste1 = 1, 2, 4 gehen weiss ich nicht.
    Das formatieren kostet viel überflüßige Zeit, wenn man es nicht sofort macht.

    Gruß Sternthaler

    P.S.: Versuch einmal, ob der Asuro anders reagiert, wenn du sofort nach dem Einschalten einen der ersten 3 Taster drückst.
    Dann sollte das 'Menü' ja schon ausgewählt werden. Aber ob dann nicht die 4-fach-Tastenabfrage blockiert?
    Lieber Asuro programieren als arbeiten gehen.

Seite 2 von 2 ErsteErste 12

Berechtigungen

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

fchao-Sinus-Wechselrichter AliExpress