Hallo,
ist es möglich ist die Standard Funktionen wie printf(), getch(), stdout(), stdin(), stderr u.s.w. auf die IR Schnittstelle umzuleiten?
Mich nerven diese SerWrite() und SerRead() Funktionen zu sehr!!!
Gruss Winne
Druckbare Version
Hallo,
ist es möglich ist die Standard Funktionen wie printf(), getch(), stdout(), stdin(), stderr u.s.w. auf die IR Schnittstelle umzuleiten?
Mich nerven diese SerWrite() und SerRead() Funktionen zu sehr!!!
Gruss Winne
Was in jedem Fall geht ist ein sprintf() in einen String und dann über SerWrite() raus.
CU, Robin
printf() funktioniert schon mal.
Die Ausgabe ist schneller als SerWrite(), aber hat einen grösseren Overhead zu folge.
Code:/******************************************************************************
Beschreibung: stdio.h
Datum: 2005-09-20
Autor: Winold Doege
Email: winne123@web.de
Font: Courier / Size: 12
******************************************************************************/
#include <stdio.h>
#include "asuro.h"
int usart_putchar( char data )
{
UCSRB = 0x08; /* enable transmitter */
while ( !( UCSRA & (1<<UDRE)) ); /* Wait for empty transmit buffer */
UDR = (unsigned char) data; /* char send */
if (data == '\n') /* new Line */
usart_putchar('\r'); /* cr */
return 0; /* Put data into buffer, sends the data */
}
int usart_getchar( void )
{
UCSRB = 0x10; /* enable receiver */
while ( !(UCSRA & (1<<RXC)) ); /* Wait for data to be received */
return (int) UDR; /* Get and return received data from buffer */
}
int main(void)
{
Init();
fdevopen(usart_putchar,usart_getchar, 0);
for(;;)
printf("\ntest");
while(1); //Endlosschleife
return(0);
}
Hallo Winne,
sehr interessant. Ich habe gar nicht gewußt, daß man einer Funktion anderer Funktionen als Argument übergeben kann.
Wo hast Du denn den Trick mit fdevopen gefunden ?
Gruss,
stochri
Ja, das hab ich mich auch grad gefragt. Das wüsste ich auch gerne.Zitat:
Zitat von stochri
Scheint aber sonst ganz gut zu funktionieren. Nur werde ich es wahrscheinlich eher selten verwenden, da mir dass sonst schneller geht.
Danach habe ich auch schon gesucht.
Gestern habe ich das gefunden : http://www.mikrocontroller.net/artic...R-GCC-Tutorial
Hier gibt es das Beispiel. Aber @winne war schneller !
Auf der suche nach dem guten alten printf() bin ich über fdevopen() gestolpert.
Jetzt mal ne ganz andere Frage die IR-Schnittstelle ist ja Interruptfähig. Ich vermute, dass durch Einstreuung beim Senden auch etwas empfangen wird und immer wieder das gesendet im Empfangspuffer landet. Sollte das so sein ist es schwierig eine Eingabe zu realisieren das oben drein noch Interruptfähig funktioniert.
Die infos habe ich aus:
http://www.nongnu.org/avr-libc/user-manual/index.html
Code:#include "asuro.h"
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#define Pin1 0
#define Pin2 1
#define Pin3 2
#define Pin4 3
#define Pin5 4
#define Pin6 5
#define Pin7 6
#define Pin8 7
#define READ 1
#define WRITE 2
#define F_CPU 8000000
#define USART_BAUD_RATE 2400
#define USART_BAUD_SELECT (F_CPU/(USART_BAUD_RATE*16l)-1)
//static unsigned char changed = 0;
//static unsigned char data = 0;
//volatile unsigned char changed = 0;
volatile unsigned char data = 0;
void usart_init(int Enable, int Interupts)
{
if (Enable & READ) UCSRB = (1<<RXEN);
if (Enable & WRITE) UCSRB |= (1<<TXEN);
if (Interupts & READ) UCSRB |= (1<<RXCIE);
if (Interupts & WRITE) UCSRB |= (1<<TXCIE);
UBRRL = (unsigned char) USART_BAUD_SELECT;
}
void usart_writeChar(unsigned char c)
{
//unsigned char hilfsregister;
//hilfsregister = UCSRB;
//UCSRB &= ~(1<<RXCIE); //interrupt flag disable
while (!(UCSRA & (1<<UDRE)));
UDR = c;
while(!(UCSRA & (1<<TXC)));
//UCSRB = hilfsregister;
}
unsigned char usart_readChar(void)
{
//while(!(UCSRA & (1<<RXC)));
//return UDR;
return data;
}
void usart_writeString(unsigned char *string) {
unsigned char hilfsregister;
hilfsregister = UCSRB;
UCSRB &= ~(1<<RXCIE); //interrupt flag disable
while (!(UCSRA & (1<<UDRE)));
while ( *string)
{
while (!(UCSRA & (1<<UDRE)));
usart_writeChar(*string++);
}
UCSRB = hilfsregister;
}
SIGNAL (SIG_UART_RECV)
{
data = UDR;
//changed = 1;
//usart_writeChar('[');
usart_writeChar(data);
//usart_writeChar(']');
}
int main (void)
{
//int a=0;
unsigned char zeichen;
Init();
usart_init( (READ + WRITE) , READ);
//changed = 0;
//usart_writeString("\nTest");
//for(a = 0; a<3000;a++) Sleep(72); //3 Sekunden warten
sei();
while (1)
{
zeichen = usart_readChar();
//for(a = 0; a<3000;a++) Sleep(72); //1 Sekunden warten
usart_writeString("das Zeichen-->");
usart_writeChar(zeichen);
usart_writeString("<--\n");
} // endlosschleife
}
Hallo Winne,
es ist tatsächlich so, dass jedes gesendetet Zeichen ziemlich sicher auf die Empfangsdiode rückkoppelt.
Das gleiche gilt übrigens für die PC-Seite.
Wenn man eine sichere Kommunikation mit dem PC herstellen will, muss man das Master Slave-Prinzip verwenden.
Ich habe damit schon eine Kommunikation realisiert, mit der ich sämtliche Sensordaten gezielt auslesen kann und auch die Motoren des ASURO steuern kann (chris.lugr.de).
Für diese Art der Kommunikation ist es wichtig, dass der jeweilige Sender seinen Empfangsbuffer nach dem Senden leert.
Gruss,
stochri
@stochri
Ok, ich hab es jetzt mit dem leeren nach dem Senden probiert. Ich bekomme das noch nicht hin!
Poste mal den Code den Du verwendest hast.
Gruß Winne
Hallo Wine,
hast Du schon mal folgendes zu Programmiern:
1. Sende mit dem PC genau ein Byte
2. Der ASURO sendet ein Antwort Byte zurück.
Wenn Du das hinkriegst, kannst Du daraus eine super Kommunikation aufbauen.
Gruss,
stochri
@stochri
Das ist kein Problem (siehe Selftest). Ich möchte, dass der Asuro beim Emfange eines Zeichens ein Interrupt auslöst z.B. durch RXCIE. Aber das Programm funktioniert nicht richtig. Irgendwo beim Übertragen über die IR-Schnittstelle habe ich ein Denkfehler. Ich habe ein Sourcecode gefunden, der eine RS232 mit einer SPI-Schnittstelle Aufbaut.
Bei mir wartet der Asuro immer auf ein Zeichen und führt dann eine Aktion aus.:
byte receive()
{
byte c;
/* Warten auf ein Zeichen von der seriellen Schnittstelle */
SerRead(&c, 1, 0);
toggle_led();
return c;
}
while(1)
{
/* Warten auf ein Kommando der seriellen Schnittstelle */
command = receive();
switch(command)
{
case TEST:
{
.......
Ich habe diese Art der Kommunikation schon früher in Mikrocontrollerrn verwendet, normalerweise kann beim Warten auf das Zeichen auch irgend eine Aktion durchführen. Das Empfangen und Verarbeiten des Zeichens geht so schnell, dass man keine Interrupt-getriebene Komunikation braucht.
Gruss,
stochri
Bei mir wartet der Asuro immer auf ein Zeichen und führt dann eine Aktion aus.:
byte receive()
{
byte c;
/* Warten auf ein Zeichen von der seriellen Schnittstelle */
SerRead(&c, 1, 0);
toggle_led();
return c;
}
while(1)
{
/* Warten auf ein Kommando der seriellen Schnittstelle */
command = receive();
switch(command)
{
case TEST:
{
.......
Ich habe diese Art der Kommunikation schon früher in Mikrocontrollerrn verwendet, normalerweise kann beim Warten auf das Zeichen auch irgend eine Aktion durchführen. Das Empfangen und Verarbeiten des Zeichens geht so schnell, dass man keine Interrupt-getriebene Komunikation braucht.
Gruss,
stochri
OK, jetzt funktionieren die Interrupt richtig.
Ich habe ein mini Test Programm geschrieben.
Die fdevopen Sache ist noch nicht fertig, kommt aber bald.
Den Motorspeed über Hyperterminal einstellen.
Hallo @all
Jetzt ist es möglich scanf() und printf() zu benutzen.
Nachteil:
1. Overhead ist grösser als wie bei SerWrite() und SerRead()
2. Keine Interruptfähige Ein-/Ausgabe mehr
3. Fliesskommazahlen werden nicht verarbeitet.
In der makefile-Datei gibt es weiter Optionen die man einstellen kann.
Leider funktioniert bei mir das nicht:
-Wl,-u,vfscanf -lscanf_flt -lm
-Wl,-u,vfprintf -lprintf_flt -lm
hat jemand einen Tipp?
Gruss Winne