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
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
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
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
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.