Ultraschall-Sensor Firmware funktioniert nicht

[Markus B. (markus_b95)]

Nun, da mir bereits bei der Schaltung an sich viel geholfen wurde hier 
im Forum, versuche ich nun auch mit der Software mein Glück hier :)

Konkret geht es um folgendes: An einem, mit 16MHz laufenden ATMega16 
hängt eine Platine, die vom Pin PD5 vom µC mit Hilfe des 8-Bit-Timers 
ein 40kHz Rechteck-Signal bekommt, das zum Senden benutzt wird, 
jedenfalls, das funktioniert alles.

Das Funktionskonzept an sich ist, das ich einen Ultraschall-Impuls 
erzeuge durch definiertes auf Ausgang-/Eingang-Schalten des Pins.
Das funktioniert ebenfalls wie es soll.

Das vom Ultraschall-Empfänger empfangene Signal wird verstärkt und durch 
einen Kondensator zu GND hin geglättet, das verstärkte Signal an sich 
ist zwar nicht ideal (Oberwellen etc.), aber sollte schon mal 
einigermaßen als reflektiertes Signal erkennbar sein.

Nun zu meinem Problem: Ich habe unten folgende Software geschrieben und, 
nun ja, sie funktioniert scheinbar hinten und vorne nicht, bis auf das 
die grüne Status-LED leuchtet wie sie soll passiert absolut nichts, 
keine Reaktion auf Objekte vor dem Sensor :(

Wie aus dem Code ersichtlich ist, wird das Empfangssignal abgetastet mit 
dem ADC, ein Mittelwert gebildet über eine definierte Anzahl an 
Messungen, und sobald dieser einen definierten Schwellenwert 
überschreitet der 16-Bit-Timer angehalten, dessen Zählerstand abgelesen 
u. resettet, in eine Zeit umgerechnet und daraus wiederum der Abstand 
errechnet.

Ich bin noch relativ neu in der ganzen µC-Programmierung, ich kann mir 
gut vorstellen das der Code zum "Hände-über-den-Kopf-zusammenschlagen" 
für die Profis hier ist, aber ich mache das ja eben um zu lernen :)

Was folgt ist der AVR-GCC-Code, momentan besteht dieser nur aus einer 
Datei, später werde ich die eine oder andere Funktion in eine seperate 
Datei 'auslagern'

/*
 */
#ifndef F_CPU
#define F_CPU = 16000000UL
#endif

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/iom16.h>
#include <stdint.h>

//Variablen
uint16_t timer1 = 0;
char pulse_received = 0;
int pulselenght = 4; //Zahl der Perioden
int messungen = 5; //Zahl der Messungen des ADCs bevor das Ergebnis ausgewertet wird
unsigned long i = 0;
char nothing_received = 0;
uint32_t result = 0;
int z = 0;
unsigned long grenzwert = 50000ULL;
unsigned long timeout = 500000ULL;
uint8_t distance = 0;
uint16_t runtime = 0;


//Funktionsprototypen
void ultrasonic(int a);
uint16_t time_meassurement(void);
void init_adc(void);
uint16_t adc_single_conversion(void);
uint16_t adc_average_conversion(int);
void led_ausgabe(uint8_t z);
void enable_led_portc(int y);



int main(void)
{

    //Grüne Status-LED anschalten
    DDRD |= (1<<DDD1);
    PORTD |= (1<<PD1);
    DDRC = 0xFF;
    init_adc();


/* Timer Konfiguration:
Target Timer Count = (1 / Target Frequency) / (1 / Timer Clock Frequency) - 1
=> Target Timer Count = 1/80.000 Hz (T/2) / (1/16.000.000 Hz -1
    = 199
Following up: Register-configuration, CTC-modus with top-value of 199 */

  // Timer 0 konfigurieren (8-Bit-Timer)
  TCCR0 = (1<<WGM01); // CTC Modus
  TCCR0 |= (1<<CS00); // CPU-Takt,d.h. prescaler = 1
  OCR0 = 199;

  // Compare Interrupt erlauben und Zähler starten
  TIMSK |= (1<<OCIE0);

  // Global Interrupts aktivieren
  sei();



    while(1)
    {
            ultrasonic(pulselenght *2 ); //Multiplikation mit 2, da in einer Periode 2x getoggelt werden muss
            _delay_ms(1000); //Verzögerung zwischen den Pulsen
            //Ausschalten für permanentes Pulsen zum Messen des Empfangsignals*/

    }

    return 0;
}

void ultrasonic(a)
{

    //PD5 als Ausgang
    DDRD |= (1<< DDD5);
    _delay_ms(a);
    DDRD &= ~(1<<DDD5); //ebenfalls für permanentes Senden des Signals auszuschalten
    if(!nothing_received) timer1 = time_meassurement();

    /*Umrechnung des Zählerstandes in Sekunden
    16 MHz getaktet => 16 Mio. Takte/s
    => Zählerstand = Takte
    => x Takte bis zum Zählerstand x
    Vergangene Zeit = Zählerstand / CPU-Takt
    */
    runtime = (uint16_t)(timer1 / F_CPU);
    distance = 172 * runtime * 100; //Schallgeschwindigkeit bei Raumtemperatur in etwa 343 m/s, geht in die Formel mit 1/2 ein; distance in cm, daher der Faktor 100
    led_ausgabe(distance);
}


uint16_t time_meassurement(void)
{
        TCCR1A = 0x00; // Kein PWM oder sonstiges Gedöhns, lediglich als 16-Bit-Timer verwenden
        TCCR1B = (1<<CS11); // Timer läuft mit CPU-Takt/8
/*
Sofern der durchschnittliche Messwert keinen gewissen Schwellwert überschreitet, gilt das als
wäre kein Echo erkannt.
Weiterhin wird eine Variable i als Zählvariable verwendet, um eine Obergrenze festzulegen, ab
wann definitiv kein Echo empfangen wurde.
Der Wert 500000 entspricht etwas mehr als berechnete 464.000 Takte die der AVR für 29ms braucht,
was in etwa einem Abstand von 5 m entsprechen würde.
*/
        i = 0;
        while(!pulse_received)
        {
            if(adc_average_conversion(messungen) <= grenzwert)
                {
                    i++;
                    if(i >= timeout) nothing_received = 1;
                }
            else pulse_received = 1;
        }
        cli(); //Interrupts deaktivieren
        uint16_t b = TCNT1; //Lese den Zählerstand ab
        TCCR1B &= ~(1<<CS11); //Timer anhalten
        TCNT1 = 0x00; //Timerstand zurücksetzen
        sei(); //und wieder die Interrupts aktivieren
        return b;
}

void init_adc(void)
{
    ADMUX |= (1<<REFS1) | (1<<REFS0); //interne 2,56V als Referenz benutzen
    ADCSRA |= (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2); //ADC-Frequenz: 16MHz/128 = 125kHz
    ADCSRA |= (1<<ADEN); //Aktiviere den ADC
    //Das erste Ergebnis der Wandlung nach dem Initalisieren ist Murks, also:
    ADCSRA |= (1<<ADSC); //Führe eine Wandlung durch
    while(ADCSRA & (1<<ADSC)) {} //So lange wie das Bit ADSC nicht auf 0, d.h. logisch false zurück springt, tu nix und warte
    result = ADCW; //Lese das Ergebnis, nun ist der Wandler bereit
}

uint16_t adc_single_conversion(void)
{
    ADMUX = 0x00; //Wandlung auf Kanal 0, Pin PA0;
    ADCSRA |= (1<<ADSC); //starte Einzelwandlung
    while(ADCSRA & (1<<ADSC)) {}
    return ADCW;
}

uint16_t adc_average_conversion(int d)
{
    for(z = 0; z < d; z++)
    {
        result =+ adc_single_conversion();
    }
    result = (uint16_t) (result/d);
    return result;
}

//Timer-Interrupt-Routine: Wechsel von High auf Low; der Puls kann ausgegeben werden durch Toggeln von DDRD
ISR (TIMER0_COMP_vect)
{
    //PD5 toggeln
    PORTD ^= (1 << PD5);
}

void led_ausgabe(uint8_t z)
{
    if(z <= 20) enable_led_portc(7);
    if(z <= 40) enable_led_portc(6);
    if(z <= 60) enable_led_portc(5);
    if(z <= 80) enable_led_portc(4);
    if(z <= 100) enable_led_portc(3);
    if(z <= 120) enable_led_portc(2);
    if(z <= 140) enable_led_portc(1);
    if(z > 140) enable_led_portc(0);
}

void enable_led_portc(int y)
{
    DDRC = 0xFF;
    PORTC = 0x00; //alle LEDs ausschalten zu Beginn
    switch(y)
    {
        case 0 : PORTC = (1<<PC0);break;
        case 1 : PORTC = (1<<PC1);break;
        case 2 : PORTC = (1<<PC2);break;
        case 3 : PORTC = (1<<PC3);break;
        case 4 : PORTC = (1<<PC4);break;
        case 5 : PORTC = (1<<PC5);break;
        case 6 : PORTC = (1<<PC6);break;
        case 7 : PORTC = (1<<PC7);break;
    }
}

[Krapao (Gast)]

Was mir auf die Schnelle auffällt:

> uint16_t adc_average_conversion(int d)

Result ist nur beim ersten Aufruf initialisiert. result wird besser als 
lokale Variable in der Funktion implementiert. Aufpassen auf Overflow 
beim addieren.

> void enable_led_portc(int y)

Maximal aufwändig implementiert. Besser: statt switch/case nur PORTC = 
(1<<y);

> uint16_t adc_single_conversion(void)
>     ADMUX = 0x00; //Wandlung auf Kanal 0, Pin PA0;

Zerstört die Einstellung

> void init_adc(void)
>    ADMUX |= (1<<REFS1) | (1<<REFS0); //interne 2,56V als Referenz benutzen

> uint16_t time_meassurement(void)
>         while(!pulse_received)

Was setzt pulse_received? volatile Schlüsselwort bei dessen Definition 
fehlt.

> uint8_t distance = 0;
> uint16_t runtime = 0;
>    distance = 172  runtime  100;

Overflow im uint8_t Datentyp.

[Markus B. (markus_b95)]

Hey!
Danke, das sollte schon mal helfen, aber weiterhin leider keinerlei 
sichtbare Reaktion der LEDs :(

Ich habe soweit versucht deine Anmerkungen 1:1 umzusetzen, der 
veränderte Code folgt unten...

Schätze ich werd wohl später mal nach und nach mir die Variablen via LED 
ausgeben lassen müssen :/

/*
 */
#ifndef F_CPU
#define F_CPU = 16000000UL
#endif

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/iom16.h>
#include <stdint.h>

//Variablen
uint16_t timer1 = 0;
volatile char pulse_received = 0;
int pulselenght = 4; //Zahl der Perioden
int messungen = 1; //Zahl der Messungen des ADCs bevor das Ergebnis ausgewertet wird
unsigned long i = 0;
char nothing_received = 0;
uint32_t result = 0;
int z = 0;
unsigned long grenzwert = 10000ULL;
unsigned long timeout = 500000ULL;
uint16_t distance = 0;
uint16_t runtime = 0;


//Funktionsprototypen
void ultrasonic(int a);
uint16_t time_meassurement(void);
void init_adc(void);
uint16_t adc_single_conversion(void);
uint16_t adc_average_conversion(int);
void led_ausgabe(uint8_t z);
void enable_led_portc(int y);



int main(void)
{

    //Grüne Status-LED anschalten
    DDRD |= (1<<DDD1);
    PORTD |= (1<<PD1);
    DDRC = 0xFF;
    init_adc();


/* Timer Konfiguration:
Target Timer Count = (1 / Target Frequency) / (1 / Timer Clock Frequency) - 1
=> Target Timer Count = 1/80.000 Hz (T/2) / (1/16.000.000 Hz -1
    = 199
Following up: Register-configuration, CTC-modus with top-value of 199 */

  // Timer 0 konfigurieren (8-Bit-Timer)
  TCCR0 = (1<<WGM01); // CTC Modus
  TCCR0 |= (1<<CS00); // CPU-Takt,d.h. prescaler = 1
  OCR0 = 199;

  // Compare Interrupt erlauben und Zähler starten
  TIMSK |= (1<<OCIE0);

  // Global Interrupts aktivieren
  sei();



    while(1)
    {
            ultrasonic(pulselenght *2 ); //Multiplikation mit 2, da in einer Periode 2x getoggelt werden muss
            _delay_ms(1000); //Verzögerung zwischen den Pulsen
            //Ausschalten für permanentes Pulsen zum Messen des Empfangsignals*/

    }

    return 0;
}

void ultrasonic(a)
{

    //PD5 als Ausgang
    DDRD |= (1<< DDD5);
    _delay_ms(a);
    DDRD &= ~(1<<DDD5); //ebenfalls für permanentes Senden des Signals ausgeschaltet
    if(!nothing_received) timer1 = time_meassurement();

    /*Umrechnung des Zählerstandes in Sekunden
    16 MHz getaktet => 16 Mio. Takte/s
    => Zählerstand = Takte
    => x Takte bis zum Zählerstand x
    Vergangene Zeit = Zählerstand / CPU-Takt
    */
    runtime = (uint16_t)(timer1 / F_CPU);
    distance = 172 * runtime * 100; //Schallgeschwindigkeit bei Raumtemperatur in etwa 343 m/s, geht in die Formel mit 1/2 ein; distance in cm, daher der Faktor 100
    led_ausgabe(distance);
}


uint16_t time_meassurement(void)
{
        TCCR1A = 0x00; // Kein PWM oder sonstiges Gedöhns, lediglich als 16-Bit-Timer verwenden
        TCCR1B = (1<<CS11); // Timer läuft mit CPU-Takt/8
/*
Sofern der durchschnittliche Messwert keinen gewissen Schwellwert überschreitet, gilt das als
wäre kein Echo erkannt.
Weiterhin wird eine Variable i als Zählvariable verwendet, um eine Obergrenze festzulegen, ab
wann definitiv kein Echo empfangen wurde.
Der Wert 500000 entspricht etwas mehr als berechnete 464.000 Takte die der AVR für 29ms braucht,
was in etwa einem Abstand von 5 m entsprechen würde.
*/
        i = 0;
        while(!pulse_received)
        {
            if(adc_average_conversion(messungen) <= grenzwert)
                {
                    i++;
                    if(i >= timeout) nothing_received = 1;
                }
            else pulse_received = 1;
        }
        cli(); //Interrupts deaktivieren
        uint16_t b = TCNT1; //Lese den Zählerstand ab
        TCCR1B &= ~(1<<CS11); //Timer anhalten
        TCNT1 = 0x00; //Timerstand zurücksetzen
        sei(); //und wieder die Interrupts aktivieren
        return b;
}

void init_adc(void)
{
    ADMUX |= (1<<REFS1) | (1<<REFS0); //interne 2,56V als Referenz benutzen
    ADCSRA |= (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2); //ADC-Frequenz: 16MHz/128 = 125kHz
    ADCSRA |= (1<<ADEN); //Aktiviere den ADC
    //Das erste Ergebnis der Wandlung nach dem Initalisieren ist Murks, also:
    ADCSRA |= (1<<ADSC); //Führe eine Wandlung durch
    while(ADCSRA & (1<<ADSC)) {} //So lange wie das Bit ADSC nicht auf 0, d.h. logisch false zurück springt, tu nix und warte
    result = ADCW; //Lese das Ergebnis, nun ist der Wandler bereit
}

uint16_t adc_single_conversion(void)
{
    /*
    ADMUX = 0x00; //Wandlung auf Kanal 0, Pin PA0;
    Nicht notwendig, da ADMUX entsprechend mit Kanal 0 initalisiert wird
    */
    ADCSRA |= (1<<ADSC); //starte Einzelwandlung
    while(ADCSRA & (1<<ADSC)) {}
    return ADCW;
}

uint16_t adc_average_conversion(int d)
{
    result = 0;
    for(z = 0; z < d; z++)
    {
        result =+ adc_single_conversion();
    }
    result = (uint16_t) (result/d);
    return result;
}

//Timer-Interrupt-Routine: Wechsel von High auf Low; der Puls kann ausgegeben werden durch Toggeln von DDRD
ISR (TIMER0_COMP_vect)
{
    //PD5 toggeln
    PORTD ^= (1 << PD5);
}

void led_ausgabe(uint8_t z)
{
    if(z <= 20) enable_led_portc(7);
    if(z <= 40) enable_led_portc(6);
    if(z <= 60) enable_led_portc(5);
    if(z <= 80) enable_led_portc(4);
    if(z <= 100) enable_led_portc(3);
    if(z <= 120) enable_led_portc(2);
    if(z <= 140) enable_led_portc(1);
    if(z > 140) enable_led_portc(0);
}

void enable_led_portc(int y)
{
    DDRC = 0xFF;
    PORTC = 0x00; //alle LEDs ausschalten zu Beginn
    PORTC = (1<<y);
}