-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 16

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

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    25.08.2005
    Ort
    Berlin
    Alter
    44
    Beiträge
    53

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

    Anzeige

    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

  2. #2
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    02.12.2004
    Ort
    München
    Alter
    44
    Beiträge
    198
    Was in jedem Fall geht ist ein sprintf() in einen String und dann über SerWrite() raus.

    CU, Robin

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    25.08.2005
    Ort
    Berlin
    Alter
    44
    Beiträge
    53
    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);
    }

  4. #4
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    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

  5. #5
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    04.04.2005
    Ort
    Hamburg
    Alter
    29
    Beiträge
    826
    Zitat Zitat von 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
    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.
    www.subms.de
    Aktuell: Flaschcraft Funkboard - Informationssammlung

  6. #6
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    29.04.2005
    Ort
    Weilburg
    Beiträge
    676
    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 !
    Prostetnic Vogon Jeltz

    2B | ~2B, That is the Question?
    The Answer is FF!

  7. #7
    Benutzer Stammmitglied
    Registriert seit
    25.08.2005
    Ort
    Berlin
    Alter
    44
    Beiträge
    53
    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
    	
    
    }
    Angehängte Dateien Angehängte Dateien

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    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

  9. #9
    Benutzer Stammmitglied
    Registriert seit
    25.08.2005
    Ort
    Berlin
    Alter
    44
    Beiträge
    53
    @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

  10. #10
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    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

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •