ACS an NIBObee

[radbruch]

// Übungen für ACS an Nibobee                                         11.6.11 mic

// https://www.roboternetz.de/community/showthread.php?53494-ACS-an-NIBObee

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "acs_defines.h" // Definitionen als Headerdatei einbinden

void set_leds(uint8_t status)
{
	PORTB &= 0xf0;
	PORTB |= (0x0f & status);
}

int main(void)
{
	ddr_acs_led_l |= pin_acs_led_l;
	//port_acs_led_l |= pin_acs_led_l;
	port_acs_led_l &= ~pin_acs_led_l;

	ddr_acs_led_r |= pin_acs_led_r;
	//port_acs_led_r |= pin_acs_led_r;
	port_acs_led_r &= ~pin_acs_led_r;

	ddr_acs_36kHz |= pin_acs_36kHz;
	port_acs_36kHz &= ~pin_acs_36kHz;
	
	DDRB |= 0x0f; // LEDs
	set_leds(0b1001);
	_delay_ms(1000);
	set_leds(0);

	while(1)
	{
		if(port_acs_tsop & pin_acs_tsop)
			set_leds(0b0001);
		else
			set_leds(0b1000);
	}
	return(0);
}

Deine Datei acs_defines.h:

// pacman-bee

// Die Anoden der rechten IR-LEDs hängen mit Vorwiderstand an PA0 (X1-AN0)
// Die Anoden der linken IR-LEDs hängen mit Vorwiderstand an PA1 (X1-AN1)
// Die Kathoden beider IR-LEDs sind mit PA3 (X3-AN3) verbunden
// Der IR-Empfänger ist mit PA2 (X2-AN2) verbunden

#define ddr_acs_led_l  	DDRA 	// Anoden der IR-LEDs links
#define port_acs_led_l 	PORTA
#define pin_acs_led_l	(1<<PA1)

#define ddr_acs_led_r  	DDRA    // rechts
#define port_acs_led_r 	PORTA
#define pin_acs_led_r 	(1<<PA0)

#define ddr_acs_36kHz  	DDRA 	// Kathoden der IR-LEDS mit 36kHz getaktet
#define port_acs_36kHz 	PORTA
#define pin_acs_36kHz 	(1<<PA3)

#define ddr_acs_tsop  	DDRA 	// Eingang IR-Empfänger
#define port_acs_tsop 	PINA  // Achtung, das ist ein Eingang!
#define pin_acs_tsop  	(1<<PA2)

[Edit]

Mittlerweile habe ich auch ein Programm geschrieben was beide IR-LEDs leuchten lässt.

#define ddr_acs_36kHz DDRA // Kathoden der IR-LEDS mit 36kHz getaktet

Das ist dir aber sicher auch schon aufgefallen ;)

Du bist nun da wo Pinsel gestartet ist:
https://www.roboternetz.de/community...bstandsmessung

Um es nun etwas abzukürzen:

// ACS Testprogramm für die bee                                      11.6.2011 mic

// Infrarot-ACS für die bee im zweiten Anlauf mit pacman ;)

// https://www.roboternetz.de/community/showthread.php?53494-ACS-an-NIBObee
// https://www.roboternetz.de/community/showthread.php?46233-nibobee-IR-Abstandsmessung
// &p=444151&viewfull=1#post444151

#include <nibobee/iodefs.h>
#include <nibobee/led.h>
#include "acs_defines.h" // Definitionen der ACS-Hardware als Headerdatei einbinden

volatile uint8_t count36kHz;
volatile uint8_t acs=0;

void Sleep(uint8_t pause);
void Msleep(uint16_t pause);
void ACSData(uint16_t *data);

int main(void)
{
    uint16_t data[2]; // Speicher für ACS-Werte

    led_init();

    // 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 Bottum!
    enable_interrupts();

    ddr_acs_led_l |= pin_acs_led_l;        // die Anoden der IR-LEDs
    port_acs_led_l &= ~pin_acs_led_l;

    ddr_acs_led_r |= pin_acs_led_r;
    port_acs_led_r &= ~pin_acs_led_r;

    ddr_acs_36kHz |= pin_acs_36kHz;        // die Kathoden der IR-LEDs

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

    while(1)
   {
      ACSData(data);
      PORTB &= ~15; // alle Leds aus
      if(data[0] > 251) led_set(1,1);
         else if(data[0] > 230) led_set(0,1);
      if(data[1] > 251) led_set(2,1);
         else if(data[1] > 230) led_set(3,1);
      Msleep(100);
   }
   return(0);
}
ISR (TIMER2_COMP_vect)
{
    port_acs_36kHz ^= pin_acs_36kHz; // IR-LEDs togglen
}
// Frequenzkorrektur für 36kHz (512-416 plus 3 Takte fürs Laden von TCNT2?)
ISR (TIMER2_OVF_vect)
{
    TCNT2  += 99; // += bewirkt, dass schon erfolgte Zähltakte nicht ignoriert werden!
    port_acs_36kHz &= ~pin_acs_36kHz; // bei Nulldurchgang soll die IR-LED aus sein!
    //port_acs_36kHz |= pin_acs_36kHz; // seltamerweise funktioniert das auch?
    if(count36kHz) count36kHz--;
   if(acs) acs--;
}

void Sleep(uint8_t pause) // 1/36000 Pause blockierend
{
    count36kHz=pause;
    while(count36kHz);
}
void Msleep(uint16_t pause) // 1/1000 Pause blockierend
{
    while(pause--) Sleep(36);
}
void ACSData(uint16_t *data)
{
   OCR2=253;
   port_acs_led_l |= pin_acs_led_l; // ACS LED left on
   while((port_acs_tsop & pin_acs_tsop) && (OCR2 > 151))
   {
      acs=10; // Impulse senden, acs wird in OVF-ISR runtergezählt
      while(acs);
      OCR2--;
   }
   port_acs_led_l &= ~pin_acs_led_l; // ACS LED left off
   data[0]=OCR2;
   while(!(port_acs_tsop & pin_acs_tsop)); // warten bis keine Echo mehr

   OCR2=253;
   port_acs_led_r |= pin_acs_led_r; // ACS LED right on
   while((port_acs_tsop & pin_acs_tsop) && (OCR2 > 151))
   {
      acs=10;
      while(acs);
      OCR2--;
   }
   port_acs_led_r &= ~pin_acs_led_r; // ACS LED right off
   data[1]=OCR2;
   while(!(port_acs_tsop & pin_acs_tsop));
} 

Das Programm reagiert auf die Annäherung eines Hindernisses und auf eine Fernbedienung. Es wird nun doch die nibobee-Library verwendet. Erklärung folgt...