Problem mit For Schleife

[Sebi (Gast)]

Hey ich hab da mal ein Problem ich hab ein Programm geschreiben um mit 
den HC-SR 04 Entfernungen auszumessen. Das klappt auch super. Nun hab 
ich gemerkt das ab und zu mal in der Messung ein wert aus der reihe tanz 
und dachte mir ich mach 2 Messungen mehr und zieh den höchsten und 
geringsten wert vom Mittelwert ab. Da ganze funktioniert auch, aber ich 
bekomm beim Build immer 2 Warnings und 2 Messages.

kann mir vielleicht mal erklären warum ich die bekomme und was eine 
abhilfe wäre:

void HC_SR_04()
{
  unsigned char i,k;
  unsigned short Timedifferenz,Ergebnis = 0;
  unsigned short Messung[8];
  unsigned short min = 65535, max = 0;
  for (i=0;i<=9;i++)
  {
    wiederholung:;
    complete_hc = 0;
    PORTB |= (1<<HC_TRIGGER);
    _delay_us(40);
    PORTB &= ~(1<<HC_TRIGGER);
    while(complete_hc == 0)
    ;
    if (Timestart == Timestop)
    {
      Error();
      goto wiederholung;
    }
    else if (Timestart < Timestop)
    {
      Timedifferenz = (Timestop-Timestart);  
    }
    else if (Timestart > Timestop)
    {
      Timedifferenz = (Timestop-Timestart+65535);
    }
    else
    {
      Error();
      goto wiederholung;
    }
    
    
    Messung[i] = Timedifferenz;
    
    
  }
  
  for (k=0;k<=9;k++)
  {
    Ergebnis = Ergebnis+ Messung[k];
    if (Messung[k] <= min)
    {
      min = Messung [k];
    }
    if (Messung [k] >= max)
    {
      max = Messung[k];
    }
    
  }
  Ergebnis = Ergebnis - (min+max);
  Ergebnis_HC = Ergebnis / 8;
  if (error_counter != 0)
  {
    error_counter --;
  }
  
}

das ist der Code.

Und hier die Fehler :

    (247,31): warning: iteration 8u invokes undefined behavior 
[-Waggressive-loop-optimizations]
       Ergebnis = Ergebnis+ Messung[k];
                                   ^
(245,2): info: containing loop
      for (k=0;k<=9;k++)
      ^
(240,14): warning: iteration 8u invokes undefined behavior 
[-Waggressive-loop-optimizations]
       Messung[i] = Timedifferenz;
                  ^
(211,2): info: containing loop
      for (i=0;i<=9;i++)
      ^

[Tom (Gast)]

> unsigned short Messung[8];
> Messung[i]
Welche Werte darf i haben?

> for (i=0;i<=9;i++)
Welche Werte nimmt i an?

[Dussel (Gast)]

Sebi schrieb:
> (247,31): warning: iteration 8u invokes undefined behavior
> [-Waggressive-loop-optimizations]
>        Ergebnis = Ergebnis+ Messung[k];
k geht bis 9, Messung aber nur bis 7. Das andere dürfte was ähnliches 
sein.

[Sebi (Gast)]

Oh das hab ich ganz vergessen mit zu ändern danke.

[Sebi (Gast)]

Habs jetzt geändert und Warnung ist weg besten Dank.

[Rolf M. (rmagnus)]

Aus dem Grund verteilt man solche Zahlen besser nicht auf das ganze 
Programm sondern definiert sich einmal eine symbolische Konstante und 
verwendet die an allen Stellen, so dass man immer nur genau eine Stelle 
anpassen muss, wenn man die Größe mal ändern möchte.

[A. S. (Gast)]

Rolf M. schrieb:
> Aus dem Grund verteilt man solche Zahlen besser nicht auf das ganze
> Programm sondern definiert sich einmal eine symbolische Konstante und
> verwendet die an allen Stellen, so dass man immer nur genau eine Stelle
> anpassen muss, wenn man die Größe mal ändern möchte.

oder verwendet countof(), um sicher zu gehen, dass beides 
zusammengehört.

[M. K. (sylaina)]

Und vom goto würd ich mich auch verabschieden. So passieren nämlich auch 
solche Fehler wie oben: Das erste if und das else am Schluss 
unterscheiden sich nicht:

Sebi schrieb:

     if (Timestart == Timestop)
     {
       Error();
       goto wiederholung;
     }
     ...
     else
     {
       Error();
       goto wiederholung;
     }

Das kannste mindestens einen Teil von löschen.

[Joe F. (easylife)]

Dass dein Array Messung[] zu klein ist hast du jetzt gelernt.

Nun zu den anderen Problemen deines Programmes:

a)

    if (Timestart == Timestop)
    {
      Error();
      goto wiederholung;
    }
    else if (Timestart < Timestop)
    {
      Timedifferenz = (Timestop-Timestart);  
    }
    else if (Timestart > Timestop)
    {
      Timedifferenz = (Timestop-Timestart+65535);

      // macht das gleiche wie:
      // Timedifferenz = Timestop-Timestart-1;
      // also nicht wirklich hilfreich
    }
    else
    {
      // warum diese zusätzliche else condition?
      // das wäre der gleiche Fall wie der erste:
      // if (Timestart == Timestop)

      Error();
      goto wiederholung;
    }

Da also
Timedifferenz = (Timestop-Timestart+65535)
eh falsch ist, kannst du die ganze Berechnung auf das hier 
runterbrechen:

    if (Timestart == Timestop)
    {
      Error();
      goto wiederholung;
    }
    else 
        Timedifferenz = Timestop-Timestart;

Selbst bei einem Überlauf zwischen Timestop und Timestart kommt das 
richtige Ergebnis heraus.
Bei zwei Überläufen allerdings nicht mehr, und das ist eventuell auch 
der Grund für deine seltsamen Ausreißer.
In welchem Wertebereich befindet sich denn Timedifferenz üblicherweise?

b)
Sebi schrieb:
> und dachte mir ich mach 2 Messungen mehr und zieh den höchsten und
> geringsten wert vom Mittelwert ab.

Warum? Was soll das bringen?
Um Ausreisser herauszunehmen sortiert man üblicherweise die Messwerte 
der Größe nach, und nimmt sich einen (oder mittelt ein paar Werte) aus 
der Mitte des sortierten Feldes. Die Ausreisser bleiben dadurch komplett 
unberücksichtigt.

c)
Ergebnis = Ergebnis+ Messung[k];

Hier addierst du 10 16-bit Werte in einer Variablen, die selbst nur 
16-bit breit ist.
Das funktioniert nur, wenn die zu addierenden Werte so klein sind, dass 
"Ergebnis" nicht überläuft (also im Mittel <= 6553).
Ist das sichergestellt?

d)
Ergebnis_HC = Ergebnis / 8;

Hier stimmt dann der Teiler nicht. Müsste 10 sein.

Nachtrag:
Achso, jetzt verstehe ich. Du suchst dir den kleinsten und größten Wert 
und gehst davon aus, dass dies die Ausreisser sind. Daher ziehst du 
diese von der Summe ab, und teilst durch 8.
Kann man hilfsweise so machen.
Trotzdem mal prüfen, ob 10 Messwerte aufaddiert ohne Überlauf in 
"Ergebnis" passen.

[Sebi (Gast)]

Also der Teiler ist richtg da ich min und max aus der Rechnung nehme:

Ergebnis = Ergebnis - (min+max);
  Ergebnis_HC = Ergebnis / 8;

das mit den 16bit werten passt auch der max wert einer Messung liegt bei 
300.
400*10 Messung sind 4000 liegt unterhalb der 65535.

Die andern tipps hab ich schon umgestzt besten dank.

mal so ne frage wie würde den der Code aussehen wenn ich 20 messungen 
pro durchlauf mache und nur die 10 in der mitte zur Mittelwert Bildung 
nutze?

[Joe F. (easylife)]

Sebi schrieb:
> mal so ne frage wie würde den der Code aussehen wenn ich 20 messungen
> pro durchlauf mache und nur die 10 in der mitte zur Mittelwert Bildung
> nutze?

Du musst die 20 Array-Einträge nach der Messung der Größe nach 
sortieren, und nimmst aus dem sortierten Array dann die Werte 5..14.

Ich würde aber erstmal gucken, ob dein Problem mit den Ausreissern nicht 
schon dadurch verschwindet, dass du dein Array groß genug machst.

Es liegt momentan ziemlich nahe, dass die letzten 2 Werte einfach nur 
Müll sind, da sie momentan in anderweitig benutztem Speicher liegen.

[A. S. (Gast)]

Sebi schrieb:
> das mit den 16bit werten passt auch der max wert einer Messung liegt bei
> 300.

naja, wenn der Maxwert da liegt und Du "Ausreißer" hast, dann teste das 
auch. Also zumindest < 400 oder so. Und m.E. auch ohne goto, also z.B.:

    for(i=0; i<10; /*nur bei Erfolg ++ am Ende */)
    {
        complete_hc = 0;
        PORTB |= (1<<HC_TRIGGER);
        _delay_us(40);
        PORTB &= ~(1<<HC_TRIGGER)
        while(!complete_hc) {}
        Timedifferenz = (Timestop-Timestart);  
        if((Timedifferenz < 1) || (Timedifferenz > 400)) 
        {
            Error();
        } 
        else
        {
            Messung[i++] = Timedifferenz;
        }
    }

statt 1 den minmalen plausiblen Wert eingeben. Wenn 0 falsch ist, wird 
es 3 oder 5 vermutlich auch sein, oder?

ich gebe zu, eine vergewaltigung der for-Schleife. Aber der Preis einer 
separaten inneren Schleife wäre mir in diesem Fall zu hoch. Und i-- im 
Errorfall auch.

[Sebi (Gast)]

Habs jetzt geändert alles, jedoch hab ich immer noch nach ca. 15 
Ergebnissen leichte ausreißer(also nach 150 Messungen). Wenn ich jetzt 
ne aus 20 Messungen die 12 Aus der mitte nehme reicht da Bubblesort für 
aus oder ist es für 20 Messungen zu Zeit intensiv? was wäre dann den 
eine schnellere alternative ?

[A. S. (Gast)]

Sebi schrieb:
> reicht da Bubblesort für aus

JA!

Wenn Du 1000 Messungen hast, kannst Du über optimierung nachdenken. Aber 
nur zu:

1) Quick-Bubble-Sort ;-)
2) nur die 3 kleinsten rausfiltern und die 3 größten. Also wie bisher, 
nur dann 3 mal.
3) die min- und max-Tests mit einbauen, dann sollten es noch weniger 
sein.

Aber es gibt auch eine Standard-C-Funktion zum sortieren: qsort(). Die 
kannst Du kaum durch eigenes basteln schlagen.

[A. S. (Gast)]

Sebi schrieb:
> nach ca. 15 Ergebnissen leichte ausreißer(also nach 150 Messungen).
Du solltest Dir die Rohwerte ausgeben lassen, um zu wissen, was da 
passiert.

Wenn (als Beispiel) 10 Werte im Bereich von 190 bis 210 wild verteilt 
liegen, ist es etwas anderes als wenn Du manchmal auch 999 oder 1 misst. 
Bei ersterem reicht die Mittelung, bei solltest Du den Fehler 
korrigieren oder Kriterien zu dessen Erkennung herausarbeiten.

[Joe F. (easylife)]

Achim S. schrieb:
> Und m.E. auch ohne goto, also z.B.:

Ja, das goto ist hässlich.
Und Ausreisser gleich bei der Erfassung zu erkennen, und gleichzeitig 
auch sicherzustellen, dass der Wertebereich für die spätere 
Aufsummierung nicht überschritten wird, ist eine wirklich sehr gute 
Idee.
Statt einem halben "for" fände ich dann "while" allerdings irgendwie 
schöner:

    i=0;
    while(i<10)
    {
        complete_hc = 0;
        PORTB |= (1<<HC_TRIGGER);
        _delay_us(40);
        PORTB &= ~(1<<HC_TRIGGER)
        while(!complete_hc)
            ;

        Timedifferenz = (Timestop-Timestart);  
        if((Timedifferenz < 1) || (Timedifferenz > 400)) 
            Error();
        else
            Messung[i++] = Timedifferenz;
    }

Achim S. schrieb:
> 2) nur die 3 kleinsten rausfiltern und die 3 größten. Also wie bisher,
> nur dann 3 mal.

Das könnte man auch so erledigen, indem man die 3 größten und die 3 
kleinsten Werte im Array einfach mit 0 überschreibt.
Beim Mittelwert-bilden über das gesamte Array fallen genau diese Werte 
dann also automatisch aus der Summe raus.

[Sebi (Gast)]

Das mit der while gefällt mir auch schon besser vielen Danke. Wie groß 
der Ausreißer ist schau ich später mal nach gibt es für bubblesort auch 
eine fertige Funktion wie für qbubblesort und in welcher h sind die den?

[Achim (Gast)]

qsort ist nicht quick-bubblesort, sondern einiges komplizierter und 
effektiver, bei größeren Datenmengen. Habe ich aber jahrelang auch 
gedacht und es "eben selbst implementiert", um den Overhead der compare 
Funktion zu sparen.

Quick-bubblesort ist ja nur, den inneren Zähler jedesmal 1 weniger 
zählen zu lassen.

[Nop (Gast)]

Achim S. schrieb:
> Aber es gibt auch eine Standard-C-Funktion zum sortieren: qsort(). Die
> kannst Du kaum durch eigenes basteln schlagen.

Doch, kann man, und zwar recht problemlos. Denn in C artet jeder 
Vergleich und jeder Tausch in einen Funktionsaufruf aus, und dann auch 
noch über einen Zeiger. Zudem ist Quicksort bei kleinen Listen (bis etwa 
100 Elemente) langsam. Und rekursiv, was man embedded auch nicht will.

Abhilfe: man implementiert einen Shellsort mit der Sequenz nach Ciura. 
Shellsort ist iterativ, in-place, bei diesen Längen schneller als 
Quicksort, hat keine Pathologien, braucht keine Funktionsaufrufe.

Manche embedded-libs implementieren qsort zwar ohnehin von selber als 
Shellsort, aber der Overhead durch die Funktionaufrufe bleibt.

[Joe F. (easylife)]

Für 20 Einträge ist auch insertionsort recht effektiv:

void insertionsort (unsigned short* a, int n)
{
    int i, j;
    unsigned short t;

    for (i=1; i<n; i++) 
    {
        t=a[i];
        j=i;
        while (j>=1 && a[j-1]>t) 
        {
            a[j]=a[j-1];
            j=j-1;
        }
        a[j]=t;
    }
}

[Sebi (Gast)]

So hab jetzt einige ratschläge befolgt. bei großen Entfernungen also 
alles ab 10 cm Entfernung klappt es jetzt. jedoch schwanken die werte 
bei nahen Hindernissen kleiner 10cm gerne um 2-3 cm.

[Sebi (Gast)]

Der Code schaut jetzt so aus hab den Timer auch mal empfindlicher 
eingestellt daher jetzt auch ein Max von 4000.

  unsigned char i=0,k;
  unsigned short Timedifferenz;
  uint32_t Ergebnis = 0;
  uint16_t Messung[20];
  while(i<20)
  {
      complete_hc = 0;
      PORTB |= (1<<HC_TRIGGER);
      _delay_us(60);
      PORTB &= ~(1<<HC_TRIGGER);
      while(!complete_hc);
      Timedifferenz = (Timestop-Timestart);
    if((Timedifferenz < 2) || (Timedifferenz > 4000))
    Error();
    else
    Messung[i] = Timedifferenz;
    i++;
    }
  
  int l, j;
  for (l = 0; l < 20 - l; ++l)
  {

    for (j = 0; j < 20 - l - 1; ++j)
    {
      if (Messung[j] > Messung[j + 1])
      {
        int tmp = Messung[j];
        Messung[j] = Messung[j + 1];
        Messung[j + 1] = tmp;
      }
    }
  }
  for (k=4;k<=15;k++)
  {
    Ergebnis = Ergebnis+ Messung[k];    
  }
  
  Ergebnis_HC = Ergebnis / 12;
  if (error_counter != 0)
  {
    error_counter --;
  }
  
}

[Sebi (Gast)]

Also hab jetzt ein Messobjekt 1.50m entfernt.

Ergebniss liegt zwischen 1.49 und 1.51m das ist ok da der Timer auf eine 
Genauigkeit +- 1cm eingestellt ist.

Bei messungen unter 10cm hier jetzt mal 6cm habe ich Ergebnisse im 
Bereich vom 3-8cm. jemand eine Idee warum?

[Joe F. (easylife)]

Dazu wäre es hilfreich den Code zu zeigen, der complete_hc, Timestop und 
Timestart setzt.

[Sebi (Gast)]

ISR(INT0_vect)                                    /* Interrupt bei Pegel Wechsel an HC_ECHO */
{
  if (complete_hc == 0)    /* Solange die Ergebnisse nicht abgeholt wurden wird die Interupt Routine nicht ausgefuehrt */
  {
    if (MCUCR & (1 << ISC00))                           /* Wenn Pegel wechsel von LOW auf High */
    {
      Timestart = timer0;                                   /* Zeit Low >> High nehmen */
    }
    if (!(MCUCR & (1 << ISC00)))                         /* Wenn Pegel wechsel von High auf Low */
    {
      Timestop = timer0;                                     /* Zeit High >> Low nehmen */
      complete_hc = 1;               /* Routine sperren solange die Ergebnisse nicht gespeichert wurden */
    }
    
    MCUCR ^= (1<<ISC00);                    /* Wechsel der Interupt Routine (High >> Low) oder (Low >> High) */
  }
  
}

[Sebi (Gast)]

Habs gefunden,

habe die Auflösung noch etwas erhöht auch 3.33mm Genauigkeit.

hab jetzt bei Entfernungen bis 1m eine Genauigkeit von +/-0.666cm

und bei Entfernungen von 1m bis 3m eine Genauigkeit von +/- 1.333cm

die Ungenauigkeit die ich jetzt noch hab ist dann Mathematischer Natur.

[Eric B. (beric)]

Alternativ könnte man nur die 3 max und min werte in zwei Arrays 
speichern und bei jedem neuen Wert schauen ob es in das min- oder 
max-Array gespeichert werden soll, oder zu der laufende Summe 
hinzuaddiert.

Wenn der neue Wert zB in das max-Array gespeichert wird, wird statt der 
gemessene Wert das kleinste Element aus dem max-Array zu die Summe hinzu 
addiert.

z.B.
max[] = {200, 250, 300} und value = 275
Dann wird 200 zu der Summe hinzu addiert, und max[] enthält danach {250, 
275, 300}.

Die min und max Arrays werden während den Messungen sortiert gehalten 
(insertion sort).

#define MIN_LENGTH 3
#define MAX_LENGTH 3
#define NR_OF_MEASUREMENTS (MIN_LENGTH + MAX_LENGTH + 20)

uint16_t perform_measurements()
{
  uint16_t sum;
  uint16_t min[MIN_LENGTH];
  uint16_t max[MAX_LENGTH];

  // initialize
  memset(min, 0, sizeof(min));
  memset(max, 0, sizeof(max));

  // do measurements
  for(uint16_t i = 0; i < NR_OF_MEASUREMENTS; i++) {
    value = GET_MEASUREMENT_VALUE();

    // check with minima
    for(uint16_t j = 0; j < MIN_LENGTH; j++) {
      if(value < min[j]) {
         // swap value and min[j]
         uint16_t tmp = x; x = y; y = tmp;
      }
    }

    // check with maxima
    for(uint16_t j = 0; j < MAX_LENGTH; j++) {
      if(value > max[j]) {
         // swap value and max[j]
         uint16_t tmp = x; x = y; y = tmp;
      }
    }
  
    sum += value;
  }

  return sum / (NR_OF_MEASUREMENTS - MIN_LENGTH - MAX_LENGTH);
}

[ms (Gast)]

Hallo,

der uC braucht eine gewisse Zeit um Anweisungen auszuführen. Diese Zeit 
sollte man bei der Fehler Berechnung miteinbeziehen (Start Stop 
abfrage). Bei großen Distanzen wird der Fehler klein sein. Je kleiner 
die Distanz wird umso größer wird der Fehler.

ms

[Joe F. (easylife)]

Machs doch mal so:

In deiner main():

// ganz am Anfang:
MCUCR |= (1<<ISC00); // prepare interrupt for low to high transition

(...)

timer_state = 2;
PORTB |= (1<<HC_TRIGGER);
_delay_us(60);
PORTB &= ~(1<<HC_TRIGGER);
while(timer_state > 0)
  ;

und der Interrupt:

ISR(INT0_vect)
{
  unsigned short t = timer0;

  if (timer_state == 2)
  {
    Timestart = t;
    MCUCR &= ~(1<<ISC00); // prepare interrupt for high to low transition
    timer_state = 1;
  }
  else if (timer_state == 1)
  {
    Timestop = t;
    MCUCR |= (1<<ISC00); // prepare interrupt for low to high transition
    timer_state = 0;
  }
}

So nimmst du in deiner Interrupt routine immer direkt nach 
Flankenwechsel erstmal die Zeit, ohne dass noch andere Instruktionen 
verarbeitet werden müssen.
Danach entscheidest du dann, ob und was du mit dieser Zeitinformation 
machst.
Das sollte die Genauigkeit verbessern.

[Sebi (Gast)]

Ach du meinst bevor ich die If abfrage Starte schonmal den Timerwert 
zwischwenspeichern und dann die if abfragen durchführen?

[Sebi (Gast)]

ISR(INT0_vect)                                    /* Interrupt bei Pegel Wechsel an HC_ECHO */
{
  unsigned short t_tmp = timer0;
  if (complete_hc == 0)    /* Solange die Ergebnisse nicht abgeholt wurden wird die Interupt Routine nicht ausgefuehrt */
  {
    if (MCUCR & (1 << ISC00))                           /* Wenn Pegel wechsel von LOW auf High */
    {
      Timestart = t_tmp;                                   /* Zeit Low >> High nehmen */
    }
    if (!(MCUCR & (1 << ISC00)))                         /* Wenn Pegel wechsel von High auf Low */
    {
      Timestop = t_tmp;                                     /* Zeit High >> Low nehmen */
      complete_hc = 1;               /* Routine sperren solange die Ergebnisse nicht gespeichert wurden */
    }
    
    MCUCR ^= (1<<ISC00);                    /* Wechsel der Interupt Routine (High >> Low) oder (Low >> High) */
  }
  
}

[Joe F. (easylife)]

Ja, so gehts auch. Ich würde halt nur das MCUCR Register immer in einem 
definierten Zustand halten.

MCUCR ^= (1<<ISC00);
ist relativ zufällig beim allerersten mal.

Ich muss ja mal sagen, dass mir dieser Thread hier sehr gefällt.
Der Ton ist durchweg freundlich, viele nützliche Tipps von allen Seiten, 
TO lernt schnell und viel, und das Ergebnis kann sich sehen lassen.

[Sebi (Gast)]

Da muss ich dir recht geben. Daher auch von mir noch mal sehr vielen 
dank.

Die erste Benutzung vom Register hab ich durch ne Init abgesichert:

void int0_init()
{
  GICR |= (1<<INT0);                                    /* Sonderfunktion INT0 aktivieren */
  MCUCR |= (1<<ISC00);                                    /* Interrupt von LOW auf High */
}

[Joe F. (easylife)]

Na, ist doch prima. Sag bitte noch bescheid, wie sich das Zeitnehmen 
direkt am Anfang des Interrupts auf die Genauigkeit ausgewirkt hat.

[Sebi (Gast)]

Minimal,es  macht 8 Takte im Debug Modus(bei 16 Mhz) weniger fehler, bei 
einem timer der sich alle 20us erhöht kann es bei dem ein oder anderen 
das kippen zwischen den Ergbnissen verhindern.

An der Hardware ist der wert jetzt bei gleicher Entfernung konstant.
6
6
6
6
6
6
6
6
6
6
6
6
6
6
6
6
6
5
5
5
5
5
5
5
5
5
5
5
5
4
4
4
4
4
4

hier mal die Ergebniss aus der Uart in cm also keine Ausreisser mehr.

hier jetzt auch mal bei 1.495m Entfernung Schreibtisch zu Deckenhöhe:
148
148
148
148
148
149
148
148

schaut auch sehr gut aus angenommen ist der Schall bei 20 Grad Celsius 
im Raum sind 20.8 Grad von daher Top.

[Sebi (Gast)]

Eine kleine frage hab ich noch:

Kann man ein Reset auch anders Ausführen, als über den WD, also über ein 
direkten befehl?

im Moment hab ich das jetzt so gemacht:

void RESET()
{
  WDTCR |= (1<<WDE);                                         /* WatchDog Aktivieren */
   _delay_us(16300);     /* Wartezeit bis WD-Signal benötigt, bevor WD Auslöst, um WD auszulösen und Reset durchzufuehren */
}

nur wirklich schön find ich es nicht.

[Joe F. (easylife)]

Sebi schrieb:
> Minimal,es  macht 8 Takte im Debug Modus(bei 16 Mhz) weniger fehler, bei
> einem timer der sich alle 20us erhöht kann es bei dem ein oder anderen
> das kippen zwischen den Ergbnissen verhindern.

Ah ok.
Also ein "Fehler" von 0.5us.
Auch wenn es in deinem Fall jetzt keine wirkliche Rolle spielt, würde 
ich es prinzipiell so machen um die Fehlerquellen von vorneherein so 
gering wie möglich zu halten.

[ms (Gast)]

Sebi schrieb:
> Kann man ein Reset auch anders Ausführen

Port Pin Inverter usw.

ms

[M. K. (sylaina)]

Sebi schrieb:
> Kann man ein Reset auch anders Ausführen, als über den WD, also über ein
> direkten befehl?

Klar, du kannst direkt zur Resetadresse springen wenn du das unbedingt 
willst.

[Sebi (Gast)]

Also mit setzen des Flags im MCUCSR Register ist es nicht getan ?

[A. S. (Gast)]

Folgefehler mangels Klammern:

aus meinem
> if((Timedifferenz < 1) || (Timedifferenz > 400))
>         {
>             Error();
>         }
>         else
>         {
>             Messung[i++] = Timedifferenz;
>         }
wurde (zwar noch korrekt, aber "gefährlich")

Joe F. schrieb:
> if((Timedifferenz < 1) || (Timedifferenz > 400))
>             Error();
>         else
>             Messung[i++] = Timedifferenz;

was Du entzerrt hast zu
Sebi schrieb:
> if((Timedifferenz < 2) || (Timedifferenz > 4000))
>     Error();
> else
>     Messung[i] = Timedifferenz;
>     i++;

was hier falsch ist.

[Sebi (Gast)]

ok stimmt die klammern

[Sebi (Gast)]

[c]
if((Timedifferenz < 1) || (Timedifferenz > 400))
{
    Error();
}
else
{
     Messung[i] = Timedifferenz;
     i++;
}
[/c)

hab dann mal geändert

[Sebi (Gast)]

Gibt es eig eine Möglichkeit das delay für den Trigger durch was anders 
zu ersetzten mit selben Effekt ?

[Joe F. (easylife)]

Sebi schrieb:
> Gibt es eig eine Möglichkeit das delay für den Trigger durch was anders
> zu ersetzten mit selben Effekt ?

Es gibt da viele Möglichkeiten, allerdings ist das ja keine allzu 
schlechte Lösung, wenn dein uC während der Messung nichts anderes tun 
muss.

Allerdings fällt mir bei dieser Gelegenheit ein weiteres Problem auf:
Der Sensor kann max. 50 Messungen pro Sekunde machen.
Die Berechnung der Zeitdifferenz wird vernachlässigbar wenig Zeit 
brauchen, so dass deine Abtastung u.U. viel zu schnell abläuft.
Du solltest nach der Berechnung der Zeitdifferenz also noch ein weiteres 
Delay einbauen, damit die nächste Abtastung frühestens 1/50s nach der 
vorherigen startet.
Als ersten Ansatz könnte man ja die Zeitdifferenz in ms umrechnen, und 
dann ein weiteres Delay einfügen mit t_wait = 20ms - Zeitdifferenz(in 
ms)

[Sebi (Gast)]

stimmt ein Messzyklus liegt im Moment bei 72us + der Laufzeit.

[Sebi (Gast)]

Wundert mich nur das er im Moment nicht einen Fehler mehr macht wobei er 
im schnitt mit fast 1kHz läuft.

[Joe F. (easylife)]

Vielleicht geht es technisch ja und die 50Hz sollten nicht überschritten 
werden, damit das Ding nicht zu heiss wird?
Der Transducer haut unter Umständen ziemlich laute Pulse raus und möchte 
dann ein wenig abkühlen.

[Sebi (Gast)]

Also hab gerade noch mal alles durchgerechnet: der Programmablauf 
benötigt 72us. Die Messung für eine Entfernung von 10cm nimmt ca 600us 
in Anspruch dann wäre ich bei einer Messfrequenz oberhalb von 1,5kHz

[Sebi (Gast)]

Also Temperatur ist es schonmal nicht. Das teil läuft seit 2 Stunden 
ohne pause und hat Raumtemperatur.

[Joe F. (easylife)]

Achso, ne die 50Hz ergeben sich durch die max. zu erwartende Laufzeit.
Bei der Reichweite des Moduls von 3m sind das 17.5-18ms.
D.h. also, je näher dein Objekt ist, desto öfter kannst du abfragen.
Ergibt sich ja dann auch automatisch dadurch, dass complete_hc früher 
auf 1 geht.
Ich würde es trotzdem nicht übertreiben, und auch bei nahen Objekten 
eine vernünftige Zeit warten. Du hast ja auch Echos im Raum, die erstmal 
abklingen sollten.

[Sebi (Gast)]

Ich hatte das mit den 50 Hz Messfrequenz auch schonmal gelesen aber hab 
mir gerade das Datasheed mal angesehen. Da steht kein Limit der 
Messungen drinne

[Sebi (Gast)]

Also wenn man kein Signal empfängt geht er sogar 200ms auf High damit 
wären nur 5 Messungen pro sekunde möglich passt auch wenn man den 
Trigger mal beim messen zuhält.

[Joe F. (easylife)]

Ja, wie gesagt, das ist glaube ich eher ein theoretisches Limit, dass du 
auch bis 3m mit 50Hz abtasten kannst.
Aber es könnte ein Grund für deine Ausreisser sein.

Wenn dein Hauptobjekt sagen wir mal 20cm entfernt ist, und in 30cm 
Entfernung ein weiteres Objekt steht, dann misst du das 1. Echo bei 
20cm.
Dann startest du direkt die nächste Messung, und der Sensor empfäng das 
2. Echo der vorherigen Messung.
Das sieht dann so aus, als ob das Objekt plötzlich nur 10cm entfernt 
ist.

[Sebi (Gast)]

ok das ist richtig dann müsste ich aber von der Frequenz noch weiter 
runter gehen, da er zwar nur eindeutig bis 4m die echos aber keine 
grenze haben. Bzw die grenze durch ihre Wellenlänge. Aber ich behalte es 
mal im hinter kopf.

[Joe F. (easylife)]

Vermutlich sind deswegen die 50Hz empfohlen.

Ich glaube ich muss mir mal so ein Modul bestellen. Hab grad selber Bock 
damit rumzuspielen.
So richtig geil wäre ja, man würde das Modul so modifizieren, dass man 
den Empfänger für eine definierte Zeit "taub" stellen kann.
Dann könnte man das 1. Echo messen, wüsste die Entfernung zum ersten 
Objekt, und würde bei der 2. Messung den Empfänger so lange disablen, 
bis das erste Echo vorbei ist. Dann müsste man das nächste Echo "sehen " 
können, usw... Verstehste?

[A. S. (Gast)]

Eine Frage hätte ich noch: Wofür brauchst Du eigentlich die 
Interrupt-Routine?

Du schaltest doch vermutlich einen Sender mit

>       PORTB |= (1<<HC_TRIGGER);
oder
>       PORTB &= ~(1<<HC_TRIGGER)
ein und wartest dann auf die Antwort. Warum nicht einfach plain code?

Sebi schrieb:

  while(i<20)
  {
    /* einschalten (?) */
    PORTB |= (1<<HC_TRIGGER);
    /* Zeit Messen */
    Timestart = timer0;
    delay(40);
    /* abschalten */
    PORTB &= ~(1<<HC_TRIGGER);
    /* warten bis empfang */
    while(...); 
    /* Ende der Zeitmessung */
    Timestop = timer0;
    /* wie gewohnt ... */
    if((Timedifferenz < 2) || (Timedifferenz > 4000))
    {
       ...
    }
    ...
  }

Wenn der Empfang schon im Delay sein darf ... na, auch das wäre einfach.

Eventuell macht es sogar Sinn, den Timer neu zu starten für jede 
Messung, dann entfällt die Subtraktion. Oder Du startest die Messung 
beim 0-Durchgang des Timers, dann hast Du die Verzögerung.

[Sebi (Gast)]

Ich war gerade am überlegen wie viele Messwerte ich Prozentual für die 
Mittelwertbildung nutzen sollte. Dachte da an Gauß mit knapp 2/3 der 
Messergebnisse, da sollten die groben aussreisser ja raus sein oder ?

[Sebi (Gast)]

Jap versteh was du meinst Joe.

Zum Timer mit den zurücksetzten hatte ich auch schonmal überlegt wurde 
mir aber von abgeraten, da ich im schlimmsten fall eine Zeiteinheit 
verlieren kann, wenn während des zurücksetztens gerde der Timer um 1 
hochzählt.

Zu dem Interrupt ich habe es per Interrupt gemacht, weil es schneller 
ging und ich noch 3 andere Interrupts am laufen habe welche gesperrt 
werden während der Interrupt des HC ausgeführt wird, und somit 
gewährleistet ist das kein Interrupt die Messungstört.

[Achim (Gast)]

Sebi schrieb:
> weil es schneller ging und ich noch 3 andere Interrupts am laufen habe
> welche gesperrt werden während der Interrupt des HC ausgeführt wird,

Verstehe ich nicht. Was sind das für Interrupts und ist sicher, dass der 
Interrupt der Messung die anderen unterbricht?

[Sebi (Gast)]

Ja ist weiter oben eingestellt, das keine Interrupts während eines 
Interrupts statt findet.

[A. S. (Gast)]

Sebi schrieb:
> Ja ist weiter oben eingestellt, das keine Interrupts während eines
> Interrupts statt findet.

hast Du oben was dazu geschrieben? Naja, wenigstens weisst Du nun, warum 
Du manchmal ausreißer hast. Wenn die anderen Interrupts während der 
Messung wichtig sind, brauchst du um ein input capture timer.