Asuro und printf("\nHallo Welt!!!");

[Winne]

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

[Archi]

Was in jedem Fall geht ist ein sprintf() in einen String und dann über SerWrite() raus.

CU, Robin

[Winne]

printf() funktioniert schon mal.
Die Ausgabe ist schneller als SerWrite(), aber hat einen grösseren Overhead zu folge.

/******************************************************************************
 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);
}

[stochri]

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

[Andun]

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.

Scheint aber sonst ganz gut zu funktionieren. Nur werde ich es wahrscheinlich eher selten verwenden, da mir dass sonst schneller geht.

[Vogon]

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 !

[Winne]

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

#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
	

}

[stochri]

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

[Winne]

@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

[stochri]

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