SRF05 HILFE!

[verzweifelter Schüler (Gast)]

Hallo erstmals :)

Ich wollte Fragen ob mir jemand bei einem Problem helfen kann?

Ich bin Anfänger im Programmieren und komm überhaupt nicht mit dem SRF05 
Ultraschallsensor zu recht.

Ich habe ein Beispielcode gefunden jedoch will der SRF05 nicht wirklich 
was machen.

Was ich machen will ist das ich den Ultraschallsensor mit dem Modus 2 
zum laufen bekomme ich schaffe das leider nicht.

Vielleicht ist ein Fehler in der Library?

/*
*********************************************************
Filename:  SRF05.h
Version:  1.0
Date:    01.11.2012
Author:    Jascha Breithaupt
Website:  www.jaybe-stuff.de
*********************************************************
Description:
------------
This library is to use one Devantech SRF04/05 (or similar) by simply
including this header to your program.
See data sheet (ger/eng): 
http://www.robotikhardware.de/download/srf05doku.pdf
*********************************************************
Features:
---------
Mode 1:  - is fully compatible with SRF04/US-020/HC-SR04
    - uses 2 pins (echo/trigger)
Mode 2: - uses 1 pin (e.g. PD2/INT0)
Output:  - measured time (µs)
    - distance in cm
    - distance in inch
*********************************************************
How to use:
-----------
1.  Include "SRF05.h" in your code
2.  Check settings:
  choose mode        [1/2]
  configure pins      (e.g. PORTD/DDRD/PD2)
   define ISRs        (e.g. INT0_vect/TIMER0_COMP_vect)
  define CPU-clock    (e.g. 16000000UL -> UL: UnsignedLong)
3.  Initialize the sensor in your code:
  SRF05_INIT();
4.  Now you can get the data from your SRF05:
  value/time in µs:  SRF05_VALUE();
  distance in cm:    SRF05_CM();
  distance in inch:  SRF05_INCH();
  
*********************************************************
Code Example:
-------------
#define F_CPU 16000000UL

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

int main(void)
{
  SRF05_INIT();
  uint16_t distance = 0;
  
  while(1)
  {
    distance = SRF05_VALUE();
    distance = SRF05_CM();
    distance = SRF05_INCH();
  }
}
*********************************************************
Notes:
------
- Tested with Atmel ATMEGA32 @ 16MHz and Atmel Studio 6 SP1
- To use another INT or TIMER you have to fit registers!
*********************************************************
*/

/* ***************************************************** */
/*                   S E T T I N G S                     */
/* ***************************************************** */
// CHOOSE MODE
const uint8_t SRF05_MODE =  2;
/* ***************************************************** */
// CONFIGURE THESE FOR MODE 1
#define SRF05_TPORT      PORTD  //
#define SRF05_TREGISTER    DDRD  // TRIGGER
#define SRF05_TPIN      PD6    //

#define SRF05_EPORT      PORTD  //
#define SRF05_EREGISTER    DDRD  // ECHO
#define SRF05_EPIN      PD2    //
/* ***************************************************** */
// CONFIGURE THESE FOR MODE 2
#define SRF05_TEPORT    PORTD  //
#define SRF05_TEREGISTER  DDRD  // TRIGGER/ECHO
#define SRF05_TE      PD2    //
/* ***************************************************** */
// DEFINE INTERRUPT/TIMER ISR
#define SRF05_INT      INT0_vect
#define SRF05_TIMER      TIMER0_COMP_vect
/* ***************************************************** */
// DEFINE CPU
#ifndef F_CPU
#define F_CPU      16000000UL 
#endif
#ifndef XTAL
#define XTAL      16000000UL
#endif
/* ***************************************************** */
/*                 E N D   S E T T I N G S               */
/* ***************************************************** */
#pragma once            // MS-compiler
#include <util/delay.h>
#pragma once
#include <avr/interrupt.h>

volatile uint16_t  usec = 0;    // save pulse length in µs
volatile uint8_t  intocc = 0;    // indicate if interrupt has occurred
volatile uint8_t  meascomp = 0;  // indicate that measurement is complete
/* ***************************************************** */
/* ***************************************************** */


// INITIALIZE SRF05
void SRF05_INIT()
{
  // SETUP TIMER
  TCCR0  = (1 << WGM01);        // mode 2: CTC of Timer0  
  OCR0  = ((F_CPU/8)/100000)-1;    // ((16000000 / 8 ) / 100000) -1 = 19 -> 155 steps = interrupt every 10µs
  TIMSK  |= (1 << OCIE0);        // Enable Compare Match interrupt
  TCNT0  = 0;            // set timer to 0
  
  // SETUP INTERRUPT
  GICR   |= (1 << INT0);          // external interrupt mask register INT0
  MCUCR  = (1 << ISC01) | (1 << ISC00);  // trigger on rising edge

  // SETUP PINS
  if(SRF05_MODE == 1)
  {
    SRF05_TREGISTER |= (1 << SRF05_TPIN);  // set trigger pin to output
    SRF05_EREGISTER &= ~(1 << SRF05_EPIN);  // set echo pin/INT0 as input
  }
  if(SRF05_MODE == 2) // might be deleted  
  {
    SRF05_TEREGISTER |= (1 << SRF05_TE);  // set pin to output
  }
}

// GET DISTANCE VALUE (µs)
uint16_t SRF05_VALUE()
{
  usec = 0;      // reset microseconds counter variable
  TCNT0 = 0;      // set timer to 0

  // TRIGGER MEASUREMENT
  if(SRF05_MODE == 1)
  {
    SRF05_TPORT |= (1 << SRF05_TPIN);  // set trigger pin to 1
    _delay_us(10);            // minimum 10µs trigger signal
    SRF05_TPORT &= ~(1 << SRF05_TPIN);  // set trigger pin to 0
  }
  if(SRF05_MODE == 2)
  {
    _delay_ms(50);  // ensure the ultrasonic "beep" has faded away
    SRF05_TEREGISTER |= (1 << SRF05_TE);  // set pin to output
    SRF05_TEPORT |= (1 << SRF05_TE);    // set pin to 1
    _delay_us(10);
    SRF05_TEPORT &= ~(1 << SRF05_TE);    // set pin to 0
    SRF05_TEREGISTER &= ~(1 << SRF05_TE);  // set pin to input
    _delay_us(800);  // wait for SRF to change from trigger to echo
  }
    
  // TRIGGER INT0 ON RISING EDGE
  MCUCR = (1 << ISC01) | (1 << ISC00);

  // ENABLE INTERRUPTS
  sei(); 

  // WAIT UNTIL MEASUREMENT IS COMPLETE
  while(meascomp != 1){}
    
  // DISABLE INTERRUPTS
  cli(); 

  meascomp = 0;  // reset  
  
  return usec;  // value;
}

// GET DISTANCE IN CM
uint16_t SRF05_CM()
{  
  if(SRF05_MODE == 1){return SRF05_VALUE() / 58;}
  if(SRF05_MODE == 2){return SRF05_VALUE() / 58;}    // 29? -> data sheet
}

// GET DISTANCE IN INCH
uint16_t SRF05_INCH()
{
  if(SRF05_MODE == 1){return SRF05_VALUE() / 148;}
  if(SRF05_MODE == 2){return SRF05_VALUE() / 148;}  // 74? -> data sheet
}

// EXTERNAL INTERRUPT
ISR(SRF05_INT)
{  

  if(intocc == 0)
  {  // INTERRUPT ON RISING EDGE
    TCCR0 |= (1 << CS01); // start Timer0 with prescaler 8

    // TRIGGER INT0 ON FALLING EDGE
    MCUCR = (1 << ISC01) | (0 << ISC00); // EICRA = External Interrupt Control Register A

    intocc = 1; // to indicate, that an interrupt has already occurred
  }
  else
  {  // INTERRUPT ON FALLING EDGE
    TCCR0 &= ~(1<<CS01); // stop Timer0

    intocc = 0; // reset variable
    meascomp = 1; // variable to indicate end of measurement
  }
}

//INTERRUPT EVERY 10µS
ISR(SRF05_TIMER)
{
  usec += 10;
}

Eine andere Frage von mir ist wie kann ich die Takt des µC(ich verwende 
den ATMEGA16) ändern ?

Achja ich benutze einen STK500 mit ATMEL Studio 6.2.

Ich hoffe mich kann jemand mit seiner Weisheit erleuchten.

[Stefan F. (Gast)]

> Was ich machen will ist das ich den Ultraschallsensor
> mit dem Modus 2 zum laufen bekomme ich schaffe das leider nicht.

Du has vergessen, zu beschreiben, wo dein Problem ist. Ich werde nicht 
deinen ganzen Source im Kopf theoretisch analysieren. Du musst den 
fehler schon selbst einkreisen. Irgendwelche ideen, wie du vorgehen 
kannst?

> wie kann ich die Takt des µC ändern?

Du kannst extern unterschiedliche Taktquellen anschließen. Du kannst mit 
Fuses den Takteingang konfigurieren und einen Teiler durch 8 ein/aus 
schalten.

[J. D. (jch)]

Hallo,
ich nutze den selben Code von folgender Seite
http://jaybe-stuff.de/elektronik/ultraschallsensor-srf05/

Als Ultraschallsensor habe ich den HC-SR04 mit getrenntem Echo- und 
Triggerpin. Deshalb habe ich nur folgende Zeile geändert.

const uint8_t SRF05_MODE =  1;

Ich nutze AVR Studio 4 und einen ATmega16.
Wenn ich es compiliere und flashe, dann kann man den Ultraschallsensor 
sogar hören. Die Triggerfrequenz liegt schwankend bei 100-250Hz.

Was mache ich falsch? Ich habe nichts weiter geändert.

[Rainer V. (rudi994)]

Zum HC-SR04 habe ich Datenblätter mit unterschiedlichen Inhalten. Hier 
eine grobe Zusammenfassung:
- Den Sensor mit einem mind. 10µs langen TTL-High-Pegel triggern.
- Der Sensor wartet nach der abgefallenen Triggerflanke ca. 250µs lang 
und sendet dann 8 Impulse eines 40kHz-US-Signals (Gesamtdauer=200µs).
- Danach wird der Echo-Pin auf High gesetzt und auf ein Echo gewartet, 
das innerhalb 150µs-25ms eintreffen sollte. Wird kein Objekt detektiert, 
dann wird der Echo-Pin nach 38ms wieder auf Low gesetzt.
- Der kürzeste, sinnvolle Triggerabstand beträgt also knapp 40ms, manche 
Anleitungen empfehlen 50ms, eine andere Anleitung verwendet 20ms.

Triggerfrequenz 100Hz oder mehr dürfte zu hoch sein. Beim Problem im 
Code kann ich leider nicht helfen :-(

[J. D. (jch)]

Danke schonmal. Dass 100 Hz zu hoch sind weiss ich, aber leider nicht 
woran es liegt geschweige denn, wie ich es beheben kann.