SRV05 Ultraschallsensor

[Jens K. (mister232)]

Ich versuche mich gerade daran einen Ultraschallsensor vom Typ SRV05 an 
einem ATmega328 zum laufen zu bringen. Folgender Code ist für das 
Handling des SRV05 zuständig:

/*
 * SRF05.c
 *
 * Created: 08.03.2016 11:36:49
 *  Author: Admin
 */ 

#include "SRF05.h"
#include "global.h"
#include "EDIP.h"
#include "uart.h"
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <string.h>


#define TRIGGER PB1
#define MEASURE PD3

volatile unsigned int microseconds = 0; // to save pulse length
volatile uint8_t INT1_interrupt = 0; // to indicate whether an INT1 interrupt has already occurred
volatile uint8_t measurement_complete = 0; // is used to indicate that the measurement is complete

// Function to initialize the SRF05-Interface
void SRF05_init(void)
{
  // Setup timer 1
  TCCR1A = (1<<WGM12); // CTC Mode of Timer 1
  // (8000000 / 8 ) / 10 = 1000 -> Every 1ms
  OCR1A = 10 - 1; // Interrupt fires every 10us
  TIMSK1 |= (1<<OCIE1A); // Enable compare interrupt
  
  DDRB |= (1<<TRIGGER); // set trigger pin to output
  
  DDRD &= ~(1<<MEASURE); // set INT1 as input
  EICRA |= (ISC10) | (ISC11);
  EIMSK |= (1<<INT1);
}


// Check distance
void SRF05_Measure(void)
{
  uint16_t dist = 0;
  char distanceBuf[20];
      
  dist = 0; // Reset distance
  microseconds = 0; // Reset ms counter
  TCNT1 = 0; // Set timer 1 to 0

  // Trigger the SRF05 measurement
  PORTB |= (1<<TRIGGER);
  _delay_ms(1); // 1ms trigger signal
  PORTB &= ~(1<<TRIGGER);
  uart_send("Trigger\n\r", 9);

  while(measurement_complete != 1); // wait until measurement is complete


  measurement_complete = 0; // Reset

  dist = microseconds / 29  ;

  // Print distance to LCD
  sprintf(distanceBuf, "Distanz: %ucm", dist);
  LCD_clearLine(0x11);
  LCD_Puts(distanceBuf, strlen(distanceBuf), 0x00, 0x11, 'L');
}


// Interrupt for signal from SRF05
ISR(INT1_vect)
{
   // Only if there hasn't been triggered on a rising edge yet
  if(INT1_interrupt == 0)
  {
    TCCR1B |= (1<<CS11); // Start timer with prescaler 8
    EICRA |= (1<<ISC11); // Set INT1 to trigger in falling edge
    EICRA &= ~(1<<ISC10);

    INT1_interrupt = 1; // To indicate, that an interrupt has already occurred
  }
  else
  {
    TCCR1B &= ~(1<<CS11); // Stop Timer

    INT1_interrupt = 0; // Reset variable
    measurement_complete = 1; // Variable to indicate end of measurement
  }

  
  EIFR = (1<<INTF1);
}


//Interrupt every 10µs
ISR(TIMER1_COMPA_vect)
{
  microseconds += 10;
}

Leider funktioniert es nicht so richtig. Auf dem LA sehe ich, dass der 
SRV05 sein Startsignal bekommt und brav darauf antwortet. Der µC zeigt 
mir nur einmal 0cm an, beim zweiten Aufruf der Funktion sendet er das 
Startsignal und hängt sich auf. Auf dem LA sehe ich, dass aber auch die 
zweite antwort vom SRV05 korrekt gesendet wird

[N. G. (newgeneration)]

ein Tipp von mir:

der SRF05 gibt ja pro cm 58us high zurück, also: lass einen Timer alle 
58us ein hoch zählen (ab einfachsten im CTC-mode)

Ich würde die PCInts nehmen (nehme ich generell lieber). Diese reagieren 
auf jeden Flankenwechsel.
D.h. bei der Steigenden Flanke speicherst du dir den 58us-Timerwert ab.
Bei einer fallenden Flanke ziehst du den aktuellen Timerwert vom 
gespeicherten ab.
UND: das ist deine Distanz in Zentimetern.

Denke allerdings dran, dass wenn du den Mode mit nur einem 
Auslöse-/Echo-Pin nimmst, du vor dem Start-Signal die PCInts abschalten 
musst und danach wieder ein.

Zu deinem Code:
warum nutzt du Interrupts, wenn du sowieso auf das Ergebnis wartest?
Dann könnte man einfach pollen und dein Problem würde wahrscheinlich 
einfacher zu lösen sein.

//liefert die Entfernung zum Objekt in cm
void srf05_get_distance(void) {
    PORT_START_PIN |= (1 << START_PIN);
    _delay_ms(1);
    PORT_START_PIN |= (1 << START_PIN);
    while (! (PIN_MEASURE_PIN & (1 << MEASURE_PIN))) ; //auf steigende Flanke warten
    uint16_t starttime = currentTick58us(); //den aktuellen Timer-wert speichern
    while (PIN_MEASURE_PIN & (1 << MEASURE_PIN)) ; //auf fallendeFlanke warten
    return currentTick58us() - starttime; //das ist dann schon die Distanz
}

[Jens K. (mister232)]

Vielen Dank. Werde ich gleich mal ausprobieren. Ich habe gerade gemerkt, 
dass ich überall SRV05 statt SRF05 geschrieben habe...ups :-)

[Jens K. (mister232)]

Habe den COde jetzt mal wie folgt abgeändert:

/*
 * SRF05.c
 *
 * Created: 08.03.2016 11:36:49
 *  Author: Admin
 */ 

#include "SRF05.h"
#include "global.h"
#include "EDIP.h"
#include "uart.h"
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <string.h>


#define TRIGGER PB1
#define MEASURE PD3

uint16_t timerCNT = 0;

// Function to initialize the SRF05-Interface
void SRF05_init(void)
{
  // Setup timer 1
  TCNT1 = 65478; // Preload
  TCCR1B |= (1<<CS11); // Prescaler 8
  TIMSK1 |= (1<<TOIE1); // Enable overflow interrupt
  
  DDRB |= (1<<TRIGGER); // set trigger pin to output
}


// Task, which periodically checks the distance
void SRF05_Measure(void)
{
  uint16_t dist = 0;
  char distanceBuf[20];
      
  dist = 0; // Reset distance

  // Trigger the SRF05 measurement
  PORTB |= (1<<TRIGGER);
  _delay_ms(1); // 1ms trigger signal
  PORTB &= ~(1<<TRIGGER);


  while(!(PIND & (1<<MEASURE))); // Wait for rising edge
  timerCNT = 0; // Reset timer 1
  while(PIND & (1<<MEASURE)); // Wait for falling edge
    
  dist = timerCNT;

  // Print distance to LCD
  sprintf(distanceBuf, "Distanz: %dcm", dist);
  LCD_clearLine(0x32);
  LCD_Puts(distanceBuf, strlen(distanceBuf), 0x00, 0x32, 'L');
}


//Interrupt every 58µs
ISR(TIMER1_OVF_vect)
{
  timerCNT++;
}

Jetzt funktioniert die Messung zwar dauerhaft, aber leider kommt immer 
nur 0cm raus. Ein test zeigt, dass er in der Wartezeit garnicht 
hochzählt.

[Tom (Gast)]

Jens K. schrieb:
> Ein test zeigt, dass er in der Wartezeit garnicht
> hochzählt.

Ich sollte mal einen Bot programmieren, der immer diesen Link postet ;)
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Datenaustausch_mit_Interrupt-Routinen

[N. G. (newgeneration)]

Hallo nochmal,

dein Timer stimmt leider noch nicht.

Jens K. schrieb:
> uint16_t timerCNT = 0;

volatile fehlt, sonst kriegt der Compiler das ändern in der ISR nicht 
mit, bzw. er optimiert es, da er denkt, dass die Variable nie geändert 
wird.

Jens K. schrieb:
> // Setup timer 1
>   TCNT1 = 65478; // Preload
>   TCCR1B |= (1<<CS11); // Prescaler 8
>   TIMSK1 |= (1<<TOIE1); // Enable overflow interrupt

der Preload ist zwar gut gemeint, gilt aber leider nur bis zum ersten 
Overflow, ab da zählt der Timer wieder schön von 0 hoch.

Jens K. schrieb:
> //Interrupt every 58µs
> ISR(TIMER1_OVF_vect)
> {
>   timerCNT++;
> }
Du müsstest dann hier auch einen Preload machen.
Aber warum das? Setze dich mal mit dem CTC mode auseinander.

Dieser setzt den Timer beim erreichen der ISR automatisch auf 0 zurück.
Ein Beispiel:

TIMSK5 = (1 << OCIE5A);
TCCR5B = (1 << CS51) | (1 << WGM52);  //prescaler 8, CTC
OCR5A = 58 * 2; //58us@16MHz

Aber eigentlich sollte mit einem richtigen Timer der Code klappen

[Jens K. (mister232)]

Super, jetzt klappt es. Vielen Dank!