www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Hilfe, PWM-Messung - klappt nicht mehr als einmal (Interrupts falsch?)


Autor: Veit H. (veith)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So Profis, ich benutze einen Atmega8 um ein 1khz PWM-Signal zu 
generieren und gleichzeitig ein anderes 1khz-Signal auszuwerten. Der 
Atmega läuft mit einem 8MHz-Oszillator, mit Prescaler 8 und im 
Phase-and-Frequency-Correct-Mode läuft der 16-Bit-Timer von 0 bis 500 
und zurück, also komme ich mit 1000 125us Schritten genau auf 1kHz und 
kann meine PWM schön einstellen. Das klappt so weit alles prima.

Jetzt wollte ich die Auflösung desselben Timers nutzen, um das 
Tastverhältnis eines 1kHz-Signals auszuwerten. Habe das Signal dazu an 
den Pin ICP1 des Atmega8 angeschlossen und kann die Flankenwechsel per 
Interrupt auswerten.

Nun ist es ja so, dass ich, um die Dauer zwischen der steigenden und 
fallenden Flanke zu bestimmen, wissen muss, ob der Counter gerade hoch 
oder runter zählt und ob die beiden Flankenwechsel in derselben 
Counterperiode (also 2*500=1000 Schritte) oder in zwei aufeinander 
folgenden Counterperioden stattgefunden haben.

Also habe ich zwei Interrupts bei Timer-Top und Timer-Bottom aktiviert, 
bei der ich eine Hilfsvariable setze, die mir anzeigt ob der Timer hoch 
oder runter zählt. Zusätzlich wird der Periodenzähler um eins erhöht, 
wenn der Counter wieder bei 0 beginnt:
volatile uint8_t isUpcounting;
volatile uint16_t pwm_period_counter;

/* Timer on Bottom */
ISR(TIMER1_OVF_vect)
{
  isUpcounting = 1;
  pwm_period_counter++;
}

/* Timer on top */
ISR(TIMER1_COMPA_vect)
{
  isUpcounting = 0;
}
(das ist irgendwie von hinten ins Knie geschossen mit diesen beiden 
Interrupts, bin für jeden Vereinfachungsvorschlag dankbar)

In der PWM-Messroutine wird der Interrupt auf steigende Flanke 
eingestellt, frei gegeben und auf Deaktivierung des Interrupts 
(geschieht in der Interrupt-Routine) gewartet.
Die zugehörige Interrupt-Routine speichert bei Aufruf den Timer-Wert, 
setzt den Periodenzähler auf 0 und stellt den Interrupt auf fallende 
Flanke. Beim nächsten Aufruf dieser Interrupt-Routine wird also der 
Timer-Wert der fallenden Flanke und die Anzahl der möglicherweise 
vergangenen Perioden gespeichert.
Anschließend wird der Interrup deaktiviert, damit nur eine Messung 
stattfindet.
Mit diesen Werten kann ich in der PWM-Messroutine prima die High- und 
Low-Dauer des Signals ausrechnen. Das klappt wunderbar - einmal. Wenn 
ich die Funktion mehrmals oder gar regelmäßig aufrufe, bekomme ich total 
unterschiedliche Werte. Ich vermute, das liegt an den Interrupts, dass 
ich irgendwas nicht beachtet habe. Jede Hilfe wäre hier echt toll, ich 
kann den Fehler alleine nicht finden.

Dieser Aufruf klappt (einmal halt)
uint8_t measurePWM = 1;

/*-- Main Routine --*/
while(1)
{
    if (measurePWM)
    {
      timediff = pwm_messen();
      measurePWM = 0;
    }
    // verschicke timediff-Wert per I2C
}


Dieser Aufruf klappt nicht
uint8_t measurePWM = 1;

/*-- Main Routine --*/
while(1)
{
      timediff = pwm_messen();
      // verschicke timediff-Wert per I2C
}

Dabei habe ich schon mit verschiedenen Delays gearbeitet, um 
möglicherweise unvollständigen Rechnungen und dem I2C-Bus genügend Zeit 
zu geben, alles vergebens :-(

Mein pwm_messen() sieht so aus (die PWM kommt durch einen Transistor 
invertiert am Atmega an, deshalb sind start und stopp vertauscht)
volatile uint16_t pwm_temp;
volatile uint16_t pwm_start;
volatile uint16_t pwm_stop;
volatile uint16_t numberPeriod;

uint16_t pwm_messen()
{
  uint16_t result = 0;
  
  /* Initialize Variables */
  pwm_temp = 0;
  pwm_start = 0;
  pwm_stop = 0;
  numberPeriod = 0;

  /* Trigger Interrupt on rising edge */
  TCCR1B |= (1 << ICES1);

  /* Enable Interrupt on ICP1 */
  TIMSK |= (1 << TICIE1);

  /* Wait for end of measure (disabled ICP-Interrupt) */
  while (TIMSK & (1 << TICIE1))
  {
    ;
  }

  /* Perhaps disable Interrupt once again? */
  TIMSK &= ~(1 << TICIE1);

  /* Calculate Timedifference */
  result = pwm_start + numberPeriod * 1000 - pwm_stop;

  return result;
}

Und meine Interrupt-Routine zum Messen so:
/* Interrupt routine to measure PWM */
ISR(TIMER1_CAPT_vect)
{
  /* capture PWM value */
  pwm_temp = ICR1;

  /* rising edge (inverted, means stop) */
  if (TCCR1B & (1 << ICES1))
  {
    /* Trigger Interrupt next time on falling edge */
    TCCR1B &= ~(1 << ICES1);

    /* Reset Period counter */
    pwm_period_counter = 0;

    /* Get Timer-Value in Dependence of up- or downcounting */
    if (isUpcounting)
    {
      pwm_stop = pwm_temp;
    }
    else
    {
      pwm_stop = 500 + (500 - pwm_temp);
    }
  }
  /* falling edge (inverted, means start) */
  else
  {
    /* Disable Interrupts on IPC1 */
    TIMSK &= ~(1 << TICIE1);

    /* Get Timer-Value in Dependence of up- or downcounting */
    if (isUpcounting)
    {
      pwm_start = pwm_temp;
    }
    else
    {
      pwm_start = 500 + (500 - pwm_temp);
    }

    /* Save value of period-counter */
    numberPeriod = pwm_period_counter;
  }
}

Liegt es daran, dass aus einer Interrupt-Routine keine Änderungen in den 
Konfigurationsregistern wie TIMSK vorgenommen werden können, da die nach 
der Routine wieder auf den vorherigen Stand gebracht werden?
Ich bin im Moment echt ratlos, woran es liegen könnte, dass nur bei 
einmaligem Aufruf der Wert korrekt ist.

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

>In der PWM-Messroutine wird der Interrupt auf steigende Flanke
>eingestellt, frei gegeben und auf Deaktivierung des Interrupts
>(geschieht in der Interrupt-Routine) gewartet.

Geht nicht. ICES1 stellt nur ein, ob der Timer-Wert bei einer steigenden 
ober fallenden Flanke übernommen wird. Der Interrupt wird in beiden 
Fällen ausgelöst.

MfG Spess

Autor: Veit H. (veith)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja okay. Dafür überprüfe ich ja in der Interrupt-Routine, ob der 
Auslöser von einer steigenden oder einer fallenden Flanke kommt.

In der Mess-Routine gebe ich den ICP1-Interrupt erst frei, nachdem ich 
ihn auf steigende Flanke eingestellt habe.

Hhmm, dann kann natürlich die fallende Flanke auch einen Interrupt 
auslösen und die Routine einen völlig falschen (ungültigen) Wert aus dem 
ICR-Register kopieren. Könnte erklären, weshalb ich manchmal genau den 
Abstand 1000 bekomme. Puh, ich bekomme mein Gehirn heute nicht mehr auf 
Trab und beschäftige mich morgen nochmal damit. Danke!

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

Entschuldige. Die Aussage zu Interrupt von mir war falsch. Ich habe das 
jetzt noch mal am realen AVR getestet. Der Interrupt wird nur an der mit 
ICES1 eingestellten Flanke ausgelöst.

MfG Spess

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Veit H. schrieb:
> So Profis, ich benutze einen Atmega8 um ein 1khz PWM-Signal zu
> generieren und gleichzeitig ein anderes 1khz-Signal auszuwerten. Der
> Atmega läuft mit einem 8MHz-Oszillator, mit Prescaler 8 und im
> Phase-and-Frequency-Correct-Mode läuft

Warum?
Wie willst Du mit nem Vor-/Rückwärtszähler vernünftige ICP-Werte 
erhalten?

Wenn ich PWM und ICP benötige, nehme ich immer Mode 15, das geht 
einwandfrei.


Peter

Autor: Veit H. (veith)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Warum?
> Wie willst Du mit nem Vor-/Rückwärtszähler vernünftige ICP-Werte
> erhalten?
>
> Wenn ich PWM und ICP benötige, nehme ich immer Mode 15, das geht
> einwandfrei.

Ja, weil der 16Bit-Timer ja gleichzeitig ein 1kHz-Signal im 
Phase-and-Frequency-Correct-Mode generiert. Deswegen will ich den Timer 
ja gleichzeitig auch zum Messen nutzen.
Mit den anderen zwei 8Bit-Timern bekomme ich ja nicht so eine genaue 
Auflösung auf 125us (Umlaufzeit bei 1kHz = 1ms, kleinste PWM-Auflösung 
5% up von 1ms) hin.
Deswegen gehe ich ja den Umweg, festzustellen ob der Timer hoch oder 
runter zählt.

Gruß,
Veit

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Veit H. schrieb:
> Deswegen gehe ich ja den Umweg, festzustellen ob der Timer hoch oder
> runter zählt.

Nochmal warum?
Hast Du Dir Mode 15 überhaupt mal angeschaut?

In Mode 15 mußt Du natürlich Ausgang OC1B als PWM nehmen.


Peter

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Beim durchlesen ist mir jetzt nichts grossartiges in deinem Programm 
aufgefallen.
Aber die Frage muss schon sein: Warum ist es so wichtig, dass deine PWM 
Frequenz genau 1kHz ist. Bei einer PWM steckt ja die Information nicht 
in der Frequenz sondern in der Pulslänge. Normalerweise ist es daher 
ziemlich unkritisch, wenn die PWM Frequenz höher liegt (Kann natürlich 
auch sein, dass am anderen Ende der Leitung ein Gerät steckt, welches 
auf die 1kHz angewiesen ist, genau darum frage ich)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
  /* Calculate Timedifference */
  result = pwm_start + numberPeriod * 1000 - pwm_stop;

Ich denke auch, dass diese Berechnung nicht stimmt.
Mal mit ein paar Zahlen.
Angenommen der Startpuls kommt beim DownCounting und einem Wert von 100. 
Timer zählt weiter, dreht seine Richtung um und zählt wieder aufwärts. 
Der Stoppuls kommt bei 50.

Laut deiner Rechnung macht das ein result von 50  ( 100 + 0 * 1000 - 50 
).
Tatsächlich sind aber 150 Ticks vergangen (100 im Down, 50 im Up)


Mal dir einfach mal eine Linie auf, die den Zählumfang deines Zählers 
symbolisiert. Und dann spiel alle möglichen Kombinationen durch, die für 
das Auftreten des Start und Stop Pulses möglich sind. Interessant sind 
dabei weniger die Fälle, wenn Start und Stop Puls beim selben 
Timer-Sweep (also beide auf Up, oder beide auf Down) liegen, sondern die 
Fälle, in denen der Timer zwischendurch seine Richtung ändert.

Edit: Ich habe jetzt noch nicht eingerechnet, was du im Capture 
Interrupt mit den Start und Stop Werten gemacht hast. Aber das scheint 
auch nicht das Gewünschte zu leisten.

    pwm_start = 500 + (500 - pwm_temp);

Das heist im Downcounting, bei einem Timerstand von 100, registrierst du 
einen Start Wert von  500 + ( 500 - 100 ) = 900
pwm_stop ergibt sich im Beispiel zu 50

    pwm_start + numberPeriod * 1000 - pwm_stop;

   900 + 0 * 1000 - 50 = 850

Immer noch falsch. Da müsste 150 rauskommen.

Autor: Veit H. (veith)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
>
>   /* Calculate Timedifference */
>   result = pwm_start + numberPeriod * 1000 - pwm_stop;
> 
>
> Ich denke auch, dass diese Berechnung nicht stimmt.
> Mal mit ein paar Zahlen.
> Angenommen der Startpuls kommt beim DownCounting und einem Wert von 100.
> Timer zählt weiter, dreht seine Richtung um und zählt wieder aufwärts.
> Der Stoppuls kommt bei 50.
>
> Laut deiner Rechnung macht das ein result von 50  ( 100 + 0 * 1000 - 50
> ).
> Tatsächlich sind aber 150 Ticks vergangen (100 im Down, 50 im Up)

Hallo Karl Heinz, danke dass du dir die Mühe gemacht und mein Programm 
angeschaut hast. Ich gebe zu, es ist mit dem invertierten Start/Stopp 
sehr verwirrend. Die Sache ist, dass ein Transistor vor der Schaltung 
die einkommende PWM invertiert. In pwm_messen() wird ja zuerst auf eine 
steigende Flanke getriggert, pwm_stop kommt also vor pwm_start (hat also 
den kleineren Wert).

Also, um bei deinen Zahlenbeispiel zu bleiben, Start und Stopp kurz 
umgedreht: der Stopp-Puls (steigende Flanke) kommt beim Downcounting 
beim Timer-Wert 100. Der Timer-Wert steht in pwm_temp. Dann wird mit
/* Reset Period counter */
    pwm_period_counter = 0;
 der Periodencounter auf Null gesetzt und mit
if (isUpcounting)
    {
      pwm_stopp = pwm_temp;
    }
    else
    {
      pwm_stopp = 500 + (500 - pwm_temp);
    }
wird pwm_stopp = 500 + 500 - 100 = 900.

Der Timer dreht (startet wieder bei 0).
Der Interrupt zu
/* Timer on Bottom */
ISR(TIMER1_OVF_vect)
{
  isUpcounting = 1;
  pwm_period_counter++;
}
erhöht den Periodenzähler nun auf 1.

Der Start-Puls (steigende Flanke) kommt nun bei 50.
Mit
/* Get Timer-Value in Dependence of up- or downcounting */
    if (isUpcounting)
    {
      pwm_start = pwm_temp;
    }
    else
    {
      pwm_start = 500 + (500 - pwm_temp);
    }

    /* Save value of period-counter */
    numberPeriod = pwm_period_counter;
wird pwm_start = 50 und numberPeriod = 1;

In pwm_messen() wird mit
/* Calculate Timedifference */
  result = pwm_start + numberPeriod * 1000 - pwm_stop;
das result auf 50 + 1 * 1000 - 900 = 150 Ticks gerechnet.


Müsste doch stimmen oder?

Meine Vermutung, weshalb das nur beim einmaligen Durchlauf klappt ist, 
dass in pwm_messen() der TICIE1-Interrupt aktiviert und anschließend 
gewartet wird, bis dieser Interrupt aus seiner Routine heraus 
deaktiviert wird. Habe ich da einen Denkfehler?
  /* Trigger Interrupt on rising edge */
  TCCR1B |= (1 << ICES1);

  /* Enable Interrupt on ICP1 */
  TIMSK |= (1 << TICIE1);

  /* Wait for end of measure (disabled ICP-Interrupt) */
  while (TIMSK & (1 << TICIE1))
  {
    ;
  }

> Mal dir einfach mal eine Linie auf, die den Zählumfang deines Zählers
> symbolisiert. Und dann spiel alle möglichen Kombinationen durch, die für
> das Auftreten des Start und Stop Pulses möglich sind. Interessant sind
> dabei weniger die Fälle, wenn Start und Stop Puls beim selben
> Timer-Sweep (also beide auf Up, oder beide auf Down) liegen, sondern die
> Fälle, in denen der Timer zwischendurch seine Richtung ändert.

Ja, das habe ich auch bereits gemacht :-)

Vielleicht ist der Hinweis von Peter nicht verkehrt, im Prinzip spricht 
glaube ich wirklich nichts gegen den Mode15, vom Timing her müsste das 
ja auch passen.
Ich habe es glaube ich auch erst mit einem anderen Modus versucht und es 
hat nicht hingehauen, und mit dem Phase-and-Frequency Modus hat's dann 
plötzlich geklappt und so habe ich den genutzt.

Ich werde mal versuchen das auf Mode15 umzustricken, da spare ich mir 
einige Up- und Downcounting-Interrupts. Vielleicht ist das der Hinweis, 
den ich brauchte und woran ich im Laufe der Problembewältigung nicht 
mehr gedacht habe.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Veit H. schrieb:

> angeschaut hast. Ich gebe zu, es ist mit dem invertierten Start/Stopp
> sehr verwirrend.

Dann nenne die Variablen um :-)
pwm_start ist der Zählerstand, wenn der Puls beginnt
pwm_stop ditto, wenn der Puls endet.

Alles andere führt nur zu Verwirrung :-)

> Die Sache ist, dass ein Transistor vor der Schaltung
> die einkommende PWM invertiert.

Wie das Signal physisch aussieht, braucht mich nicht zu interessieren. 
Bei pwm_start hat es begonnen, bei pwm_stop hat es aufgehört.


> Der Timer dreht (startet wieder bei 0).
> Der Interrupt zu
/* Timer on Bottom */
> ISR(TIMER1_OVF_vect)
> {
>   isUpcounting = 1;
>   pwm_period_counter++;
> }
> erhöht den Periodenzähler nun auf 1.

Moment, wir waren im Downcounting.
Da wird kein Overflow ausgelöst (oder irre ich mich da jetzt)


> Müsste doch stimmen oder?
Ähm. Ist mir jetzt ehrlich gesagt zu verwirrend mit deinen 
Start/Stop/Up/Down/Counter Verdrehungen :-)



Hast du es am anderen Ende auch ausprobiert?
Puls beginnt bei 850, Zähler zählt hoch, dreht um und der Puls endet bei 
750.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> Ähm. Ist mir jetzt ehrlich gesagt zu verwirrend mit deinen
> Start/Stop/Up/Down/Counter Verdrehungen :-)

Den besser geeigneten Mode 15 zu nehmen, war im wohl zu einfach.

Ich will damit aber nicht sagen, daß es in den anderen T1-Modies 
garnicht geht.


Peter

Autor: Veit H. (veith)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So, ich habe heute auf den Modus 15 umgestellt, was schneller ging als 
ich dachte, allerdings mit demselben Ergebnis: beim einmaligen Aufrufen 
klappt's, in einer Schleife nicht.

Habe dann lange den (Denk-) Fehler gesucht und herum experimentiert, und 
als ich mir die beiden Trigger zur steigenden und fallenden Flanke auf 
zwei Pins ausgegeben und auf'm Oszillskop angeschaut habe, habe ich 
gemerkt, dass der Interrupt zum Flankenwechsel nicht zwei mal (steigend 
und fallend), sondern vier mal aufgetreten ist, zwischendurch also 
nochmal aufgerufen wurde.

Habe daraufhin meine Überlegung, von wegen Capture-Interrupt anschalten, 
zwei Flanken abwarten, ausschalten, Abstand messen, verworfen und das 
Programm so umstrukturiert, dass das PWM-Signal kontinuierlich berechnet 
wird und ich einfach den berechneten Abstand in meiner Main-Routine 
abfrage.
Das klappt nach den ersten Tests auch endlich gut und zufrieden 
stellend! Also vielen Dank für die Hinweise! (das invertierte 
start-stop-Getausche habe ich auch beseitigt)

Jetzt weiß ich leider nicht, wo genau der Fehler lag. Ich vermute, dass 
diese else-Bedingung zu schwach formuliert war:
/* Interrupt routine to measure PWM */
ISR(TIMER1_CAPT_vect)
{
  /* rising edge */
  if (TCCR1B & (1 << ICES1))
  {
    // do something

  }

  /* falling edge */
  else
  {
    // do other stuff
  }
}

Zur Sicherheit habe ich die Else-Bedingung mit
/* falling edge */
  else if( !(TCCR1B & (1 << ICES1)) )
 verstärkt und auch den Flanken-Trigger-Wechsel in die Interrupt-Routine 
statt in die Mess-Routine eingetragen.

Ich denke, dass es daran gelegen hat.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Veit H. schrieb:
> Habe daraufhin meine Überlegung, von wegen Capture-Interrupt anschalten,
> zwei Flanken abwarten, ausschalten, Abstand messen, verworfen

Das geht schon, nur muß man eben damit rechnen, daß das Interruptflag 
auch bei abgeschaltetem Interrupt gesetzt wird.
Das muß auch so sein, damit man keine Interrupts verliert.
Bzw. man kann ja auch das Flag pollen.

Will man aber gewollt ältere Ereignisse nicht behandeln, muß man nur 
einfach das Interruptflag direkt vor der erneuten Freigabe löschen (beim 
AVR auf 1 setzen!).


> und das
> Programm so umstrukturiert, dass das PWM-Signal kontinuierlich berechnet
> wird und ich einfach den berechneten Abstand in meiner Main-Routine
> abfrage.

Und das hat sogar den Vorteil, daß man schneller das nächste Meßergebnis 
hat.


Peter

Autor: STK500-Besitzer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
/* Interrupt routine to measure PWM */
ISR(TIMER1_CAPT_vect)
{
  /* capture PWM value */
  pwm_temp = ICR1;

  /* rising edge (inverted, means stop) */
  if (TCCR1B & (1 << ICES1))
  {
    /* Trigger Interrupt next time on falling edge */
    TCCR1B &= ~(1 << ICES1);
    ...
  }
  /* falling edge (inverted, means start) */
  else
  {
    /* Disable Interrupts on IPC1 */
    TIMSK &= ~(1 << TICIE1);
    ...
  }
}


kann man auch so lösen:
/* Interrupt routine to measure PWM */
ISR(TIMER1_CAPT_vect)
{
  /* capture PWM value */
  pwm_temp = ICR1;

  /* rising edge */
  if (TCCR1B & (1 << ICES1))
  {
    ...
  }
  /* falling edge */
  else
  {
    ...
  }
  /* toggle detecting edge */
    TCCR1B ^= (1 << ICES1);
}
[/c]

Da braucht man sich nicht um das Setzen der richtige Flankenrichtung zu 
kümmern. Das passiert einfach automatisch.
Und kürzer ist es auch noch... :)

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.