- 3D-Druck Einstieg und Tipps         
Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 15

Thema: [gelöst] Einfache IR-Kommunikation für den RP6

  1. #1
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    61
    Beiträge
    5.799
    Blog-Einträge
    8

    [gelöst] Einfache IR-Kommunikation für den RP6

    Anzeige

    E-Bike
    Hallo

    Da mich das Kabelgewurschtel nervt, Suche ich nach einer einfachen Möglichkeit, vorerst nur Daten mit IR vom RP6 zum PC zu senden. Später auch zurück, aber immer schön einen Schritt nach dem anderen. Ziel ist dann eine Erweiterung für die Lib, aber das wird wohl noch etwas dauern. Hier mein erster kleiner Versuch in dieser Richtung:

    Code:
    // Sendet einzelne Zeichen mit 2400 Baud über die IR-Dioden.
    // Das ist noch eine frühe Beta-Version zur allgemeinen Erheiterung ;)
    
    // Leider funktioniert das so bei mir nur im Ultranahbereich.
    // (Empfänger liegt auf der Diode!). Um die nervige Nabelschnur
    // loszuwerden muss ich wohl noch ein bisschen tüfteln.           mic 22.7.07
    
    #include "RP6RobotBaseLib.h"
    
    #define BAUD_2400 		2400  //IR speed - 2400 Baud
    //#define UBRR_BAUD_2400	((F_CPU/(16*BAUD_2400))-1) // ergibt einen Fehler?
    #define UBRR_BAUD_2400	(((F_CPU/16)/BAUD_2400)-1)
    
    uint8_t i;
    
    void IRwriteChar(uint8_t zeichen)
    {
    	UBRRH = UBRR_BAUD_2400 >> 8;	   	// Setup UART: Baudrate ist 2400
    	UBRRL = (uint8_t) UBRR_BAUD_2400;
    	cli();										// Bitte nicht stören!
    	PORTD &= ~IRCOMM;                	// IR-LEDs D3+D4 ausschalten
    	if (UCSRA & (1<<TXC)) UCSRA=1<<TXC; // Flag löschen falls gesetzt
       while (!(UCSRA & (1<<UDRE)));       // Warten bis Register leer (mit cli()!)
       UDR = (uint8_t)zeichen;             // Zeichen reinschreiben
    
    	while (!(UCSRA & (1<<TXC)))         // Solange noch nicht alle Bits
    	{                                   // rausgeschoben sind, erkenntlich
    		statusLEDs.LED2=1;               // an LED2, lauschen wir, was an
          if ((PIND & (1<<PD1)) && 1)      // TX rausgeht und steuern damit
          {
             statusLEDs.LED1=0;            // die LED1 und
             PORTD &= ~IRCOMM;             // die IR-LEDs D3+D4 ;)
    		}
    		else
    		{
             statusLEDs.LED1=1;
             PORTD ^= IRCOMM;
    		}
    		updateStatusLEDs();
    	}
    	sei(); // Enable Global Interrupts  // wir haben fertig
    	sleep(10);
    // ACHTUNG! TXC-Flag schreiben bedeutet löschen!
    // Und zwar mit = weil so ohne Wirkung auf andere Flags
    // Normales Setzen mit | würde andere Flags mitlöschen!
    	UCSRA=1<<TXC;
    	statusLEDs.LED2=0;                  // und das zeigen wir auch
    	updateStatusLEDs();
    	UBRRH = UBRR_BAUD_LOW >> 8;         // Loaderterminalbaudrate setzen
    	UBRRL = (uint8_t) UBRR_BAUD_LOW;    // Setup UART: Baudrate is Low Speed
    }
    int main(void)
    {
    	initRobotBase();
    	setLEDs(0b111111);
    	mSleep(100);
    	setLEDs(0);
    	powerON();
    
    	while(true)
    	{
    		for (i='a'; i<='z'; i++)
    		{
    			IRwriteChar(i);
    		}
    		IRwriteChar('\n');
    		IRwriteChar('\r');
    		mSleep(200);
    	}
    	return 0;
    }
    Das ist aber noch eine Vorbetaversion und soll nur zeigen, wie es im Ansatz funktionieren könnte.

    Gruß

    mic

    [Edit]
    Nun ist mir auch klar, warum das nicht richtig funktioniert: Es fehlt noch die 36kHz-Trägerfrequenz!

    [Edit2]
    Thread-Titel geändert
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  2. #2
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    61
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Nachdem ich mich nun etwas durch das Datenblatt und die Lib gekämpft habe, erscheint die Lösung unglaubwürdig einfach:

    Code:
    // Die Funktion IRwriteChar() sendet ein Zeichen über die IRCOMM-LEDs zum PC.
    
    // Die Baudrate wird zum Senden auf 2400 Baud eingestellt. Das Zeichen wird dann
    // mit dem UART ausgegeben. Dabei "lauscht" die Funktion am TX-Pin des ATMega32
    // und schaltet den IRCOMM-Pin. Da die TX-Pegel invertiert sind, werden bei TX==1
    // die IRCOMM-LEDs ausgeschaltet, bei TX==0 wird ein mit 36kHz moduliertes Signal an
    // denn LEDs erzeugt. Da der Timer2 schon im CTC-Mode läuft und weil der IRCOMM-Pin
    // zufällig auch der OC2-Pin ist, wird dazu einfach der Timer2-Ausgang aktiviert und
    // auf togglen eingestellt.
    
    // Mit dem asuro/yeti IR-Transceiver können die gesendeten Zeichen nun über
    // mehrere Meter Entfernung empfangen werden.                            mic 30.7.07
    
    #include "RP6RobotBaseLib.h"
    
    #define BAUD_2400 		2400					//IR speed - 2400 Baud
    #define UBRR_BAUD_2400	(((F_CPU/16)/BAUD_2400)-1)
    
    uint8_t i;                                // Hilfsvariable
    
    void IRwriteChar(uint8_t zeichen)
    {
    	PORTD &= ~IRCOMM;                      // IRCOMM-LEDs ausschalten
      	UBRRH = UBRR_BAUD_2400 >> 8;           // Baudrate auf 2400 setzen
    	UBRRL = (uint8_t) UBRR_BAUD_2400;
       UDR = (uint8_t)zeichen;                // Zeichen ins Senderegister des UARTs
    	while (!(UCSRA & (1<<TXC)))            // Solange das Schieberegister nicht leer
    	{
          if (PIND & TX)								// ist, lauschen wir am TX-Pin
          {
             TCCR2 &= ~(1 << COM20);          // und schalten OC2 und IRCOMM-LEDs aus
             PORTD &= ~IRCOMM;
    		}
    		else
    		{
             TCCR2 |= (1 << COM20);           // oder togglen mit 36kHz ;)
    		}
    	}
    	UCSRA=1<<TXC;                          // TXC-Flag setzen bedeutet löschen!!!
    	PORTD &= ~IRCOMM;                      // IRCOMM-LEDs ausschalten
    	UBRRH = UBRR_BAUD_LOW >> 8;            // RP6Loaderbaudrate setzen
    	UBRRL = (uint8_t) UBRR_BAUD_LOW;
    }
    
    int main(void)
    {
    	initRobotBase();
    	setLEDs(0b111111);
    	mSleep(100);
    	setLEDs(0);
    	powerON();
    
    	while(true)                            // endlos das Alphabet senden
    	{
    		for (i='a'; i<='z'; i++)
    		{
    			IRwriteChar(i);
    		}
    		IRwriteChar('\n');
    		IRwriteChar('\r');
    		mSleep(200);
    	}
    	return 0;
    }
    Das könnte man nun z.b. in der writeChar()-Funktion einbinden und dann wahlweise normal oder Infrarot senden. Vorteil wäre, dass man dann alle writexxx()-Funktionen der Standart-Library verwenden könnte. Aber das muss ich noch überdenken, denn im Moment ist es noch eine blockierende Funktion die vielleicht das Task-System stören könnte.

    Der nächste Schritt ist nun aber das Lesen und damit die bidirektionale IR-Kommunikation. Wenn alles fertig ist, können die Roboter auch untereinander funken. Oder der RP6 mit dem asuro oder was weis ich noch alles.

    Gruß

    mic
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  3. #3
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    61
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Jetzt habe ich erstmal ein blockierendes Lesen fertig:

    Code:
    #include "RP6RobotBaseLib.h"
    
    #define BAUD_2400 		2400					//IR speed - 2400 Baud
    #define UBRR_BAUD_2400	(((F_CPU/16)/BAUD_2400)-1)
    
    uint8_t i;                                // Hilfsvariable
    
    void IRwriteChar(uint8_t zeichen)
    {
    	UBRRH = UBRR_BAUD_2400 >> 8;           // Baudrate auf 2400 setzen
    	UBRRL = (uint8_t) UBRR_BAUD_2400;
    	if (UCSRA & (1<<TXC)) UCSRA=1<<TXC;		// TXC-Flag löschen falls gesetzt
    	UDR = (uint8_t)zeichen;                // Zeichen ins Senderegister des UARTs
    	while (!(UCSRA & (1<<TXC)))            // Solange das Schieberegister nicht leer ist,
    	{
          if (PIND & TX)								// lauschen wir am TX-Pin
          {
             TCCR2 &= ~(1 << COM20);          // und schalten OC2 und IRCOMM-LEDs aus
             PORTD &= ~IRCOMM;
    		}
    		else
    		{
             TCCR2 |= (1 << COM20);           // oder toggeln mit 36kHz ;)
    		}
    	}
    	UCSRA=1<<TXC;                          // TXC-Flag setzen bedeutet löschen!!!
    	TCCR2 &= ~(1 << COM20);                // toggeln ausschalten
    	PORTD &= ~IRCOMM;								// IRCOMM-LEDs ausschalten
    	UBRRH = UBRR_BAUD_LOW >> 8;            // RP6Loaderbaudrate setzen
    	UBRRL = (uint8_t) UBRR_BAUD_LOW;
    }
    
    
    uint8_t IRreadChar(void)
    {
    uint8_t zeichen=0;								// Speicher für die einzelnen Bits
    uint8_t bitnr;                            // Nummer des aktuellen Bits
    uint8_t bitwert[8]={1,2,4,8,16,32,64,128};// Die Werte der Bits (lsb kommt zuerst)
    
    /*
    Baudrate Bitlänge
    300 Baud 3,33 ms
    2400 Baud 417 µs                          // sleep(4) dauert etwa 400us
    9600 Baud 104 µs                          // mit sleep(3) beim Startbit wird der
    38400 Baud  26,04 µs                      // Fehler kompensiert ;)
    */
    
    	while(PINB & ACS);							// Blockierend auf Startbit warten
       sleep(3);                              // Lesemoment ca. auf Mitte Startbit
       for (bitnr=0; bitnr<8; bitnr++)        // Die Bits in einer Schleife einlesen
       {
    		sleep(4);                           // ca. in der Mitte des Bits lesen
          if (PINB & ACS) zeichen+=bitwert[bitnr];
    	}
     	sleep(8);                              // es kommen noch 2 Stopbits
    	return zeichen;
    }
    
    int main(void)
    {
    	initRobotBase();
    	setLEDs(0b111111);
    	powerON();
    	mSleep(300);
    	setLEDs(0);
    
    	while(1)
    	{
    		i=IRreadChar();                  	// Zeichen einlesen
    		IRwriteChar(i+1);                	// und als ascii+1 zurücksenden
    	}
    	return 0;
    }
    Eine Timeout-Erweiterung und eine vernüftige Einbindung in die Library wären nun die nächsten Schritte.

    Beim Senden wird nun zuerst das TXC-Flag gelöscht, falls es gesetzt war. Nach dem Senden wird nun auch das Toggeln ausgeschaltet, dann sollten die IRCOMM-LEDs auch ausbleiben.

    Gruß

    mic

    [Edit]
    Nicht sehr elegant, aber es funktioniert nun auch mit Timeout:
    Code:
    #include "RP6RobotBaseLib.h"
    
    #define BAUD_2400 		2400					//IR speed - 2400 Baud
    #define UBRR_BAUD_2400	(((F_CPU/16)/BAUD_2400)-1)
    
    uint8_t i;                                // Hilfsvariable
    
    void IRwriteChar(uint8_t zeichen)
    {
    	UBRRH = UBRR_BAUD_2400 >> 8;           // Baudrate auf 2400 setzen
    	UBRRL = (uint8_t) UBRR_BAUD_2400;
    	if (UCSRA & (1<<TXC)) UCSRA=1<<TXC;		// TXC-Flag löschen falls gesetzt
    	UDR = (uint8_t)zeichen;                // Zeichen ins Senderegister des UARTs
    	while (!(UCSRA & (1<<TXC)))            // Solange das Schieberegister nicht leer ist,
    	{
          if (PIND & TX)								// lauschen wir am TX-Pin
          {
             TCCR2 &= ~(1 << COM20);          // und schalten OC2 und IRCOMM-LEDs aus
             PORTD &= ~IRCOMM;
    		}
    		else
    		{
             TCCR2 |= (1 << COM20);           // oder toggeln mit 36kHz ;)
    		}
    	}
    	UCSRA=1<<TXC;                          // TXC-Flag setzen bedeutet löschen!!!
    	TCCR2 &= ~(1 << COM20);                // toggeln ausschalten
    	PORTD &= ~IRCOMM;								// IRCOMM-LEDs ausschalten
    	UBRRH = UBRR_BAUD_LOW >> 8;            // RP6Loaderbaudrate setzen
    	UBRRL = (uint8_t) UBRR_BAUD_LOW;
    }
    
    
    uint8_t IRreadChar(uint16_t timeout)
    {
    uint8_t zeichen=0;								// Speicher für die einzelnen Bits
    uint8_t bitnr;                            // Nummer des aktuellen Bits
    uint8_t bitwert[8]={1,2,4,8,16,32,64,128};// Die Werte der Bits (lsb kommt zuerst)
    
    /*
    Baudrate Bitlänge
    300 Baud 3,33 ms
    2400 Baud 417 µs                          // sleep(4) dauert etwa 400us
    9600 Baud 104 µs                          // mit sleep(3) beim Startbit wird der
    38400 Baud  26,04 µs                      // Fehler kompensiert ;)
    */
    	if (timeout)
    	{
    		startStopwatch1();                  // Stopuhr starten
    		setStopwatch1(0);                   // vorsichtshalber zurücksetzen
    	   while(PINB & ACS)
    	      if (getStopwatch1() >= timeout)   // bei Timeout Zeichen null zurückgeben
    	         return 0;
    	}
    	else while(PINB & ACS);						// Blockierend auf Startbit warten
       sleep(3);                              // Lesemoment ca. auf Mitte Startbit
       for (bitnr=0; bitnr<8; bitnr++)        // Die Bits in einer Schleife einlesen
       {
    		sleep(4);                           // ca. in der Mitte des Bits lesen
          if (PINB & ACS) zeichen+=bitwert[bitnr];
    	}
     	sleep(10);                              // es kommen noch 2 Stopbits
    	return zeichen;
    }
    
    int main(void)
    {
    	initRobotBase();
    	setLEDs(0b111111);
    	powerON();
    	mSleep(300);
    	setLEDs(0);
    
    	while(1)
    	{
    		i=IRreadChar(500);
    		if (i) IRwriteChar(i+1);
    	}
    	return 0;
    }
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  4. #4
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    61
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Ich habe jetzt meine Library upgedatet (Stand 7.8.07) und seltsamerweise erhalte ich jetzt einen Fehler beim Kompilieren. Ursache ist folgender Hinweis in der Datei RP6RobotBase.h:

    Code:
    /*****************************************************************************/
    // IRCOMM pin:
    
    // ### WARNING! 
    // 
    // #define IRCOMM 	(1 << PIND7)	// Output
    //
    // ### DO NOT USE THIS PIN BY YOURSELF! 
    // ONLY LET THE INTERRUPT ROUTINE OF THE LIBRARY 
    // CONTROL THIS PIN! 
    // The IR LEDs must be controlled by a modulated
    // signal with minimal 5kHz or higher 
    // modulation frequency! 
    // Nominal modulation frequency is 36kHz! 
    // YOU MAY DAMAGE THE IRCOMM IF YOU USE IT 
    // IN ANY OTHER WAY! 
    
    // Only use this macro to make sure IRCOMM is
    // turned off:
    #define IRCOMM_OFF() PORTD &= ~(1 << PIND7);
    
    // NEVER try to control IRCOMM by yourself if you
    // do not know what you are doing!
    // Always use Timer based modulation control!
    
    
    /*****************************************************************************/
    Hintergrund ist der Widerstand R6 vor den IR-Dioden D3/D4. Der hat nur 10 Ohm und wird im Dauerbetrieb extrem heis. Möglicherweise kann der RP6 durch falsche Ansteuerung des IRCOMM-Pins dauerhaft Schaden nehmen.

    Das wusste ich bei den ersten Versionen meiner Funktionen noch nicht und habe deshalb ziemlich unvorsichtig den IR-Pin manipuliert. Die aktuelle Version moduliert die LEDs mit den geforderten 36kHz und schaltet nach dem Senden die LEDs auch aus. Trotzdem muss ich leider darauf hinweisen, dass die Verwendung meiner Funktionen auf euer eigenes Risiko geschied!

    Ich werde das Projekt jetzt erstmal auf Eis legen und abwarten, ob irgendwelche negativen Berichte über die Verwendung gepostet werden. Da ich selbst die Funktionen seit Tagen ohne Schaden am RP6 verwende, biete ich euch auf euer eigenes Risiko noch den Quellcode meiner letzten Version an.

    Mit den im Quellcode beschriebenen Änderungen in RP6uart.h und RP6uart.c sind nun noch die Funktionen void IRuartON(void) und void IRuartOFF(void) dazugekommen. Damit schaltet man die Baudraten und die writeChar()-Umleitung ein oder aus. (Ausführliche Doku für Interessierte im Quellcode)

    Gruß

    mic
    Angehängte Dateien Angehängte Dateien
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  5. #5
    Benutzer Stammmitglied
    Registriert seit
    10.08.2007
    Beiträge
    47
    Hi radbruch,

    das ist eine tolle Idee!

    Hab's auch versucht. Leider ohne Erfolg bisher...

    Ich verwende ein Notebook (ohne ser. Schnittstelle) und habe 3USB Anschluesse. An einem steckt der RP6-USB Programmieradapter. Das klappt auch gut (sonst waere der Rest obsolet *g*).
    An einem zweiten USB-Port habe ich den ASURO-USB-IR Adapter stecken. Der wird wahlweise auch vom RP6Loader erkannt. Beides gleichzeitig scheint nicht zu funktionieren (auch mit einem anderen Terminalprogramm z.B. Hyperterminal nicht).

    Ohne den RP6Loader mit Adapter sehe ich aber die zweiten (Kontroll-) Ausgaben (tee) nicht.

    Im Hyperterminal oder im RP6Loader sehe ich nur kurz eine Reihe von nicht darstellbaren Zeichen. Das koennten die vom RP6 uebertragenen Zeichen sein.

    Wie ist denn das genaue Setup? Welches Terminalprogramm (z.B. HTerm?) mit welchen Einstellungen brauche ich?

    Kann ich parallel den RP6Loader mit Adapter und den ASURO-USB-IR_Adapter verwenden? (Fuer erste Tests waere das hilfreich.)

    Hast Du vielleicht noch ein paar Tipps?

    mfg
    KaY

  6. #6
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    61
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Ich verwende das Win-Hyperterminal. Die Parameter sind 2400,8,1,none. Die "Kontrollausgaben" im RP6-Loader-Terminal dürften nicht lesbar sein weil die Baudrate zu klein ist, man sieht aber, ob überhaupt was vom RP6 gesendet wird. Das ist eigentlich ein ungewollter Effekt, lässt sich aber nicht vermeiden, weil beim IR-Senden der USART den Datenstrom erzeugt und die Funktion IRwrite() dabei nur am TXD-Pin lauscht. Beim Loader-Terminal ist die Baudrate fest eingestellt und viel zu hoch für IR-Kommunikation. Die Bitlänge ist dann so kurz, dass man die 36KHz nicht mehr draufmodulieren kann. Deshalb läuft die IR-Kommunikation nicht mit Loader-Terminal.

    Kannst du mit dem asuro-Transceifer die Daten sehen, die mit dem Win-Terminal gesendet werden (Weisblatttest)? Senden die IR-LEDs des RP6 (Digicam-Test)? Welche IRwrite()-Version verwendest du? Die Version vom 6.8.07 schaltet bei jedem zu sendenden Zeichen die Baudrate auf 2400 und wieder zurück, bei der Version vom 8.8.07 muss man selbst mit IRuartON() auf 2400 Baud umschalten und mit IRuartOFF() wieder die Loaderbaudrate einstellen. Zum Testen würde ich die Version vom 6.8.07 empfehlen.

    Gruß

    mic
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  7. #7
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    29.07.2007
    Beiträge
    386
    eine einfache lösung habe ich :
    1 atmega8 mit max , tsop und irdiode für den pc. am notebook(pc) habe ich ein serialadapter.

    kann gut mit dem rp6 über ir kommunizieren.

  8. #8
    Benutzer Stammmitglied
    Registriert seit
    10.08.2007
    Beiträge
    47
    Ein neuer Treiber wirkt Wunder ...
    Nun tut's wie's soll. Danke fuer eure Hilfe!

  9. #9
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    07.12.2007
    Ort
    Berlin
    Alter
    40
    Beiträge
    211
    ich werde das mal mit nem thinkpad t43 und linux versuchen

    gruss
    carlitoco

  10. #10
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    07.12.2007
    Ort
    Berlin
    Alter
    40
    Beiträge
    211
    ach vermaledeit ! Das Risiko von dem du (radbruch) oben sprichst, dass der widerstand heiss wird und ev. schaden nimmt möchte ich nur ungern eingehen.

    Was heisst das konkret? Der RP6 kann nicht dauerhaft mit einem anderen IR-fähigen Gerät kommunzieren?

    danke & gruss
    carlitoco

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

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

Solar Speicher und Akkus Tests