Als erstes würde ich mir mal eine String-Ausgabe machen:
1 | // Sendet ein einzelnes Zeichen
|
2 | void uart_putc( char c )
|
3 | {
|
4 | // Warte bis die Sendeeinheit bereit ist
|
5 | while( !(USR & ( 1<<UDRE) ) )
|
6 | ;
|
7 | UDR = c;
|
8 | }
|
9 |
|
10 | // Sende einen C-String
|
11 | void uart_puts( const char* str )
|
12 | {
|
13 | while( *str ) {
|
14 | uart_putc( *str );
|
15 | str++;
|
16 | }
|
17 | }
|
Damit kannst du schon mal solche Dinge machen:
1 | int main()
|
2 | {
|
3 | while( 1 )
|
4 | uart_puts( "Hallo du\n" );
|
5 | }
|
oder auch
1 | int main()
|
2 | {
|
3 | char Text[] = "Hallo Welt\n";
|
4 | while( 1 )
|
5 | uart_puts( Text );
|
6 | }
|
Dann gehts weiter: Du brauchst eine Funktion, die nicht
nur ein einzelnes Zeichen empfängt, sondern eine Zeile
davon. Als Zeile definieren wir mal: Alles was bis zum
Return Zeichen geht:
1 | unsigned char USART_RX(void)
|
2 | {
|
3 | while(!(UCSRA&(1<<RXC)))
|
4 | ;
|
5 | return UDR;
|
6 | }
|
7 |
|
8 | void uart_gets( char* Input )
|
9 | {
|
10 | char c = USART_RX();
|
11 | uart_putc( c ); // und gleich wieder zurückschicken, damit
|
12 | // der Benutzer auch was sieht
|
13 |
|
14 | while( c != '\n' ) {
|
15 | *Input = c;
|
16 | Input++;
|
17 | c = USART_RX();
|
18 | uart_putc( c );
|
19 | }
|
20 | *Input = '\0';
|
21 | }
|
Damit kann man dann schon so was machen:
1 | #include <string.h>
|
2 |
|
3 | .... // hier die uart Funktionen
|
4 |
|
5 | int main()
|
6 | {
|
7 | char Buffer[20];
|
8 |
|
9 | while( 1 ) {
|
10 | uart_gets( Buffer ); // Auf eine Zeile vom Benutzer warten
|
11 |
|
12 | //
|
13 | // Testweise die komplette Zeile zurückschicken, so wie
|
14 | // sie vom µC empfangen wurde
|
15 | //
|
16 | uart_puts( "Ich habe verstanden : " );
|
17 | uart_puts( Buffer );
|
18 | uart_putc( '\n' );
|
19 |
|
20 | // war die Eingabe vom Benutzer der Text 'Floyd'
|
21 | if( strcmp( Buffer, "Floyd" ) == 0 ) {
|
22 | // Wenn ja, dann begrüsse ihn
|
23 | uart_puts( "Hallo Floyd\n" );
|
24 | uart_puts( "Wie gehts\n" );
|
25 | }
|
26 | }
|
27 | }
|
Wenn du dich jetzt mit einem Terminalprogramm an den
µC klemmst, muss der brav jede Eingabe wieder zurück-
schicken. Jedesmal wenn du Return drückst, zeigt
er dir die zuletzt gelesene komplette Zeile an.
Und so gehts dann weiter:
Du vereinbarst mit dir, dass das erste Zeichen in der
Übertragung die Motornummer ist, das nächste Zeichen
ignorierst du und daran anschliessend kommt der PWM Wert.
An das erste Zeichen kommst du ganz einfach mit Buffer[0] ran.
Ab Buffer[1] steht dann eine 'Zahl' in ihrer ASCII Form.
Die Funktion atoi() kann diese ganz leicht in eine tatsächliche
Zahl wandeln.
1 | ....
|
2 |
|
3 | int MotorNr;
|
4 |
|
5 | while( 1 ) {
|
6 |
|
7 | uart_gets( Buffer );
|
8 |
|
9 | // zu testzwecken. Ist immer gut zu kontrollieren
|
10 | // was der µC tatsächlich empfängt
|
11 | uart_puts( "Ihre Eingabe: " );
|
12 | uart_puts( Buffer );
|
13 | uart_putc( '\n' );
|
14 |
|
15 | MotorNr = Buffer[0] - '0'; // Die Motornummer nummerisch machen
|
16 | PWMWert = atoi( &Buffer[2] ); // Den PWM Wert umrechnen lassen
|
17 |
|
18 | if( MotorNr == 0 )
|
19 | uart_puts( "Setze Motor 0 auf neuen Wert\n" );
|
20 |
|
21 | else if( MotorNr == 1 )
|
22 | uart_puts( "Setze Motor 1 auf neuen Wert\n" );
|
23 |
|
24 | else
|
25 | uart_puts( "Diesen Motor gibt es nicht!\n" );
|
26 | }
|
27 | }
|
Verbinde dich wieder mit dem Terminalprogramm zum µC und
gib ein:
0 200
(und natürlich Return drücken)
Der µC sollte antworten mit:
Ihre Eingabe: 0 200
Setze Motor 0 auf neuen Wert
1 154
Ihre Eingabe: 1 154
Setzte Motor 1 auf neuen Wert
2 300
Diesen Motor gibt es nicht!
