Pwm mit 3 frequenzen

[Florian P. (chillkroedde)]

Hallöchen habe ein Problem mit dem PWM Mode des ATMega 644

Ich gehe wie folgt vor:

1. Pin low setzen
2. Pin als Ausgang definieren
3. geeignette Wellenform definieren

TCCR1A = 0x00 | (1<<COM1A1) | (1<<WGM10); // nichtinv. PWM 8 Bit (FAST)
TCCR1B = 0x00 | (1<<WGM13) | (1<<CS11); //FAST PWM Prescaler 8

soweit so gut

nun möchte ich eine trägerfrequen von 8620,7 Hz definieren. Hierfür muss 
ich das Vergleichsregister OCR1A definieren ( Ich glaube mit dem wert 
143 - bin mir allerdings nicht sicher und hoffe auf eine Antwort von 
euch)

ist es so, dass ich zwei verschiedene Pulse unter dieser Trägerfrequenz 
verwenden möchte.

Eine logische 1 = 116 us
Eine logische 0 = 232 us (also genau das doppelte)

Ist es möglich unter dieser Trägerfrequenz die ja immer präsent sein 
soll den Output so zu manipulieren, dass bei einer gelesenen 1 (aus 
einem vorgegebenen Byte) der Puls 116 us dauert und bei einer 0 doppelt 
so lang?

void sende_paket (bool nullodereins)
{
  if (nullodereins == 0)
    {
      TCCR1A = blubblubbla;
      TCCR1B = blubblubbla;
      
      OCR1A = ?;
      OCR1B = ?;
    }
  else
    {
      TCCR1A = blubblubbla;    // Hier die gleichen Einstellungen wie oben allerdings andere Vergleichsregister
      TCCR1B = blubblubbla;
      
      OCR1A = !;
      OCR1B = !;
    }
}

könnte man dies so machen?

[Michael K. (mmike)]

Hallo Florian,

Interessant zu wissen wäre noch der Prozessor Takt (extern, intern, 
frequenz). Wenn Du Timer1 im Fast PWM 8 bit Mode festlegst, dann hängt 
Deine PWM Frequenz auch von der Prozessorfrequenz ab:

Beispiel:

fCPU = 16 MHz

fPWM = 16MHz / (Prescaler * 256) (in Deinem Fall läuft Dein Timer noch 
nicht da kein Prescaler eingestellt wurde, siehe Datenblatt Tabelle 
14-6)

um Deine Frequenz von 8620,7 Hz zu erzeugen würde ich Dir den Timer Mode 
14 (Fast PWM) empfehlen. Damit kannst Du dann die PWM Frequenz mittels 
ICR1 bestimmen. Beispiel:

fCPU = 16MHz
Prescaler = 1;
fPWM (wanted) = 8620,7 Hz = fCPU / (Prescaler * ICR1)
=> ICR1 = fCPU / (Prescaler * 8620,7) = 1855,99777 also 1856.

Jetzt brauchts noch Deine Pulslängen 116µs und 232µs:

Die minimale Auflösung von Deinem Timer mit oben genannten 
Rahmenbedingungen (Takt, Prescaler) ist:

deltaTimer = Prescaler / fCPU = 62,5ns

Damit bekommst Du die Werte für OCR1A bzw. OCR1B mit

116µs / deltaTimer = 1856
232µs / deltaTimer = 3712

Jetzt nur noch den Timer anständig initialisieren und schon gehts ....

Alles roger ?

Grüße,

Michael

[Florian P. (chillkroedde)]

int traeger_counter (void)            // Trägerfrequenztimer
{
  
  TCCR1A = (1<<WGM11)  | (1<<COM1A1);    // modus 14, fast pwm frequenz variabel einzustellen
  TCCR1B = (1<<WGM13)            // TOV1 Flag wird beim TOP gesetzt
       | (1<<WGM12)            // TOP = ICR1
       | (1<<CS10);            // Clock selection bits: Prescaler 1 (Systemtakt)
  ICR1 = 2320;              // Berechnung: F_CPU / (Prescaler * 8620,7)
}

also wäre das die init für die trägerfrequenz ja?

bei einem Systemtakt von 20 MHz mit dem Atmega 644

[Michael K. (mmike)]

sieht gut aus.

[Florian P. (chillkroedde)]

// verwendet wird der ATMega 644

#include <avr/io.h>
#include <avr/iom644.h>
#include <inttypes.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>           // variablen in den Speicher legen


#define F_CPU 20000000UL

unsigned int dcc_preamble = 0x3FF;      // Preamble
unsigned char dcc_adresse = 0x0A;      // Lockadresse 10 stellt den ICE im Versuch dar
unsigned char dcc_data = 0x74;        // vorwärts mit der Fahrstufe 5
unsigned char dcc_xor = 0x7E;        // Vorberechnete Prüfsumme der oben genannten Einstellung
        
/*Ports*/

void sendeEins (void)            // Eine Eins hat die länge von einem Wartezyklus, also 116 us
{                // PWM Ausgang OC1A
  TCCR1A |= (1<<COM1A1);
  OCR1A = 2320;
}

void sendeNull (void)            // Eine Null hat die doppelte länge eine Eins, also 232 us
{                // PWM Ausgang OC1A
  TCCR1A |= (1<<COM1A1);
  OCR1A = 4640;
}

/* Paket senden */

void sendePaket (void)
{
  uint8_t bit = 0;            // Hilfsvariablen
  uint8_t data = 0;
  uint8_t bitzaehler = 0;
  
  data = dcc_preamble;
  for (bitzaehler = 1; bitzaehler <11; bitzaehler++)
  {
    bit = ((data & 0x80) >> 9);
    if (bit == 0)
    {
    sendeNull();
    }  else
      {
        sendeEins();
      }
        data <<= 1;
  }


  sendeNull();              // das Nullbit als Statbit für das Adressbyte senden
  
  data = dcc_adresse;            // Lokadresse des ICE
  for (bitzaehler = 1; bitzaehler < 9; bitzaehler++) 
  {
    bit = ((data & 0x80) >> 7);
    if (bit == 0) 
    {
    sendeNull();
    }   else 
      {
        sendeEins();
      }
        data <<= 1;
  }
  
  sendeNull();              // das Nullbit als Startbit für das Datenbyte senden
  
  data = dcc_data;            // Fahrtrichtung sowie Geschwindigkeit des Zuges
  for (bitzaehler = 1; bitzaehler < 9; bitzaehler++)
  {
    bit = ((data & 0x80) >> 7);
    if (bit == 0)
    {
    sendeNull();
    }  
      else
      {
        sendeEins();
      }
        data <<= 1;
  }
  
  sendeNull();              // das Nullbit als Startbit für die XOR Prüfsumme senden
  
  data = dcc_xor;              // Prüfsumme des Vordefinierten ICE Zuges
  for (bitzaehler = 1; bitzaehler < 9; bitzaehler++)
  {
    bit = ((data & 0x80) >> 7);
    if (bit == 0)
    {
    sendeNull();
    }
      else
      {
        sendeEins();
      }
        data <<= 1;
  }
  
  sendeEins();
}




/* Timer1 für die DCC-Trägerfrequenz von 8620,7 Hz im FAST PWM 8 Bit Modus.
 in dieser Trägerfrequenz ernthalten sind die einzelnen Perioden für eine Null oder eine Eins
*/

int timer1_interrupt_init()          // Trägerfrequenztimer
{
  DDRD |= (1<<PD5);
  ICR1 = 2320;            // Berechnung: F_CPU / (Prescaler * 8620,7)
  TCCR1A = (1<<WGM11);          // modus 14, fast pwm frequenz variabel einzustellen
  TCCR1B = (1<<WGM13)          // TOV1 Flag wird beim TOP gesetzt
       | (1<<WGM12)          // TOP = ICR1
       | (1<<CS10);          // Clock selection bits: Prescaler 1 (Systemtakt)
  TIMSK1 = (1<<OCIE1A);           // aktiviert CTC interrupt 
  sei();
}

//Hier startet das Hauptprogramm

void main (void)
{
  timer1_interrupt_init();
  sendePaket();
}

Erst einmal vielen vielen Dank Michael, den Timer1 im PWM hab ich 
verstanden, nun hapert es wohl nur noch an der Umsetzung.

Ich hatte mir das jetz so gedacht. Aber irgendwie tut das Programm nicht 
was es soll. Die Vordefinierten Daten sollen behandelt werden und je 
nachdem ob es sich um eine Null oder eine Eins handelt soll der PWM 
Ausgang  eine Pulsweite von 116 us bzw. 232 us haben.

Wäre furchtbar lieb, wenn man mir da ein-zwei Schläge auf den Hinterkopf 
geben könnte.

[Florian P. (chillkroedde)]

weil wenn ich mir auf ein blatt Papier mein Sägezahn Pwm aufzeichne mit 
dem TOPwert von 2320 (ICR1) und dieses genau das Signal ist welches 116 
us anliegen würde, wäre nur noch die doppelte zeit von interesse. Wenn 
ich aber OCR1A mit 4640 belege, hab ich einen größeren wert als Top und 
dies darf doch nicht sein oder?

Daher wäre es für mich von der Logik her nun so, dass ich den Timer 
weiter so initialisiere. ICR1 und OCR1A identisch sind für eine 1 (also 
2320) und für eine 0 das Signal einfach doppelt so lange anliegen soll. 
Nun stellt sich blos die frage ob das so ohne weiteres umsetzbar ist.

[Michael K. (mmike)]

Florian Pramme wrote:
> weil wenn ich mir auf ein blatt Papier mein Sägezahn Pwm aufzeichne mit
> dem TOPwert von 2320 (ICR1) und dieses genau das Signal ist welches 116
> us anliegen würde, wäre nur noch die doppelte zeit von interesse.

die 2320 definieren ja Deine PWM Frequenz. Damit lädst Du ja ICR1. 
Soweit so gut.

> Wenn
> ich aber OCR1A mit 4640 belege, hab ich einen größeren wert als Top und
> dies darf doch nicht sein oder?

Richtig.

> Daher wäre es für mich von der Logik her nun so, dass ich den Timer
> weiter so initialisiere. ICR1 und OCR1A identisch sind für eine 1 (also
> 2320) und für eine 0 das Signal einfach doppelt so lange anliegen soll.
> Nun stellt sich blos die frage ob das so ohne weiteres umsetzbar ist.

Nicht ganz. Der Timer wird einmalig initialisiert und dann nur noch der 
Wert für Dein Compare Register angepasst. In Deinem Fall OCR1A.
Zudem fehlt eine Endlosschleife in Deinem Programm !!!!
Zudem entsprechen 8620,7Hz = 116µ. Damit gehen die 232µ schon gar nicht 
mehr! Die Pulsweiten hast Du ja genannt, aber die Frequenz passt nicht 
dazu. Mal doch vllt. mal auf was genau für ein Signal Du erzeugen willst 
!

In dem Beispiel brauchst Du noch nicht einmal Interrupts, da die PWM 
Generierung ja in Hardware funktioniert. Ausser Du willst es mit 
Soft-PWM machen. Geht natürlich auch ....

Hier ist ein möglicher Aufbau für Deine PWM Geschicht, wo noch die 
eigentliche PWM Frequenz (XXXX) festgelegt werden muss:

// Hier die header einbinden

// Hier die glob. Variablen deklarieren.

void InitTimer1 ()
{
  TCCR1A = (1 << WGM11) | (1 << COM1A1);
  TCCR1B = (1 << WGM13) | (1 << WGM12)  | (1 << CS10);
  ICR1 = XXXX;
}


int main ()
{
  DDRD |= (1<<PD5);        // Hardware PWM Pin als Ausgang definieren

  InitTimer1 ();           // Timer initialisieren

  for (;;)                 // Endlosschleife
  {
    if (IrgendeineVariable == 0)
      OCR1A = 2320;
    else
      OCR1B = 4640;
  }

  return 0;
}

Grüsse,

Michael

[Michael K. (mmike)]

Noch was ...

Du schaltest den Interrupt mittels TIMSK für den Compare Match A ein:

TIMSK1 = (1<<OCIE1A);           // aktiviert CTC interrupt

und danach enable'st du die globalen Interrupts mit:

sei ();

es gibt jedoch keine ISR (Interrupt Service Routine) für den Interrupt ! 
Somit macht Dein Controller einen Reset.

Grüße,
Michael

[Florian P. (chillkroedde)]

solch ein Signal würde ich gern erzeugen.

[Michael K. (mmike)]

ahhhh jetzt haben wirs !

also folgendes:

1: PWM Frequenz 8620,7 (116µs)
0: PWM Frequenz 4310,35 (232µs)
Bei beiden Frequenzen ist das PWM Tastverhältnis 50%

Wir wissen ja schon, dass wir die Frequenz mit dem ICR1 Register 
einstellen und das Tastverhältnis mit OCR1A das wir einfach auf ICR1 / 2 
setzen.

Jetzt brauchen wir aber den OVF Interrupt, da wir die Einstellungen für 
das nächste zu sendende Bit in der ISR einstellen müssen.

// Hier die header einbinden

// Hier die glob. Variablen deklarieren.

// Interrupt service routine
ISR (TIMER1_OVF_vect)
{
  if (NextBit == 0)
  {
    ICR1  = 4640;
    OCR1A = 2320;
  }
  else
  {
    ICR1  = 2320;
    OCR1A = 1160;
  }
}

void InitTimer1 ()
{
  // Erzeuge am Anfang 0'en
  ICR1   = 4640;
  OCR1A  = 2320;
  // Init Timer 1, Mode 14 Fast PWM, Hardware PWM OC1A enabled (clear on compare)
  TCCR1A = (1 << WGM11) | (1 << COM1A1);
  TCCR1B = (1 << WGM13) | (1 << WGM12)  | (1 << CS10);
  // Enable overflow interrupt
  TIMSK |= (1 << TOIE1);                               
}


int main ()
{
  DDRD |= (1<<PD5);        // Hardware PWM Pin als Ausgang definieren

  InitTimer1 ();           // Timer initialisieren

  sei ();                  // Interrupts einschalten

  set_sleep_mode (SLEEP_MODE_IDLE); // Sleep mode um Strom zu sparen

  for (;;)                 // Endlosschleife
  {
    sleep_mode ();
  }

  return 0;
}

so könnts gehen. Hast Du nen Oszi um zu schauen, was hinten auch 
rauskommt ? Wenn ja mach am Anfang ein paar Tests mit nur 0en senden und 
dann nur 1en und dann z.B. abwechselnd 0 1 0 1 ... wenn das funzt, dann 
schieb Deine Daten mal raus ...

Grüße,

Michael

[Florian P. (chillkroedde)]

> 1: PWM Frequenz 8620,7 (116µs)
> 0: PWM Frequenz 4310,35 (232µs)
> Bei beiden Frequenzen ist das PWM Tastverhältnis 50%
 Ja das klingt gut hab ich hier auch ausgerechnet

>
> Jetzt brauchen wir aber den OVF Interrupt, da wir die Einstellungen für
> das nächste zu sendende Bit in der ISR einstellen müssen.
Ok hab ich mir angesehen.

Also denkst du dir das etwa so?

/* Includes
###########
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdbool.h>
#include <stdlib.h>

/* Defines
##########
*/
#define F_CPU 20000000UL


//volatile uint16_t dcc_preamble = 0b1111111111;
//volatile uint8_t dcc_adresse = 0b00001010;
//volatile uint8_t dcc_data = 0b01110100;
//volatile uint8_t dcc_xor = 0b01111110;

volatile uint8_t nullen = 0;
uint8_t NextBit = 0;
uint8_t data = 0;
uint8_t bitzaehler = 0;


/* Interrupt Service Routine
############################
*/
ISR (TIMER1_OVF_vect)
{
  if (NextBit == 0)
  {
    ICR1  = 4640;
    OCR1A = 2320;
  }
  else
  {
    ICR1  = 2320;
    OCR1A = 1160;
  }
}

/* Timer initialisierung für die Trägerfrequenz von 8620,7 Hz im Fast PWM modus
###############################################################################
*/
void InitTimer1 ()
{
  ICR1  = 4640;
  OCR1A = 2320;
  // Init Timer 1, Mode 14 Fast PWM, Hardware PWM OC1A ein (clear on compare)
  TCCR1A = (1<<WGM11) | (1<<COM1A1);
  TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS10);

  ICR1 = 2320;
  TIMSK1 = (1<<TOIE1);
}


/* Mainfunktion
###############
*/

int main ()
{
  DDRD |= (1<<PD5);  // Hardware PWM Pin als Ausgang definieren

  InitTimer1 ();    // Timer initialisieren

  sei();        // Interrupts einschalten

//  set_sleep_mode (SLEEP_MODE_IDLE);  // Sleep Mode um strom zu Sparen
  data = nullen;
  for (bitzaehler = 1; bitzaehler <9; bitzaehler++)      // Endlosschliefe
  {
//  sleep_mode ();
  NextBit = (data >> 7);
  }

  return 0;
}

[Michael K. (mmike)]

Noch ein paar Anmerkungen zum Code:

* Variablen die in einer ISR verwendet werden müssen als volatile 
deklariert werden (in Deinem Fall NextBit).

> for (bitzaehler = 1; bitzaehler <9; bitzaehler++)      // Endlosschliefe

In C werden gängigerweisse die Schleifen bei 8 gestartet

also:

for (bitzaehler = 0; bitzaehler < 8; bitzaehler++)

Zudem fehlt Deine Endlosschleife !

Dein Programm läuft an. Der Timer wird initialisiert dann rattert es 
durch die for Schleife und danach steht das Programm. Ich bezeifle, dass 
so überhaupt je  ein Interrupt ausgelöst wird ! Warum nimmst Du nicht 
das Framework von mir ?

[Florian P. (chillkroedde)]

Getting isp parameter.. SD=0x0a .. OK

bekomm ich von meinem STK 500 gesagt wenn ich das programm flashe.

Hab einen Logicanalyser an PD5 angeschlossen (da soll das Signal ja 
schließlich hin)

// Hier die header einbinden
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
// Hier die glob. Variablen deklarieren.

volatile uint8_t NextBit = 0;

// Interrupt service routine
ISR (TIMER1_OVF_vect)
{
  if (NextBit == 0)
  {
    ICR1  = 4640;
    OCR1A = 2320;
  }
  else
  {
    ICR1  = 2320;
    OCR1A = 1160;
  }
}

void InitTimer1 ()
{
  // Erzeuge am Anfang 0'en
  ICR1   = 4640;
  OCR1A  = 2320;
  // Init Timer 1, Mode 14 Fast PWM, Hardware PWM OC1A enabled (clear on compare)
  TCCR1A = (1 << WGM11) | (1 << COM1A1);
  TCCR1B = (1 << WGM13) | (1 << WGM12)  | (1 << CS10);
  // Enable overflow interrupt
  TIMSK1 |= (1 << TOIE1);                               
}


int main ()
{
  DDRD |= (1<<PD5);        // Hardware PWM Pin als Ausgang definieren

  InitTimer1 ();           // Timer initialisieren

  sei ();                  // Interrupts einschalten

  set_sleep_mode (SLEEP_MODE_IDLE); // Sleep mode um Strom zu sparen

  for (;;)                 // Endlosschleife
  {
    sleep_mode ();
  }

  return 0;
}

Im Simulator läuft es, soweit (sendet nullen)

[Michael K. (mmike)]

sehr fein ! Wobei Simulator mit Vorsicht zu genießen ist. Der hat noch 
ein paar Bugs, insbesondere bei den Timern ....

Wennst nen STK hast kannst ja auch verschiedene Datensätze auf 
Knopfdruck absenden....

[Florian P. (chillkroedde)]

Michael K. wrote:
> sehr fein ! Wobei Simulator mit Vorsicht zu genießen ist. Der hat noch
> ein paar Bugs, insbesondere bei den Timern ....
Das ist wohl wahr aber die Werte sind im Simulator schon sehr schick, 
0,05 us mehr als der Buchwert hergibt.

Nun will ich mir den Spaß halt noch gern über den Logicanalyser ansehen 
da kann man schauen ob die werte sich im rahmen befinden oder ob man 
ggf. anpassen muss.

Bis hierhin aber vielen vielen Dank.

> Wennst nen STK hast kannst ja auch verschiedene Datensätze auf
> Knopfdruck absenden....

So ist es geplant ;) Mit 8 verschiedenen Datensätzen kann man schon ne 
Menge anstellen.

[Michael K. (mmike)]

> Das ist wohl wahr aber die Werte sind im Simulator schon sehr schick,
> 0,05 us mehr als der Buchwert hergibt.

Passt.

> Nun will ich mir den Spaß halt noch gern über den Logicanalyser ansehen
> da kann man schauen ob die werte sich im rahmen befinden oder ob man
> ggf. anpassen muss.

Kannst ja mal nen Screener posten.

> Bis hierhin aber vielen vielen Dank.

Gerne.

> So ist es geplant ;) Mit 8 verschiedenen Datensätzen kann man schon ne
> Menge anstellen.

Oder über RS232 beliebig viele ...

Grüße und viel Erfolg,

Michael

[Florian P. (chillkroedde)]

einfach nur 0en senden funktioniert prima haargenaues Signal auf dem 
Logic Analyzer.

Das selbe gilt für 1sen. Beim wechsel von beiden brauch er allerdings 
tierisch lang. ca 100 us länger als gesollt um genau zu gehen.

[Florian P. (chillkroedde)]

wobei man erkennen kann das eine eins immer ziemlich sauber dargesellt 
wird. aber die Null davor, bzw. danach halt viel  zu lange ist. Die nach 
den angrenzenden Nullen folgenden Nullen sind dann wieder sauber. Somit 
muss es damit zu tun haben, dass beim Wechsel von Null auf Eins und 
umgekehrt ein fehler ist, bzw. zu viel Zeit vergeht.

Oder liegt es daran, das die Register noch nicht völlig geladen sind?

das signal welches eigentlich nicht in die Folge gehört ist je nachdem 
zwischen 290 us und 348 us. Letzere Zahl ergibt sich unter anderem wenn 
man die 116 us der 1 und die 232 us der 0 zusammenzieht.

Danke im Voraus
Florian

[Florian P. (chillkroedde)]

bekomme ein solches Signal wenn ich 1 Byte einsen sende und dann eine 0. 
Nach der Null folgen wieder einsen. (Endlosschleife)

gestrichelt ist angezeigt, wie der ideale verlauf sein sollte.

[Michael K. (mmike)]

Poste mal Deinen kompletten Code, dann laß ich's auf meinem STK mal 
laufen .... geht leider erst am WE ... bin im Urlaub ;-) ....

Grüße,
Michael

[Falk B. (falk)]

@ Florian Pramme (chillkroedde)

>Dateianhang: Unbenannt-1.png (1,9 MB, 5 Downloads)

Applause *Applause* Applause *Applause* Applause

Du hast den Titel "IT-Depp den Monats" gewonnen.

Als Preis winkt die in Leder gebundene Ausgabe des Sonderhefts

Bildformate !!!

MFG
IT-Supervisor

[Plömpel (Gast)]

Juhu, der Bilderpapst war wieder da !
Woher wusste ich das, als ich die 1,9 MB sah ....

[Falk B. (falk)]

@Plömpel (Gast)

>Juhu, der Bilderpapst war wieder da !

Richtig. Du darfs mich mit "Eure Eminenz" ansprechen ;-)

MfG
Fa - wir sind Papst - lk

[Florian P. (chillkroedde)]

>>Dateianhang: Unbenannt-1.png (1,9 MB, 5 Downloads)
>
> Applause *Applause* Applause *Applause* *Applause*
>
> Du hast den Titel "IT-Depp den Monats" gewonnen.
>
> Als Preis winkt die in Leder gebundene Ausgabe des Sonderhefts
>
> Bildformate !!!

Herzlichen Dank aber dir scheint etwas entgangen zu sein. Technische 
Zeichnungen sollen in PNG gespeichert werden. Und du willst meine 
Handschrift samt dem edlen Timingdiagramm doch wohl nicht abstreiten 
eine Technische Zeichnung zu sein, oder?

Aber um deinen Pädagogischen Eingriff zu huldigen - ich werde in Zukunft 
jpg verwenden.

Lieben Gruß
Florian

[Falk B. (falk)]

@ Florian Pramme (chillkroedde)

>Herzlichen Dank aber dir scheint etwas entgangen zu sein. Technische
>Zeichnungen sollen in PNG gespeichert werden.

Und dir scheint entgangen zu sein, dass es sich dabei um einen SCAN oder 
Photo handelt.

> Und du willst meine
>Handschrift samt dem edlen Timingdiagramm doch wohl nicht abstreiten
>eine Technische Zeichnung zu sein, oder?

Technische Zeichung = Computergeneriert.

Ausnahmen bestätigen die Regel, z.B. eine gescannte technische 
Zeichnung, welche vorher gedruckt wurde.
Oder ne alte Tuschezeichung ;-)

>Aber um deinen Pädagogischen Eingriff zu huldigen - ich werde in Zukunft
>jpg verwenden.

Schau mal in den Anhang. Und vergleiche.

MFG
Falk

[Wolfgang K. (opendcc)]

>Das selbe gilt für 1sen. Beim wechsel von beiden brauch er
>allerdings tierisch lang. ca 100 us länger als gesollt um genau zu gehen.

Hallo Florian,

durchaus amüsant, die gleichen Fallen lauern überall. Weiter oben hat 
schon mal jemand den Rat gegeben, OpenDCC anzusehen. Die Lösung nähert 
sich langsam der Implenmentierung dort; ein Falle ist noch bei double 
buffering der Timer OCR versteckt.

mfg Wolfgang K, www.opendcc.de