ASURO als GFS

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

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

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Ω

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.

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!

hallo

was genau funktionier bei deinem programm nicht?

Naja wenn ich einen Taster drücke passiert garnix

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.

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?