HC-SR04 & m32

**TrainMen** · 27.12.2014, 17:46

gibts sowas nicht für den ICP

ich glaube nicht das es sowas gibt.
Ich habe mir noch mal gedanken gemacht. Beim PD6 wird ja die "Input Capture" Funktion benutzt, dieser Teil dient zur genauen Zeitmessung. Also kann ich doch in einer Funktion PD6 und PC6 und in der anderen Funktion PD6 und PC5 benutzen. Nur gleichzeitig wird es nicht gehen. Probier das doch mal aus wenn Du Zeit findest, Du hast doch mehrere von den Dingern.

**inka** · 28.12.2014, 10:36

also ich hab mir die zeit genommen. Vorausgeschickt - es funktioniert nur wenn am echo-pin (ICS) umgesteckt wird. Aber es kann durchaus an meinen programmierkünsten liegen. Von den timern verstehe ich nämlich immer noch wenig bis nix...

Klicke auf die Grafik für eine größere Ansicht

Name: 2014_12_28_HC-04_2-fach.jpg
Hits: 9
Größe: 77,0 KB
ID: 29558

folgendes habe ich jetzt gemacht:

die funktionen um PC5 und PC6 erweitert:

Code:

/********************* ULTRASCHALL & HC-SR-04 ******************************/

uint16_t distanz_PC5 = 0;
volatile uint16_t zeit_PC5 = 0;
volatile uint16_t timestamp_last_PC5 = 0;

uint16_t distanz_PC6 = 0;
volatile uint16_t zeit_PC6 = 0;
volatile uint16_t timestamp_last_PC6 = 0;




ISR(TIMER1_CAPT_vect)
{
//Wenn steigende Flanke
    if(TCCR1B & (1<<ICES1))
    {
//Flankenerkennung auf fallend
        TCCR1B ^= (1<<ICES1);
//aktuelen timer-wert speichern
        timestamp_last_PC5 = ICR1;
        timestamp_last_PC6 = ICR1;
    }
//fallende Flanke
    else
    {
//Flankenerkennung auf steigend
        TCCR1B ^= (1<<ICES1);
//Laufzeit = aktueller timerwert - vorheriger timerwert
        zeit_PC5 = ICR1 - timestamp_last_PC5;
        zeit_PC6 = ICR1 - timestamp_last_PC6;
    }

}



/*************** trig ***************************/

void trig_PC5(void)
{
    PORTC |= (1<<PC5);//Trig high
    _delay_us(12);
    PORTC &= ~(1<<PC5);//TRIG auf low
}

void trig_PC6(void)
{
    PORTC |= (1<<PC6);//Trig high
    _delay_us(12);
    PORTC &= ~(1<<PC6);//TRIG auf low
}

/***************** messung_SR_04 ********************/

void messung_SR_04_PC5 (void)
{
    DDRC |= (1 << PC5);//Trig als Ausgang
    PORTC &= ~(1<<PC5);//TRIG auf low

    DDRD &= ~(1<<PD6);//Echo als Eingang
    PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC5 = (zeit_PC5*4)/58;

}


void messung_SR_04_PC6 (void)
{
    DDRC |= (1 << PC6);//Trig als Ausgang
    PORTC &= ~(1<<PC6);//TRIG auf low

    DDRD &= ~(1<<PD6);//Echo als Eingang
    PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC6 = (zeit_PC6*4)/58;

}

die variablen im hauptprogramm:

Code:

extern volatile uint16_t zeit_PC5, zeit_PC6;
extern uint16_t distanz_PC5, distanz_PC6;

und das ist die eigentliche abfrage:

Code:

 case 2://
                setLEDs(0b0010);
                writeString_P("\n\n HC-SR-04 PC5_trig & PC6_trig\n\n");
                writeChar('\n');
                initRP6Control();
                multiio_init();
                initLCD();

                setCursorPosLCD(1, 0);
                writeStringLCD("HC-SR04 messung");
                mSleep(1500);


                while(1)
                {

                                    //Messung starten
                    messung_SR_04_PC5 ();
                    mSleep(100);
                    //Signal auslösen
                    trig_PC5();
                    _delay_ms(50);

                    //Werte ausgeben

                    writeString("zeit_PC5:      ");
                    writeIntegerLength(zeit_PC5, DEC, 4);
                    writeString("     distanz_PC5:    ");
                    writeIntegerLength(distanz_PC5, DEC, 4);
                    writeChar('\n');
                    mSleep(2000);

                    //Messung starten
                    messung_SR_04_PC6 ();
                    mSleep(100);
                    //Signal auslösen
                    trig_PC6();
                    _delay_ms(50);

                    //Werte ausgeben

                    writeString("zeit_PC6:      ");
                    writeIntegerLength(zeit_PC6, DEC, 4);
                    writeString("     distanz_PC6:    ");
                    writeIntegerLength(distanz_PC6, DEC, 4);
                    writeChar('\n');
                    mSleep(2000);


                    /**************************/
                    uint8_t key_1 = getMultiIOPressedButtonNumber();
                    key_1 = getMultiIOPressedButtonNumber();
                    if(key_1 != 0) break;

                    /**************************/
                }

                break;

**TrainMen** · 29.12.2014, 00:44

schön das Du dir Zeit genommen hast.
Aber irgendwie hast Du nicht verstanden was ich geschrieben habe. Der Echo Pin muß schon PD6 sein, diese ICP Funktion wird ja gebraucht.
Bei meiner Frage ob das auch mit 2 Sensoren geht solltest Du von beide Sensoren den Echo Pin an PD6 bringen. Den Trigger von einen an PC6 und den anderen an PC5 z.B.
So wie ich dich verstanden habe funktioniert ja die Messung mit einem und es kommen vernünftige Werte.

**inka** · 29.12.2014, 07:53

ich glaube ich hab dich schon richtig verstanden, aber vielleicht war es ja um 1:44 schon etwas spät oder zu früh, je nach dem wie man es sieht

ich habe zwei messfunktionen: die "_PC5_" und die _PC6_" je nach dem welcher pin getriggert wird, in beiden ist der PD6 als echo gesetzt. Wenn beide echo-leitungen der HCs am PD6 angeschlossen sind, liefert die auswertung bei "zeit" wie auch "distanz" für beide Sensoren "0000". Das fühlt sich so an, als wüsste die timerauswertung nicht welchen wert sie nehmen soll...

Entweder:

- muss die pause zwischen beiden messungen deutlich größer sein, oder
- ich muss den trigger- wie auch den echo-pin sofort nach der messung wieder auf den zustand vor der messung setzen, oder
- ich muss in den messfunktionen eine variable setzen und die dann bei der timerauswertung abfragen, oder
- ...

**TrainMen** · 29.12.2014, 15:24

Ich denke es wird eine Mischung aus deinen Punkten.
Ich würde wahrscheinlich 2 Funktionen schreiben mit den kompletten Teil also auch den Timer am ende die komplette Rücksetzung so das die andere Funktion wieder alles jungfräulich vorfindet. Diese dann einzeln per taste abrufen.
Laut Email sind meine Sensoren unterwegs, was immer das auch bedeutet.

**inka** · 29.12.2014, 15:30

Zitat von TrainMen

Ich würde wahrscheinlich 2 Funktionen schreiben mit den kompletten Teil also auch den Timer am ende die komplette Rücksetzung so das die andere Funktion wieder alles jungfräulich vorfindet.

so werde ich es probieren...

Zitat von TrainMen

Diese dann einzeln per taste abrufen.

ich denke DEin BOT ist auf Riegel-7?

Zitat von TrainMen

Laut Email sind meine Sensoren unterwegs, was immer das auch bedeutet.

wenn Du in china bestellt hast kommen die teile so ende januar, immerhin 2015. Wenn sie unterwegs nicht verloren gehen. Hatte ich schon alles

**TrainMen** · 29.12.2014, 15:39

so werde ich es probieren...

mach es und berichte bitte

ich denke DEin BOT ist auf Riegel-7?

schon mal was von Fernsteuerung gehört ?

**inka** · 29.12.2014, 16:02

Zitat von TrainMen

Ich würde wahrscheinlich 2 Funktionen schreiben mit den kompletten Teil also auch den Timer am ende die komplette Rücksetzung so das die andere Funktion wieder alles jungfräulich vorfindet.

ich glaube mit zwei timern wird es nicht gehen...

**TrainMen** · 29.12.2014, 23:35

ich glaube mit zwei timern wird es nicht gehen...

ja Du hast recht da meckert er

Ich habe das jetzt mal so gemacht

Code:

#include "RP6ControlLib.h"                 


/*****************************************************************************/

uint16_t distanz_PC5 = 0;
volatile uint16_t zeit_PC5 = 0;
volatile uint16_t timestamp_last_PC5 = 0;

uint16_t distanz_PC6 = 0;
volatile uint16_t zeit_PC6 = 0;
volatile uint16_t timestamp_last_PC6 = 0;

/*****************************************************************************/


ISR(TIMER1_CAPT_vect)
{
//Wenn steigende Flanke
    if(TCCR1B & (1<<ICES1))
    {
//Flankenerkennung auf fallend
        TCCR1B ^= (1<<ICES1);
//aktuelen timer-wert speichern
        timestamp_last_PC5 = ICR1;
        timestamp_last_PC6 = ICR1;
    }
//fallende Flanke
    else
    {
//Flankenerkennung auf steigend
        TCCR1B ^= (1<<ICES1);
//Laufzeit = aktueller timerwert - vorheriger timerwert
        zeit_PC5 = ICR1 - timestamp_last_PC5;
        zeit_PC6 = ICR1 - timestamp_last_PC6;
    }

}

/*****************************************************************************/

void HCSR04_vorn (void)
{
  // Messung
  DDRC |= (1 << PC5);//Trig als Ausgang
  PORTC &= ~(1<<PC5);//TRIG auf low
  DDRD &= ~(1<<PD6);//Echo als Eingang
  PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC5 = (zeit_PC5*4)/58;
    mSleep(100);
// Trig    
  PORTC |= (1<<PC5);//Trig high
  _delay_us(12);
  PORTC &= ~(1<<PC5);//TRIG auf low
  _delay_ms(50);
  
//Werte ausgeben

  writeString("zeit_PC5:      ");
  writeIntegerLength(zeit_PC5, DEC, 4);
  writeChar('\n');
  writeString("distanz_PC5:    ");
  writeIntegerLength(distanz_PC5, DEC, 4);
  writeChar('\n');
  mSleep(2000);    
    
}
/*****************************************************************************/
void HCSR04_hinten (void)
{
 
  // Messung
  DDRC |= (1 << PC6);//Trig als Ausgang
  PORTC &= ~(1<<PC6);//TRIG auf low
  DDRD &= ~(1<<PD6);//Echo als Eingang
  PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC6 = (zeit_PC6*4)/58;
    mSleep(100);
// Trig    
  PORTC |= (1<<PC6);//Trig high
  _delay_us(12);
  PORTC &= ~(1<<PC6);//TRIG auf low    
  _delay_ms(50);
  
 //Werte ausgeben

  writeString("zeit_PC6:      ");
  writeIntegerLength(zeit_PC6, DEC, 4);
  writeChar('\n');
  writeString("distanz_PC6:    ");
  writeIntegerLength(distanz_PC5, DEC, 4);
  writeChar('\n');
  mSleep(2000);     

}


/*****************************************************************************/
void taster_M32(void)
{
  uint8_t key = getPressedKeyNumber(); 
      
  if(key) 
    {
    
     while(getPressedKeyNumber());
     switch(key)
        {
         case 1: 
               setLEDs(0b0001);
            HCSR04_vorn();
            break;
         case 2: 
             setLEDs(0b0010);
            HCSR04_hinten();
            break;
                    
        }
    }
}

/*****************************************************************************/

int main(void)
{
    initRP6Control();    
    
    while(true) 
    {
    taster_M32();
    }

    return 0;
}

Versuchs mal so, testen kann ich ja leider noch nicht. Es ist fast der gleiche Code nur eben alles eingepackt in der Funktion.
Bei den globalen Interrupts könnte man am ende noch ein cli() setzen um den Interrupt wieder zu stoppen und den Timer Interrupt könnte man auch stoppen. Aber mir fehlt da jede Menge Wissen um da hinter zu steigen wie das alles genau funktioniert. Was mich aber jetzt schon Nervt ist das ich 3 meiner Kostbaren Ports weg geben soll. Ab gesehen vom unschlagbaren Preis wäre die SRF?? Sensoren da besser. Ran an den Bus und fertig.

**inka** · 30.12.2014, 10:01

also, es funktioniert, zumindest teilweise. Ich musste (wegen code:blocks) noch ein paar libs inkludieren und auch die multiIO initialisieren, jetzt lässt sich der code bei mir auch starten:

Code:

//#include "RP6ControlLib.h"


#include "RP6ControlLib.h"
#include "RP6I2CmasterTWI.h"
#include "RP6Control_MultiIOLib.h"
#include "RP6Control_I2CMasterLib.h"
#include "RP6Control_LFSBumperLib.h"
#include "RP6ControlServoLib.h"
#include "RP6Control_OrientationLib.h"
//#include "standard.h"


/*****************************************************************************/

uint16_t distanz_PC5 = 0;
volatile uint16_t zeit_PC5 = 0;
volatile uint16_t timestamp_last_PC5 = 0;

uint16_t distanz_PC6 = 0;
volatile uint16_t zeit_PC6 = 0;
volatile uint16_t timestamp_last_PC6 = 0;

/*****************************************************************************/


ISR(TIMER1_CAPT_vect)
{
//Wenn steigende Flanke
    if(TCCR1B & (1<<ICES1))
    {
//Flankenerkennung auf fallend
        TCCR1B ^= (1<<ICES1);
//aktuelen timer-wert speichern
        timestamp_last_PC5 = ICR1;
        timestamp_last_PC6 = ICR1;
    }
//fallende Flanke
    else
    {
//Flankenerkennung auf steigend
        TCCR1B ^= (1<<ICES1);
//Laufzeit = aktueller timerwert - vorheriger timerwert
        zeit_PC5 = ICR1 - timestamp_last_PC5;
        zeit_PC6 = ICR1 - timestamp_last_PC6;
    }

}

/*****************************************************************************/

void HCSR04_vorn (void)
{
  // Messung
  DDRC |= (1 << PC5);//Trig als Ausgang
  PORTC &= ~(1<<PC5);//TRIG auf low
  DDRD &= ~(1<<PD6);//Echo als Eingang
  PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC5 = (zeit_PC5*4)/58;
    mSleep(100);
// Trig
  PORTC |= (1<<PC5);//Trig high
  _delay_us(12);
  PORTC &= ~(1<<PC5);//TRIG auf low
  _delay_ms(50);

//Werte ausgeben

  writeString("zeit_PC5:      ");
  writeIntegerLength(zeit_PC5, DEC, 4);
  writeChar('\n');
  writeString("distanz_PC5:    ");
  writeIntegerLength(distanz_PC5, DEC, 4);
  writeChar('\n');
  mSleep(2000);

}
/*****************************************************************************/
void HCSR04_hinten (void)
{

  // Messung
  DDRC |= (1 << PC6);//Trig als Ausgang
  PORTC &= ~(1<<PC6);//TRIG auf low
  DDRD &= ~(1<<PD6);//Echo als Eingang
  PORTD &= ~(1<<PD6);//ECHO pullup AUS


//Timer konfigurieren
    TCCR1A = 0; // normal mode, keine PWM Ausgänge
//Noise Canceler aktivieren, Flankenerkennung auf steigende, Prescaler auf 64
    TCCR1B |= (1<<ICNC1) | (1<<ICES1) | (1<<CS11) |(1<<CS10);

//ICP Interrupt aktivieren
    TIMSK |= (1<<TICIE1);

//Globale Interrupts aktivieren
    sei();
    distanz_PC6 = (zeit_PC6*4)/58;
    mSleep(100);
// Trig
  PORTC |= (1<<PC6);//Trig high
  _delay_us(12);
  PORTC &= ~(1<<PC6);//TRIG auf low
  _delay_ms(50);

 //Werte ausgeben

  writeString("zeit_PC6:      ");
  writeIntegerLength(zeit_PC6, DEC, 4);
  writeChar('\n');
  writeString("distanz_PC6:    ");
  writeIntegerLength(distanz_PC5, DEC, 4);
  writeChar('\n');
  mSleep(2000);

}


/*****************************************************************************/
void taster_M32(void)
{
  uint8_t key = getPressedKeyNumber();

  if(key)
    {

     while(getPressedKeyNumber());
     switch(key)
        {
         case 1:
               setLEDs(0b0001);
            HCSR04_vorn();
            break;
         case 2:
             setLEDs(0b0010);
            HCSR04_hinten();
            break;

        }
    }
}

/*****************************************************************************/

int main(void)
{
 //   initRP6Control();

    initRP6Control();
    multiio_init();
    initLCD();

    while(true)
    {
    taster_M32();
    }

    return 0;
}

die jeweiligen messungen werden durch die tasten der m32 ausgelöst, allerdings wird beim druck auf die taste 2 das vorhergehende ergebnis der taste 1 ausgegeben. Also muss man die ausgaben die durch die taste 1 entstehen noch irgendwo "nullen"...

ansonsten ähnelt die situation meinem vorhergehenden test, wenn ich auf PD6 die Sensoren umstecke, läufts, wenn beide Sensoren angeschlossen sind - nicht...

die ausgabe im terminal:

Code:

Terminal cleared!
zeit_PC5:      0694
distanz_PC5:    0047
zeit_PC6:      0694
distanz_PC6:    0047
zeit_PC5:      0694
distanz_PC5:    0047
zeit_PC6:      0694
distanz_PC6:    0047