Byte an Pin ausgeben?

[F. H. (at90s1200)]

Hallo ich möchte ein Byte an BORTB PB0 ausgeben den Takt kann ich dann 
selbst bestimmen.

ATmega644 8MHz

#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>

char Manchester_enCode(unsigned char date);


int main(void)
{
  
  DDRB = (1<<PB0);

  
    while(1)
    {
    PORTB = Manchester_enCode(PIND);
    }
}

char Manchester_enCode(unsigned char date)//OUT gehendes signal an PORT.(empfaenger z.B. PORTx = Pxx) Das ganze braucht 8mSec.
{
  char code = 0;
  char i;
  bool takt;
  
  while(1)
  {
    _delay_us(250);
    ~takt;
    
    return(1);
  }
  
  code = ~(takt ^ date);
  
  for (i = 0; i < 7; ++i)
  {
    _delay_us(500);
    
    return(code << i);   // Alle 500µSec schieben
    
  }
  
}

[Helmut L. (helmi1)]

F. H. schrieb:
> for (i = 0; i < 7; ++i)
>   {
>     _delay_us(500);
>
>     return(code << i);   // Alle 500µSec schieben
>
>   }

Die Schleife wird exakt 1 mal durchlaufen. Bei return verschwindet die 
in die aufrufende Routine.

F. H. schrieb:
> while(1)
>   {
>     _delay_us(250);
>     ~takt;
>
>     return(1);
>   }

Das gleiche hier auch.

[Rolf M. (rmagnus)]

Außerdem hat folgendes keinerlei Auswirkung:

F. H. schrieb:
> ~takt;

[Thomas E. (thomase)]

F. H. schrieb:
> Hallo ich möchte ein Byte an BORTB PB0 ausgeben den Takt kann ich dann
> selbst bestimmen.
Aber so doch nicht. Nach 250µs wird PB0 auf 1 gesetzt. Mehr macht dein 
Programm nicht. Kann man auch einfacher lösen:

int main(void)
{  
  DDRB = (1<<PB0);  
  _delay_us(250);
  PORTB = (1<<PB0);   
  while(1);
}

Um in C etwas zu programmieren, brauchst du auch Kenntnisse in C. Deine 
"return-Konstruktionen" zeigen aber, daß diese gegen Null tendieren.
So wird das nichts.

mfg.

[Helmut L. (helmi1)]

Thomas Eckmann schrieb:
> Um in C etwas zu programmieren, brauchst du auch Kenntnisse in C. Deine
> "return-Konstruktionen" zeigen aber, daß diese gegen Null tendieren.
> So wird das nichts.

Karl Heinz raet ab dann immer dazu sich ein C Buch anzuschaffen.

[F. H. (at90s1200)]

Hi
Ich habe eure Vorschläge zu herzen genommen und mal einen neuen Ansatz 
versucht, ich benutze jetzt den timerer0 für den Takt.

Das mit dem Pin klappt auch durch   DDRB = (1<<PB0);

leider komme ich so nicht weiter ich denke das ich den Ansatz das mit 
nem XOR umzusetzen nicht gelingt 
http://de.wikipedia.org/wiki/Manchester-Code#Weiteres
Zitat: "Praktisch kann die Codierung und Decodierung durch eine 
invertierte XOR-Verknüpfung des Trägers mit dem Nutzsignal erfolgen."

Ich bitte um Ratschläge und weitere Anstöße.

/*
 * sender.c
 *
 * Created: 10.01.2013 19:23:23
 *  Author: 
 */ 

#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>


char Manchester_enCode(unsigned char date);
bool takt = true;

 
/*
Der Overflow Interrupt Handler
wird aufgerufen, wenn TCNT0 von
255 auf 0 wechselt (256 Schritte),
d.h. ca. alle 2 ms
*/
#ifndef TIMER0_OVF_vect
// Für ältere WinAVR Versionen z.B. WinAVR-20071221 
#define TIMER0_OVF_vect TIMER0_OVF0_vect
#endif
 
ISR (TIMER0_OVF_vect)
{
  /* Interrupt Aktion alle
  (1000000/8)/256 Hz = 488,28125 Hz
  bzw.
  1/488,28125 s = 2,048 ms  
  */
  
  ~takt;  
  
}



int main(void)
{
  
  // Timer 0 konfigurieren
  TCCR0B = (1<<CS01); // Prescaler 8
  
  // Overflow Interrupt erlauben
  TIMSK0 |= (1<<TOIE0);
  
  // Global Interrupts aktivieren
  sei();
  
  
  DDRB = (1<<PB0);

  
    while(1)
    {
     Manchester_enCode(0x0f);
    }
}

char Manchester_enCode(unsigned char date)//OUT gehendes signal an PORT.(empfaenger z.B. PORTx = Pxx) Das ganze braucht 8mSec.
{
  char code = 0;
  char i;
  
  
  
  code = ~(takt ^ date);
  
  for (i = 0; i < 7; ++i)
  {
    _delay_us(500);
    
    PORTB = (code << i);   // Alle 500µSec schieben
    
  }
  
}

[Andreas B. (andreas_b77)]

Die Interrupt-Routine macht überhaupt nichts. Wozu überhaupt diese 
Aufteilung? Wenn die Bits mit einem bestimmten Timing ausgegeben werden 
sollen, dann gehört das Pinwackeln auch in den Timer-Interrupt.

Dann wird das niedrigwertigste Bit von date invertiert, und dieser Wert 
soll dann an die 8 Pins von Port B 7 mal nacheinander ausgegeben werden, 
jeweils um eine Stelle nach links geschoben? Das macht alles keinen 
Sinn, mit Manchester-Code hat das auch überhaupt nichts zu tun.

[Rolf M. (rmagnus)]

F. H. schrieb:
> Ich habe eure Vorschläge zu herzen genommen

Meinen aber nicht, denn das hier:

F. H. schrieb:
> ~takt;

hat immer noch keinen Effekt.

[F. H. (at90s1200)]

Hi

Ja da hast du recht, ich habs gleich mal getestet und es hat wirklich 
keine aus Wirkung.

Ich habe nun ein bisschen Rum gespielt, nun sehe ich auch was auf dem 
oszi nur sind die Rechtecke immer gleichlang und der Abstand zueinander 
ist auch immer gleich, nur die posizionen wandern es rutscht nach vorne 
und nach hinten.

/*
 * sender.c
 *
 * Created: 10.01.2013 19:23:23
 *  Author: 
 */ 

#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>


char Manchester_enCode(unsigned char date);

 
int main(void)
{
  
  DDRB = (1<<PB0);
  char i;
  
    while(1)
    {
    for (i = 0; i < 127; ++i){  }//Schleife, um zu testen, was für Unterschiede bei unterschiedlichen werten auftreten. 
      
     Manchester_enCode(i);
    }
}

char Manchester_enCode(unsigned char date)//OUT gehendes Signal an PORT.(empfaenger z.B. PORTx = Pxx) das Ganze braucht 8mSec.
{
  char code = 0;
  char i;
  
  
  
  code = ~(date ^ 0x55); //Manchester-Code Umwandlung
  
  for (i = 0; i < 7; ++i) //Schleife, um an einem Pin ein Byte aus zu geben, schieben mit der maximal Frequenz nicht mehr als 2kHz
  {
    _delay_us(500);
    
    PORTB = (code << i);   // Alle 500µSec schieben und ausgeben
    
  }
  
}

Danke !!

[Walter S. (avatar)]

F. H. schrieb:
> PORTB = (code << i);   // Alle 500µSec schieben und ausgeben

das ist Käse,
zum einen warum den ganzen Port setzen?
zum anderen wird beim erstem Mal das unterste Bite ausgegeben,
dann 7x die 0!

[F. H. (at90s1200)]

Nun wie könnte man das machen?

[Karl H. (kbuchegg)]

F. H. schrieb:
> Nun wie könnte man das machen?


SChau dir halt mal die WIkipedia dazu an.

Ein 0 Bit wird übertragen, in dem die Leitung auf 0 startet und nach der 
CLockzeit auf 1 wechselt.
Ein 1 Bit wird übertragen, in dem die Leitung auf 1 startet und nach der 
Clockzeit auf 0 wechselt.


Ist doch nicht so schwer. Das Diagramm auf Wikipedia zeigt ganz klar, 
wie Manchester-Code funktioniert.


Deine 'Takt-Geschichte', an der du dich aufgehängt hast, die ist für den 
Empfänger relevant, bzw. wenn du den Manchester Code in Hardware anhand 
eines vorgegebenen Taktsignals erzeugen müsstest.