Subversion Repositories FlightCtrl

Rev

Rev 1612 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1612 Rev 1821
1 
/*#######################################################################################
 1 
/*#######################################################################################
2 
Decodieren eines RC Summen Signals oder Spektrum Empfänger-Satellit
 2 
 Decodieren eines RC Summen Signals oder Spektrum Empfänger-Satellit
3 
#######################################################################################*/
 3 
 #######################################################################################*/
4 
 
 4 
 
5 
#include "Spectrum.h"
 5 
#include "Spectrum.h"
6 
 
 6 
 
7 
//--------------------------------------------------------------//
 7 
//--------------------------------------------------------------//
8 
 
 8 
 
9 
//--------------------------------------------------------------//
 9 
//--------------------------------------------------------------//
10 
void SpektrumBinding(void)
 10 
void SpektrumBinding(void) {
11 
{
 - 
 
12 
  unsigned int timerTimeout = SetDelay(10000);  // Timeout 10 sec.
 11 
        unsigned int timerTimeout = SetDelay(10000); // Timeout 10 sec.
13 
  unsigned char connected = 0;
 12 
        unsigned char connected = 0;
14 
  unsigned int delaycounter;
 13 
        unsigned int delaycounter;
15 
 
 14 
 
16 
  UCSR1B &= ~(1 << RXCIE1);  // disable rx-interrupt
 15 
        UCSR1B &= ~(1 << RXCIE1); // disable rx-interrupt
17 
  UCSR1B &= ~(1<<RXEN1);     // disable Uart-Rx
 16 
        UCSR1B &= ~(1 << RXEN1); // disable Uart-Rx
18 
  PORTD &= ~(1 << PORTD2);   // disable pull-up
 17 
        PORTD &= ~(1 << PORTD2); // disable pull-up
19 
 
 18 
 
20 
  printf("\n\rPlease connect Spektrum receiver for binding NOW...");
 19 
        printf("\n\rPlease connect Spektrum receiver for binding NOW...");
21 
 
 20 
 
22 
  while(!CheckDelay(timerTimeout))
 21 
        while (!CheckDelay(timerTimeout)) {
23 
  {
 22 
                if (PIND & (1 << PORTD2)) {
24 
    if (PIND & (1 << PORTD2)) { timerTimeout = SetDelay(90); connected = 1; break; }
 23 
                        timerTimeout = SetDelay(90);
25 
  }
 - 
 
26 
 
 - 
 
27 
  if (connected)
 24 
                        connected = 1;
28 
  {
 - 
 
29 
   
 - 
 
30 
    printf("ok.\n\r");
 25 
                        break;
31 
    DDRD |= (1 << DDD2);     // Rx as output
 - 
 
32 
 
 26 
                }
33 
        while(!CheckDelay(timerTimeout));  // delay after startup of RX
 - 
 
34 
        for (delaycounter = 0; delaycounter < 100; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
35 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
36 
       
 27 
        }
37 
        for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
38 
    for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
39 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
40 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
41 
     
 - 
 
42 
        for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
43 
    for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
44 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
45 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
46 
 
 28 
 
47 
        for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD |= (1 << PORTD2);
 29 
        if (connected) {
48 
    for (delaycounter = 0; delaycounter < 10; delaycounter++) PORTD &= ~(1 << PORTD2);
 - 
 
49 
        for (delaycounter = 0; delaycounter < 400; delaycounter++) PORTD |= (1 << PORTD2);
 - 
 
50 
 
 30 
 
51 
  }
 - 
 
52 
   else
 - 
 
53 
  { printf("Timeout.\n\r");
 31 
                printf("ok.\n\r");
54 
 
 - 
 
55 
 
 - 
 
56 
  }
 - 
 
57 
   
 - 
 
58 
  DDRD &= ~(1 << DDD2);      // RX as input
 32 
                DDRD |= (1 << DDD2); // Rx as output
59 
  PORTD &= ~(1 << PORTD2);  
 - 
 
- 
 
 33 
 
- 
 
 34 
                while (!CheckDelay(timerTimeout))
- 
 
 35 
                        ; // delay after startup of RX
- 
 
 36 
                for (delaycounter = 0; delaycounter < 100; delaycounter++)
- 
 
 37 
                        PORTD |= (1 << PORTD2);
- 
 
 38 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 39 
                        PORTD &= ~(1 << PORTD2);
- 
 
 40 
 
- 
 
 41 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 42 
                        PORTD |= (1 << PORTD2);
- 
 
 43 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 44 
                        PORTD &= ~(1 << PORTD2);
- 
 
 45 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 46 
                        PORTD |= (1 << PORTD2);
- 
 
 47 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 48 
                        PORTD &= ~(1 << PORTD2);
- 
 
 49 
 
- 
 
 50 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 51 
                        PORTD |= (1 << PORTD2);
- 
 
 52 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 53 
                        PORTD &= ~(1 << PORTD2);
- 
 
 54 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 55 
                        PORTD |= (1 << PORTD2);
- 
 
 56 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 57 
                        PORTD &= ~(1 << PORTD2);
- 
 
 58 
 
- 
 
 59 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 60 
                        PORTD |= (1 << PORTD2);
- 
 
 61 
                for (delaycounter = 0; delaycounter < 10; delaycounter++)
- 
 
 62 
                        PORTD &= ~(1 << PORTD2);
- 
 
 63 
                for (delaycounter = 0; delaycounter < 400; delaycounter++)
- 
 
 64 
                        PORTD |= (1 << PORTD2);
- 
 
 65 
 
- 
 
 66 
        } else {
- 
 
 67 
                printf("Timeout.\n\r");
- 
 
 68 
 
- 
 
 69 
        }
- 
 
 70 
 
- 
 
 71 
        DDRD &= ~(1 << DDD2); // RX as input
- 
 
 72 
        PORTD &= ~(1 << PORTD2);
60 
 
 73 
 
61 
  Uart1Init();    // init Uart again
 74 
        Uart1Init(); // init Uart again
62 
}
 75 
}
63 
 
 76 
 
64 
//############################################################################
 77 
//############################################################################
65 
// zum Decodieren des Spektrum Satelliten wird USART1 benutzt.
 78 
// zum Decodieren des Spektrum Satelliten wird USART1 benutzt.
66 
// USART1 initialisation from killagreg
 79 
// USART1 initialisation from killagreg
67 
void Uart1Init(void)
 80 
void Uart1Init(void)
68 
//############################################################################
 81 
//############################################################################
69 
    {
 82 
{
70 
        // -- Start of USART1 initialisation for Spekturm seriell-mode
 83 
        // -- Start of USART1 initialisation for Spekturm seriell-mode
71 
        // USART1 Control and Status Register A, B, C and baud rate register
 84 
        // USART1 Control and Status Register A, B, C and baud rate register
72 
        uint16_t ubrr = (uint16_t) ((uint32_t) SYSCLK/(8 * 115200) - 1);
 85 
        uint16_t ubrr = (uint16_t) ((uint32_t) SYSCLK / (8 * 115200) - 1);
73 
        // disable RX-Interrupt
 86 
        // disable RX-Interrupt
74 
        UCSR1B &= ~(1 << RXCIE1);
 87 
        UCSR1B &= ~(1 << RXCIE1);
75 
        // disable TX-Interrupt
 88 
        // disable TX-Interrupt
76 
        UCSR1B &= ~(1 << TXCIE1);
 89 
        UCSR1B &= ~(1 << TXCIE1);
77 
        // disable DRE-Interrupt
 90 
        // disable DRE-Interrupt
78 
        UCSR1B &= ~(1 << UDRIE1);
 91 
        UCSR1B &= ~(1 << UDRIE1);
79 
        // set direction of RXD1 and TXD1 pins
 92 
        // set direction of RXD1 and TXD1 pins
80 
        // set RXD1 (PD2) as an input pin
 93 
        // set RXD1 (PD2) as an input pin
81 
        PORTD |= (1 << PORTD2);
 94 
        PORTD |= (1 << PORTD2);
82 
        DDRD &= ~(1 << DDD2);
 95 
        DDRD &= ~(1 << DDD2);
83 
        // USART0 Baud Rate Register
 96 
        // USART0 Baud Rate Register
84 
        // set clock divider
 97 
        // set clock divider
85 
       
 98 
 
86 
        UBRR1H = (uint8_t)(ubrr>>8);
 99 
        UBRR1H = (uint8_t) (ubrr >> 8);
87 
        UBRR1L = (uint8_t)ubrr;
 100 
        UBRR1L = (uint8_t) ubrr;
88 
        // enable double speed operation
 101 
        // enable double speed operation
89 
        UCSR1A |= (1 << U2X1);
 102 
        UCSR1A |= (1 << U2X1);
90 
        // enable receiver and transmitter
 103 
        // enable receiver and transmitter
91 
        //UCSR1B = (1<<RXEN1)|(1<<TXEN1);
 104 
        //UCSR1B = (1<<RXEN1)|(1<<TXEN1);
92 
 
 105 
 
93 
 
 - 
 
94 
       
 - 
 
95 
       
 106 
 
96 
        UCSR1B = (1<<RXEN1);
 107 
        UCSR1B = (1 << RXEN1);
97 
        // set asynchronous mode
 108 
        // set asynchronous mode
98 
        UCSR1C &= ~(1 << UMSEL11);
 109 
        UCSR1C &= ~(1 << UMSEL11);
99 
        UCSR1C &= ~(1 << UMSEL10);
 110 
        UCSR1C &= ~(1 << UMSEL10);
100 
        // no parity
 111 
        // no parity
101 
        UCSR1C &= ~(1 << UPM11);
 112 
        UCSR1C &= ~(1 << UPM11);
102 
        UCSR1C &= ~(1 << UPM10);
 113 
        UCSR1C &= ~(1 << UPM10);
103 
        // 1 stop bit
 114 
        // 1 stop bit
104 
        UCSR1C &= ~(1 << USBS1);
 115 
        UCSR1C &= ~(1 << USBS1);
105 
        // 8-bit
 116 
        // 8-bit
106 
        UCSR1B &= ~(1 << UCSZ12);
 117 
        UCSR1B &= ~(1 << UCSZ12);
107 
        UCSR1C |=  (1 << UCSZ11);
 118 
        UCSR1C |= (1 << UCSZ11);
108 
        UCSR1C |=  (1 << UCSZ10);
 119 
        UCSR1C |= (1 << UCSZ10);
109 
        // flush receive buffer explicit
 120 
        // flush receive buffer explicit
110 
        while(UCSR1A & (1<<RXC1)) UDR1;
 121 
        while (UCSR1A & (1 << RXC1))
- 
 
 122 
                UDR1;
111 
        // enable RX-interrupts at the end
 123 
        // enable RX-interrupts at the end
112 
        UCSR1B |= (1 << RXCIE1);
 124 
        UCSR1B |= (1 << RXCIE1);
113 
        // -- End of USART1 initialisation
 125 
        // -- End of USART1 initialisation
114 
  return;
 126 
        return;
115 
 }
 127 
}
116 
       
 128 
 
117 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 129 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
118 
// + Copyright (c) Rainer Walther
 130 
// + Copyright (c) Rainer Walther
119 
// + RC-routines from original MK rc.c (c) H&I
 131 
// + RC-routines from original MK rc.c (c) H&I
120 
// + Useful infos from Walter: http://www.rcgroups.com/forums/showthread.php?t=714299&page=2
 132 
// + Useful infos from Walter: http://www.rcgroups.com/forums/showthread.php?t=714299&page=2
121 
// + only for non-profit use
 133 
// + only for non-profit use
122 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 134 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
123 
//
 135 
//
124 
// 20080808 rw Modified for Spektrum AR6100 (PPM)
 136 
// 20080808 rw Modified for Spektrum AR6100 (PPM)
125 
// 20080823 rw Add Spektrum satellite receiver on USART1 (644P only)
 137 
// 20080823 rw Add Spektrum satellite receiver on USART1 (644P only)
126 
// 20081213 rw Add support for Spektrum DS9 Air-Tx-Module (9 channels)
 138 
// 20081213 rw Add support for Spektrum DS9 Air-Tx-Module (9 channels)
127 
//             Replace AR6100-coding with original composit-signal routines
 139 
//             Replace AR6100-coding with original composit-signal routines
128 
//
 140 
//
129 
// ---
 141 
// ---
130 
// Entweder Summensignal ODER Spektrum-Receiver anschließen. Nicht beides gleichzeitig betreiben!
 142 
// Entweder Summensignal ODER Spektrum-Receiver anschließen. Nicht beides gleichzeitig betreiben!
131 
// Binding is not implemented. Bind with external Receiver.
 143 
// Binding is not implemented. Bind with external Receiver.
132 
// Servo output J3, J4, J5 not serviced
 144 
// Servo output J3, J4, J5 not serviced
133 
//
 145 
//
134 
// Anschuß Spektrum Receiver
 146 
// Anschuß Spektrum Receiver
135 
//              Orange:         3V von der FC (keinesfalls an 5V anschließen!)
 147 
//              Orange:         3V von der FC (keinesfalls an 5V anschließen!)
136 
//              Schwarz:        GND
 148 
//              Schwarz:        GND
137 
//              Grau:           RXD1 (Pin 3) auf 10-Pol FC-Stecker
 149 
//              Grau:           RXD1 (Pin 3) auf 10-Pol FC-Stecker
138 
//
 150 
//
139 
// ---
 151 
// ---
140 
// Satellite-Reciever connected on USART1:
 152 
// Satellite-Reciever connected on USART1:
141 
//
 153 
//
142 
// DX7/DX6i: One data-frame at 115200 baud every 22ms.
 154 
// DX7/DX6i: One data-frame at 115200 baud every 22ms.
143 
// DX7se:    One data-frame at 115200 baud every 11ms.
 155 
// DX7se:    One data-frame at 115200 baud every 11ms.
144 
//              byte1:  unknown
 156 
//              byte1:  unknown
145 
//      byte2:  unknown
 157 
//      byte2:  unknown
146 
//      byte3:  and byte4:  channel data        (FLT-Mode)
 158 
//      byte3:  and byte4:  channel data        (FLT-Mode)
147 
//      byte5:  and byte6:  channel data        (Roll)
 159 
//      byte5:  and byte6:  channel data        (Roll)
148 
//      byte7:  and byte8:  channel data        (Nick)
 160 
//      byte7:  and byte8:  channel data        (Nick)
149 
//      byte9:  and byte10: channel data        (Gier)
 161 
//      byte9:  and byte10: channel data        (Gier)
150 
//      byte11: and byte12: channel data        (Gear Switch)
 162 
//      byte11: and byte12: channel data        (Gear Switch)
151 
//      byte13: and byte14: channel data        (Gas)
 163 
//      byte13: and byte14: channel data        (Gas)
152 
//      byte15: and byte16: channel data        (AUX2)
 164 
//      byte15: and byte16: channel data        (AUX2)
153 
//
 165 
//
154 
// DS9 (9 Channel): One data-frame at 115200 baud every 11ms, alternating frame 1/2 for CH1-7 / CH8-9
 166 
// DS9 (9 Channel): One data-frame at 115200 baud every 11ms, alternating frame 1/2 for CH1-7 / CH8-9
155 
//  1st Frame:
 167 
//  1st Frame:
156 
//              byte1:  unknown
 168 
//              byte1:  unknown
157 
//      byte2:  unknown
 169 
//      byte2:  unknown
158 
//              byte3:  and byte4:  channel data
 170 
//              byte3:  and byte4:  channel data
159 
//      byte5:  and byte6:  channel data
 171 
//      byte5:  and byte6:  channel data
160 
//      byte7:  and byte8:  channel data
 172 
//      byte7:  and byte8:  channel data
161 
//      byte9:  and byte10: channel data
 173 
//      byte9:  and byte10: channel data
162 
//      byte11: and byte12: channel data
 174 
//      byte11: and byte12: channel data
163 
//      byte13: and byte14: channel data
 175 
//      byte13: and byte14: channel data
164 
//      byte15: and byte16: channel data
176 
//      byte15: and byte16: channel data
165 
//  2nd Frame:
 177 
//  2nd Frame:
166 
//              byte1:  unknown
 178 
//              byte1:  unknown
167 
//      byte2:  unknown
 179 
//      byte2:  unknown
168 
//              byte3:  and byte4:  channel data
 180 
//              byte3:  and byte4:  channel data
169 
//      byte5:  and byte6:  channel data
 181 
//      byte5:  and byte6:  channel data
170 
//      byte7:  and byte8:  0xffff
 182 
//      byte7:  and byte8:  0xffff
171 
//      byte9:  and byte10: 0xffff
 183 
//      byte9:  and byte10: 0xffff
172 
//      byte11: and byte12: 0xffff
 184 
//      byte11: and byte12: 0xffff
173 
//      byte13: and byte14: 0xffff
 185 
//      byte13: and byte14: 0xffff
174 
//      byte15: and byte16: 0xffff
 186 
//      byte15: and byte16: 0xffff
175 
//
 187 
//
176 
// Each channel data (16 bit= 2byte, first msb, second lsb) is arranged as:
 188 
// Each channel data (16 bit= 2byte, first msb, second lsb) is arranged as:
177 
//
 189 
//
178 
// Bits: F 0 C3 C2 C1 C0 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0
 190 
// Bits: F 0 C3 C2 C1 C0 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0
179 
//
 191 
//
180 
// 0 means a '0' bit
 192 
// 0 means a '0' bit
181 
// F: 1 = indicates beginning of 2nd frame for CH8-9 (DS9 only)
 193 
// F: 1 = indicates beginning of 2nd frame for CH8-9 (DS9 only)
182 
// C3 to C0 is the channel number. 0 to 9 (4 bit, as assigned in the transmitter)
 194 
// C3 to C0 is the channel number. 0 to 9 (4 bit, as assigned in the transmitter)
183 
// D9 to D0 is the channel data (10 bit) 0xaa..0x200..0x356 for 100% transmitter-travel
 195 
// D9 to D0 is the channel data (10 bit) 0xaa..0x200..0x356 for 100% transmitter-travel
184 
//
 196 
//
185 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 197 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
186 
 
 198 
 
187 
//############################################################################
 199 
//############################################################################
188 
//Diese Routine startet und inizialisiert den USART1 für seriellen Spektrum satellite reciever
 200 
//Diese Routine startet und inizialisiert den USART1 für seriellen Spektrum satellite reciever
189 
SIGNAL(USART1_RX_vect)
 201 
SIGNAL( USART1_RX_vect)
190 
//############################################################################
 202 
//############################################################################
191 
{
 203 
{
192 
static unsigned int Sync=0, FrameCnt=0, ByteHigh=0, ReSync=1, Frame2=0, FrameTimer;
 204 
        static unsigned int Sync = 0, FrameCnt = 0, ByteHigh = 0, ReSync = 1, Frame2 =
- 
 
 205 
                        0, FrameTimer;
193 
        unsigned int Channel, index;
 206 
        unsigned int Channel, index;
194 
        signed int signal, tmp;
 207 
        signed int signal, tmp;
195 
        int bCheckDelay;
 208 
        int bCheckDelay;
196 
        uint8_t c;
 209 
        uint8_t c;
197 
       
 210 
 
198 
        c = UDR1; // get data byte
 211 
        c = UDR1; // get data byte
199 
       
 212 
 
200 
        if (ReSync == 1)
 213 
        if (ReSync == 1) {
201 
            {
 - 
 
202 
                // wait for beginning of new frame
 214 
                // wait for beginning of new frame
203 
                ReSync = 0;
 215 
                ReSync = 0;
204 
               
 216 
 
205 
                FrameTimer = SetDelay(7);  // minimum 7ms zwischen den frames
 217 
                FrameTimer = SetDelay(7); // minimum 7ms zwischen den frames
206 
                FrameCnt = 0;
 218 
                FrameCnt = 0;
207 
                Sync = 0;
 219 
                Sync = 0;
208 
                ByteHigh = 0;
 220 
                ByteHigh = 0;
209 
                }
 - 
 
210 
  else
 221 
        } else {
211 
  {    
 - 
 
212 
        bCheckDelay = CheckDelay(FrameTimer);
 222 
                bCheckDelay = CheckDelay(FrameTimer);
213 
        if ( Sync == 0 )
 223 
                if (Sync == 0) {
214 
            {
 - 
 
215 
                if(bCheckDelay)
 224 
                        if (bCheckDelay) {
216 
                    {
 - 
 
217 
                        // nach einer Pause von mind. 7ms erstes Sync-Character gefunden
 225 
                                // nach einer Pause von mind. 7ms erstes Sync-Character gefunden
218 
                        // Zeichen ignorieren, da Bedeutung unbekannt
 226 
                                // Zeichen ignorieren, da Bedeutung unbekannt
219 
                        Sync = 1;
 227 
                                Sync = 1;
220 
                        FrameCnt ++;
 228 
                                FrameCnt++;
- 
 
 229 
                        } else {
- 
 
 230 
                                // Zeichen kam vor Ablauf der 7ms Sync-Pause
- 
 
 231 
                                // warten auf erstes Sync-Zeichen
221 
                        }
 232 
                        }
- 
 
 233 
                } else if ((Sync == 1) && !bCheckDelay) {
- 
 
 234 
                        // zweites Sync-Character ignorieren, Bedeutung unbekannt
222 
                else
 235 
                        Sync = 2;
223 
                        {
 236 
                        FrameCnt++;
- 
 
 237 
                } else if ((Sync == 2) && !bCheckDelay) {
- 
 
 238 
                        // Datenbyte high
- 
 
 239 
                        ByteHigh = c;
- 
 
 240 
 
- 
 
 241 
                        if (FrameCnt == 2) {
- 
 
 242 
                                // is 1st Byte of Channel-data
224 
                        // Zeichen kam vor Ablauf der 7ms Sync-Pause
 243 
                                // Frame 1 with Channel 1-7 comming next
- 
 
 244 
                                Frame2 = 0;
- 
 
 245 
                                if (ByteHigh & 0x80) {
225 
                        // warten auf erstes Sync-Zeichen
 246 
                                        // DS9: Frame 2 with Channel 8-9 comming next
- 
 
 247 
                                        Frame2 = 1;
- 
 
 248 
                                }
226 
                        }
 249 
                        }
227 
                }
 250 
                        Sync = 3;
- 
 
 251 
                        FrameCnt++;
228 
        else if((Sync == 1) && !bCheckDelay)
 252 
                } else if ((Sync == 3) && !bCheckDelay) {
229 
            {
 253 
                        // Datenbyte low
- 
 
 254 
 
230 
                // zweites Sync-Character ignorieren, Bedeutung unbekannt
 255 
                        // High-Byte for next channel comes next
231 
                Sync = 2;
 256 
                        Sync = 2;
232 
                FrameCnt ++;
 257 
                        FrameCnt++;
233 
                }
 258 
 
234 
        else if((Sync == 2) && !bCheckDelay)
 259 
                        index = (ByteHigh >> 2) & 0x0f;
235 
            {
 260 
                        index++;
236 
                // Datenbyte high
 261 
                        Channel = (ByteHigh << 8) | c;
237 
                ByteHigh = c;
 262 
                        signal = Channel & 0x3ff;
- 
 
 263 
                        signal -= 0x200; // Offset, range 0x000..0x3ff?
- 
 
 264 
                        signal = signal / 3; // scaling to fit PPM resolution
238 
               
 265 
 
239 
                if (FrameCnt == 2)
 266 
                        if (index >= 0 && index <= 10) {
240 
                    {
 - 
 
241 
                    // is 1st Byte of Channel-data
 267 
                                // Stabiles Signal
242 
                        // Frame 1 with Channel 1-7 comming next
 268 
                                if (abs(signal - PPM_in[index]) < 6) {
243 
                        Frame2 = 0;
 269 
                                        if (SenderOkay < 200)
244 
                        if(ByteHigh & 0x80)
 270 
                                                SenderOkay += 10;
245 
                            {
 271 
                                        else
246 
                                // DS9: Frame 2 with Channel 8-9 comming next
 - 
 
247 
                                Frame2 = 1;
 272 
                                                SenderOkay = 200;
248 
                                }
 273 
                                }
249 
                        }      
 - 
 
250 
                Sync = 3;
 - 
 
251 
                FrameCnt ++;
 - 
 
252 
                }
 - 
 
253 
        else if((Sync == 3) && !bCheckDelay)
 274 
                                tmp = (3 * (PPM_in[index]) + signal) / 4;
254 
            {
 - 
 
255 
                // Datenbyte low
 275 
                                if (tmp > signal + 1)
256 
               
 - 
 
257 
                // High-Byte for next channel comes next
 - 
 
258 
                Sync = 2;
 276 
                                        tmp--;
259 
                FrameCnt ++;
 - 
 
260 
               
 - 
 
261 
                index = (ByteHigh >> 2) & 0x0f;
 277 
                                else if (tmp < signal - 1)
262 
                index ++;
 278 
                                        tmp++;
263 
                Channel = (ByteHigh << 8) | c;
 279 
                                if (SenderOkay >= 180)
264 
                signal = Channel & 0x3ff;
 - 
 
265 
                signal -= 0x200;                // Offset, range 0x000..0x3ff?
 - 
 
266 
                signal = signal/3;              // scaling to fit PPM resolution
 - 
 
267 
               
 - 
 
268 
                if(index >= 0  &&  index <= 10)
 280 
                                        PPM_diff[index] = ((tmp - PPM_in[index]) / 3) * 3;
269 
                    {
 281 
                                else
270 
                // Stabiles Signal
 - 
 
271 
                if(abs(signal - PPM_in[index]) < 6) { if(SenderOkay < 200) SenderOkay += 10; else SenderOkay = 200;}
 - 
 
272 
                tmp = (3 * (PPM_in[index]) + signal) / 4;  
 - 
 
273 
                if(tmp > signal+1) tmp--; else
 - 
 
274 
                if(tmp < signal-1) tmp++;
 - 
 
275 
                if(SenderOkay >= 180)  PPM_diff[index] = ((tmp - PPM_in[index]) / 3) * 3;
 - 
 
276 
                else PPM_diff[index] = 0;
 282 
                                        PPM_diff[index] = 0;
277 
                PPM_in[index] = tmp;
 283 
                                PPM_in[index] = tmp;
278 
                        }
 284 
                        }
- 
 
 285 
                } else {
- 
 
 286 
                        // hier stimmt was nicht: neu synchronisieren
- 
 
 287 
                        ReSync = 1;
- 
 
 288 
                        FrameCnt = 0;
- 
 
 289 
                        Frame2 = 0;
279 
                }
 290 
                }
280 
        else
 - 
 
281 
                {
 - 
 
282 
                // hier stimmt was nicht: neu synchronisieren
 - 
 
283 
                ReSync = 1;
 - 
 
284 
                FrameCnt = 0;
 - 
 
285 
                Frame2 = 0;
 - 
 
286 
                }
 - 
 
287 
               
 291 
 
288 
        // 16 Bytes per frame
 292 
                // 16 Bytes per frame
289 
        if(FrameCnt >= 16)
 293 
                if (FrameCnt >= 16) {
290 
            {
 - 
 
291 
                // Frame complete
 294 
                        // Frame complete
292 
                if(Frame2 == 0)
 295 
                        if (Frame2 == 0) {
293 
                        {
 - 
 
294 
                        // Null bedeutet: Neue Daten
 296 
                                // Null bedeutet: Neue Daten
295 
                        // nur beim ersten Frame (CH 0-7) setzen
 297 
                                // nur beim ersten Frame (CH 0-7) setzen
296 
                        NewPpmData = 0;  
 298 
                                NewPpmData = 0;
297 
                        }
 299 
                        }
298 
               
 - 
 
299 
                // new frame next, nach fruehestens 7ms erwartet
 - 
 
300 
                FrameCnt = 0;
 - 
 
301 
                Frame2 = 0;
 - 
 
302 
                Sync = 0;
 - 
 
303 
                }
 - 
 
304 
        // Zeit bis zum nächsten Zeichen messen
 - 
 
305 
        FrameTimer = SetDelay(7);
 - 
 
306 
   }
 - 
 
307 
}  
 - 
 
- 
 
 300 
 
- 
 
 301 
                        // new frame next, nach fruehestens 7ms erwartet
- 
 
 302 
                        FrameCnt = 0;
- 
 
 303 
                        Frame2 = 0;
- 
 
 304 
                        Sync = 0;
- 
 
 305 
                }
- 
 
 306 
                // Zeit bis zum nächsten Zeichen messen
- 
 
 307 
                FrameTimer = SetDelay(7);
- 
 
 308 
        }
308 
 
 309 
}
309 
 
 310 
 
310 
 
 311