hallo, mein problem ist folgendes ich habe zwei programme die auf zwei identischen boards laufen. das eine board ist master und das andere slave. jetzt möchte ich aber, beide programme zusammenfassen, sodas ich nurnoch ein programm habe, beidem ich vorher über taster auswählen kann ob es master oder slave sein soll. ich habe versucht das mit einer if else schleife zu realisieren, hat aber nicht geklappt. so langsam bin ich mit meinem latain am ende. ich hoffe ihr könnt mir helfen. danke schonmal im vorraus. lg henning
Der Link ist gut XD hier die codes. danke schonmal Der Code für Master:
1 | /*****************************************************************
|
2 | **************** *******************
|
3 | **************** BTM-222 *******************
|
4 | **************** Master_Modus *******************
|
5 | **************** Baudrate 19200 Baud *******************
|
6 | **************** *******************
|
7 | *****************************************************************/
|
8 | |
9 | |
10 | #define F_CPU 16000000UL
|
11 | #define OSCSPEED 16000000 // in Hz
|
12 | |
13 | |
14 | #include "util/delay.h" |
15 | #include "avr/io.h" |
16 | #include "lcd.c" |
17 | #include "EB128_BBS2.h" |
18 | |
19 | |
20 | const char info1[]PROGMEM = " Bluetooth -> Master"; |
21 | |
22 | char Line[40]; // String mit maximal 39 zeichen |
23 | char display_buffer[21]; |
24 | |
25 | |
26 | uint8_t EmpfangZeichen; |
27 | |
28 | //-------------------------------------------------------------------
|
29 | |
30 | void UART_Init(uint32_t Baud) |
31 | {
|
32 | unsigned int BaudRate = OSCSPEED / (16 * Baud) - 1; //BaudRate |
33 | |
34 | |
35 | UBRR1L = (unsigned char) BaudRate; |
36 | UBRR1H = (unsigned char) (BaudRate>>8); |
37 | |
38 | UCSR1C |= 0x06; // 8 Data , 1 Stoppbit , keine Parität |
39 | UCSR1B |= 0x18; // Freigabe RxD und TxD |
40 | }
|
41 | |
42 | //-------------------------------------------------------------------
|
43 | |
44 | |
45 | void USART1_Transmit (unsigned char data) |
46 | {
|
47 | |
48 | while ( ! ( UCSR1A & (1<<UDRE1)));//Warte bis Transmit-Speicher leer |
49 | {
|
50 | UDR1 = data; |
51 | }
|
52 | }
|
53 | |
54 | //-------------------------------------------------------------------
|
55 | |
56 | |
57 | int uart_putc(unsigned char c) |
58 | {
|
59 | while (!(UCSR1A & (1<<UDRE1))) // warten bis Senden möglich |
60 | {
|
61 | }
|
62 | |
63 | UDR1 = c; // sende Zeichen |
64 | return 0; |
65 | }
|
66 | |
67 | |
68 | |
69 | void uart_puts (char *s) |
70 | {
|
71 | while (*s) |
72 | {
|
73 | uart_putc(*s); // solange s ungleich '\0' |
74 | s++; |
75 | }
|
76 | }
|
77 | |
78 | //-------------------------------------------------------------------
|
79 | |
80 | uint8_t uart_getc(void) |
81 | {
|
82 | //while (!(UCSR1A & (1<<RXC1))) // warten bis Zeichen verfügbar
|
83 | |
84 | return UDR1; |
85 | }
|
86 | |
87 | |
88 | |
89 | void uart_gets( char* Buffer, uint8_t MaxLen ) |
90 | {
|
91 | uint8_t NextChar; |
92 | |
93 | |
94 | NextChar = uart_getc(); |
95 | |
96 | while( NextChar != 0x0D) |
97 | {
|
98 | *Buffer++ = NextChar; |
99 | |
100 | NextChar = uart_getc(); |
101 | }
|
102 | |
103 | *Buffer = '\0'; |
104 | }
|
105 | |
106 | //-------------------------------------------------------------------
|
107 | |
108 | |
109 | int main() |
110 | |
111 | {
|
112 | |
113 | DDRA=0xFF; |
114 | DDRB=0xFF; |
115 | DDRC=0xFF; |
116 | DDRE=0x00; |
117 | DDRG=0x00; |
118 | |
119 | lcd_init( LCD_DISP_ON ); |
120 | G_DISPLAY = (1<<BELEUCHTUNG); |
121 | lcd_init( LCD_DISP_ON ); |
122 | lcd_puts_p(info1); // Ausgabe Überschrift |
123 | |
124 | UART_Init(19200); // Baudrate 19200 Baud |
125 | _delay_ms(200); |
126 | |
127 | |
128 | //-----------------------------------------------------------------------
|
129 | |
130 | uart_puts ("ATR0\r"); // Master oder Slave Master=0; Slave=1 |
131 | _delay_ms(1000); |
132 | |
133 | uart_puts ("ATO0\r"); // automatische Verbindung Enable=0 |
134 | _delay_ms(1000); |
135 | |
136 | |
137 | uart_puts ("ATD=00126F09B37C\r"); //automatische Verbindung Enable=0 |
138 | _delay_ms(3000); |
139 | |
140 | uart_puts ("ATP=1234\r"); // Passwort Standard ist 1234 |
141 | _delay_ms(1000); |
142 | |
143 | //-----------------------------------------------------------------------
|
144 | |
145 | |
146 | |
147 | while(1) |
148 | {
|
149 | |
150 | /* uart_putc(0x01);
|
151 | lcd_gotoxy(0,2);
|
152 | lcd_puts("Slave -> LED_1 = AN");
|
153 |
|
154 | |
155 | _delay_ms(3000);
|
156 | |
157 | |
158 | uart_putc(0x02);
|
159 | lcd_gotoxy(0,2);
|
160 | lcd_puts("Slave -> LED_2 = AN");
|
161 | |
162 | |
163 | _delay_ms(3000);
|
164 | |
165 | |
166 | uart_putc(0x03);
|
167 | lcd_gotoxy(0,2);
|
168 | lcd_puts("Slave -> LED_3 = AN");
|
169 | |
170 | |
171 | _delay_ms(3000);*/
|
172 | |
173 | //--------------------------------------------
|
174 | |
175 | |
176 | if(PINE & (1<<PE0)) |
177 | {
|
178 | uart_putc(0x01); |
179 | lcd_gotoxy(0,2); |
180 | lcd_puts("Slave -> LED1 -> EIN"); |
181 | }
|
182 | |
183 | if(PINE & (1<<PE1)) |
184 | {
|
185 | uart_putc(0x02); |
186 | lcd_gotoxy(0,2); |
187 | lcd_puts("Slave -> LED2 -> EIN"); |
188 | }
|
189 | |
190 | if(PINE & (1<<PE2)) |
191 | {
|
192 | uart_putc(0x03); |
193 | lcd_gotoxy(0,2); |
194 | lcd_puts("Slave -> LED3 -> EIN"); |
195 | }
|
196 | |
197 | //---------------------------------------------
|
198 | |
199 | }
|
200 | |
201 | }
|
Der Code für Slave:
1 | /*****************************************************************
|
2 | **************** *******************
|
3 | **************** BTM-222 *******************
|
4 | **************** Slave-Modus *******************
|
5 | **************** Baudrate19200 Baud *******************
|
6 | **************** *******************
|
7 | *****************************************************************/
|
8 | |
9 | |
10 | #define F_CPU 16000000UL
|
11 | #define OSCSPEED 16000000 // in Hz
|
12 | |
13 | |
14 | #include "util/delay.h" |
15 | #include "avr/io.h" |
16 | #include "lcd.c" |
17 | #include "EB128_BBS2.h" |
18 | |
19 | |
20 | const char info1[]PROGMEM = " Bluetooth -> Slave"; |
21 | |
22 | char Line[40]; // String mit maximal 39 zeichen |
23 | char display_buffer[21]; |
24 | |
25 | |
26 | uint8_t EmpfangZeichen; |
27 | |
28 | //-------------------------------------------------------------------
|
29 | |
30 | void UART_Init(uint32_t Baud) |
31 | {
|
32 | unsigned int BaudRate = OSCSPEED / (16 * Baud) - 1; //BaudRate |
33 | |
34 | |
35 | UBRR1L = (unsigned char) BaudRate; |
36 | UBRR1H = (unsigned char) (BaudRate>>8); |
37 | |
38 | UCSR1C |= 0x06; // 8 Data , 1 Stoppbit , keine Parität |
39 | UCSR1B |= 0x18; // Freigabe RxD und TxD |
40 | }
|
41 | |
42 | //-------------------------------------------------------------------
|
43 | |
44 | |
45 | void USART1_Transmit (unsigned char data) |
46 | {
|
47 | |
48 | while ( ! ( UCSR1A & (1<<UDRE1)));//Warte bis Transmit-Speicher leer |
49 | {
|
50 | UDR1 = data; |
51 | }
|
52 | }
|
53 | |
54 | //-------------------------------------------------------------------
|
55 | |
56 | |
57 | int uart_putc(unsigned char c) |
58 | {
|
59 | while (!(UCSR1A & (1<<UDRE1))) // warten bis Senden möglich |
60 | {
|
61 | }
|
62 | |
63 | UDR1 = c; // sende Zeichen |
64 | return 0; |
65 | }
|
66 | |
67 | |
68 | |
69 | void uart_puts (char *s) |
70 | {
|
71 | while (*s) |
72 | {
|
73 | uart_putc(*s); // solange s ungleich '\0' |
74 | s++; |
75 | }
|
76 | }
|
77 | |
78 | //-------------------------------------------------------------------
|
79 | |
80 | uint8_t uart_getc(void) |
81 | {
|
82 | //while (!(UCSR1A & (1<<RXC1))) // warten bis Zeichen verfügbar
|
83 | |
84 | return UDR1; |
85 | }
|
86 | |
87 | |
88 | |
89 | void uart_gets( char* Buffer, uint8_t MaxLen ) |
90 | {
|
91 | uint8_t NextChar; |
92 | |
93 | |
94 | NextChar = uart_getc(); |
95 | |
96 | while( NextChar != 0x0D) |
97 | {
|
98 | *Buffer++ = NextChar; |
99 | |
100 | NextChar = uart_getc(); |
101 | }
|
102 | |
103 | *Buffer = '\0'; |
104 | }
|
105 | |
106 | //-------------------------------------------------------------------
|
107 | |
108 | |
109 | int main() |
110 | |
111 | {
|
112 | |
113 | DDRA=0xFF; |
114 | DDRB=0xFF; |
115 | DDRC=0xFF; |
116 | DDRE=0x00; |
117 | DDRG=0x00; |
118 | |
119 | lcd_init( LCD_DISP_ON ); |
120 | G_DISPLAY = (1<<BELEUCHTUNG); |
121 | lcd_init( LCD_DISP_ON ); |
122 | lcd_puts_p(info1); // Ausgabe Überschrift |
123 | |
124 | UART_Init(19200); // Baudrate 19200 Baud |
125 | _delay_ms(200); |
126 | |
127 | |
128 | //-----------------------------------------------------------------------
|
129 | uart_puts ("ATR1\r"); // Master oder Slave Master=0; Slave=1 |
130 | _delay_ms(1000); |
131 | |
132 | uart_puts ("ATO0\r"); // automatische Verbindung Enable=0 |
133 | _delay_ms(1000); |
134 | |
135 | |
136 | uart_puts ("ATE0\r"); // Echo ausschalten |
137 | _delay_ms(1000); |
138 | |
139 | |
140 | //-----------------------------------------------------------------------
|
141 | |
142 | |
143 | while(1) |
144 | {
|
145 | |
146 | EmpfangZeichen = uart_getc(); |
147 | |
148 | |
149 | if(EmpfangZeichen == 0x01) |
150 | {
|
151 | PORTA = 0x01; |
152 | lcd_gotoxy(5,2); |
153 | lcd_puts("LED1 = EIN"); |
154 | }
|
155 | |
156 | |
157 | if(EmpfangZeichen == 0x02) |
158 | {
|
159 | PORTA = 0x02; |
160 | lcd_gotoxy(5,2); |
161 | lcd_puts("LED2 = EIN"); |
162 | }
|
163 | |
164 | |
165 | if(EmpfangZeichen == 0x03) |
166 | {
|
167 | PORTA = 0x04; |
168 | lcd_gotoxy(5,2); |
169 | lcd_puts("LED3 = EIN"); |
170 | }
|
171 | |
172 | |
173 | //--------------------------------------------
|
174 | |
175 | /* switch(EmpfangZeichen)
|
176 | {
|
177 | |
178 | case 0x01: PORTA = 0x01;
|
179 | lcd_gotoxy(5,2);
|
180 | lcd_puts("LED_1 = AN");
|
181 | break;
|
182 | |
183 |
|
184 | case 0x02: PORTA = 0x02 ;
|
185 | lcd_gotoxy(5,2);
|
186 | lcd_puts("LED_2 = AN");
|
187 | break;
|
188 | |
189 | |
190 | case 0x03: PORTA = 0x04;
|
191 | lcd_gotoxy(5,2);
|
192 | lcd_puts("LED_3 = AN");
|
193 | break;
|
194 | |
195 | } */
|
196 | |
197 | }
|
198 | |
199 | }
|
200 | |
201 | //-------------------------------------------------------------------
|
Frage: Hat dein Slave überhaupt Taster? Ansonsten würd ichs ganz einfach so machen, dass ein Pin (Pullup aktiv), je nachdem ob Master oder Slave mit einem Jumper/Lötbrücke auf Masse gezogen oder offen gelassen wird. Dann würde ich das Programm etwa so formulieren:
1 | //Initialisierung ...
|
2 | //übriger Mist vor der Hauptschleife
|
3 | |
4 | if(Auswahlpin) |
5 | while(true) |
6 | {
|
7 | //Mastercode
|
8 | }
|
9 | else
|
10 | while(true) |
11 | {
|
12 | //Slavecode
|
13 | }
|
nein, slave hat keine taster (das board an sich schon, nur für das programm werden diese nicht gebraucht). der empfängt nur und gibt aus. aber der code sieht ja schon vielversprenchend aus :-) ich werde den mal ausprobieren danke :-)
bei mir siehts jetzt so aus:
1 | #include "avr/io.h" |
2 | |
3 | int main (void) |
4 | {
|
5 | |
6 | if(PINE & (1<<PE5)) |
7 | while(true) |
8 | {
|
9 | //Hier steht das Masterprogramm
|
10 | |
11 | else
|
12 | while(true) |
13 | {
|
14 | //Hier steht das Slaveprogramm
|
15 | }
|
16 | }
|
und ich bekomme immernoch 60 errors. ich mach das zwar noch nicht ganz so lange aber das stößt bei mir auf unverständnis.
Zähl ,mal deine Klammern;) Es muss eine gerade Zahl herauskommen.
die klammern in meinem richtigen code stimmen alle, ich hab hier nur eine vergessen.
1 | #include "avr/io.h" |
2 | |
3 | int main (void) |
4 | {
|
5 | |
6 | if(PINE & (1<<PE5)) |
7 | while(true) |
8 | {
|
9 | |
10 | /*****************************************************************
|
11 | **************** *******************
|
12 | **************** BTM-222 *******************
|
13 | **************** Master_Modus *******************
|
14 | **************** Baudrate 19200 Baud *******************
|
15 | **************** *******************
|
16 | *****************************************************************/
|
17 | |
18 | |
19 | #define F_CPU 16000000UL
|
20 | #define OSCSPEED 16000000 // in Hz
|
21 | |
22 | |
23 | #include "util/delay.h" |
24 | #include "avr/io.h" |
25 | #include "lcd.c" |
26 | #include "EB128_BBS2.h" |
27 | |
28 | |
29 | const char info1[]PROGMEM = " Bluetooth -> Master"; |
30 | |
31 | char Line[40]; // String mit maximal 39 zeichen |
32 | char display_buffer[21]; |
33 | |
34 | |
35 | uint8_t EmpfangZeichen; |
36 | |
37 | //-------------------------------------------------------------------
|
38 | |
39 | void UART_Init(uint32_t Baud) |
40 | {
|
41 | unsigned int BaudRate = OSCSPEED / (16 * Baud) - 1; //BaudRate |
42 | |
43 | |
44 | UBRR1L = (unsigned char) BaudRate; |
45 | UBRR1H = (unsigned char) (BaudRate>>8); |
46 | |
47 | UCSR1C |= 0x06; // 8 Data , 1 Stoppbit , keine Parität |
48 | UCSR1B |= 0x18; // Freigabe RxD und TxD |
49 | }
|
50 | |
51 | //-------------------------------------------------------------------
|
52 | |
53 | |
54 | void USART1_Transmit (unsigned char data) |
55 | {
|
56 | |
57 | while ( ! ( UCSR1A & (1<<UDRE1)));//Warte bis Transmit-Speicher leer |
58 | {
|
59 | UDR1 = data; |
60 | }
|
61 | }
|
62 | |
63 | //-------------------------------------------------------------------
|
64 | |
65 | |
66 | int uart_putc(unsigned char c) |
67 | {
|
68 | while (!(UCSR1A & (1<<UDRE1))) // warten bis Senden möglich |
69 | {
|
70 | }
|
71 | |
72 | UDR1 = c; // sende Zeichen |
73 | return 0; |
74 | }
|
75 | |
76 | |
77 | |
78 | void uart_puts (char *s) |
79 | {
|
80 | while (*s) |
81 | {
|
82 | uart_putc(*s); // solange s ungleich '\0' |
83 | s++; |
84 | }
|
85 | }
|
86 | |
87 | //-------------------------------------------------------------------
|
88 | |
89 | uint8_t uart_getc(void) |
90 | {
|
91 | //while (!(UCSR1A & (1<<RXC1))) // warten bis Zeichen verfügbar
|
92 | |
93 | return UDR1; |
94 | }
|
95 | |
96 | |
97 | |
98 | void uart_gets( char* Buffer, uint8_t MaxLen ) |
99 | {
|
100 | uint8_t NextChar; |
101 | |
102 | |
103 | NextChar = uart_getc(); |
104 | |
105 | while( NextChar != 0x0D) |
106 | {
|
107 | *Buffer++ = NextChar; |
108 | |
109 | NextChar = uart_getc(); |
110 | }
|
111 | |
112 | *Buffer = '\0'; |
113 | }
|
114 | |
115 | //-------------------------------------------------------------------
|
116 | |
117 | |
118 | int main() |
119 | |
120 | {
|
121 | |
122 | DDRA=0xFF; |
123 | DDRB=0xFF; |
124 | DDRC=0xFF; |
125 | DDRE=0x00; |
126 | DDRG=0x00; |
127 | |
128 | lcd_init( LCD_DISP_ON ); |
129 | G_DISPLAY = (1<<BELEUCHTUNG); |
130 | lcd_init( LCD_DISP_ON ); |
131 | lcd_puts_p(info1); // Ausgabe Überschrift |
132 | |
133 | UART_Init(19200); // Baudrate 19200 Baud |
134 | _delay_ms(200); |
135 | |
136 | |
137 | //-----------------------------------------------------------------------
|
138 | |
139 | uart_puts ("ATR0\r"); // Master oder Slave Master=0; Slave=1 |
140 | _delay_ms(1000); |
141 | |
142 | uart_puts ("ATO0\r"); // automatische Verbindung Enable=0 |
143 | _delay_ms(1000); |
144 | |
145 | |
146 | uart_puts ("ATD=00126F09B37C\r"); //automatische Verbindung Enable=0 |
147 | _delay_ms(3000); |
148 | |
149 | uart_puts ("ATP=1234\r"); // Passwort Standard ist 1234 |
150 | _delay_ms(1000); |
151 | |
152 | //-----------------------------------------------------------------------
|
153 | |
154 | |
155 | |
156 | while(1) |
157 | {
|
158 | |
159 | /* uart_putc(0x01);
|
160 | lcd_gotoxy(0,2);
|
161 | lcd_puts("Slave -> LED_1 = AN");
|
162 |
|
163 | |
164 | _delay_ms(3000);
|
165 | |
166 | |
167 | uart_putc(0x02);
|
168 | lcd_gotoxy(0,2);
|
169 | lcd_puts("Slave -> LED_2 = AN");
|
170 | |
171 | |
172 | _delay_ms(3000);
|
173 | |
174 | |
175 | uart_putc(0x03);
|
176 | lcd_gotoxy(0,2);
|
177 | lcd_puts("Slave -> LED_3 = AN");
|
178 | |
179 | |
180 | _delay_ms(3000);*/
|
181 | |
182 | //--------------------------------------------
|
183 | |
184 | |
185 | if(PINE & (1<<PE0)) |
186 | {
|
187 | uart_putc(0x01); |
188 | lcd_gotoxy(0,2); |
189 | lcd_puts("Slave -> LED1 -> EIN"); |
190 | }
|
191 | |
192 | if(PINE & (1<<PE1)) |
193 | {
|
194 | uart_putc(0x02); |
195 | lcd_gotoxy(0,2); |
196 | lcd_puts("Slave -> LED2 -> EIN"); |
197 | }
|
198 | |
199 | if(PINE & (1<<PE2)) |
200 | {
|
201 | uart_putc(0x03); |
202 | lcd_gotoxy(0,2); |
203 | lcd_puts("Slave -> LED3 -> EIN"); |
204 | }
|
205 | |
206 | //---------------------------------------------
|
207 | |
208 | }
|
209 | |
210 | }
|
211 | |
212 | }
|
213 | |
214 | else
|
215 | while(true) |
216 | {
|
217 | |
218 | /*****************************************************************
|
219 | **************** *******************
|
220 | **************** BTM-222 *******************
|
221 | **************** Slave-Modus *******************
|
222 | **************** Baudrate19200 Baud *******************
|
223 | **************** *******************
|
224 | *****************************************************************/
|
225 | |
226 | |
227 | #define F_CPU 16000000UL
|
228 | #define OSCSPEED 16000000 // in Hz
|
229 | |
230 | |
231 | #include "util/delay.h" |
232 | #include "avr/io.h" |
233 | #include "lcd.c" |
234 | #include "EB128_BBS2.h" |
235 | |
236 | |
237 | const char info1[]PROGMEM = " Bluetooth -> Slave"; |
238 | |
239 | char Line[40]; // String mit maximal 39 zeichen |
240 | char display_buffer[21]; |
241 | |
242 | |
243 | uint8_t EmpfangZeichen; |
244 | |
245 | //-------------------------------------------------------------------
|
246 | |
247 | void UART_Init(uint32_t Baud) |
248 | {
|
249 | unsigned int BaudRate = OSCSPEED / (16 * Baud) - 1; //BaudRate |
250 | |
251 | |
252 | UBRR1L = (unsigned char) BaudRate; |
253 | UBRR1H = (unsigned char) (BaudRate>>8); |
254 | |
255 | UCSR1C |= 0x06; // 8 Data , 1 Stoppbit , keine Parität |
256 | UCSR1B |= 0x18; // Freigabe RxD und TxD |
257 | }
|
258 | |
259 | //-------------------------------------------------------------------
|
260 | |
261 | |
262 | void USART1_Transmit (unsigned char data) |
263 | {
|
264 | |
265 | while ( ! ( UCSR1A & (1<<UDRE1)));//Warte bis Transmit-Speicher leer |
266 | {
|
267 | UDR1 = data; |
268 | }
|
269 | }
|
270 | |
271 | //-------------------------------------------------------------------
|
272 | |
273 | |
274 | int uart_putc(unsigned char c) |
275 | {
|
276 | while (!(UCSR1A & (1<<UDRE1))) // warten bis Senden möglich |
277 | {
|
278 | }
|
279 | |
280 | UDR1 = c; // sende Zeichen |
281 | return 0; |
282 | }
|
283 | |
284 | |
285 | |
286 | void uart_puts (char *s) |
287 | {
|
288 | while (*s) |
289 | {
|
290 | uart_putc(*s); // solange s ungleich '\0' |
291 | s++; |
292 | }
|
293 | }
|
294 | |
295 | //-------------------------------------------------------------------
|
296 | |
297 | uint8_t uart_getc(void) |
298 | {
|
299 | //while (!(UCSR1A & (1<<RXC1))) // warten bis Zeichen verfügbar
|
300 | |
301 | return UDR1; |
302 | }
|
303 | |
304 | |
305 | |
306 | void uart_gets( char* Buffer, uint8_t MaxLen ) |
307 | {
|
308 | uint8_t NextChar; |
309 | |
310 | |
311 | NextChar = uart_getc(); |
312 | |
313 | while( NextChar != 0x0D) |
314 | {
|
315 | *Buffer++ = NextChar; |
316 | |
317 | NextChar = uart_getc(); |
318 | }
|
319 | |
320 | *Buffer = '\0'; |
321 | }
|
322 | |
323 | //-------------------------------------------------------------------
|
324 | |
325 | |
326 | int main() |
327 | |
328 | {
|
329 | |
330 | DDRA=0xFF; |
331 | DDRB=0xFF; |
332 | DDRC=0xFF; |
333 | DDRE=0x00; |
334 | DDRG=0x00; |
335 | |
336 | lcd_init( LCD_DISP_ON ); |
337 | G_DISPLAY = (1<<BELEUCHTUNG); |
338 | lcd_init( LCD_DISP_ON ); |
339 | lcd_puts_p(info1); // Ausgabe Überschrift |
340 | |
341 | UART_Init(19200); // Baudrate 19200 Baud |
342 | _delay_ms(200); |
343 | |
344 | |
345 | //-----------------------------------------------------------------------
|
346 | uart_puts ("ATR1\r"); // Master oder Slave Master=0; Slave=1 |
347 | _delay_ms(1000); |
348 | |
349 | uart_puts ("ATO0\r"); // automatische Verbindung Enable=0 |
350 | _delay_ms(1000); |
351 | |
352 | |
353 | uart_puts ("ATE0\r"); // Echo ausschalten |
354 | _delay_ms(1000); |
355 | |
356 | |
357 | //-----------------------------------------------------------------------
|
358 | |
359 | |
360 | while(1) |
361 | {
|
362 | |
363 | EmpfangZeichen = uart_getc(); |
364 | |
365 | |
366 | if(EmpfangZeichen == 0x01) |
367 | {
|
368 | PORTA = 0x01; |
369 | lcd_gotoxy(5,2); |
370 | lcd_puts("LED1 = EIN"); |
371 | }
|
372 | |
373 | |
374 | if(EmpfangZeichen == 0x02) |
375 | {
|
376 | PORTA = 0x02; |
377 | lcd_gotoxy(5,2); |
378 | lcd_puts("LED2 = EIN"); |
379 | }
|
380 | |
381 | |
382 | if(EmpfangZeichen == 0x03) |
383 | {
|
384 | PORTA = 0x04; |
385 | lcd_gotoxy(5,2); |
386 | lcd_puts("LED3 = EIN"); |
387 | }
|
388 | |
389 | |
390 | //--------------------------------------------
|
391 | |
392 | /* switch(EmpfangZeichen)
|
393 | {
|
394 | |
395 | case 0x01: PORTA = 0x01;
|
396 | lcd_gotoxy(5,2);
|
397 | lcd_puts("LED_1 = AN");
|
398 | break;
|
399 | |
400 |
|
401 | case 0x02: PORTA = 0x02 ;
|
402 | lcd_gotoxy(5,2);
|
403 | lcd_puts("LED_2 = AN");
|
404 | break;
|
405 | |
406 | |
407 | case 0x03: PORTA = 0x04;
|
408 | lcd_gotoxy(5,2);
|
409 | lcd_puts("LED_3 = AN");
|
410 | break;
|
411 | |
412 | } */
|
413 | |
414 | }
|
415 | |
416 | }
|
417 | |
418 | }
|
419 | |
420 | }
|
Du kannst nicht einfach 2 Programme 'zusammenführen' indem du mit Copy&Paste das eine Programm so wie es ist, ins andere einfügst. Am besten gehst du so an die Dinge ran: Du schreibst grundsätzlich ein komplett neues Programm Du übernimmst den eigentlichen funktionalen Programmteil aus dem einen Programm Du übernimmst den eigentlich funktionalen Programmteil aus dem anderen Programm Aber grundsätzlich schreibst du ein komplett neues Programm und du mischt aus den Einzelprogrammen die Teile zusammen, die du brauchst.
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.