RS232 Verbindung zum PC in C

**Kaiser-F** · 19.04.2006, 12:33

Probiers mal einfach so:

main.c:

Code:

// AVR-Includes
#include <avr/io.h> 

// Defines
#define F_CPU 7372800    // Hier die Taktfrequenz in Hz eingeben
#define UART_BAUD_RATE 115200    // Hier die gewünschte Baudrate
#define UART_BAUD_SELECT (F_CPU/(UART_BAUD_RATE*16L)-1) 


// Funktionen
//  -=> UART initialisieren <=-
void UART_init(void){  
    UBRRL |= (uint8_t) UART_BAUD_SELECT; 
	UCSRB = (1<<RXEN)|(1<<TXEN);
	UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
} 

//  -=> Byte Transmit <=-
void UART_transmit(uint8_t c){ 
   while(!(UCSRA & (1<<UDRE)));
   UDR = c; 
} 

//  -=> String Transmit <=-
void UART_transmit_string(uint8_t *string){ 
    while(!(UCSRA & (1<<UDRE)));
	while( *string){ UART_transmit (*string++); }
}



int main (void)
{


UART_init();  // UART-Init Funktion ausführen

UART_transmit_string("Hurra, es funktioniert!!!");


while(1){


}
}

Stelle sicher, dass du die richtige Taktfrequenz eingibst. Und dass auch das Verwendete quarz in den Fuses eingestellt ist....

**Kaiser-F** · 19.04.2006, 12:35

Stell auch sicher, dass in deinem Terminal-Programm 8N1 eingestellt ist. Also 8 Datenbits und 1 Stop-Bit. Sowie die passende baudrate,

Wenns nicht funkt, dann sag uns genau was er macht, oder wo es hackt usw....

**ciruz** · 24.04.2006, 15:14

Hurra, es funktioniert!!!

Das ist echt schonmal super, vielen dank.
Jetzt bräuchte ich noch was zum empfangen.
Weiterhin würde mich noch interessieren wie es mit Wartezeiten in C aussieht. Gibts da nen Befehl oder muss man Schleifen machen wie in Assembler?
gruz ciruz

**Kaiser-F** · 24.04.2006, 16:57

Hoi,

Ich hätte ein gepuffertes System zusammenprogrammiert.

Evtl schaust dir das Schema mal an:

-----------------------------------------------------------------------
Ausschnitt aus dem Thema:
https://www.roboternetz.de/phpBB2/ze...090&highlight=

Hallo,

Zum Thema USART Befehle Empfangen habe ich mir Folgendes Ausgedacht:

Man überlegt sich zunächst wie man seine Befehle Sendet.
Also eine art Protokoll.

Bei mir ist das Folgendermaßen:

1. Ein Zeichen, welches für den Beginn eines neuen Befehlspaketes symbolisiert
2. die länge der Nachfolgenden Bytes
4. X-Bytes

Als Startzeichen habe ich mit ESC ausgesucht. Hat den ASCII-Code 0x1B.

Allgemein ist bekannt, dass es nicht so hinhaut die einkommenden Befehle direkt zu bearbeiten. also schreibe ich die empfangenen Zeichen in einen Puffer.
Da das Befehlspaket ein Startzeichen hat ( ESC hier ), und mir dann gleich die Länge übermittelt ist das ja ein Kinderspiel, die Daten in einen Puffer zu schreiben.

Hier der Code. Ich verwende 5 Puffer:

Code:

uint8_t UART_buffer0[8];
uint8_t UART_buffer1[8];
uint8_t UART_buffer2[8];
uint8_t UART_buffer3[8];
uint8_t UART_buffer4[8];

uint8_t *UART_pointer;



void UART_receive( uint8_t data ){
	if ( data == ESC ){
		uint8_t gotone = 0;
		UART_buffer0[1] = 0;													// Unvollständige verwerfen
		UART_buffer1[1] = 0;													// Unvollständige verwerfen
		UART_buffer2[1] = 0;													// Unvollständige verwerfen
		UART_buffer3[1] = 0;													// Unvollständige verwerfen
		UART_buffer4[1] = 0;													// Unvollständige verwerfen
		
		if( ! UART_buffer4[0] ){ UART_pointer = UART_buffer4; gotone = 1; }	// Nimm Puffer 4 wenn er frei ist
		if( ! UART_buffer3[0] ){ UART_pointer = UART_buffer3; gotone = 1; }	// Nimm Puffer 3 wenn er frei ist
		if( ! UART_buffer2[0] ){ UART_pointer = UART_buffer2; gotone = 1; }	// Nimm Puffer 2 wenn er frei ist
		if( ! UART_buffer1[0] ){ UART_pointer = UART_buffer1; gotone = 1; }	// Nimm Puffer 1 wenn er frei ist
		if( ! UART_buffer0[0] ){ UART_pointer = UART_buffer0; gotone = 1; }	// Nimm Puffer 0 wenn er frei ist
		
		if( gotone ){ 
			UART_pointer[1] = 1; 												// Markiere den gewählten Puffer
			UART_pointer[2] = 0; 												// Leeren
			UART_pointer[3] = 0; 												// Leeren
			UART_pointer[4] = 0; 												// Leeren
			UART_pointer[5] = 0; 												// Leeren
			UART_pointer[6] = 0; 												// Leeren
			UART_pointer[7] = 0; 												// Leeren
		}	
	} else {
		if( UART_pointer[1] ){													// Nur in Puffer schreiben, wenn er in Bearbeitung ist!
			
			UART_pointer[ UART_pointer[2] + 3 ] = data;
			
			UART_pointer[2]++;													// Füllzähler hochaddieren
			if( UART_pointer[3] && (UART_pointer[2] > (UART_pointer[3]+1)) ){
				UART_pointer[1] = 0;											// Puffer aus Bearbeitung entfernen
				UART_pointer[0] = 1;											// Puffer als VOLL markieren
			}
		}
	}
}

[0] = Puffer ist Volol
[1] = Puffer in Arbeit
[2] = Selbstgezählte
[3] = Empfangene Längenangabe
[4] = Databyte 1
[5] = Databyte 2
[6] = Databyte 3
[7] = Databyte 4

Die routine wird mit UART-Interrupt ausgeführt.

Als erstes wird nach einem Freien bzw. schon gelesenen Puffer gesucht
( schaun ob BufferXXX[0] = 0 ist. )

Wurde einer gefunden, dann wird einen zeiger Drauf!

Dann wird dieser als "in Bearbeitung markiert." und eventuell vorher fehlerhafte IN BEARBEITUNG werden verworfen.
demnach gibt es immer nur EINEN Puffer, der in bearbeitung ist.

sind so viele Bytes empfangen wie es das Längenbyte angab, so wird der pufer aus der Bearbeitung entfernt BufferXX[1]=0 und als VOLL markiert: BuufferXX[0] = 1.

Dieser kann dann bequem von einer anderen Funktion Verarbeitet werden. Das ganze verschafft mehr zeit zum verarbeiten!
Funktioniert bei mir einwandfrei. Hab diesen code ein wenig zugeschnitten, da ich selbst ein bisschen ein anderes "Protokoll"habe, aber dieses ist das beste meiner meinung nach.

Ich hoffe jemand findet Gebrauch dafür!

**Kaiser-F** · 24.04.2006, 17:04

Achja, inzwischen habe ich noch eine Prüfsumme eingebaut.

Also das Datenpaket schaut dann so aus:

(Startzeichen) (Anzahl der Datenbytes) (n Datenbytes) (Prüfsumme)

Der Sender zählt alle Datenbytes in eine 1Byte Zahl zusammen.
Egal ob die zahl größer als 255 wäre...

Diese wird als "Prüfsumme" mitgeschickt.

Der Empfänger rechnet auch die Prüfsumme aus den Empfangenen Bytes aus und vergleicht sie. Stimmen sie überein, dann wurde Fehlerfrei übertragen. Man kann dies dann mit einem Aknowledge dem Sender zurückbestätigen.... Oder ein Nope wenns nicht geklappt hat...

Guck dir mal das SMART-Protokoll an beim EDIP Grafikmodul von
http://www.lcd-module.de

EDIT:
Man könnte auch noch die Länge mit prüfen in der Prüfsumme.
Nur darauf achten dass Sender und Empfänger das Gleiche machen.

**ciruz** · 25.04.2006, 15:12

Vielen Dank erstmal...
Ich werde wohl noch ein bischen brauchen bis ich dazu komme, das alles umzusetzen, werde dann aber auf jeden fall nochmal feedback geben.
gruz ciruz

**ciruz** · 15.05.2006, 15:59

Komme mit dem Code nicht wirklich zurecht.
Ich bräuchte eine Funktion, die mir einen vom Twerminalprogramm gesendeten String ausliest. Dieser ist 4 Zeichen lang. Geht sowas nicht auch einfacher?

P.S. Wie kann ich einzelne Portpins auf H oder L setzten?

Gruß

**manu_f** · 29.03.2007, 20:30

hallo zusammen,

muss das thema noch mal aufwärmen.
leider habe ich auch probleme mit dem RN-Control 1.4 daten über UART zu senden.
beim RN-Control ist ja der externe quarz 16Mhz default eingestellt.
habe den code oben compiliert und übertragen.

leider tut sich am hyperterminal nichts! und soweit ich mit meinem multimeter messen konnte ändert sich der pegel (-9,3V) am tx auch nicht.

hat jemand noch ideen für mich, bekomms einfach nicht zum laufen!

Vielen Dank!
Manu

Thema: RS232 Verbindung zum PC in C

Themen-Optionen

Thema durchsuchen

Anzeige

Hybrid-Darstellung

Lesezeichen

Lesezeichen

Berechtigungen