NIBObee Erweiterungen

**Skroete** · 16.01.2010, 17:19

Hallo,

ich habe mir an den Stecker X5 einen SFH5110 IR-Empfänger angeschlossen und mit einer RC5-Fernbedienung etwas herumgespielt.
Was dabei herausgekommen ist, ist folgendes Programm, mit dem man die Nibobee fernsteuern kann.

Code:

/*********************************************
 ***  RC5 Dekoder
 ***  Version 1
 ***
 *** Nibobee wird mit IR-Fernbedienung ferngesteuert.
 ***
 *** PD0=RxD verbunden mit Ausgang IR-Empfänger SFH5110 
 ***
 *** 36kHz (27,7 usek) werden mit Timer2 erzeugt.
 *** Der Eingang PD0 wird alle 8 * 27,7 = 222 usek
 *** abgefragt.
 ***
 *** LED0 (linke gelbe) = Betrieb
 *** LED1 (linke rote)  = blinkt bei RC5 Empfang
 ***
 *** Author : H. Krause  2010 
 **********************************************/
#include <nibobee/iodefs.h> 
#include <nibobee/delay.h> 
#include <nibobee/led.h> 
#include <nibobee/usart.h>
#include <nibobee/sens.h>
#include <nibobee/motpwm.h>

#include <stdlib.h> 


volatile uint8_t count36kHz; 


//IR-Fernbedienung PhilipsII 
//diese Werte können an die Fernbedienung 
//angepasst werden
#define IRPIVor     0x1020 //Vorwärts
#define IRPIRueck   0x1021 //Rückwärts
#define IRPIPlus    0x1010 //schneller
#define IRPIMinus   0x1011 //langsamer
#define IRPIStop    0x1036 //stop
#define IRPIKr      0x1034 //Kurve rechts
#define IRPIKl      0x1032 //Kurve links
#define IRPIPlay    0x1035 //frei


/*********************************************
 ***   Unterprogramme
 *********************************************/

void SerPrint (char *data)
{
  unsigned char i = 0;

  while (data[i] != 0x00)
  {
    usart_putchar(data[i++]);
	delay(3);
  }
}


/***** RC5 ******** RC5 ********* RC5 ******************/

// -----------------------------------------------------------------------------
// Timing
// -----------------------------------------------------------------------------
#define IR_SAMPLES_PER_BIT     8   /*!< 8 Samples per Bit */
#define IR_SAMPLES_PER_BIT_EARLY 7  /*!< Flanke fruehestens nach 7 Samples */
#define IR_SAMPLES_PER_BIT_LATE 10  /*!< Flanke spaetestens nach 9 Samples */
#define IR_SAMPLES_PER_BIT_MIN   2  /*!< Flanke vor 3 Samples -> paket verwerfen */
#define IR_PAUSE_SAMPLES       250  /*!< Startbit ist erst nach 200 Samples ohne */
// Pegelaenderung gueltig -- eigentlich muesste
// man rund 500 Samples abwarten (50 x
// Bitzeit), doch weil der Samplezaehler ein
// Byte ist, beschraenken wir uns hier auf ein
// Minimum von 250 Samples

#define IR_PORT   PORTD     /*!< Port D */
#define IR_DDR    DDRD      /*!< DDR of Port D */
#define IR_PINR   PIND      /*!< Port D input */
#define IR_PIN    PD0       /*!< Pin 0 */

#define RC5_COMMAND 0x103F    /*!< Der Kommandobereich */
#define RC5_MASK (RC5_COMMAND)

static uint8_t     RC5lastsample = 0;  /*!< zuletzt gelesenes Sample */
static uint8_t     RC5bittimer   = 0;  /*!< zaehlt die Aufrufe von ir_isr() */

static uint16_t    RC5data_tmp = 0;    /*!< RC5-Bitstream */
static uint8_t     RC5bitcount = 0;    /*!< anzahl gelesener bits */

volatile uint16_t  RC5data = 0;        /*!< letztes komplett gelesenes RC5-paket */
volatile uint8_t   enableRC5 = 0;      /*!< schaltet die RC5 Abfrage ein/aus */



/**********************************
 * Interrupt Serviceroutine
 * wird alle 27.7us aufgerufen
 **********************************/
void IsrRC5 (void)
{
  // sample lesen
  uint8_t sample = 1;

  //PORTB ^= (1<<PB1); //PB1=LED1 toggeln (Test)

  if (enableRC5 && !(count36kHz % 8)) 
  {  
    if ((IR_PINR & (1<<IR_PIN)) != 0)
    {
      sample = 0;
    }

    // bittimer erhoehen (bleibt bei 255 stehen)
    if (RC5bittimer<255)
    {
      RC5bittimer++;
    }

    // flankenerkennung
    if ( RC5lastsample != sample)
    {
      if (RC5bittimer <= IR_SAMPLES_PER_BIT_MIN)
      {
        // flanke kommt zu frueh: paket verwerfen
        RC5bitcount=0;
      }
      else
      {
        // Startbit
        if (RC5bitcount==0)
        {
          if ( (sample==1) && (RC5bittimer > IR_PAUSE_SAMPLES) )
          {
            // Startbit speichern
            RC5data_tmp = 1;
            RC5bitcount++;
            led_set(1,1); //LED1 an
          }
          else
          {
            // error
            RC5data_tmp = 0;
          }

          // bittimer-reset
          RC5bittimer = 0;

        // Bits 2..14: nur Flanken innerhalb des Bits beruecksichtigen
        }
        else
        {
          if (RC5bittimer >= IR_SAMPLES_PER_BIT_EARLY)
          {
            if (RC5bittimer <= IR_SAMPLES_PER_BIT_LATE)
            {
              // Bit speichern
              RC5data_tmp = (RC5data_tmp<<1) | sample;
              RC5bitcount++;
            }
            else
            {
              // zu spaet: paket verwerfen
              RC5bitcount = 0;
            }
            // bittimer-reset
            RC5bittimer = 0;
          }
        }
      }

    }
    else
    {
      // keine flanke innerhalb bitzeit?
      if (RC5bittimer > IR_SAMPLES_PER_BIT_LATE)
      {
        // 14 bits gelesen?
        if (RC5bitcount==14)
        {
          RC5data = RC5data_tmp;
        }
        // paket verwerfen
        RC5bitcount = 0;
        led_set(1,0); //LED1 aus
      }
    }

    // sample im samplepuffer ablegen
    RC5lastsample = sample;
  }
}

/*********************************************************
 * IR-Daten lesen
 * @return wert von ir_data, loescht anschliessend ir_data
 *********************************************************/
uint16_t ReadRC5 (void)
{
  uint16_t retvalue = RC5data;
  RC5data = 0;
  return retvalue;
}

/*****************************************
 * Init IR-System
 *****************************************/
void InitRC5 (void)
{
  IR_DDR  &= ~IR_PIN;   // Pin auf Input
  IR_PORT |= IR_PIN;    // Pullup an
  enableRC5 = 1;
}

/************************ RC5 Ende **************************/


/*********************************************
 ***   Interrupt Service Routinen
 *********************************************/

ISR (TIMER2_COMP_vect) 
{ 
   //wird nicht benutzt 
} 

// Frequenzkorrektur für 36kHz (512-416 plus 3 Takte fürs Laden von TCNT2?) 
ISR (TIMER2_OVF_vect) 
{ 
   TCNT2 = 99; 
   count36kHz ++;
   IsrRC5();      //RC5 Decoder aufrufen
} 


/*********************************************
 ***   Hauptprogramm
 *********************************************/
int main(void) 
{ 
  static unsigned int cmd;
  int16_t speed_l = 0;
  int16_t speed_r = 0;
  //Test
  //char text[7];

  motpwm_init();
  led_init(); 
  sens_init();
  InitRC5();

  //usart_enable();
  //UCSRB = _BV(RXCIE) + _BV(UDRIE) + _BV(RXEN) + _BV(TXEN);
  UCSRB = _BV(TXEN); //Nur Sender TxD aktivieren
  usart_setbaudrate(2400);

  // Setup Timer2 
  TCCR2 = (1 << WGM20)|(1 << CS20); // PhaseCorrect-PWM, no prescaling, no OC2-Pin! 
  TCNT2  = 96; // (512-416) 36kHz @15MHz 
  //OCR2 = 151; // (255-(208/2)) 151 ist 50:50 Compare Match für symetrische Halbwellen 
  //TIMSK |= (1 << OCIE2)|(1 << TOIE2); // Comp und OVF-ISR enable, Overflow bei Bottom! 
  TIMSK |= (1 << TOIE2); // OVF-ISR enable, Overflow bei Bottom! 

  enable_interrupts(); 

  //Test
  //delay(200);  // wait4programmer 
  //SerPrint("\n\r\n*** Nibobee mit RC5 ***");

  led_set(0,1); 
  delay(2000); // wait4programmer 

  //Test
  //SerPrint("\n\r*** Fuehler links schalten --> Start ***");

  //mit Schalten von Fühler links das Programm starten
  while(sens_getLeft() == 0) 
  {
     delay(100); 
     PORTB ^= (1<<PB0);
  } // hektisches Blinken mit LED0
   
  led_set(0,1); //LED0 einschalten

  //Test
  //SerPrint("\n\r***  --> Start ***");

  while(1) 
  { 
     cmd = ReadRC5();

     if (cmd)
     {
        cmd &= RC5_MASK;

		//Test
        //led_set(2,1); 
        //itoa(cmd, text, 16);
        //SerPrint(text);


        switch (cmd)
        {
             case IRPIVor:
 		            //Test
                    //SerPrint("vor\r\n");
					speed_l = speed_r = 200;
                    break;
             case IRPIRueck:
 		            //Test
                    //SerPrint("zurueck\r\n");
					speed_l = speed_r = -200;
                    break;
             case IRPIPlus:
 		            //Test
                    //SerPrint("schneller\r\n");
					if (speed_r > 0)
					{
                       speed_l += 50;
                       speed_r += 50;
 					   if (speed_r > 1023)
					      speed_l = speed_r = 1023;
                   }
                    else
					{
                       speed_l -= 50;
                       speed_r -= 50;
 					   if (speed_r < -1023)
					      speed_l = speed_r = -1023;
                    }
                    break;
             case IRPIMinus:
 		            //Test
                    //SerPrint("langsamer\r\n");
					if (speed_r > 0)
					{
                       speed_l -= 50;
                       speed_r -= 50;
 					   if (speed_r < 0)
					      speed_l = speed_r = 0;
                    }
                    else
					{
                       speed_l += 50;
                       speed_r += 50;
 					   if (speed_r > 0)
					      speed_l = speed_r = 0;
                    }
                    break;
             case IRPIStop:
 		            //Test
                    //SerPrint("stop\r\n");
					speed_l = speed_r = 0;
                    break;
             case IRPIKr:
 		            //Test
                    //SerPrint("Kurve rechts\r\n");
					if (speed_r > 0)
					{
                       speed_l += 50;
                       speed_r -= 50;
 					   if (speed_r < 0)
					      speed_l = speed_r = 0;
                    }
                    else
					{
                       speed_l -= 50;
                       speed_r += 50;
 					   if (speed_r > 0)
					      speed_l = speed_r = 0;
                    }
                    break;
             case IRPIKl:
 		            //Test
                    //SerPrint("Kurve links\r\n");
					if (speed_r > 0)
					{
                       speed_l -= 50;
                       speed_r += 50;
 					   if (speed_r < 0)
					      speed_l = speed_r = 0;
                    }
                    else
					{
                       speed_l += 50;
                       speed_r -= 50;
 					   if (speed_r > 0)
					      speed_l = speed_r = 0;
                    }
                    break;
             case IRPIPlay:
 		            //Test
                    //SerPrint("play taste\r\n");
                    break;
        }//end switch

        motpwm_setLeft(speed_l);
        motpwm_setRight(speed_r);
     }//end if (cmd)

     delay(100); 

  } 
  return(0); 
}

Viel Spass beim Ausprobieren.
Skroete

Thema: NIBObee Erweiterungen

Themen-Optionen

Thema durchsuchen

Anzeige

Hybrid-Darstellung

Lesezeichen

Lesezeichen

Berechtigungen