Hallo,
laut suche haben das ja schon einige hin bekommen.
Ich habe mir auch schon den Code von U. Radig angesehen und ausprobiert.
Leider ohne Erfolg. Mal ein paar Eckdaten:
Ich habe hier einen 2.4GHz Empfänger "Carson Reflex 6CH", an dem ich an
einem Pin das Summensignal abgreifen kann. Zumindest denke ich das es
das Summensignal ist.
An dem Pin im Receiver kommt vom Funkmodul die Daten die auf einen
Prozessor geht, der daraus die einzelnen Servodaten erzeugt.
Schalte ich den Sender aus, fällt auch dieses Signal aus.
Allerdings passen die Zeiten so gar nicht mit meinen Erwartungen:
1: 0,2ms bis 0,95ms
0: der Rest bis zur nächsten 1. = 18ms
Über eine längere Zeit betrachtet am Scope ist auch keine Syncpause zu
erkennen.
Auch wenn ich etwas ansteuere, kann ich keinen Unterschied erkennen,
falls die Anlage nur Veränderungen überträgt. Ich sehe nur einen starken
"Jitter" bei den Einsen.
Im Moment teste ich das ganze mit einem Polin Eval Board V2 und einem
ATMega16 mit 8MHz.
Ich hab versucht die Länge der Einsen in einer Schleife zu zählen und
gelegentlich über UART auszugeben. Ein vernünftiges Muster sehe ich hier
leider auch nicht.
Im Moment bin ich etwas ratlos.
Mein Testcode sieht im Moment so aus, ich hoffe U.R. verzeiht mir den
Missbrauch. Ich bin hier schon am verzweifeln:
1 | // Wertet ein RC Summen Signal aus
|
2 |
|
3 | #include <avr/interrupt.h>
|
4 | #include <avr/io.h>
|
5 | #include "usart.h"
|
6 | //#include "rc.h"
|
7 |
|
8 | uint16_t temp[20];
|
9 | uint8_t pos=0;
|
10 | uint8_t lastval=0;
|
11 | uint8_t nowval=0;
|
12 |
|
13 | void printval()
|
14 | {
|
15 | usart_write("pos=%i:",pos);
|
16 | for(uint8_t i=0;i<pos;i++)
|
17 | {
|
18 | usart_write("%i:",(temp[i]));
|
19 | temp[i]=0;
|
20 | }
|
21 | usart_write("\r\n");
|
22 | pos=0;
|
23 |
|
24 | // Auf die Null warten, die Ausgabe braucht zuviel Zeit
|
25 | while(PIND&_BV(PD3))
|
26 | lastval=nowval;
|
27 |
|
28 | }
|
29 |
|
30 | int main (void)
|
31 | {
|
32 | usart_init(9600); // Serielle Schnittstelle initialisieren
|
33 |
|
34 | usart_write("RC_SUM_ENCODE_V0.1\r\n");
|
35 | rc_sum_init();
|
36 | //sei();
|
37 | DDRD=0x00|_BV(PD6);
|
38 |
|
39 | while(1)
|
40 | {
|
41 | nowval = PIND&_BV(PD3);
|
42 | if (nowval>0)
|
43 | {
|
44 | temp[pos]++;
|
45 | lastval=nowval;
|
46 | }
|
47 | else
|
48 | {
|
49 | if (lastval>0) // bei fallender flanke nächster Kanal
|
50 | {
|
51 | pos++;
|
52 | lastval=0;
|
53 | }
|
54 | if (temp[(pos-1)]>250) // In früherem Test war die 620 eine gute Schwelle zwischen anderen Impulsen
|
55 | {
|
56 | printval();
|
57 | }
|
58 | if (pos>15) // Notanker falls Sync nicht erkannt
|
59 | printval();
|
60 | }
|
61 | //PORTD=PORTD^_BV(PD6);
|
62 | }
|
63 | }
|
Der Code ist nicht optimal und diente nur um mal ein paar Daten zu
bekommen, wie folgt. Vielleicht hat ja jemand eine Idee:
pos=14:137:192:248:98:155:210:68:124:181:236:87:143:199:268:
pos=4:76:136:192:256:
pos=3:159:220:275:
pos=6:183:241:92:147:205:265:
pos=6:174:235:82:138:198:255:
pos=10:168:224:74:130:187:243:93:157:212:273:
pos=5:236:83:142:201:258:
pos=16:165:221:74:134:190:247:97:152:208:65:122:178:234:84:141:197:
pos=4:73:134:190:253:
pos=3:156:216:273:
pos=6:180:238:88:144:200:261:
pos=16:170:230:76:133:193:249:95:162:219:69:126:181:239:88:152:209:
pos=4:78:136:197:253:
pos=16:159:215:68:128:185:241:92:148:205:62:119:175:231:81:138:193:
pos=8:70:129:185:250:96:151:212:269:
pos=5:234:84:141:197:257:
pos=16:167:227:73:130:190:246:92:160:215:65:122:178:235:84:147:203:
pos=15:73:131:192:249:95:155:211:64:124:180:236:87:144:200:262:
pos=4:76:131:188:256:
pos=10:162:219:65:124:181:244:90:146:206:263:
pos=5:229:79:135:192:253:
pos=10:162:222:68:124:185:242:87:155:212:267:
pos=5:230:81:144:200:260:
pos=10:164:223:69:127:188:244:91:151:206:268:
pos=5:232:83:139:195:259:
Thread beobachten
Seitenaufteilung abschalten