rc5 daten senden mit winavr

[muraad]

Also so wie dein Code ist kann er nicht richtig funktionieren.
Hab ihn mal bisschen umgeändert, aber so wie du wolltest.
Hier:

#include <stdio.h> 
#include <inttypes.h> 
#include <avr/io.h> 
#include <avr/delay.h> 
#include <avr/interrupt.h> 
#include <avr/signal.h> 
#include <string.h> 
#include <stdint.h> 


uint16_t zaehler; 
uint32_t zaehler1; 

void us_889(void) 
{ 
    
   for (zaehler=0; zaehler<1185; zaehler++) 
   asm volatile("nop"); 
    
}    
       
void ms_89(void) 
{ 
   for (zaehler1=0; zaehler1<117105; zaehler1++) 
   asm volatile("nop"); 
}    

void ir_init_send(void) { 
   //36kHz Träger 
   TCCR1A = (1<<COM1A1) | (1<<COM1A0) | (1<<WGM11); 
   TCCR1B = (1<<WGM12) | (1<<WGM13) | (1<<CS10); 
   OCR1A = 111; 
   ICR1 = 222; 
   //Timer-Interrupt alle 2,048ms zur Signalerzeugung --> 1/(8MHz/256/64) 
   TCCR0 = (1<<CS01) | (1<<CS00);    //Prescaler von 64 
   TIMSK |= (1<<TOIE0);               //Timer0 Overflow Interrupt aktivieren 
} 
  
void rc5_send(uint16_t code)   // Nur die ersten 14Bits zählen die obersten 2 werden ignoriert
{
   uint8_t i;
   for(i=0;i<=14;i++)
   {
     DDRD&= ~(1<<PD5);     // PWM 36kHz Signal auf low
	  us_889();             // halbe Bitzeit warten
	  if (code & (1<<i))       // aktuelles Bit in code prüfen ob high   
	     DDRD|= (1<<PD5);     //wenn ja, PWM 36kHz Signal auf high
	  us_889();             // zweite halbe Bitzeit
   }
   ms_89();                  // Pause

int main(void) 
{ 

   ir_init_send(); 
   rc5_send(0b0000110001001111);     // Nur untersten 14Bits sind wichtig   
}

Jetzt werden nur deine for() Schleifen benutzt. Ich weiß allerdings nicht genau ob man einer Funktion den Wert einer Variable als Binärzahl übergeben darf, ich denke aber schon.
Gruß Muraad

[pebisoft]

hallo arexx-henk schreibt folgendes:

ich hab mahl geguck wie dass bei Asuro Roboter gemacht wird.
PB3 --------R220OHM--------(+)IRDIODE(-)--------PD1
An PB3 steht immer 36KHz und die daten kommen aus PD1.
Wenn PD1 hoch ist wird kein IR-Signal ausgestrahlt.
Denn
- wenn PB3 hoch ist und PD1 hoch, lauft kein Strom.
- wenn PB3 niedrich ist und PD1 hoch, lauft auch kein Strom weil die
IRDIODE dann gesperrt ist.
Wenn PD1 niedrich ist wird ein IR-Signal ausgestrahlt.

Dass 36KHz signal an PB3 wird von einem timer erzeugt.
Und PD1 ist die USART TX ausgang.

vielleicht baucht ocr1a nicht geschaltet werden sondern nur ein anderes signal und ocr1a liefert nur das 36khz-signal.

allmählich komme ich mit der signalgebung ins schleudern.
versucht ihr es noch einmal zu überdenken.
vielen dank.
mfg pebisoft

[muraad]

Ich hab den Code jetzt nochmal grundlegend geändert.
Was mir nie aufgefallen ist. Bei rc5 dauert ein Bit zu senden 1778us, in der Mitte entscheidet sich ob 1 oder 0. Bei 1 muss in der Mitte der Zeit ein wechsel von high auf low sein, bei 0 ein wechsel von low auf high.
D.h. man muss auch mit einbeziehen was das letzte Bit war(0 oder 1) und damit der aktuelle Signalpegel.
Ich hab jetzt ne neue Funktion, mit deinen for() Schleifen, die das alles macht.

#include <avr/io.h> 
#include <avr/delay.h> 
#include <avr/interrupt.h> 
#include <avr/signal.h> 
#include <string.h> 
#include <stdint.h> 


uint16_t zaehler; 
uint32_t zaehler1; 
#define PWM_PORT        DDRD
#define PWM_BIT         PD5
void us_889(void) 
{ 
    
   for (zaehler=0; zaehler<1185; zaehler++) 
   asm volatile("nop"); 
    
}    
        
void ms_89(void) 
{ 
   for (zaehler1=0; zaehler1<117105; zaehler1++) 
   asm volatile("nop"); 
}    

void rc5_init(void) { 
   //36kHz Träger 
   TCCR1A = (1<<COM1A1) | (1<<COM1A0) | (1<<WGM11); 
   TCCR1B = (1<<WGM12) | (1<<WGM13) | (1<<CS10); 
   OCR1A = 111; 
   ICR1 = 222; 
} 
  
void rc5_send(uint16_t code)   // Nur die ersten 14Bits zählen die obersten 2 werden ignoriert 
{ 
   uint8_t i,X;  
   
   // Prüfen ob das erste Bit low oder high ist um zu wissen wie man anfängt
   if(code&(1<<0));       // Ist erstes Bit high 
   {
       i=1;                  // letztes Bits war high
	   PWM_PORT|= (1<<PWM_BIT);     //wenn ja, PWM 36kHz Signal auf high 
	   us_889();             // halbe Bitzeit warten 
	   PWM_PORT&= ~(1<<PWM_BIT);     // PWM 36kHz Signal auf low  
	   us_889();             // zweite halbe Bitzeit 
   }
   else
   {
       i=0;
	   us_889();             // halbe Bitzeit warten
	   PWM_PORT|= (1<<PWM_BIT);
	   us_889();             // zweite halbe Bitzeit
   }
   
   // Sendet die letzten 13Bits und prüft wie das letzte Bit war
   for(X=1;X<=13;X++)       
   {
      if((i=1)&&(code&(1<<X))         // letztes Bit war high und nächstes ist high
	  {
	     PWM_PORT|= (1<<PWM_BIT);          // high
		 us_889();
		 PWM_PORT&= ~(1<<PWM_BIT);
		 us_889();
      }
	  else if((i=1)&&(!(code&(1<<X))))   // letztes high und nächstes low
	  {
	     i=0;
		 us_889();
		 PWM_PORT|= (1<<PWM_BIT);
		 us_889();
	  }
	  else if((i=0)&&(code&(1<<X)))        // letzes low, nächstes high
	  {
	     i=1;
		 us_889();
		 PWM_PORT&= ~(1<<PWM_BIT);
		 us_889();
	  }
	  else if((i=0)&&(code&(1<<X)))       // letzes low, nächstes low
      {
	     PWM_PORT&= ~(1<<PWM_BIT);
		 us_889();
		 PWM_PORT|= (1<<PWM_BIT);
		 us_889();
	  }
	  else
	     asm volatile ("nop");            // zu else sollte es nie kommen
   } 
   ms_89();                  // Pause falls gleich noch etwas gesendet wird
}
int main(void) 
{ 

   ir_init_send(); 
   rc5_send(0b0000110001001111);     // Sendet das was du in deinem Code senden wolltest   
}

Ach und was das beim Asuro mit dem USART Pins zu tun hat weis ich auch nicht. Auf jedenfall wird das nicht das rc5 Protokoll sein denk ich.

Viele grüße Muraad

[pebisoft]

hallo, muraad vielen dank. dein programm lässt sich compilieren. es kommt aber kein signal an. ist egal wo ich die ir-diode mit 100ohm anschliesse (+ oder minus und pd5 ocra1), mit Bascom läuft die diode. ich gebe aber nicht auf. es muss doch möglich sein, eine addresse und ein command zu senden plus toggle und startsbits.
ich kann auch nicht prüfen , ob die daten vom trägersignal stimmen.
mfg pebisoft

[muraad]

Es könnten noch zwei Fehler sein. Erstens könnte irgendwas falsch sein an der ir_init(), die Frequenz stimmt schon, ich weiß nur nicht ob FastPWM stimmt. Vielleicht sollte man hier mal auf PhaseCorrect PWM umstellen.
Und zweitens könnte es sein dass das hier:
for(X=1;X<=13;X++)
{
if((i=1)&&(code&(1<<X)) // letztes Bit war high und nächstes ist high
{
PWM_PORT|= (1<<PWM_BIT); // high
us_889();
PWM_PORT&= ~(1<<PWM_BIT);
us_889();
}
else if((i=1)&&(!(code&(1<<X)))) // letztes high und nächstes low
{
i=0;
us_889();
PWM_PORT|= (1<<PWM_BIT);
us_889();
}
else if((i=0)&&(code&(1<<X))) // letzes low, nächstes high
{
i=1;
us_889();
PWM_PORT&= ~(1<<PWM_BIT);
us_889();
}
else if((i=0)&&(code&(1<<X))) // letzes low, nächstes low
{
PWM_PORT&= ~(1<<PWM_BIT);
us_889();
PWM_PORT|= (1<<PWM_BIT);
us_889();
}
else
asm volatile ("nop"); // zu else sollte es nie kommen
}
zu lange dauert, und ein Bit dadurch nicht 1,778ms sondern vielleicht 2ms braucht. Deswegen könnte es sein das deine rc5_recieve() Funktion, die du verwendest, es nicht als rc5 Code erkennt.
Man müsste in einem Simulator mal genau schauen wie lange mein for() Schleife (13Bits) mit den if Anweisungen braucht. Ist da dann wirklich ein größere Zeitfehler muss/kann man vielleicht noch deinen us_889() Wartefunktionen verändern.
In der ir_init_send() war auch noch was von Timer0 drinnen, das hatte ich nur vergessen zu löschen. Habs jetzt verbessert, und die Funktion rc5_init() gennant.
Gruß Muraad

[pebisoft]

hallo muraad, hallo dino dieter, könnt ihr eure erfahrungen einmal zusammenlegen. es funktioniert bis jetzt noch nicht, auch wenn die timerabstimmung stimmt. ich finde den fehler nicht. dino dieter, du hast doch einmal einen pic als sender genommen und das in c geschrieben.
dieses hier hat dino dieter vorgeschlagen, aus einem pic-rc5-sender:

//Eine 0 senden
void SendBit0()
{
 unsigned char i;

 //890us Impuls mit 36kHz senden
 //Bei 28us Periodendauer ergibt das 32 Impulse
 //Die Befehle unten ergeben nur 20us*32 = 640us
 //Der Rest wird mit dem Schleifenoverhead verbraten
 //Deshalb sieht die Nullphase auch kürzer aus als sie
 //tatsächlich ist !
 //Beim 12C508 ist der Overhead kleiner !!
 //Liegt am Compiler
 //Deshalb sind hier mehr NOPs als im Programm für 16F84
 for(i=0; i<32; i++)
  {
   LED_ON();
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
   NOP; NOP;
   LED_OFF();
   NOP; NOP; NOP; NOP; NOP; NOP;
  }

//890us Pause
 for(i=0; i<32; i++)
  {
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
  }

}

//Eine 1 senden
void SendBit1()
{
 unsigned char i;

//890us Pause
 for(i=0; i<32; i++)
  {
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
  }

 //890us Impuls mit 36kHz senden
 for(i=0; i<32; i++)
  {
   LED_ON();
   NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP; NOP;
   NOP; NOP;
   LED_OFF();
   NOP; NOP; NOP; NOP; NOP; NOP;
  }
}

void PhaseMod()
{
 unsigned char mask;     
 unsigned char i;
 
 SendBit1(); //Erstes Startbit=1
 SendBit1(); //Zweites Startbit=1

//Togglebit
   if(toggle==0)
    {
     SendBit0();
    }
   else
    {
     SendBit1();
    }  
//Ende Togglebit

//5 Bit Gerätecode
   mask=0x10; //Beginn bei MSB
   
   for(i=0; i<5; i++)
    {
     if(SUBCODE&mask) //Send 1
      {
       SendBit1();
      }
     else //Send 0
      {
       SendBit0();
      }
      
     mask>>=1;   //Nächstes Bit
    }
//Ende Gerätecode

//6 Bit Kommandocode
   mask=0x20; //Beginn bei MSB
   
   for(i=0; i<6; i++)
    {
     if(comcode&mask) //Send 1
      {
       SendBit1();
      }
     else //Send 0
      {
       SendBit0();
      }
     mask>>=1;  //Nächstes Bit
    }
//Ende Kommandocode

//Übertragung komplett
   LED_OFF(); //IR-LED abschalten
}

könnte man beim AVR nicht auch ein 36khz-signal erzeugen an einem beliebigen port. der dann erst erzeugt wird, wenn die 14bit gesendet werden (36khz brauchen ja erst beim senden einer "1" oder "0" erzeugt werden, oder sehe ich das verkehrt). diese massnahme hält den roboter nicht zeitlich gross auf und ist im steuerungsprogramm nicht spürbar.

mfg pebisoft

[pebisoft]

hallo muraad, vielleicht kannst du mir sagen, wie ich ein 36khz signal erzeuge ohne interrupt. nur wenn ich das halbbit sende von 889us soll der frei wählbare pin pulsieren mit 36khz.
mfg pebisoft

[muraad]

Ganz erlich gesagt hab ich keine Idee. Außer den Pin 36000mal in der Sekunde an und auszuschalten.
Ach und das der Code von DinoDieter sich kompilieren lässt ist schon klar, ist ja standart C. Aber ich bezweifle das er auf einem AVR genauso lange braucht wie auf einem PIC. In dem Code steht das er schon für einen anderen Pic angepasst werden muss.
Du musst dir halt selber for() Schleifen machen, wie in dem PIC Code, und rumtesten solange bis du ein 36kHz Signal hast.
Gruß Muraad

[Dino Dieter]

Hallo Pebisoft

In dem Code oben, stehen doch alle Lösungen.

for(i=0; i<32; i++)
  {
   PORTA &= ~(1<< LED_PIN);  //oder welcher port auch immer  (LED an)
    //Hier eine Zeitschleife rein, die ca 13 µs verbrät 

   PORTA |= (1<< LED_PIN);  //oder welcher port auch immer (LED aus)
 

   //Hier eine Zeitschleife rein, die ca 13 µs verbrät 
  }

//890us Pause
 for(i=0; i<32; i++)
  {
  //Hier eine Zeitschleife rein, die ca 27 µs verbrät 

  }

}

Der Code läßt doch eine LED mit ungefähr 36 KHz leuchten für ca 889 µs. Danach 889µ aus.


Hier mal ein Teil von meinem Code damals. Wie gesagt für einen Tiny mit 1,2 MHz. Mußte halt die Variablen in Register halten.

#include <avr/io.h>

#define uchar	unsigned char
#define uint	unsigned int

void licht_aus (void);
void licht_an (void);
void send_0 (void);
void send_1 (void);
void daten (void);


#define led     1

//Funktion zum senden einer 0 +++++++++++++++++++++++++++++++++++++++
void send_0 ()
{
	licht_an();
	licht_aus();
}


//Funktion zum senden einer 1 +++++++++++++++++++++++++++++++++++++++
void send_1 ()
{
	licht_aus();
	licht_an();
}

//Funktion Licht aus+++++++++++++++++++++++++++++++++++++++++++++++++
void licht_aus (void)
{
	register uchar n asm("r2");

		for(n=0;n< 146;n++)			// 889µs Pause
		{	asm volatile (" nop");
			asm volatile (" nop");
		}
}

//Funktion Licht an++++++++++++++++++++++++++++++++++++++++++++++++++
void licht_an ()
{
	register uchar n asm("r2");

	for(n=0;n<33;n++)
	{
		// 13 us Licht an  ca 15 Takte
		  PORTB = 0x01;		// LED an
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
 // 13 us Licht aus ca 15 Takte
		  PORTB = 0x00;		//LED aus
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");
		  asm volatile (" nop");


		
	}

}

//Funktion Daten senden++++++++++++++++++++++++++++++++++++++++++++++
void daten()
{
	//Sendet immer nur zum Test diesen Code
	//Adresse = 0
	//Command = 1
	// 2 Startbits senden
	send_1();
	send_1();
	// Togglebit senden
	send_0();
	//Adresse senden
	send_0();
	send_0();
	send_0();
	send_0();
	send_0();
	//Comand senden
	send_0();
	send_0();
	send_0();
	send_0();
	send_0();
	send_1();
}


//Einstellen der Hardware des AVR++++++++++++++++++++++++++++++++++++
void init(void)
{

	//Ports einstellen
	DDRB = 0xff;
	TCCR0 = (1<<CS02)| (1<< CS00);
	//OSCCAL setzen sonst läuft er nicht sauber mit 1,2 MHZ
	//nur bei TINY 12 mit internen Takt notwendig
	asm volatile (" ldi 0x18, 0x3e");
	asm volatile (" out 0x31, 0x18");

}

//Hauptprogramm++++++++++++++++++++++++++++++++++++++++++++++++++++++
void main (void)
{
	init();

	DDRB = 0xff;

	register uchar d asm("r4");

	for(;;)
	{
		daten();
		TCNT0 = 0;
		while ( TCNT0 < 36);		//kleine Verzögerung
	}
}

Die Funktion daten ist nicht so dolle. Der Sender hat jedoch immer nur eine RC5 Befehl gesendet, von daher.


MFG
Dieter

[pebisoft]

hallo muraad, dino dieter usw.
es ist vollbracht !
durch ausdauer und nicht aufgeben hat man das ziel erreicht.
ich kann jetzt unter winavr-c ganz sauber rc5-code (14bit) senden ohne interrupt.
es tritt über haupt kein übertragungsfehler auf, klasse.
die 36khz werden nur zur zeit des gesetzten bits erzeugt also nur immer 890us lang.
dank eurer hilfe ist es endlich gelungen.
wie man sieht ist das programm nicht kompliziert. und ist für jeden anfänger nachvollziebar.
hallo muraad, du kannst dieses programm auch wieder bekannt machen.
es läuft bei mir mit dem AVR16 und 8mhz.
ir-diode von portb0 über 10kohm nach 5volt.
der port kann beliebig gewählt werden.

#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <avr/signal.h> 
#include <string.h> 
#include <stdint.h> 


//89ms pause
void ms_89(void)
{

uint32_t zaehler;

	for (zaehler=0; zaehler<118666; zaehler++) 
	asm volatile("nop");
}
	
//Eine 0 senden
void SendBit0(void)
{

uint16_t i,zaehler;

	//890us Impuls mit 36kHz senden
	//Bei 28us Periodendauer ergibt das 32 Impulse

	for(i=0; i<32; i++)
	{
		PORTB=1;
		for (zaehler=0; zaehler<18; zaehler++)  //  ~14us
		asm volatile("nop");		
		PORTB=0;
		for (zaehler=0; zaehler<18; zaehler++)  // ~14us
		asm volatile("nop");		
	}

	//890us Pause
    for (zaehler=0; zaehler<1186; zaehler++) 
    asm volatile("nop");		

}

//Eine 1 senden
void SendBit1(void)
{
 
uint16_t i,zaehler;

	//890us Pause
    for (zaehler=0; zaehler<1186; zaehler++) 
    asm volatile("nop");		

	//890us Impuls mit 36kHz senden
	for(i=0; i<32; i++)
	{
		PORTB=1;
        for (zaehler=0; zaehler<18; zaehler++) 
        asm volatile("nop");		
        PORTB=0;
        for (zaehler=0; zaehler<18; zaehler++) 
        asm volatile("nop");		
	}
}


int main(void)

{
 
	DDRB=1; // Portb1 = ausgang
	
	while (1)
	{
	SendBit1(); //Erstes Startbit=1
	SendBit1(); //Zweites Startbit=1

	SendBit0(); //Togglebit
  
	//5 Bit Gerätecode
	SendBit0();
	SendBit1();
	SendBit0();
	SendBit1();
	SendBit1();

	//6 Bit Kommandocode
	SendBit1();
	SendBit1();
	SendBit1();
	SendBit1();
	SendBit1();
	SendBit1();

	//Übertragung komplett
	PORTB=0;  //IR-LED abschalten
	ms_89(); // warte 89ms
	}

}

mfg pebisoft