Ultraschallsensor und ATmega 2560

[Fabio M. (fabiom)]

Hallo,

ich möchte seriell die Distanz eines HC-SR04 Sensors ausgeben. Die 
Ausgabe funktioniert super. Außerdem habe ich auch eine Funktion die wie 
micros() von Arduino funktioniert. Aber statt eine Funktion ist es eine 
Variable.

Ich mache alles in Atmel Studio auf einem Arduino Mega 2560, benutze 
aber nicht die Arduino IDE und ihren Code. Manchen Code habe ich aus der 
NewPing libary kopiert und verändert.

Leider gibt mir meine Funktion aber nur falsche Werte aus. Wenn ich die 
Hand ca. 10cm vor den Sensor halte, bekomme ich den Wert 23-24. Wenn er 
kein Signal zurück bekommt gibt er 0 aus. Ich würde den richtigen 
CM-Wert erwarten.

Könnt ihr mir bitte meine Fehler sagen? Hier ist der Code.

main.c

 
#include <avr/io.h>
#include "Serial.h"
#include "Ultrasonic.h"
#include <util/delay.h>
#include "avr/interrupt.h"

int main(void) {
  SerialInit();
  UltrasonicInt();
  
  // set up timer 0
  TCCR0B = (1<<CS01); // Prescaler 8
  TIMSK0 |= (1<<TOIE0);
  sei();
  
  while(1) {
    SerialPrintNumberULong(UltrasonicRead(300, 0));
    SerialPrint("\n");
    _delay_ms(100);
  }
}

Ultrasonic.c

#include "Ultrasonic.h"
#include <util/delay.h>
#include <avr/interrupt.h>

unsigned long microseconds = 0;

#define US_ROUNDTRIP_CM  57     // Microseconds (uS) it takes sound to travel round-trip 1cm (2cm total), uses integer to save compiled code space
#define NO_ECHO          0      // Value returned if there's no ping echo within the specified MAX_SENSOR_DISTANCE or maxCmDistance
#define MAX_SENSOR_DELAY 5800   // Maximum uS it takes for sensor to start the ping
#define PING_OVERHEAD    5      // Ping overhead in microseconds (uS)

unsigned int maxEchoTime;
unsigned long maxTime;

bool ping_trigger() {
  PINL &= ~(1 << PL6);                    // Set the trigger pin low, should already be low, but this will make sure it is.
  _delay_ms(4);                        // Wait for pin to go low.
  PINL |= (1 << PL6);                    // Set trigger pin high, this tells the sensor to send out a ping.
  _delay_ms(15);                        // Wait long enough for the sensor to realize the trigger pin is high. Sensor specs say to wait 10uS.
  PINL &= ~(1 << PL6);                    // Set trigger pin back to low.
  
  if (PIND & (1 << PD0))
    return false;                      // Previous ping hasn't finished, abort.
  
  maxTime = microseconds + maxEchoTime + MAX_SENSOR_DELAY;  // Maximum time we'll wait for ping to start (most sensors are <450uS, the SRF06 can take up to 34,300uS!)
  while (PIND & (1 << PD0))                  // Wait for ping to start.
    if (microseconds > maxTime)
      return false;                    // Took too long to start, abort.
  maxTime = microseconds + maxEchoTime;            // Ping started, set the time-out.
    return true;                      // Ping started successfully.
}

void UltrasonicInt(void) {
  DDRL |= (1 << PL6);  //Trigger as OUTPUT
  DDRD &= ~(1 << PD0); //Echo as INPUT
}

unsigned long UltrasonicRead(long maxCM, uint8_t nr) {
  switch (nr) {
    case 0:
      if (maxCM > 0)
        maxEchoTime = (maxCM+1) * US_ROUNDTRIP_CM;      // Call function to set a new max sensor distance.

      if (!ping_trigger())
        return NO_ECHO;                    // Trigger a ping, if it returns false, return NO_ECHO to the calling function.
  
      while (PIND & (1 << PD0))                // Wait for the ping echo (Read echo)
        if (microseconds > maxTime)
          return NO_ECHO;                  // Stop the loop and return NO_ECHO (false) if we're beyond the set maximum distance.
      
      unsigned long echoTime = (microseconds - (maxTime - maxEchoTime) - PING_OVERHEAD); // Calculate ping time, include overhead.
      if(echoTime)
        return ((unsigned int) echoTime + US_ROUNDTRIP_CM / 2); //(max(((unsigned int) echoTime + US_ROUNDTRIP_CM / 2) / US_ROUNDTRIP_CM, 1)); // Convert uS to centimeters.
      else
        return 555; //(max(((unsigned int) echoTime + US_ROUNDTRIP_CM / 2) / US_ROUNDTRIP_CM, 0)); // Convert uS to centimeters
      break;
    default:
      return 0;
  }
}

ISR(TIMER0_OVF_vect) {
  microseconds++;
}

Ultrasonic.h

#ifndef ULTRASONIC_H_
#define ULTRASONIC_H_

#include "avr/io.h"
#include <stdbool.h>

extern unsigned long microseconds;

//Init of all Ultrasonics
void UltrasonicInt(void);

//Read an Ultrasonic Sensor
unsigned long UltrasonicRead(long max, uint8_t nr);

bool ping_trigger();

#endif /* ULTRASONIC_H_ */

[Stefan F. (Gast)]

Dein Mikrosekunden-Timer ist viel zu schnell. So schnell kann der AVR 
die ISR gar nicht ausführen. Außerdem muss die Variable als volatile 
gekennzeichnet werden.

Ich schlage einen anderen wesentlich simpleren Lösungsansatz ohne Timer 
und ohne diese umfangreiche Mathematik vor: 
http://stefanfrings.de/hc-sr04/index.html

[Fabio M. (fabiom)]

Stefanus F. schrieb:
> Dein Mikrosekunden-Timer ist viel zu schnell. So schnell kann der AVR
> die ISR gar nicht ausführen. Außerdem muss die Variable als volatile
> gekennzeichnet werden.
>
> Ich schlage einen anderen wesentlich simpleren Lösungsansatz ohne Timer
> und ohne diese umfangreiche Mathematik vor:
> http://stefanfrings.de/hc-sr04/index.html

Vielen Dank. Es funktioniert. Aber das Problem ist, dass ich ca. 10 
Sensoren benutzen möchte und das spätere Programm in 10-20ms Takt 
arbeiten soll. Alle 3-6 Takte soll er dann die Sensoren abfragen. Dafür 
ist die Methode dann nicht die beste. Kannst du mir sagen wie ich bei 
meinem Code den Timer langsamer stellen kann?

[Joachim B. (jar)]

Fabio M. schrieb:
> Aber das Problem ist, dass ich ca. 10
> Sensoren benutzen möchte und das spätere Programm in 10-20ms Takt
> arbeiten soll.

dann schmeisse die delay raus und baue das zu einer state machine um

Arduino wait without delay wäre was zum LESEN
https://playground.arduino.cc/Learning/BlinkWithoutDelayDe

https://de.wikipedia.org/wiki/Endlicher_Automat
https://www.mikrocontroller.net/articles/Statemachine

[Stefan F. (Gast)]

Fabio M. schrieb:
> Kannst du mir sagen wie ich bei
> meinem Code den Timer langsamer stellen kann?

Das ergäbe wenig Sinn. 10µs wären vielleicht machbar, aber dann wird die 
Messung schon recht ungenau. Das problem ist auch, dass du mit zu vielen 
Interrupts riskierst, dass dein Hauptprogramm zu langsam wird und daher 
das Ergebnis ungenau wird.

Ich nehme mal an, dass die 10 Sensoren räumlich getrennt sind und 
gleichzeitig arbeiten können. Dann würde ich so vorgehen:

Triggere alle 10 Sensoren gleichzeitig, lass dann die 58µs Schleife so 
oft wiederholen, bis alle Sensoren das Echo erfasst haben (oder in den 
Timeout gelaufen sind). Du kannst für jeden Sensor einzeln die Zeit 
speichern. Etwa so:

        
        int16_t cm=0;  

        // Trigger a measurement
        TRIGGER_ON;
        _delay_us(10);
        TRIGGER_OFF;
        
        // Wait for response
        // Assuming that all sensors need the same time
        while (!ECHO_SIGNAL_SENSOR1);
  
        // Measure pulse width of all 10 sensors
        while (cm<300)
        {
            if (ECHO_SIGNAL_SENSOR1) value1=cm;
            if (ECHO_SIGNAL_SENSOR2) value2=cm;
            if (ECHO_SIGNAL_SENSOR3) value3=cm;
            if (ECHO_SIGNAL_SENSOR4) value4=cm;
            if (ECHO_SIGNAL_SENSOR5) value5=cm;
            if (ECHO_SIGNAL_SENSOR6) value6=cm;
            if (ECHO_SIGNAL_SENSOR7) value7=cm;
            if (ECHO_SIGNAL_SENSOR8) value8=cm;
            if (ECHO_SIGNAL_SENSOR9) value9=cm;
            if (ECHO_SIGNAL_SENSOR10) value10=cm;
            _delay_us(57);
            cm++;
        }

Die 58µs habe ich auf 57 reduziert, um die Zeit auszugleichen, die für 
die ganzen if-Abfragen drauf geht. Vielleicht muss man sogar noch etwas 
mehr abziehen. Das kannst du ja mal ausmessen oder anhand des 
Assembler-Listings ausrechnen.

Das Prinzip müsste so klar sein, oder?

[Fabio M. (fabiom)]

Ja, vielen Dank.

[Stefan F. (Gast)]

Joachim B. schrieb:
> dann schmeisse die delay raus und baue das zu einer state machine um

Ja, das wäre auch denkbar, dann braucht es allerdings einen Timer der im 
58µs Raster hoch zählt.

Schwierig stelle ich mir dann allerdings vor, den richtigen Moment für 
den Beginn der Messung abzupassen. Ich meine den Moment, wo das Echo 
Signal auf High geht.

Ich bemerke grade einen Fehler: bei den 10 if Abfragen muss ein ! rein, 
weil das Echo Signal der Sensoren auf Low geht, wenn die Messung beendet 
ist.

[Fabio M. (fabiom)]

Stefanus F. schrieb:
> Joachim B. schrieb:
>> dann schmeisse die delay raus und baue das zu einer state machine um
>
> Ja, das wäre auch denkbar, dann braucht es allerdings einen Timer der im
> 58µs Raster hoch zählt.
>
> Schwierig stelle ich mir dann allerdings vor, den richtigen Moment für
> den Beginn der Messung abzupassen. Ich meine den Moment, wo das Echo
> Signal auf High geht.
>
> Ich bemerke grade einen Fehler: bei den 10 if Abfragen muss ein ! rein,
> weil das Echo Signal der Sensoren auf Low geht, wenn die Messung beendet
> ist.

Welchen Timer bzw. Prescaler sollte ich dafür wählen? Kann mir jemand 
auf die Sprünge helfen?

[my2ct (Gast)]

Fabio M. schrieb:
> Welchen Timer bzw. Prescaler sollte ich dafür wählen? Kann mir jemand
> auf die Sprünge helfen?

Probiers aus, denk selber nach.

Welchen statistischen Fehler hat die Länge deines Eingangssignals?
Das ist der Maßstabe für deine Auflösung beim Timer. Die Zeit viel 
genauer zu messen ist oft wenig sinnvoll, weil die letzten Bits dann nur 
noch Hausnummern enthalten.

Wie lang ist deine längste Pulsdauer vom US-Geber?
Das muss dein Timer noch auszählen können.

u.s.w.

[Stefan F. (Gast)]

Fabio M. schrieb:
> Welchen Timer bzw. Prescaler sollte ich dafür wählen? Kann mir jemand
> auf die Sprünge helfen?

Ich denke jetzt nur mal laut, ohne ins Datenblatt zu schauen:

8MHz Systemtakt geteilt durch Prescaler 8 ergibt einen Timer-Takt von 
1MHz (1µs). Wenn man den Timer jetzt so einstellt, dass er immer von 
Null bis 58 zählt und dann einen Interrupt auslöst, wird die ISR alle 
58µs aufgerufen.

58µs Intervalle ergeben Messwerte mit 1cm Auflösung. 29µs Intervalle 
ergeben Messwerte mit 0,5cm Auflösung. Noch höhere Auflösung macht 
keinen Sinn, weil die Messung alleine schon aufgrund von 
Temperaturschwankungen viel mehr vom Soll abweicht.

> Wie lang ist deine längste Pulsdauer vom US-Geber?

Je nach Händler werden da 29ms (5 Meter) bis 41ms (7 Meter) angegeben. 
Ich weiß aber aus Erfahrung, dass diese Sensoren nur bis etwa 17ms (3 
Meter) zuverlässig funktionieren. Diesen Wert hatte der TO in seinem 
ersten Programmentwurf auch als Limit festgelegt.

Da fällt mir gerade etwas auf: Fabio, du willtest im 10-20ms Intervall 
messen. Aber so schnell sind die Sensoren gar nicht. Zwischen den 
Messungen soll man mindestens 60ms warten.

[Fabio M. (fabiom)]

Reicht für diese Anwendung ein 8bit Timer oder muss ich ein 16bit Timer 
nehmen. Mein Sensor kann bis max ca. 3Meter messen.

Stefanus F. schrieb:
> Da fällt mir gerade etwas auf: Fabio, du willtest im 10-20ms Intervall
> messen. Aber so schnell sind die Sensoren gar nicht. Zwischen den
> Messungen soll man mindestens 60ms warten.

Deshalb soll er nur jeden 6. Takt auslesen bzw. immer wenn er bereit 
ist.

[Stefan F. (Gast)]

Fabio M. schrieb:
> Reicht für diese Anwendung ein 8bit Timer oder muss ich ein 16bit Timer
> nehmen. Mein Sensor kann bis max ca. 3Meter messen.

Wie viele Bits braucht man, um bis 58 zu zählen? Du schaffst das!

[Fabio M. (fabiom)]

Ok, ich habe mal angefangen es umzusetzen. Ich habe den Timer0 (8Bit) 
benutzt. Dieser zählt von 0-58, und das immer. Aber was mir noch nicht 
klar ist, wann ich trigger bzw. lesen muss.

[Wolfgang (Gast)]

Stefanus F. schrieb:
> Noch höhere Auflösung macht keinen Sinn, weil die Messung alleine
> schon aufgrund von Temperaturschwankungen viel mehr vom Soll abweicht.

Das ist kein Argument. Der ATmega kann mit einem Quarz laufen und die 
Abhängigkeit der Schallgeschwindigkeit von der Temperatur ist bekannt, 
kann also ohne weiteres berücksichtigt werden, wenn man sich noch einen 
Temperatursensor spendiert.

Da kommt es auf die Anforderungen an.

[Fabio M. (fabiom)]

Solche Genauigkeit brauche ich nicht. Ein Zentimeter genau ist schon 
mehr als nur perfekt.

Ich habe jetzt mal ein bisschen rumprobiert. Leider klappt es noch nicht 
so. Er gibt mir immer 0 aus. Und nach ca. 10 Sekunden ist irgendetwas so 
schief gelaufen, dass er nur noch nicht erkannte Zeichen ausgibt. Den 
Fehler konnte ich selbst leider nicht finden. Hier ist der Code:

#include <avr/io.h>
#include "Serial.h"
#include <util/delay.h>
#include "avr/interrupt.h"
#include <stdbool.h>

volatile uint8_t usZumNachtsenCM = 0;
volatile bool Trigger = true;

// The Ultrasonic sensor is connected to Port D2 and D3
#define TRIGGER_ON   { DDRL |= (1<<PL6); PORTL |= (1<<PL6); }
#define TRIGGER_OFF  { PORTL &= ~(1<<PL6); }
#define ECHO_SIGNAL  ( PIND & (1<<PD0) )

int16_t cm = 0;

int main(void) {
  SerialInit();

  sei();

  while(1) {
    SerialPrintNumber(cm);
    SerialPrintln("");
  
         _delay_ms(100);
    
  }
}

volatile bool ready = true;
volatile bool newTrigger = true;
ISR(TIMER1_OVF_vect) {
  newTrigger = false;
  if (usZumNachtsenCM == 0 && ready) {
    TRIGGER_ON;
    newTrigger = true;
  } 
  else if (usZumNachtsenCM == 10 && ready) {
    TRIGGER_OFF;
    ready = false;
    newTrigger = true;
  } 
  
  if (ECHO_SIGNAL && ((usZumNachtsenCM == 58 && !newTrigger) || (usZumNachtsenCM == 68 && newTrigger))) {
    ready = false;
    usZumNachtsenCM = 0;
    cm++;
  } else {
    ready = true;
  }
  usZumNachtsenCM++;
}

[Stefan F. (Gast)]

Wenn dies das ganze Programm ist, wird die ISR niemals aufgerufen. Der 
Timer wird gar nicht gestartet. Außerdem hast du munter Mikrosekunden 
und 58µs Intervalle durcheinander gewürfelt.

Ich schlage vor, dass Du mal im Datenblatt das Kapitel für den Timer 0 
mindestens 3 mal durchliest. Ziel ist, dass der Timer alle 58µs einen 
Interrupt auslöst.

Dann lies meine Einleitung zu Zustandsautomaten: 
http://stefanfrings.de/net_io/protosockets.html (die obere Hälfte). In 
meinem Buch 
http://stefanfrings.de/mikrocontroller_buch/Einstieg%20in%20die%20Elektronik%20mit%20Mikrocontrollern%20-%20Band%203.pdf 
Band 3 Kapitel 9.1.4 findest du ein konkretes Anwendungsbeispiel mit 
einer LED Anzeige.

Das Starten der Messung und das Messen der Pulsbreite solltest du 
außerhalb der ISR machen, sonst läufst du ganz schnell Gefahr, dass 
deine ISR selbst länger als 58µs benötigt und du dann wieder das gleiche 
Problem bekommst, wie in deinem ersten Beitrag. Vergiss nicht, dass du 
am Ende 10 Sensoren abfragen willst.

Alle Variablen, die in ISR geändert und außerhalb der ISR gelesen werden 
(oder umgekehrt) müssen volatile sein. Außerdem muss man außerhalb der 
ISR beim Zugriff auf Variablen größer als 8bit vorher cli() und danach 
sei() aufrufen, damit die Variable nicht während des Zugriffes durch die 
ISR verändert wird. Der Zugriff auf diese Variablem ist relativ 
ineffizient, deswegen sollte man nicht unnötig viele verwenden.

Die Vorgehensweise ist so:

Die ISR soll alle 58µs vom Timer aufgerufen werden und einfach nur eine 
Variable hochzählen. Nennen wir sie uint32_t systick (8bit wäre zu 
klein).

uint32_t volatile systick=0;

ISR(TIMER1_OVF_vect) 
{
    systick++;
}

Dann schreibst du dir noch eine Funktion, mit der du systick sicher 
lesen kannst ohne dass die ISR dazwischen funkt:

uint32_t getSystick() 
{ 
    uint32_t temp;
    cli();
    temp=systick;
    sei();
    return temp;
}

;

In der Hauptschleife sendest du das Trigger Signal an den Sensor und 
kopierst die Variable "systick" in eine Variable "started" die unbedingt 
den gleichen Typ (uint32_t) haben muss, wie systick.

uint32_t started;

TRIGGER_ON;
_delay_us(10);
TRIGGER_OFF;
started=getSystick();

Dann wartest du, bis die Messung beendet ist.

if (!ECHO_SIGNAL)
{
    cm = getSystick() - started;
}

Selbst wenn systick zwischendurch einmal überläuft (von 0xFFFF auf 0) 
kommt dabei trotzdem das richtige Ergebnis heraus.

Jetzt hast du geschrieben, dass dein Hauptprogramm irgend etwas im 10ms 
Intervall machen soll. Du musst also abfragen können, ob inzwischen 10ms 
verstrichen sind. Das macht man so:

uint32_t anfang = getSystick();

... irgendwas machen

uint32_t jetzt=getSystick();
if (jetzt-anfang > 10000/58)
{
    // es sind 10ms verstrichen
}

Um blöden Sprüchen von den erfahrenen Entwicklern zuvor zu kommen:

a) Anstatt cli() und sei() kann man auch die Makros aus der <atomic.h> 
verwenden. 
https://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html 
Manche Leute denken, dass der Code auf diese Weite besser auf andere 
Mikrocontroller portierbar ist.

b) In Zustandsautomaten empfiehlt es sich, Enumeration anstatt Zahlen 
für den Zustand zu benutzen. Denn dann hat man sprechende Namen und man 
kann leichter etwas mittendrin einfügen.

[Stefan F. (Gast)]

Wolfgang schrieb:
> Da kommt es auf die Anforderungen an.

Das habe ich schon berücksichtigt. Wer einen HC-SR04 verwendet hat keine 
hohen Anforderungen. Wenn der halbwegs korrekte Zentimeter-Werte 
liefert, kann man sich schon glücklich schätzen.

Wer mehr Genauigkeit braucht als +/-1 cm braucht, muss einen anderen 
Sensor verwenden. Das wird dem Fabio angesichts des Preises des Sensors 
sicher klar sein.

[Wolfgang (Gast)]

Fabio M. schrieb:
> Solche Genauigkeit brauche ich nicht. Ein Zentimeter genau ist schon
> mehr als nur perfekt.

Bei einer Temperaturänderung von 20 K weicht der Messungwert schon bei 
einer Strecke von 30 Zentimeter um mehr als einen Zentimeter vom wahren 
Wert ab.

[Fabio M. (fabiom)]

Ich muss euch allen schon einmal vielmals Danken. Es funktioniert jetzt. 
Ich habe den 10ms Takt erstmal weggelassen und nur 1 Sensor benutzt, 
aber ich kann es ja noch hinzufügen. Ich habe leider eine 10cm Toleranz. 
Das kann ich aber ja mit der Zeit anpassen. Trotzdem könntet ihr noch 
einmal über meinen Code schauen?

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "Serial.h"

//Variablen für die Zeit
volatile unsigned long USTimePerCM;
unsigned long cm = 0;
#define TRIGGER_ON   { DDRL |= (1<<PL6); PORTL |= (1<<PL6); }
#define TRIGGER_OFF  { PORTL &= ~(1<<PL6); }
#define ECHO_SIGNAL  ( PIND & (1<<PD0) )

unsigned long getUSTimePerCM() {
  unsigned long temp;
  cli();
  temp = USTimePerCM;
  sei();
  return temp;
}

int main()
{
  SerialInit();
  DDRB |= (1 << PB7);         //Builtin LED

    // Timer 0 konfigurieren
    TCCR0A = (1<<WGM01); // CTC Modus
    TCCR0B |= (1 << CS01); //Prescaler 8
    // ((1000000/8)/1000) = 125
  //prescaler: 8 116
  
    OCR0A = 116-1;
  
    // Compare Interrupt erlauben
    TIMSK0 |= (1<<OCIE0A);

    // Global Interrupts aktivieren
    sei();

  while(1) {
    unsigned long started;
    TRIGGER_ON;
    _delay_us(10);
    TRIGGER_OFF;
    started = getUSTimePerCM();
    while(!ECHO_SIGNAL);
    while(ECHO_SIGNAL)
    {
      cm = getUSTimePerCM() - started;
    }
    SerialPrintNumberULong(cm);
    SerialPrintln("");
    _delay_ms(60);
  }
}

ISR (TIMER0_COMPA_vect) {
  USTimePerCM++;
}

[Stefan F. (Gast)]

Fabio M. schrieb:
> Ich habe leider eine 10cm Toleranz.

Das klingt lustig. Erkläre mal, was du damit ausdrücken wolltest, ich 
komme nicht dahinter.

[Fabio M. (fabiom)]

Der Wert ist immer ungefähr 10cm höher.

[Stefan F. (Gast)]

Fabio M. schrieb:
> Der Wert ist immer ungefähr 10cm höher.

Das ist mehr als erwartet - sehr viel mehr.

Versuche mal, diese beiden Zeilen zu vertauschen:

started = getUSTimePerCM();
while(!ECHO_SIGNAL);

Begründung: Die Breite des Echo-Pulses (High Pegel) soll gemessen 
werden, nicht die Dauer vom Trigger bis zum Ende des Echo-Pulses.

[Fabio M. (fabiom)]

Perfekt! Jetzt ist es auf den Zentimeter genau.

[Stefan F. (Gast)]

Und jetzt 10 Sensoren:

    while(!ECHO_SIGNAL1); // assuming that all sensors need the same time

    started = getUSTimePerCM();
    uint8_t count=0;
    while(count<0)
    {
      if (!ECHO_SIGNAL1)
      {
        cm1 = getUSTimePerCM() - started;
      }
      if (!ECHO_SIGNAL2)
      {
        cm2 = getUSTimePerCM() - started;
      }
      ...
    }

Bist du sicher, dass du keine Zustandsautomaten verwenden willst? Der 
Vorteil wäre, dass du dann während der Messung noch was anderes machen 
könntest.

[Fabio M. (fabiom)]

Stefanus F. schrieb:
> Bist du sicher, dass du keine Zustandsautomaten verwenden willst? Der
> Vorteil wäre, dass du dann während der Messung noch was anderes machen
> könntest.

Doch, aber ich bin mir noch nicht 100% sicher wie er funktionieren soll. 
Wie Zustandsautomaten funktionieren können weiß ich. Aber nicht in 
diesem Fall.

Ich habe bis jetzt leider erst einen Sensor zu testen, die anderen 
werden noch geliefert.

[Fabio M. (fabiom)]

Stefanus F. schrieb:
> Bist du sicher, dass du keine Zustandsautomaten verwenden willst? Der
> Vorteil wäre, dass du dann während der Messung noch was anderes machen
> könntest.

Meinst du das als Zustandsautomat? Da es nur 2 Zustände hat habe ich es 
mit einer if-Abfrage gelöst.

  while(1) {
    if ((getUSTimePerCM() / 59)*1000 - lastChecked >= 60) {
      lastChecked = getUSTimePerCM();
      unsigned long started;
      TRIGGER_ON;
      _delay_us(10);
      TRIGGER_OFF;
      
      while(!ECHO_SIGNAL);
      
      started = getUSTimePerCM();
      while(ECHO_SIGNAL) {
        cm = getUSTimePerCM() - started;
        if (getUSTimePerCM() - started > 350)
        {
          cm = 350;
          break;
        }
      }
      SerialPrintNumberULong(cm);
      SerialPrintln("");
    }
  }

[Stefan F. (Gast)]

So ist gar nicht gut:
> if ((getUSTimePerCM() / 59)*1000 - lastChecked >= 60) {

Überlege mal, wie viel Rechenzeit wiegen dieser Zeile bei jedem 
Schleifendurchlauf drauf geht. Du hast da eine Division und eine 
Multiplikation bei jedem Schleifendurchlauf.

Besser so:

> if (getUSTimePerCM() - lastChecked >= 60*1000/58) {

Der Unterschied ist, dass in diesem Fall die Multiplikation und die 
Division beide vom Compiler vorberechnet werden können. Die Kosten zur 
Laufzeit sind 0.

60*1000/58 = 1034.

Das würde ich in eine definition auslagern, um dem Ausdruck einen 
sprechenden Namen zu geben:

#define TIME_60_MS = 60*1000/58;
if (getUSTimePerCM() - lastChecked >= TIME_60_MS) {
   ...
}

[Wolfgang (Gast)]

Stefanus F. schrieb:
> So ist gar nicht gut:
>> if ((getUSTimePerCM() / 59)*1000 - lastChecked >= 60) {
>
> Überlege mal, wie viel Rechenzeit wiegen dieser Zeile bei jedem
> Schleifendurchlauf drauf geht.

Das ist primär erstmal kein Rechenzeitproblem. Solange die Rechenung 
derart herbe Rundungsfehler produziert, gibt es noch ganz andere Gründe, 
bei einer Ganzzahlrechnung über die Reihenfolge der Rechenschritte 
nachzudenken.

[Stefan F. (Gast)]

Während du auf das Echo Signal wartest ist das Programm aber immer noch 
blockiert. Stelle Dir mal vor, du möchtest parallel dazu die Tasten 
eines Bedienfeldes abfragen oder eine LED blinken lassen. Das geht so 
nicht. Da musst du noch mehr Zustände einführen. Ein Zustandsautomat 
darf nur eine einzige Wiederholschleife enthalten, und zwar die 
main-loop. Und delays sind tabu.

int main()
{
   init_io_pins();
   init_timer();
   init_whatever();
   for(;;) // forever
   {
      measure_distances();
      query_buttons();
      blink_leds();
   }
}

void measure_distances()
{
    static enum {WAIT_60MS, TRIGGER_START, TRIGGER_TIME, WAIT_ECHO, MEASURE} status=WAIT_60MS;
    uint32_t lastChecked=0;
    uint32t echoStart=0;
    uint32_t triggerStart=0;
    
    switch (status)
    {
        case WAIT_60MS:
            if (getUSTimePerCM() - lastChecked >= TIME_60_MS) // 60ms elapsed
            {
                status=TRIGGER_START;
            }
            break;

        case TRIGGER_START:
            TRIGGER_ON;
            triggerStart=getUSTimePerCM();
            status=TRIGGER_TIME;
            break;

        case TRIGGER_TIME:
            if (getUSTimePerCM() - triggerStart >= 1) // 58µs elapsed
            {
                TRIGGER_OFF;
                status=WAIT_ECHO;
            }
            break;

        case WAIT_ECHO:
            if (ECHO_SIGNAL1) // echo signal begins (HIGH)
            {
                echoStart=getUSTimePerCM();
                echoCount=0;
                finishedBits=0;
                status=MEASURE;
            }
            break;

        case MEASURE:
            int needToWait=0;
            uint32_t now=getUSTimePerCM();
            if (ECHO_SIGNAL1)
            {
                needToWait=1;
            }
            else
            {
                cm1=now-echoStart;
            }
            if (ECHO_SIGNAL2)
            {
                needToWait=1;
            }
            else
            {
                cm2=now-echoStart;
            }
            ...
            if (ECHO_SIGNAL10)
            {
                needToWait=1;
            }
            else
            {
                cm10=now-echoStart;
            }

            if (needToWait==0) // All sensors are done (LOW)
            {
                lastChecked=now;
                status=WAIT_60MS;
            }
            break;
        }    
    }
}

Ich habe das jetzt einfach schnell runter getippt. Könnte Logik- und 
Syntaxfehler enthalten.

Der Triggerimpuls ist dieses mal 58µs lang, weil dies das kleinste 
messbare Intervall mit dem Timer ist.