Suche Programm für UART Übertragung

[Maik15]

Hallo ich bin es mal wieder.

Ich brauch noch ein Tool um mit meinem Hauptprogramm anzufangen.
Nach dem ich Timergesteuert Analog und Digital Werte aufnehmen kann und sie in einem EEPROM zu speichern und auch wieder auslesen kann.
Brauch ich jetzt noch ein Programm um die Daten an den PC zu schicken.

RS232 ist ja recht alt und an neuen Rechnern kaum noch zu finden also will ich über einen FT232 die Daten Signal auf USB Pegel wandeln und über eine virtuelle RS232 auf den PC schicken.

Die Hardware steht soweit jetzt brauch ich nur mal wieder ein Programm das Daten vom PC empfängt und zurück schickt.

Nach dem ich in 2 Büchern etwas über UART (RS232) gelesen hab,
hab ich mal wieder mehr fragen als Antworten.

Bei mir tun sich aber paar grundlegende Fragen auf.

1.Mit welchem Programm arbeite man am PC am besten?
HyperTerminal oder gibt es etwas besseres?
Am ende sollen die Daten in einer Excel Tabelle abgelegt werden

2.Wie Speicher ich automatisch die Daten im PC?
Mit VBA in Excel ist es ja kein Problem aber bei HyerTerminal oder sonst ein Programm?

3.Bei einer Baudrate von 9600 kommt das Externe EEPROM mit den 100Byt/s niemals hinterher, macht das Probleme oder kann ich die Übertragung für nach jedem Byte schlafen legen bis das nächste Byte aus dem Speicher gelesen wurde?

4. Welche Baudraten hat die USB Verbindung eigentlich?

Beim Suchen im Netz bin ich auf ein Programm gestoßen das über eine Grafische Oberfläche AVR's programmieren kann. Ähnlich wie bei der Programmierung von einer SPS mit Funktionsbausteinsprache (FBL).
http://www.avrtools.no/
Hat einer schon mal was davon gehört oder gibt es bereits andere Programme.
Zum Download gibt es das Programm ab dem 15.10.09.
Vielleicht wird ja dann das Programmieren bedeutend einfacher.

Aber um nochmal auf meine Frage zurück zu kommen hat einer ein Programm zum senden und empfangen von Daten zum PC über eine UART Schnittstelle?

gruß
Maik

 

[dino03]

Hallo Maik,

1.Mit welchem Programm arbeite man am PC am besten?
HyperTerminal oder gibt es etwas besseres?
Am ende sollen die Daten in einer Excel Tabelle abgelegt werden

Finger weg ! Nimm PuTTY oder Teraterm. Wobei PuTTY automatisch in eine
Datei loggen kann Das würde dir entgegenkommen.

2.Wie Speicher ich automatisch die Daten im PC?
Mit VBA in Excel ist es ja kein Problem aber bei HyerTerminal oder sonst ein Programm?

Mit PuTTY die ankommenden Daten in eine Log-Datei packen lassen.
Wenn der AVR die Daten mit Komma getrennt liefert kannst du die Datei
danach direkt mit Excel als CSV laden

3.Bei einer Baudrate von 9600 kommt das Externe EEPROM mit den 100Byt/s niemals hinterher, macht das Probleme oder kann ich die Übertragung für nach jedem Byte schlafen legen bis das nächste Byte aus dem Speicher gelesen wurde?

Die RS232 ist asynchron. Das heißt, er sendet nur wenn du im was ins
Register schreibst. Du kannst zwischen den gesendeten Bytes auch ne
Minute Pause machen. Das ist kein Problem.

4. Welche Baudraten hat die USB Verbindung eigentlich?

Du kannst mit 75Baud oder geringer anfangen und ich hab schon mal mit
2MBit/s experimentiert. Diese hohe Geschwindigkeit geht aber nur noch
mit nem RS232-USB-Dongle. Aber fehlerfrei

Beim Suchen im Netz bin ich auf ein Programm gestoßen das über eine Grafische Oberfläche AVR's programmieren kann. Ähnlich wie bei der Programmierung von einer SPS mit Funktionsbausteinsprache (FBL).
http://www.avrtools.no/
Hat einer schon mal was davon gehört oder gibt es bereits andere Programme.
Zum Download gibt es das Programm ab dem 15.10.09.
Vielleicht wird ja dann das Programmieren bedeutend einfacher.

... Naja ... Da sag ich jetzt mal nix zu. Für Schulen und 10 jährige mag das
ganz toll sein wenn die ihr Programm einfach nur zusammenklicken müssen.
Aber sowie du außerhalb der Möglichkeiten der Bausteine bist hat sich das
erledigt.

Aber um nochmal auf meine Frage zurück zu kommen hat einer ein Programm zum senden und empfangen von Daten zum PC über eine UART Schnittstelle?

Also ich nehme PuTTY.

Gruß
Dino

 

[Maik15]

Danke für deine Antworten.

PuTTY hab ich mir gerade runtergeladen.

Der letzte Punkt angeht (mit dem Programm zum Senden und Empfangen).
Da hab ich eigentlich an ein C Programm für den AVR gedacht.
So könnte ich mir mal die Programmierung ansehen und vielleicht Teile davon übernehmen.
Dann muss man nicht alles neu erfinden.

gruß
Maik

 

[dino03]

Hallo Maik,

Der letzte Punkt angeht (mit dem Programm zum Senden und Empfangen).
Da hab ich eigentlich an ein C Programm für den AVR gedacht.
So könnte ich mir mal die Programmierung ansehen und vielleicht Teile davon übernehmen.
Dann muss man nicht alles neu erfinden.

ein C-Programm oder Fragmente davon um über den USART Daten zum PC zu
senden oder zu empfangen sollten eigentlich hier im Forum zu finden sein. Such
mal nach Beiträgen von "Kani" . Da waren mal Versuche mit RS232 glaube ich.
Da waren wohl auch Hilfen von "Nomis3000" dabei. Selber hab ich mit C noch
nix gemacht.

Gruß
Dino

 

[Hemi]

Ich habe auch noch etwas da, kann hochladen, wenn Interesse besteht.

Also Programm verwende ich HTERM, kann nur empfehlen.

Grüsse
Heinrich

 

[BlackDevil]

Putty is dufte Selbst was schreiben wär aber auch nich das Problem, da is der Datenstream is da das schwierigste

 

[dino03]

Hallo,

Putty is dufte

sach ich doch Früher hab ich mal mit ZOC gearbeitet. Aber das ist Shareware
und hat keinen SSH-Client direkt drin (jedefalls damals). Dann bin ich auf
TeraTerm umgestiegen. Das war aber nicht so doll weil man das Logging
jedes mal per Hand aktivieren mußte. Und seitdem PuTTY ab 0.5.8 auch Seriell
kann ist das mein absoluter Favorit. Und auch noch GPL Besser geht nicht mehr!

Ach ja ... Für Linux gibts das auch.

Wenn Du die Configs davon suchst ... Bei Linux in nem dot-Verzeichnis unter
dem User-Home und bei Windows sind die Konfigurationen in der Registry.

Gruß
Dino

 

[Maik15]

So jetzt hab ich es geschafft das Musterprogramm auf meinen AVR umzuschreiben.
Den alten Code hab ich teilweise drin gelassen und Auskommentiert.

Jedoch musste ich so viele kleine Sachen ändern das ich mir nicht mehr sicher bin das es wirklich noch funktioniert.

Es soll eigentlich nur Daten an den AVR gesendet werden und der AVR sendet sie als Echo wieder zurück. Da steht noch was von Datenausgabe auf einem LCD aber dafür hab ich nicht eine Programmzeile gefunden.

Wenn ich über Putty einen Buchstaben sende wird er mir in Putty auch angezeigt. (ist das jetzt die Bestätigung das mein Programm funktioniert oder ist das bei Putty normal?
Und warum muss ich nach jedem Buchstaben 3sek warten bevor ich den nächsten sende?
Warte ich nicht kommt nur Buchstabenmist zurück (kommt mir vor wie eine eingebaute Enigma)

Und wieso funktioniert es anscheint ohne main?
Hab Sicherheitshalber mal ein recht sinnlosen main dazu geschrieben.
OK das Empfangen ist Interrupt gesteuert aber das Senden?
Hab ich es vielleicht überlesen oder wann wird das zurücksenden der Daten gestatte?

P.S. es gibt noch immer 4 Warnungen und die Headerdatei <uart.h> wird auch nicht gefunden und das obwohl ich sie in das Projekt eingebunden hab.
Aber in der Headerdatei wurden nur die Funktionen Deklariert.
Also hab ich die Funktionsdeklaration ohne die <uart.h> gemacht.

Mir fehlt aber irgend wie noch das richtige Verständnis für das Programm.
Kann mir da jemand weiterhelfen?

// Eingaben über ein Hyperterminal werden als ECHO zurückgesendet 
// oder auf dem LCD ausgegeben

#include <avr/io.h>				// Datei für Ein und Ausgänge
#include <util/delay.h>				// Datei für Pausen (delay )
//#include <uart.h>
#include <avr/signal.h>
#include <avr/interrupt.h>

#define UART_BAUD_RATE 9600L
#define UART_BAUD_CALC(UART_BAUD_RATE,F_CPU) ((F_CPU)/((UART_BAUD_RATE)*16L)-1)

#define RBUFFLEN 40 							//Pufferlänge für seriellen Empfang

volatile unsigned char rbuff[RBUFFLEN];			// Ringpuffer
volatile uint8_t 	rbuffpos, 					// Position, die als nächstes gelesen werden muß im Ringpuffer
					rbuffcnt, 					// Anzahl zu lesender Zeichen im Puffer
					udr_data;					// Daten aus dem UART (volatile, damit nicht wegoptimiert wird vom Präprozessor)

//***************************************************************************
// Funktionen Deklarieren
unsigned char ser_getc (void);	
void uart_putc(unsigned char);
void uart_puts (char *);
void uart_ini (void);

//****************************************************************************

// Interruptroutine, die Zeichen aus dem UART sofort ausliest, wenn empfangen
SIGNAL (SIG_UART_RECV) 		
{
	udr_data= UDR0; 										//Byte auf jeden Fall abholen, sonst Endlosinterrupt
	
	if(rbuffcnt < RBUFFLEN)									// keinen Zeichen in einem vollen Ringpuffer überschreiben
		rbuff[(rbuffpos+rbuffcnt++) % RBUFFLEN] = udr_data;	// welche Position? Gelesene Zeichenpos + Anzahl Zeichen MODULO Pufferlänge 
															// (von 0 wieder anfangen, wenn Ende erreicht)
}

//****************************************************************************

// Nächstes zu lesendes Zeichen aus Ringpuffer zurückgeben
unsigned char ser_getc (void)		
{
	unsigned char c;

	while(!rbuffcnt);   				// Warte bis ein Zeichen vorhanden ist
	
	cli();								// Interrupfbehandlung kurz aussetzen. Ab jetzt muß es schnell gehen (wenig Befehle), damit Zeichen, die 
										// ab jetzt eintreffen nicht verloren gehen.
	rbuffcnt--;							// anschl. ein Zeichen weniger zum ausgeben
	c = rbuff [rbuffpos++];				// Zeichen holen, was nach dem bereits gelesenen liegt
	if (rbuffpos >= RBUFFLEN)  rbuffpos = 0;	// wenn hinterstes Zeichen (rechts im Puffer) gelesen wurde, dann wieder vorne anfangen

	sei();								// Interruptbehandlung wieder aktivieren

	return (c);							// Zeichen zurückgeben
}

//****************************************************************************

// Ein Zeichen senden
void uart_putc(unsigned char c)
{
    while(!(UCSR0A & (1 << UDRE0)));   	// warte, bis UDR bereit 

    UDR0 = c;    						// sende Zeichen 
}

//****************************************************************************

// Einen String senden
void uart_puts (char *s)
{
    while (*s)							// so lange *s != NULL
    {    
        uart_putc(*s);
        s++;
    }
}

//****************************************************************************

// USART initialisieren
void uart_ini ()
{
	sei();	// Interruptbehandlung aktivieren

	UCSR0B |= (1 << TXEN0);												// UART TX (senden) einschalten
	UCSR0B |= (1 << RXEN0);												// UART RX (empfangen) einschalten
	UCSR0B |= (1 << RXCIE0);											// Interruptauslösung wen Daten empfangen wurden
	
	UCSR0B |= (1 << UCSZ02);											// 8 Datenbit im Diagram
	UCSR0C |= (1 << UCSZ01);											// 8 Datenbit im Diagram
	
	UCSR0C |= (1 << USBS0);												// 2 Stopp Bit's
	UCSR0C |= (3 << UPM00);												// Parity Modus Gerade Anzahl

	//UBRR0H=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_CPU)>>8);			// Baudrate Automatisch wählen
	//UBRR0L=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_CPU);
	UBRR0H = 0x00;														// Baudrate = 4800 bei 1Mhz
	UBRR0L = 0x0C;														// Baudrate = 4800 bei 1Mhz
}

//****************************************************************************



int main (void)
	{
		unsigned int x;
		
		DDRB = 0xFF;												
		DDRD = 0x00;													
		PORTD = 0xFF;													
		PORTB =0x00;													
		
		while (1)
			{
				x = PIND;												
				PORTB = x;												
			}
if (
	return 0;
	}

gruß
Maik

 

[dino03]

Hi Maik,

Wenn ich über Putty einen Buchstaben sende wird er mir in Putty auch angezeigt. (ist das jetzt die Bestätigung das mein Programm funktioniert oder ist das bei Putty normal?

das ist das Echo vom AVR wenn du im PuTTY kein lokales Echo aktiviert hast.
Das kannst du aber kontrollieren ... AVR vom PC abziehen. Wenn es dann
beim Tastendruck keine Antwort mehr gibt dann ist das vom AVR.

Und warum muss ich nach jedem Buchstaben 3sek warten bevor ich den nächsten sende?
Warte ich nicht kommt nur Buchstabenmist zurück (kommt mir vor wie eine eingebaute Enigma)

? ? Das liegt wohl irgendwo an deinem Programm. Müßte ich jetzt
aber erst mit meinen dünnen C-Kenntnissen durchsehen ... Aber da werde ich
wohl nicht viel helfen können.

Gruß
Dino

 

[Maik15]

Danke erstmal für die Info.

Dann bin ich also auf dem Richtigem Weg.

gruß
Maik

 

[Dirk]

Hallo Maik,

eine interruptgesteuerte Empfangsroutine, die die empfangenen Daten in einem Buffer ablegt, ist zwar elegant aber für Programmieranfänger schwerer zu verstehen, man "baut" hierbei auch schnell mal einen Fehler ein.

Ich würde an deiner Stelle einfach pollen. Also einfach so lange warten, bis ein Byte im Receivebuffer ist. Wenn die Übertragung der Daten funktioniert, kannst du immer noch die Interrupts nutzen.

uart.h wird ja in deinem Projektverzeichnis sein, dann also nicht <uart.h>, sondern "uart.h" verwenden.

Grüße,
Dirk

 

[Maik15]

So wieder ein Tag verschwändet.
Selbe ohne ein reines Blinkprogramm sendet Echos an den PC zurück.
Das muss dann wohl der FT232 Chip (RS232-USB Converter) machen.

Aber immer nur wenn der AVR gesteckt ist.

Und Sinnlosen Daten senden vom AVR kommt nicht zum PC durch.
Egal ob mit String oder ohne.

Jetzt versuch ich es noch mal kurz mit dem Polling Prinzip.
Aber damit kann ich später eigentlich nicht viel anfangen.

Alternativ wäre da noch ein Seriell -> USB Stick Modul
http://www.avr-tools.de/component/p...id,0/option,com_virtuemart/Itemid,1/vmcchk,1/

Hat damit schon mal jemand gearbeitet?

gruß
Maik