ADXL213 mit C167CR auswerten

Peter Gast #732488
Lesenswert?
• ▲
▼ 
Hey,

ich habe es jetzt geschafft den ADXL213 Neigungssensor (ähnliche 
Funktionsweise wie ADXL202) mit meinem uC, einem C167CR auszuwerten.
Der Sensor liefert ein seinem Neigungswinkel proportionales 
Tastverhältniss eines Rechtecksignals.
Dieses Tastverhältniss schwankt zwischen minimal 20% (Winkel=-90°) und 
maximal 80% (Winkel=+90°).

Ich verwende für jede Achse einen Timer in Gated Timer Mode zum 
auswerten.
Der Timer zählt also solange das Ausgangssignal des Sensors HIGH ist. 
Somit erhalte ich einen dem Tastverhältniss proportionalen Timerwert.
Mit absteigender Flanke wird der Timer in einem Interrupt ausgelesen und 
wieder 0 gesetzt.
Mein C167CR liefert mir nun Werte zwischen 480(20%) und 2000(80%).
Diese Verteilung ist zwar nicht ganz linear, aber man kann damit 
rechnen. Ich habe nähmlich eine Bandbreite von 1520 Werten.
Im Dateianhang befindet sich ein Datenblatt des Sensors, wo auf Seite 8 
der Verlauf des Tastverhältnis dargestellt ist. Für die errechnung des 
Winkels wird nur die X-Achse betrachtet, die Y-Achse könnt ihr euch also 
wegdenken.
Ich habe 30%Tastverhältnis pro g und einen Offset von 50%.
Ich ziehe nun von dem erhaltenen Timerwert die 50% Offset ab und 
dividiere diesen Wert durch 30%.
Meine Formel zur Winkelberechnung:
winkel= (aktueller_timerwert-wert50%)/(wert50%-wert20%);
Damit erhalte ich Werte zwischen +1 und -1, die ich mithilfe von 
ArcusSinus in einen Winkel umwandeln kann.
Das funktioniert und der Winkel passt auch.

Mein Problem ist nun folgendes:
Der errechnete Winkel erstreckt sich nicht stufenlos von +90° bis -90°.
Bei einem Wert von 2000 erhalte ich folgenden Winkel:
winkel = (2000-1240)/(1240-480)=1 =>asin(1)=90°
das passt.
Der nächstkleinere Wert ist allerdings 1999.
Wenn ich nun 1999 in die Formel einsetze erhalte ich
winkel=759/760=099868 =>asin(0.99868)=87°
Ich brauche allerdings einen Winkel von zumindest 89°.

Habt ihr eine Idee, wie ich meine Formel ändern könnte, oder was ich 
falsch gemacht habe.

MfG. Peter
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Michael K. #732520
Lesenswert?
• ▲
▼ 
Du musst die Timerauflösung erhöhen!
Wenn Du sehr genaue Winkelauflösungen willst, dann fahr die Bandbreite 
runter (ist bei mir bei ca. 0.5Hz) und dann kommst Du auch in 1/100° 
Regionen (relativ).
Ich hab das Ganze auch schon mal durchexerziert und hier der Code (nicht 
dokumentiert und optimiert und zudem noch für nen AVR):

1
#include <avr/io.h>

2
#include <avr/interrupt.h>

3


4


5
#include <math.h>

6
#include "m_usart.h"

7
#include "fcts.h"

8
#include "main.h"

9


10


11
// Globals

12
volatile uint32_t  value, pw;

13
volatile uint16_t  endpw, endvalue;

14
volatile uint8_t    MState = 0;

15


16


17


18
// ISR's ******************************************************************************

19
ISR (SIG_UART_RECV)

20
{

21
  uint8_t ch;

22
  ch = UDR;

23
}

24


25
ISR (TIMER1_OVF_vect)

26
{

27
  if (MState < 2)

28
    value += 65535;

29
  if (MState < 3)

30
    pw     += 65535;

31
}

32


33
ISR (INT0_vect)

34
{

35
  if (MState == 0)

36
  {

37
    Enable16bitTimer ();

38
    EnableEInt0Falling ();

39
    MState++;

40
  }

41
  else if (MState == 1)

42
  {

43
    endvalue = TCNT1;

44
    EnableEInt0Rising ();

45
    MState++;

46
  }

47
  else if (MState == 2)

48
  {

49
    endpw = TCNT1;

50
    Disable16bitTimer ();

51
    DisableEInt0 ();

52
    MState++;

53
  }

54
}

55


56
double MeasureAngle ()

57
{

58
  value   = 0;

59
  pw     = 0;

60
  MState   = 0;

61
  TCNT1    = 0;

62
  EnableEInt0Rising ();

63


64
  while (MState < 3);

65


66
  pw += endpw;

67
  value += endvalue;

68


69
  // 0.49 = ZeroGBias (normalerweise 0.5)

70
  // 0.3  = Sensitivity pro g

71
  double ratio = (((double)value / (double) pw) - 0.49) / 0.3;

72


73
  double angle = asin (ratio) * RAD2DEG;

74


75
  return angle;

76
}

77


78
/*******************************************************************************************/

79
int main ()

80
{

81
  // Locals

82


83
  DDRD   = 0x00;

84
  PORTD  |= (1 << PD2) | (1 << PD3);        // Enable pullups

85


86
  DDRC = 0xFF;

87
  PORTC = 0xFF;

88


89
  // Value init

90
  pw = 0;

91


92
  Init_UART ();

93


94
  sei ();

95


96
  for (;;)

97
  {

98
    uint8_t  i;

99
    uint8_t count = 250;

100
    double mangle = 0.0;

101
    double rangle = 0.0;

102


103
    for (i = 0; i < count; i++)

104
    {

105
      mangle = MeasureAngle ();

106
      rangle += mangle / (double)count;

107
    }

108
    

109
    long   rvalue = (int)(rangle * 100.0);

110
    

111
    if (rvalue < 0)

112
    {

113
      uart_putc (' ');

114
      uart_putc ('-');

115
      rvalue = -rvalue;

116
    }

117
    uart_putc (0x30 + (rvalue % 10000) / 1000);

118
    uart_putc (0x30 + (rvalue % 1000) / 100);

119
    uart_putc ('.');

120
    uart_putc (0x30 + (rvalue % 100) / 10);

121
    uart_putc (0x30 + (rvalue % 10));

122
    uart_putc ('\n');

123
  }

124
  

125
  return 1;

126
}


Hoffe es hilft!

Grüße,
Michael
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Peter Gast #732721
Lesenswert?
• ▲
▼ 
Hey,

meine Timerauflösung ist bereits auf dem maximal möglichen, nämlich bei 
einer Abtastubngsperiodedauer von 0.4us.
Allerdings ist unser Sensorausgangssignal relativ 'hochfrequent', 
nämlich 1kHz.
Ich nehme an du meinst mit Bandbreite die Frequenz des Sensors?
Es gibt aber auch im Datenblatt eine Bandbreite zu bestimmen, mit den 
beiden Kondensatoren, wobei ich die auf ca 25Hz (Cx=0.22uF) habe. Wozu 
diese Bandbreite genau dient habe ich nie verstanden, ich weiß nur ich 
würde gerne 25 Mal pro sekunde einen Winkel bekommen.

Mit dem Code fang ich leider nichts an, weil ich die Programmiersprache 
nicht kenne und somit auch den Code nicht verstehe.
Und die mathematische Herleitung ist eh ungefähr so wie bei mir.

Danke trotzdem Mal für die Hilfe.

MfG. peter
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Michael K. #733095
Lesenswert?
• ▲
▼ 
Sofern ich es verstanden habe bestimmt die Bandbreite die 
"Schnelligkeit" des Sensors. D.h. bis zu welcher Frequenz können 
Bewegungen des Sensors bei eingestellter Bandbreite noch detektiert 
werden. Bei meiner Beschaltung hat der Sensor noch eine Bandbreite von 
0.5Hz um das Rauschen maximal zu unterdrücken(Siehe Tabelle 6 RMS 
noise[mg]). Wird jetzt der Sensor schlagartig geneigt, so läuft der 
gemessene und ausgegeben Wert dem aktuellen Wert nach ....

> Allerdings ist unser Sensorausgangssignal relativ 'hochfrequent',
> nämlich 1kHz.
Die Ausgabe des Sensorsignals T2 (in Deinem Fall rund 1ms) wird über R2 
bestimmt.
T2(s) = Rset / 125MOhm
Datenblatt Seite 1 unter dem functional block diagram ....
für eine Ausgabe von 25 Hz brauchst Du:

T2 (25Hz) = 40ms

40ms = Rset / 125MOhm

RSet = 125e6 * 40e-3 = 5e6 Ohm = 5 MOhm

> Mit dem Code fang ich leider nichts an, weil ich die Programmiersprache
> nicht kenne und somit auch den Code nicht verstehe.

C !!??

Grüße,
Michael
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren