Zeiten zwischen Flanken von Interrupts messen

So hab mir jetzt folgendes Testprogramm geschrieben, aber es will nicht so recht:

Code:

---

#include "RP6ControlLib.h"                // The RP6 Control Library.
                                                                // Always needs to be included!
#include <stdlib.h>
#include <avr/interrupt.h>

volatile unsigned long timestamp;    // volatile wegen Zugriff im Interrrupt
unsigned long impuls;
unsigned long periode;
unsigned long zeit;
uint8_t flag;
uint8_t position;
unsigned long wert;
char puffer[5];

void int1(void)  //  Flanke an INT1
{ 
        timestamp = TCNT1;
        if (position == 0)
        {
                MCUCR = (0<<ISC10); //fallende Flanke
                TCNT1 = 0; //zurücksetzen (Anti-Überlauf)
                position = 0;
        }
        else
        {
                MCUCR = (1<<ISC10); //steigende Flanke
                position = 1;
        }
        flag = 1;
}

int main(void)
{
        initRP6Control();
        initLCD();
        INT1_setEventHandler(int1);
       
        MCUCR = (1<<ICS11) + (1<<ICS10); // Flanke von INT1 einstellen
        GICR = (1<<INT1); // INT1 aktivieren
        sei(); // Interrupts aktivieren
        while(true)
        {
                if (flag == 1)
                {
                        flag = 0;
                        if (position == 0)
                        {
                                periode = timestamp - zeit; // Zeit der kompletten Periode
                                zeit = timestamp; // neue Zeit
                                wert = impuls / periode; // werte ins Verhältnis setzen
                                utoa(wert,puffer,4);
                                writeStringLCD(puffer); // Ausgeben lassen
                        }
                        else
                        {
                                impuls = timestamp - zeit; // Zeit zwischen Rising up und Rising down
                        }
                }
        }
        return 0;
}

---

Wenn ich das kompilieren will kommt folgende Fehlermeldung:

Code:

---

Beschleunigungssensor.c: In function 'main':
Beschleunigungssensor.c:66: error: 'ICS11' undeclared (first use in this function)
Beschleunigungssensor.c:66: error: (Each undeclared identifier is reported only once
Beschleunigungssensor.c:66: error: for each function it appears in.)
Beschleunigungssensor.c:66: error: 'ICS10' undeclared (first use in this function)
make: *** [Beschleunigungssensor.o] Error 1

---

Ich hoffe ihr findet meinen dummen Fehler -.-

Gruß Lee

//EDIT: hab vergessen den Prescaler von 64 zu setzen und den Timer zu starten, aber ich weiß grad nicht wie -.-

//EDIT 2.0: mir ist gerade erst aufgefallen das man die 16 bit Register in zwei Schritten lesen muss. Och man ey ich raff det nich #-o

Die Fehler beim Compilieren kommen daher, das io.h nicht eingebunden ist. Da werden die ganzen Register und Bit namen erst definiert.

Der prescaler sollte eher bei 8 liegen. Die einstellung geht im Register TCCR1B.

Den Zugriff für die 16 Bit Registerpaare macht gcc schon selber, das ist also schon richtig so.

Es müssen noch ein paar mehr Variablem als volatile markiert werden, denn auch auf flag und postion wird in der ISR und main zugriffen. Bei den Variablen kommt man im wesentlichen mit dem Typ unsigned int aus. Man braucht da kein LONG. Das zurücksetzen des Zähler ist auch nicht nötig. Wenn ein Überlauf auftritt, dann wird der bei der Differenzbildung richtig berücksichtigt, wenn man konsequent beim Datentyp unsigned int bleibt.

Code:

---

timestamp = TCNT1;
  if (position == 0)
  {
      MCUCR = (0<<ISC10); //fallende Flanke
      TCNT1 = 0; //zurücksetzen (Anti-Überlauf)
      position = 0;
  }
  else
  {
      MCUCR = (1<<ISC10); //steigende Flanke
      position = 1;
  }

---

Sollte da in der Zuweisung bei position = 0; nicht position = 1 stehen und umgekehrt ?
Sonst wird ja beim nächsten Interrupt wieder die "if (position == 0)" durchlaufen.

Mh, habe jetzt die von euch genannten Punkte geändert und es sieht jetzt so aus:

Code:

---

#include "RP6ControlLib.h"                // The RP6 Control Library.
                                                                // Always needs to be included!
#include "stdlib.h"
#include "avr/io.h"
#include "avr/interrupt.h"

volatile unsigned long timestamp;    // volatile wegen Zugriff im Interrrupt
unsigned int impuls;
unsigned int periode;
unsigned int zeit;
volatile uint8_t flag;
volatile uint8_t position;
unsigned int wert;
char puffer[5];

void int1(void)  //  Flanke an INT1
{ 
        timestamp = TCNT1;
        if (position == 1)
        {
                MCUCR = (0<<ISC10); //fallende Flanke
                position = 0;
        }
        else
        {
                MCUCR = (1<<ISC10); //steigende Flanke
                position = 1;
        }
        flag = 1;
}

int main(void)
{
        initRP6Control();
        initLCD();
        INT1_setEventHandler(int1);
       
        MCUCR = (1<<ICS11) + (1<<ICS10); // Flanke von INT1 einstellen
        GICR = (1<<INT1); // INT1 aktivieren
        TCCR1B = (1<<CS11);                // Prescaler von 8
        sei();
        while(true)
        {
                if (flag == 1)
                {
                        flag = 0;
                        if (position == 0)
                        {
                                periode = timestamp - zeit;
                                zeit = timestamp;
                                wert = impuls / periode;
                                utoa(wert,puffer,4);
                                writeStringLCD(puffer);
                        }
                        else
                        {
                                impuls = timestamp - zeit;
                        }
                }
        }
        return 0;
}

---

Nach wie vor erhalte ich:

Code:

---

Beschleunigungssensor.c: In function 'main':
Beschleunigungssensor.c:66: error: 'ICS11' undeclared (first use in this function)
Beschleunigungssensor.c:66: error: (Each undeclared identifier is reported only once
Beschleunigungssensor.c:66: error: for each function it appears in.)
Beschleunigungssensor.c:66: error: 'ICS10' undeclared (first use in this function)
make: *** [Beschleunigungssensor.o] Error 1

> Process Exit Code: 2
> Time Taken: 00:00

---

Weiß echt nicht warum -.-

Gruß Lee

Es muss ISC11 stat ICS11 heißen. Ein einfacher Buchstabendreher.

Oh, ich Depp. OK jetzt compiliert er das ganze und ich bekomme Messwerte auf 0,1° genau. Allerdings muss ich wohl noch etwas mit dem Verhältnis spielen, da bei 90° die Abweichung schon ca. 1° beträgt. Ich denke mal das ist Temperaturabhängig, da die Messwerte des Herstellers bei 25°C aufgenommen wurden. Ich werde da mal ein wenig mit Faktoren rumspielen und evtl. den Analogen Temperatur output noch mit einbinden, um das möglichst genau zu bekommen.

Danke für Eure Hilfe!

Gruß Lee

Zitat:

---

OK jetzt compiliert er das ganze und ich bekomme Messwerte auf 0,1° genau. Allerdings muss ich wohl noch etwas mit dem Verhältnis spielen, da bei 90° die Abweichung schon ca. 1° beträgt.

---

Wie genau ist denn dein Referenzgerät ?

Wir haben auch mal fast eine Woche nach einem Fehler in der Software gesucht, bis wir festgestellt haben, das unser Referenz Voltmeter uns falsche Werte angezeigt hat.
Unser Gerät war im Nachhinein genauer als unser Referenz Gerät !?

Im übrigen sollten Referenzen von der Meßtoleranz her um den Faktor 10 besser sein, als die Schaltung die man abgleichen will.

Mh, ich konnte den Sensor nicht ohne den Roboter auslesen, sprich ich habe kein Referenzgerät. Ein Voltmeter hätte es ohnehin nicht getan, viel eher wäre ein Oszilloskop hilfreich.

Naja ich erreiche jetzt bei voller Fahrt (20cm/s) eine Genauigkeit von +- 0,3°. Ich finde dies schon recht gut, da der Hersteller diese 0,3° schon als statische Toleranz angibt.

Falls jemand das nachbauen möchte hier mein Ansatz:

Ich messe sowohl X als auch Y, wobei ich den Sensor im Winkel von 45° montiert habe. So hebt sich die Beschleunigung des Roboters wieder auf, da dann X steigt, während Y sinkt und umgekehrt. Auf einem Meter Strecke nehme ich jetzt 10 Messwerte auf und verarbeite dann den Mittelwert weiter. Dies wirkt eventuellen Unebenheiten oder Vibrationen während der Fahrt entgegen.

Wie gesagt, alles in allem ist die Toleranz für meinen Zweck völlig annehmbar.

Gruß Lee

Egal wie man den Sensor montiert sollte es unmöglich sein zwischen einer Neigung des Sensors und einer Beschleunigung zu unterscheiden. Den einzigen Ansatzpunkt den man hat, ist es das die Erdbeschleunigung einen konstanten bekannten Wert hat. Bei eine zusätzlichen Beschleunigung senkrecht dazu ändert sich der Betrag der Beschleuningung, was man theoretisch auswerten kann. Allerdings kriegt man so nicht das Vorzeichen einer Beschleunigung in der horizontalen und kann daher auch nichts korrigieren. Bestenfalls kann man einige Fälle erkennen in denen Beschleunigt wird, sodass man weiss dass diese Werte nicht zur Neigungsmessung taugen.

Es geht ja nicht darum die Beschleunigung des Fahrzeuges zu erkennen, sondern diese eben nicht aufzunehmen. Durch die Montage in 45°, misst bei 0° nach einiger Rechnerei die X-Achse 45° und die Y-Achse sogesehen -45°. Wenn jetzt das Fahrzeug beschleunigt, würd die messbare Erdbeschleunigung an der X-Achse ein wenig steigen und an der Y-Achse dementsprechend sinken. Durch die Differenzbildung bliebe der Winkel bei 0°. So hebt sich die Beschleunigung des Fahrzeugs auf, sodass man wirklich nur die Neigung misst. Eine senkrechte Beschleunigung gibt es theoretisch gar nicht, da das Fahrzeug ja nur Fahren kann. Durch unebenheiten in der Straße könnten solche Beschleunigungen zwar auftreten, diese werden aber durch die Mittelwertsbildung weitestgehend kompensiert.

Gruß Lee