Moin,
ich versuche Daten, die vom GPS und XBee an meinen Atmega1284P gesendet
werden, über das XBee zurückzusenden. Dafür habe ich von dieser Homepage
http://www.mikrocontroller.net/articles/FIFO den 2^n-Ringbuffer benutzt.
Das hier ist die FIFO Datei: Es ist 3x das gleiche, nur dass es einmal
XI ( empfangene XBee Daten), XO (XBee Daten zum senden) und GPS für die
empfangenden GPS Daten.
1 | #include "fifo.h"
|
2 |
|
3 | //OUT_Buffer
|
4 | struct XO_Buffer {
|
5 | uint8_t data[BUFFER_SIZE];
|
6 | uint8_t read;
|
7 | uint8_t write;
|
8 | } XO_buffer = {{}, 0, 0};
|
9 |
|
10 | uint8_t XO_BufferIn(uint8_t byte)
|
11 | {
|
12 | uint8_t next = ((XO_buffer.write + 1) & BUFFER_MASK);
|
13 | if (XO_buffer.read == next)
|
14 | return FAIL;
|
15 | XO_buffer.data[XO_buffer.write] = byte;
|
16 | XO_buffer.write = next;
|
17 | UCSR1A |= (1<<UDRIE1);
|
18 | return SUCCESS;
|
19 | }
|
20 |
|
21 | uint8_t XO_BufferOut(uint8_t *pByte)
|
22 | {
|
23 | if (XO_buffer.read == XO_buffer.write)
|
24 | {
|
25 | UCSR1A &= ~(1<<UDRIE1);
|
26 | return FAIL;
|
27 | }
|
28 | *pByte = XO_buffer.data[XO_buffer.read];
|
29 | XO_buffer.read = (XO_buffer.read+1) & BUFFER_MASK;
|
30 | return SUCCESS;
|
31 | }
|
32 |
|
33 |
|
34 | //IN_Buffer
|
35 | struct XI_Buffer {
|
36 | uint8_t data[BUFFER_SIZE];
|
37 | uint8_t read;
|
38 | uint8_t write;
|
39 | } XI_buffer = {{}, 0, 0};
|
40 |
|
41 | uint8_t XI_BufferIn(uint8_t byte)
|
42 | {
|
43 | uint8_t next = ((XI_buffer.write + 1) & BUFFER_MASK);
|
44 | if (XI_buffer.read == next)
|
45 | return FAIL;
|
46 | XI_buffer.data[XI_buffer.write] = byte;
|
47 | XI_buffer.write = next;
|
48 | return SUCCESS;
|
49 | }
|
50 |
|
51 | uint8_t XI_BufferOut(uint8_t *pByte)
|
52 | {
|
53 | if (XI_buffer.read == XI_buffer.write)
|
54 | return FAIL;
|
55 | *pByte = XI_buffer.data[XI_buffer.read];
|
56 | XI_buffer.read = (XI_buffer.read+1) & BUFFER_MASK;
|
57 | return SUCCESS;
|
58 | }
|
59 |
|
60 |
|
61 | //GPS_Buffer
|
62 | struct GPS_Buffer {
|
63 | uint8_t data[BUFFER_SIZE];
|
64 | uint8_t read;
|
65 | uint8_t write;
|
66 | } GPS_buffer = {{}, 0, 0};
|
67 |
|
68 | uint8_t GPS_BufferIn(uint8_t byte)
|
69 | {
|
70 | uint8_t next = ((GPS_buffer.write + 1) & BUFFER_MASK);
|
71 | if (GPS_buffer.read == next)
|
72 | return FAIL;
|
73 | GPS_buffer.data[GPS_buffer.write] = byte;
|
74 | GPS_buffer.write = next;
|
75 | return SUCCESS;
|
76 | }
|
77 |
|
78 | uint8_t GPS_BufferOut(uint8_t *pByte)
|
79 | {
|
80 | if (GPS_buffer.read == GPS_buffer.write)
|
81 | return FAIL;
|
82 | *pByte = GPS_buffer.data[GPS_buffer.read];
|
83 | GPS_buffer.read = (GPS_buffer.read+1) & BUFFER_MASK;
|
84 | return SUCCESS;
|
85 | }
|
Erstes Problem: In den FIFO Funktionen für XO wird das UDRE Interrupt
Bit gesetzt und wieder gelöscht, wenn keine Daten mehr drin sind. Aber
das UDRE Interreput wird nie ausgelöst.
Anderes Problem. Ich habe versucht, die Daten vom XBee ohne FIFO zurück
zusenden. Hier ist die Main Funktion:
1 | #include <avr/io.h>
|
2 | #include <util/delay.h>
|
3 | #include <avr/interrupt.h>
|
4 |
|
5 | #include "defines.h"
|
6 | #include "fifo.h"
|
7 | #include "uarts.h"
|
8 | #include "steer.h"
|
9 |
|
10 | int main(void)
|
11 | {
|
12 | uint8_t tmp_byte = 0x00;
|
13 | DDRC = 0xff;
|
14 | PORTC |= 0xff;
|
15 | delay_ms(1000);
|
16 | PORTC &= ~PORTC;
|
17 |
|
18 | uart_init();
|
19 | sei();
|
20 | while(1)
|
21 | {
|
22 |
|
23 | if(GPS_BufferOut(&tmp_byte))
|
24 | {
|
25 | //XO_BufferIn(tmp_byte);
|
26 | }
|
27 | if(XI_BufferOut(&tmp_byte))
|
28 | {
|
29 | //XO_BufferIn(tmp_byte);
|
30 | uart_putc(tmp_byte);
|
31 | }
|
32 | }
|
33 | return 0;
|
34 | }
|
35 |
|
36 | //USART Interrupts
|
37 | //GPS
|
38 | ISR(USART0_RX_vect)
|
39 | {
|
40 | //uart_putc('G');
|
41 | uint8_t tmp = UDR0;
|
42 | if(!GPS_BufferIn(tmp))
|
43 | PORTC = 0xff;
|
44 | }
|
45 |
|
46 | //XBee
|
47 | ISR(USART1_RX_vect)
|
48 | {
|
49 | //uart_putc('X');
|
50 | uint8_t tmp = UDR1;
|
51 | if(!XI_BufferIn(tmp))
|
52 | PORTC = 0xff;
|
53 | }
|
54 |
|
55 | ISR(USART1_UDRE_vect)
|
56 | {
|
57 | //uart_putc('O');
|
58 | uint8_t tmp;
|
59 | if(XO_BufferOut(&tmp))
|
60 | UDR1 = tmp;
|
61 | }
|
Aber das Byte wird nach dem abfragen nicht gelöscht, und sobald man auch
nur einen Buchstaben/Zahl sendet, bekommt man die gleich unendlich mal
zurück gesendet. Ich kann meinen Fehler nicht finden. Vielleicht findet
einer von den.
MfG
Philipp