HC-SR04 & m32

[inka]

hallo allerseits,

nach mehrtägiger internetsuche fand ich endlich ein auswertungsprogramm für die chinesischen HC-sensoren, allerdings ist atmega32 != m32 - musste ich feststellen. Eigentlich wusste ich es ja schon vorher...

Wenn ich code für die base z.b. (oder auch RP6-fremde codeschnipsel) für die anwendung an der m32 umwandle, funktioniert es inzwischen recht gut und es ist - zumindest sehe ich es so - auch lehrreich für mich...

nun scheitere ich allerdings an diesem code (siehe weiter unten), ich möchte zunächstmal ein bischen beschreiben was ich schon weiss und gemacht habe:

- die vier pins des sensors anzuschliessen ist noch eine relativ leichte übung, im code ist angegeben:

- GND und VCC (ist klar)
- Echo: soll an INT1, der ist an der m32 an XBUS, Pin8
- Trig: soll an den PB0, der ist durch das EEPROM an der m32 belegt, habe also den PB1 gewählt, der ist am sockel IC5, Pin1 (EEPROM Chip select2) - hätte es hier eine alternative gegeben?

und jetzt wird es schwierig, die sache mit den Registern, Ports und Pins fühlt sich im gegensatz zu einem "normalen" c-code immer noch sehr fremd an. Folgendes habe ich geändert:

von:
        DDRB = 1; // PB0 output - connected to Trig
        PORTB = 0; // clear

in:
             DDRB = (1<<PB1); //PB1 output - connected to Trig
             PORTB = 0; // clear

der ganze code:

um es ohne fehler kompilieren zu können musste ich nur die uart.h inkludieren, andere libs waren direkt angegeben...

Bis ich daran gehe, die RP6 libs zu verwenden, wäre es wichtig zu wissen, ob der hardwareanschluss so geht und ob dieser durch meine software-änderung sichergestellt wird? Funktionieren tut der sensor nämlich nicht...

Könnte bitte jemand drüberschauen?

//stammt von hier: http://www.embedds.com/interfacing-ultrasonic-rangefinder-with-avr/

//#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 "RP6uart.h" //eingefügt 2014_10_15



//#define F_CPU 12000000
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>  // for sei()
#include <util/delay.h>     // for _delay_ms()

#define INSTR_PER_US 12                   // instructions per microsecond (depends on MCU clock, 12MHz current)
#define INSTR_PER_MS 12000                // instructions per millisecond (depends on MCU clock, 12MHz current)
#define MAX_RESP_TIME_MS 200      // timeout - max time to wait for low voltage drop (higher value increases measuring distance at the price of slower sampling)
#define DELAY_BETWEEN_TESTS_MS 2000 // echo cancelling time between sampling
volatile long result = 0;
volatile unsigned char up = 0;
volatile unsigned char running = 0;
volatile uint32_t timerCounter = 0;

/*
// timer overflow interrupt, each time when timer value passes 255 value für atmega_8
SIGNAL(TIMER0_OVF_vect)
{
    if (up)         // voltage rise was detected previously
    {
        timerCounter++; // count the number of overflows
        // dont wait too long for the sonar end response, stop if time for measuring the distance exceeded limits
        uint32_t ticks = timerCounter * 256 + TCNT0;
        uint32_t max_ticks = (uint32_t)MAX_RESP_TIME_MS * INSTR_PER_MS; // this could be replaced with a value instead of multiplying
        if (ticks > max_ticks)
        {
            // timeout
            up = 0;          // stop counting timer values
            running = 0; // ultrasound scan done
            result = -1; // show that measurement failed with a timeout (could return max distance here if needed)
        }
    }
}
*/



// timer overflow interrupt, each time when timer value passes 255 value
//changes_for atmega32:http://www.embedds.com/interfacing-ultrasonic-rangefinder-with-avr/
//geändert 2014_10_15

SIGNAL(TIMER0_OVF_vect)
{
    if (up)
    {
        // voltage rise was detected previously
        timerCounter++; // count the number of overflows
// dont wait too long for the sonar end response, stop if time for measuring the distance exceeded limits
        uint32_t ticks = timerCounter * 256 + TCNT0;
        uint32_t max_ticks = (uint32_t)MAX_RESP_TIME_MS * INSTR_PER_MS; // this could be replaced with a value instead of multiplying
        if (ticks > max_ticks)
        {
// timeout
            up = 0; // stop counting timer values
            running = 0; // ultrasound scan done
            result = -1; // show that measurement failed with a timeout (could return max distance here if needed)
        }
    }
}// interrupt for INT1 pin, to detect high/low voltage changes





/**
        We assume, that high voltage rise comes before low drop and not vice versa -
        however this should be implemented more correctly using both interrupts INT0/INT1,
        (i.e. INT0 configured for high rise, and INT1 - for low rise, thus the code must be separated also)
*/
SIGNAL(INT1_vect)
{
    if (running)   //accept interrupts only when sonar was started
    {
        if (up == 0)   // voltage rise, start time measurement
        {
            up = 1;
            timerCounter = 0;
            TCNT0 = 0; // reset timer counter
        }
        else
        {
            // voltage drop, stop time measurement
            up = 0;
            // convert from time to distance(millimeters): d = [ time_s * 340m/s ] / 2 = time_us/58
            result = (timerCounter * 256 + TCNT0) / 58;
            running = 0;
        }
    }
}
/**
        Sonar interfacing:
                1. Send high impulse to Trig input for minimum 10us
                2. Sonar automatically sends eight 40kHz inpulses
                3. Sonar rises high on Echo output and then after some time drops
                   output to low (can take a while on long distances! - must include timeouts)
                4. Based on output time difference deltaT = lowT-highT calculate:
                        distance = [ deltaT * sound_speed(340m/s) ] / 2
                5. Make a delay before starting the next cycle to compensate for late echoes
*/
// generate an impulse for the Trig input (starts the sonar)
void sonar()
{
    PORTB = 0x00; // clear to zero for 1 us
    _delay_us(1);
    PORTB = 0x01; // set high for 10us
    running = 1;  // sonar launched
    _delay_us(10);
    PORTB = 0x00; // clear
}
int __attribute__((noreturn))

main(void)
{
    // ------------------- ultrasonic init code --------------------
//    DDRB = 1; // PB0 output - connected to Trig
    DDRB = (1<<PB1); //PB1 output - connected to Trig
    PORTB = 0; // clear
//    PORTB = (1<<PB1);
    // turn on interrupts for INT1, connect Echo to INT1
    MCUCR |= (0 << ISC11) | (1 << ISC10); // enable interrupt on any(rising/droping) edge
    GICR |= (1 << INT1);      // Turns on INT1
    // setup 8 bit timer & enable interrupts, timer increments to 255 and interrupts on overflow
    TCCR0 = (0<<CS02)|(0<<CS01)|(1<<CS00); // select internal clock with no prescaling
    TCNT0 = 0; // reset counter to zero
    TIMSK = 1<<TOIE0; // enable timer interrupt
    sei(); // enable all(global) interrupts
    for(;;)
    {
        /* main program loop */
        // other code here...
        if (running == 0)
        {
            // launch only when next iteration can happen
            // create a delay between tests, to compensate for old echoes
            _delay_ms(DELAY_BETWEEN_TESTS_MS);
            sonar(); // launch measurement!
        }
        // other code here...
//        clearLCD();
        writeString("\nHC-SR04 SENSOR ->");
        writeString("\nDistance:  ");
        writeInteger(result, DEC);
        writeString(" cm");
//        mSleep(100);
//        _delay_us(10000);

    }
//return 0; //eingefügt 2014_10_20
}

[Dirk]

Hi inka,
ich habe nicht das ganze Programm angesehen.

Nur was mir auffällt:

Echo: soll an INT1, der ist an der m32 an XBUS, Pin8

INT1 des ATmega32 ist PD3,- das ist in dem Programm gemeint.
Im RP6 System liegt INT1 des ATmega32 auf der CONTROL M32 am XBUS INT2 (also Pin 11).

Trig: soll an den PB0, der ist durch das EEPROM an der m32 belegt, habe also den PB1 gewählt, der ist am sockel IC5, Pin1 (EEPROM Chip select2) - hätte es hier eine alternative gegeben?

PB1 geht, aber ist schlecht erreichbar (nicht an einem Stecker).
Nimm z.B. PC7, der ist frei und liegt am Stecker I/O, Pin 1.
Als Ausgang definieren: DDRC |= IO_PC7;
Auf HIGH setzen: PORTC |= IO_PC7;
Auf LOW setzen: PORTC &= ~IO_PC7;

#define INSTR_PER_US 12

Die M32 läuft mit 16 MHz (nicht mit 12), so dass man diese und die folgende Definition anpassen müßte.

TCCR0 = (0<<CS02)|(0<<CS01)|(1<<CS00);

Auf der M32 ist der Timer 0 belegt. Aber: Timer 1 ist frei und nutzbar!

[inka]

Hi Dirk,

INT1 des ATmega32 ist PD3,- das ist in dem Programm gemeint.
Im RP6 System liegt INT1 des ATmega32 auf der CONTROL M32 am XBUS INT2 (also Pin 11).

ok, das habe ich missverstanden, ist geändert

PB1 geht, aber ist schlecht erreichbar (nicht an einem Stecker).

ich habe den PB1 von der m32 auf den USRBUS pin 3 gelegt, deshalb für mich besser erreichbar als der PC7, deshalb würde ich gerne bei PB1 bleiben - ein zweites EEPROM ist bei mir eher unwarscheinlich...

Als Ausgang definieren: DDRC |= IO_PC7;
Auf HIGH setzen: PORTC |= IO_PC7;
Auf LOW setzen: PORTC &= ~IO_PC7;

würden die befehle für den PB1 so aussehen?

Als Ausgang definieren: DDRB |= IO_PB1;
Auf HIGH setzen: PORTB |= IO_PB1;
Auf LOW setzen: PORTB &= ~IO_PB1;

ich würde dann die funktion sonar ändern:

von:
void sonar()
{
    PORTB = 0x00; // clear to zero for 1 us
    _delay_us(1);
    PORTB = 0x01; // set high for 10us
    running = 1;  // sonar launched
    _delay_us(10);
    PORTB = 0x00; // clear
}
int __attribute__((noreturn))

in:
void sonar()
{
    PORTB &= ~IO_PB1; // clear to zero for 1 us
    _delay_us(1);
    PORTB |= IO_PB1; // set high for 10us
    running = 1;  // sonar launched
    _delay_us(10);
    PORTB &= ~IO_PB1; // clear
}
int __attribute__((noreturn))

EDIT: das oben hat der compiler angemeckert, das hier unten ging:

void sonar()
{
    PORTB &= ~(1<<PB0); // clear to zero for 1 us  PORTB &= ~IO_PB1;
    _delay_us(1);
    PORTB |= (1<<PB1); // set high for 10us  PORTB |= IO_PB1;
    running = 1;  // sonar launched
    _delay_us(10);
    PORTB &= ~(1<<PB0); // clear
}
int __attribute__((noreturn))

fliegt mir da was um die ohren?

Die M32 läuft mit 16 MHz (nicht mit 12), so dass man diese und die folgende Definition anpassen müßte.

ok geändert...

Auf der M32 ist der Timer 0 belegt. Aber: Timer 1 ist frei und nutzbar!

meinst Du evtl. den Timer2 (TCCR2) - beim TCCR1 bekomme ich die meldung: TCCR1 not declared???

[Dirk]

Hi inka,

würden die befehle für den PB1 so aussehen?
Als Ausgang definieren: DDRB |= IO_PB1;
Auf HIGH setzen: PORTB |= IO_PB1;
Auf LOW setzen: PORTB &= ~IO_PB1;

Wenn du überall "IO_PB1" durch "MEM_CS2" ersetzt: Ja.
Übrigens: Diese Portpin-Definitionen stehen in der RP6Control.h !

ich würde dann die funktion sonar ändern: ...
fliegt mir da was um die ohren?

Nein, alles wird gut.

meinst Du evtl. den Timer2 (TCCR2) - beim TCCR1 bekomme ich die meldung: TCCR1 not declared???

Nein, ich meinte schon den Timer 1.
Wenn du mal in der RP6ControlLib.c ganz am Ende in die Funktion initRP6Control() schaust:
Du siehst die Nutzung von Timer 0 und Timer 2 und "Timer 1 is free for your application!"

Mögliches Problem:
Du kannst deinen Muster-Code mit Timer 0 nicht so 1:1 für Timer 1 übernehmen, weil Timer 0 ein 8-Bit-Timer ist und Timer 1 ein 16-Bit-Timer.
Die Initialisierung sieht also unterschiedlich aus. Wenn du das anpassen willst, must du zuerst verstehen, wie in deinem Muster-Code der Timer 0 genutzt wird und dir dann den Timer 1 identisch konfigurieren.

[inka]

hallo,

ich habe jetzt einen code umgeschrieben:

#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"

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


volatile uint16_t timestamp_last = 0;
volatile uint16_t zeit = 0;
uint16_t distanz = 0;

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



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

}


int main(void)
{

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

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

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

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

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


    //PC7:

//  DDRC |= IO_PC7; //Pin PC7 als Ausgang
//  PORTC |= IO_PC7; //Auf HIGH setzen
//    PORTC |= (1<<PC7);//internen Pull-Up an PC7 aktivieren
//    PORTC &= ~IO_PC7; //Auf LOW setzen

    DDRC &= ~(1<<PC7);  //Pin PC7 als Eingang (ECHO)
    PORTC &= ~(1<<PC7);//ECHO pullup aus

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

    setCursorPosLCD(1, 0);
    writeStringLCD("ultraschall_test_4");
    mSleep(1500);

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

//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();
    while(1)
    {
//Entfernung aus Laufzeit berechnen
        distanz = (zeit*4)/58;

        /******LCD ausgabe*******/
        /*
                setCursorPosLCD(1, 0);
                writeStringLCD("zeit  ");
                setCursorPosLCD(1, 8);
                writeIntegerLCD (zeit, DEC);
                setCursorPosLCD(1, 15);
                writeStringLCD("us  ");
                mSleep(500);
                setCursorPosLCD(3, 0);
                writeStringLCD("distanz  ");
                setCursorPosLCD(3, 8);
                writeIntegerLCD (distanz, DEC);
                setCursorPosLCD(3, 15);
                writeStringLCD("cm  ");
                mSleep(500);
                clearLCD();
        */
        /************/

        /*****terminal ausgabe*******/

        writeString("zeit:      ");
        writeIntegerLength(zeit, DEC, 4);
        writeString("      ");
        writeIntegerLength(distanz, DEC, 4);
        writeChar('\n');
        mSleep(200);

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

//Messung auslösen
        trig();
        _delay_ms(50);
    }

    return 0;
}

der timer funktioniert auch soweit, der ECHO anschluss funktioniert aber nur auf PD6, hier noch ein codeschnipsel:

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

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


    //PC7:

//  DDRC |= IO_PC7; //Pin PC7 als Ausgang
//  PORTC |= IO_PC7; //Auf HIGH setzen
//    PORTC |= (1<<PC7);//internen Pull-Up an PC7 aktivieren
//    PORTC &= ~IO_PC7; //Auf LOW setzen

    DDRC &= ~(1<<PC7);  //Pin PC7 als Eingang (ECHO)
    PORTC &= ~(1<<PC7);//ECHO pullup aus

der versuch auf PC7 "umzuschalten" funktioniert aber nicht, obwohl mir die beiden definitionen fürs ECHO am PD6 und PC7 schon vergleichbar scheinen... - so wie es ist müssten eigentlich PD6 und PC7 als eingänge funktionieren, oder?

gibt es dafür eine erklärung? btw. alle jumper auf dem jumperblock der freien I/Os auf der multiIO habe ich vorsichtshalber entfernt...

[Dirk]

PD6 und PC7 sind nicht vergleichbar, weil PD6 der "ICP" Pin ist und diese Funktion wird hier gebraucht.

[TrainMen]

Hi inka,
mein Nachbarssohn hat so ein Einsteigerpaket mit Arduino bekommen. Da ist auch der hc-sr04 mit bei. Mal sehen ob ich den mal mopsen kann. Funktioniert das nun bei dir ?
Ich würde das gerne mal ausprobieren und gleich noch eine Frage. Wir haben ja nur ein ICP Pin, kann man trotzdem 2 Sensoren benutzen. Hast Du da mal was gemacht ?

[oberallgeier]

Mal so, nur ganz Allgemein und sicher reichlich OT : Ich wundere mich.
Über die Funktion (eher die Fehlfunktion-en) des hc-sr04 habe ich gerade in der letzten Zeit hier recht viel gelesen. Klar, bei Preisen um die zwei Euro neigt man schnell dazu mal zuzugreifen. Und ich habe auch oft bei der Kaufentscheidung bei billigen Angeboten mit meiner Meinung zu kämpfen "... wird schon werden ... werd ich schon hinkriegen ...".

Ich habe mir für mehr als zwölf Flocken ein paar SRF02 gekauft - und finde, dass der Mehrpreis den Vorteil mehr als rechtfertigt. Klartext-Messwertausgabe über UART oder so richtig pfiffig über I²C . . . und in mehreren Tests musste ich und ein paar Jungs von einer Jugend-forscht-Gruppe eigentlich kaum Fehlfunktionen feststellen. Gut, die Funktionsgrenzen sind bei Ultraschall bekannt - aber innerhab derer hatten wir beim höherpreisigen Sensor schnelle Inbetriebnahme und zuverlässige, zentimetergenaue Messungen festgestellt. Mal abgesehen von dem äusserst geringen Platzbedarf.

[TrainMen]

also mir geht es ja um den RP6 und den Sensor HC-SR04.
Ich habe gestern mit dem Nachbarssohn den Sensor am Arduino am laufen gehabt. Die Resultate waren gut. Vieleicht 1-2 cm unterschied. Gemessen haben wir den Bereich unter 50cm. Deswegen fand ich das gut und will den mal am RP6 ausprobieren.

[inka]

also ich finde den HC-04 sogar besser als den SRF-02. Im messbereich, im preis(unter 2 eur/st. bei 5 stück). Und die genauigkeit lässt meiner meinung nach auch keine wünsche offen. Habe sogar versucht die dinger ohne jegliche anpassung zu tauschen, in den messungen minimale bis keine unterschiede. Der einziger nachteil ist kein I2c...
Wie ich den HC-04 abfrage kann man im code weiter oben sehen...

was den ICP-pin betrifft bin ich nicht weitergekommen - nur umstecken funktioniert. Es gibt ja z.b. i2c-port-expander, gibts sowas nicht für den ICP?