Ultraschallmessung, Atmega8 resettet sich

[Niine (Gast)]

Hi,

ich habe leider ein Problem. Ich möchte ein Ultraschallsensor HC-SR04 
ansteuern. Man muss ihm ein 10 us High Signal geben und nach der Messung 
sendet er ein Abstandsabhängiges (Zeitlänge) High Signal auf dem Echo 
Kanal zurück.

Nun wollte ich bei einer Messung einen schnellen Timer starten und 
sobald das High Signal anliegt die Dauer messen und wenn es vorbei ist, 
den Counter auswerten, damit ich die Zeitdauer habe.

Allerdings stürzt der Atmega dann irgendwie ab. Er bringt die Test1 und 
Test2 auf dem Display und dann wieder Test1. Schafft er es von der 
Geschwindigkeit irgendwie nicht und stürzt deswegen ab?

Auffallend ist noch, das die eig 300ms zwischen Test1/Test2 viel mehr 
ist. Die Frequenz von 8Mhz hab ich bei Symbols im Projektmenü im 
AtmelStudio eingestellt.

Hier mein Code:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdbool.h>
#include "lcd-routines.h"

#define triggeraus PORTB &= ~(1 << PB2)
#define triggeran PORTB |= (1 << PB2)

int counter=0;
int first = 0;
int lastValue=0;
int messen = 0;
  
ISR(TIMER0_COMPA_vect) //Timer alle 5 Mikrosekunden!
{
  if(first==0) 
  {
    if(bit_is_set(PINB,1)) {counter++; first = 1;} else { counter=0;}
  }
  else
  {
    if(bit_is_set(PINB,1)) {counter++;} else { lastValue=counter; counter=0; first = 0; messen = 0; TIMSK = (0<<OCIE1A);}
  }

}

int Ausgabe(int value) 
{
  lcd_clear();
  char Buffer[20];
  
  lcd_string("Distanz: "); //Ausgabe als String
  itoa( value, Buffer , 10 );
  lcd_string(Buffer);
}  
  
int getAbstand()
{
  int cm=0;
  
  triggeraus;
  _delay_us(2);
  triggeran;
  _delay_us(10);
  triggeraus;
  messen = 1;
  TIMSK = (1<<OCIE1A);
  
  
  while(messen == 1) { }
  
  cm = lastValue*5 / 58;
  
  return cm;
}

int main(void)
{
    //Timer initialisieren
    TCCR1A = 0x00;
    TCCR1B = (1<<CS11);    //Prescaler 8, CTC-Mode
    OCR1A = 4;    //Vergleiswert setzten
    TIMSK = (0<<OCIE1A);  //OC-Interrupt aktivieren
    sei();
  
  DDRB |= _BV(PB2);
  DDRB &= ~_BV(PB1);
    
  PORTC &= ~_BV(PB2);
  PORTB|= _BV(PB1);
  
  lcd_init();
  lcd_string("Test1");
  _delay_ms(300);
  lcd_clear();
  lcd_string("Test2");  
  _delay_ms(300);
  lcd_clear();
    
    while(1)
    {
        //TODO:: Please write your application code 
    int abstand=0;
    
    abstand = getAbstand();
    
    Ausgabe(abstand);      
        
    _delay_ms(200);
  }
}

Danke für eure Hilfe.

Mit besten Grüßen

Niine

[Hubert G. (hubertg)]

Deine Timer Initialisierung stimmt nicht. Es fehlt WGM12 im TCCR1B.
Im TIMSK das OCIE1A Bit zu löschen ist nicht sehr sinnvoll. Sollte eine 
ISR anstehen, wird sie sofort ausgeführt.
Besser wäre es den Timer zu stoppen.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Niine schrieb:
> Auffallend ist noch, das die eig 300ms zwischen Test1/Test2 viel mehr
> ist. Die Frequenz von 8Mhz hab ich bei Symbols im Projektmenü im
> AtmelStudio eingestellt.

Etwa 8-mal so viel? Dann solltest du dir mal anschauen, ob der MC vllt. 
noch im Auslieferzustand ist. In diesem Fall ist nämlich die CLKDIV Fuse 
gesetzt und der MC läuft mit 1 MHz statt mit 8.

> int counter=0;
Variablen, die auch in einer ISR geändert werden, solltest du immer als 
'volatile' angeben, damit der Compiler weiss, das sie benutzt werden. Im 
allgmeinen sind ISRs für den Compiler erstmal Unterroutinen, die nicht 
angesprungen werden.
Und dir ist klar, das 'int' eine 16-bit Variable ist? Wenn es das 
wirklich sein soll, musst du 'atomic' Zugriffe gestalten, da es sonst 
passieren kann, das die eine Hälfte der Variable bearbeitet wurde und 
dann ein Interrupt zuschlägt, wodurch die andere Hälfte (AVRs sind ja 
8-bitter) evtl. vermurkst wird.
Besser ist es, eindeutige Typen zu nehmen:
uint8_t ist immer ein Byte ohne Vorzeichen
uint16_t ein Word ohne Vorzeichen usw.

> Nun wollte ich bei einer Messung einen schnellen Timer starten und
> sobald das High Signal anliegt die Dauer messen und wenn es vorbei ist,
> den Counter auswerten, damit ich die Zeitdauer habe.

Schau dir dafür den Input Capture Modus an. Das scheint mir genau das zu 
sein, was du suchst.

> TCCR1A = 0x00;
>     TCCR1B = (1<<CS11);    //Prescaler 8, CTC-Mode
Nö, ist kein CTC Modus. Du startest einfach nur den Timer.

> ISR(TIMER0_COMPA_vect) //Timer alle 5 Mikrosekunden!
Du hast eine ISR für Timer 0 geschrieben, programmierst aber Timer 1. 
Das wird abstürzen.