Lauflicht KITT

[Marten M. (mcgonahy148)]

Tach...ich bombadier förmlich das Forum momentan, scheisse wenn man 
Urlaub hat und heiss auf uController ist. :-)

Ich hab schon zwei Threats in den Fingern gehabt zu dem Thema, auch bei 
googgle. Jedoch finde ich immer nur Assembler-Geschichten, ich möchte es 
in C programmieren.

Wobei wir bei der Frage sind, ein Lauflicht hab ich schon hinter mir, 
kein Thema. So, bei PWM bin ich gerade angelangt, und mein Atmega16 hat 
ja 4 PWM-Kanäle. Momentan hab ich nur eine angeschlossen. Bei dem 
Knightrider Lauflicht, glimmen ja immer ein paar LED´s nach bzw. bei 
langen Lichtleisten ziemlich viele. Das ist doch dann mit einem 4-Kanal 
PWM nicht mehr machbar?

Ich würds mir so vorstellen, ein Lauflicht normal programmieren (harte 
Lichtübergänge von einer LED), anschließend mit PWM die nachleuchtenden 
LEDs mit PWM einschalten und helligkeit reduzieren, dass mit 
verschiedenen stufen. Kann ich also nur 4 LEDs nachglimmen lassen?

[kermit der frosch (Gast)]

wenn das fest sein soll, dann mach das einfach über kondensator und 
widerstände

[Mh. M. (mhm)]

So direkt mit Hardware-PWM kannst du in der Tat nur vier LEDs mit PWM 
steuern. Verwendest du jedoch eine Soft-PWM kannst du theoretisch alle 
Pins per PWM steuern, abhängig von der Frequenz deines Controllers und 
der Effizienz deiner Soft-PWM Routine. Einfach mal in dem Artikel hier 
schauen, da wird recht gut beschrieben wie man sowas in C macht: 
http://www.mikrocontroller.net/articles/Soft-PWM

[Jonas F. (wuschelkuchen)]

Als Anregung:
http://www.evilmadscientist.com/article.php/larsonkit
bzw.
http://www.evilmadscientist.com/article.php/laaaaaaaaaaaaaaaarsonscanner

grüssse
w.

[Marten M. (mcgonahy148)]

kermit der frosch schrieb:
> wenn das fest sein soll, dann mach das einfach über kondensator und
> widerstände

Ja hast schon recht, aber ich möchte mich ja etwas mit dem uController 
beschäftigen, an dem hab ich momentan eben nur ein paar leds dranhängen, 
daher die Überlegung

[Marten M. (mcgonahy148)]

Mh. M. schrieb:
> So direkt mit Hardware-PWM kannst du in der Tat nur vier LEDs mit PWM
> steuern. Verwendest du jedoch eine Soft-PWM kannst du theoretisch alle
> Pins per PWM steuern, abhängig von der Frequenz deines Controllers und
> der Effizienz deiner Soft-PWM Routine. Einfach mal in dem Artikel hier
> schauen, da wird recht gut beschrieben wie man sowas in C macht:
> http://www.mikrocontroller.net/articles/Soft-PWM

Ok, danke. Ich weiss zu meinem jetzigen Unterschied noch nicht den 
Unterschied zwischen einer soft und einer hardware-PWM...

Jonas R. schrieb:
> Als Anregung:
> http://www.evilmadscientist.com/article.php/larsonkit
> bzw.
> http://www.evilmadscientist.com/article.php/laaaaa...
>
> grüssse
> w.

Dankeschön..

[Marten M. (mcgonahy148)]

OCR0B = *(pwmtable_8D+tmp)

Der "*" heisst was noch gleich in C?

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:
>

OCR0B = *(pwmtable_8D+tmp)

>
> Der "*" heisst was noch gleich in C?

Dereferenzieren.

Das Statement ist identisch zu

   OCR0B = pwmtable_8D[ tmp ];

nur dass da jemand den Hacker raushängen lassen wollte und es daher 
lieber 'kryptisch' geschrieben hat.


Ansonsten: C-Buch

[Marten M. (mcgonahy148)]

:-) Gut, mit den "[]" find ich persönlich schöner...


Danke dir!

[Marten M. (mcgonahy148)]

Was ich noch nicht verstehe ist, warum muss ich

zB

 
    for(tmp=255; tmp>=0; tmp--){
      OCR1A = pgm_read_word(pwmtable_16+tmp);
      my_delay(delay);
    }

schreiben und kann nicht

 
    for(tmp=255; tmp>=0; tmp--){
      OCR1A = pwmtable_16[tmp];
      my_delay(delay);
    }

schreiben? Es geht darum ja lediglich darum die Werte aus der Tabelle zu 
lesen und ins compare-register zu schreiben. Funktioinert aber nicht :-)

[Stefan B. (stefan)]

Und wo ist die Tabelle gespeichert?

Tipp:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

[Marten M. (mcgonahy148)]

Die is global im Programm definiert...

[Stefan B. (stefan)]

Marten Mcgonahy schrieb:

> Die is global im Programm definiert...

Richtig, aber wo stehen die Bytes physikalisch im µC?
Die Definition gibt das an.

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:
> Die is global im Programm definiert...

Das ist nicht die Frage,
Die Frage ist:
Ist sie im SRAM oder ist sie im Flash?

Ist sie im SRAM (default), dann kann man mittels  pwmtable_16[tmp] auf 
den Tabelleninhalt zugreifen.
ISt sie im Flash, dann muss man eine Funktion bemühen, der man sagt von 
welcher Adresse im Flash man ein Byte lesen möchte.

Default ist in der C-Programmierung immer: Alles liegt im SRAM (bis auf 
das eigentliche Programm, das liegt im Flash). Nur wenn das nicht so 
ist, braucht man Sonderlösungen.

[Marten M. (mcgonahy148)]

Ui..ihr fragt mich sachen. Ähm, die Tabelle is folgendermaßen angelegt:

uint16_t pwmtable_16[256] PROGMEM = {0, 1, 1, 1, 1, 1, 1, 1, 1

also so wie sich das programm verhält, liegt sie im Flash-speicher? Wie 
kann ich definierren ob im Flash oder SRAM Bereich? Fakt ist,

pwmtable_16[tmp]

 funktioniert nicht, nur mit dieser seltsamen pgmreadword-funktion.

Hat das auch was mit dem Thema der Dereferenzierung *(pwmtable_16+tmp) 
zu tun?

[Marten M. (mcgonahy148)]

Marten Mcgonahy schrieb:
> PROGMEM = {0, 1,

ICh schätze das es was mit dem zu tun hat wo die Tabelle abgelegt wird?!

[Stefan B. (stefan)]

Richtig!

Die fetten 256 Bytes für eine Tabelle im SRAM sind bei kleinen AVRs 
kostbarer als der Platz im Flash.

Konstante Daten so wie im Bsp. die Tabelle speichert man deshalb gerne 
ausschliesslich im Flash, mit dem "Haken", dass man spezielle 
Lesefunktionen dafür braucht.

[Marten M. (mcgonahy148)]

Ja, wenn ich das PROGMEM lösche und unten dann mit pwmtable[xx] arbeite, 
dann funktioniert es. Ebenfalls mit der dereferenzierung *, ist ja 
gleichbedeutend wie Karl Heinz angedeutet hat.

ABer wg. dem Verständnis, wann leg ich es in den Flash/Sram Bereich?

PROGMEM=Flash,
????=SRAM?

Flash is schneller wie sram?

[Marten M. (mcgonahy148)]

Stefan B. schrieb:
> Die fetten 256 Bytes für eine Tabelle im SRAM sind bei kleinen AVRs
> kostbarer als der Platz im Flash.

Ja aber ich dachte das Programm wird ohnehin in den Flashspeicher 
gebracht?

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:
> Ja, wenn ich das PROGMEM lösche und unten dann mit pwmtable[xx] arbeite,
> dann funktioniert es. Ebenfalls mit der dereferenzierung *, ist ja
> gleichbedeutend wie Karl Heinz angedeutet hat.
>
> ABer wg. dem Verständnis, wann leg ich es in den Flash/Sram Bereich?
>
> PROGMEM=Flash,
> ????=SRAM?

indem du nichts angibst.

Wie schon gesagt:
Default ist, dass alles was keine "Sonderbehandlung" hat immer im SRAM 
liegt.

> Flash is schneller wie sram?

Nein.
Du hast mehr Flash als SRAM

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:

> Ja aber ich dachte das Programm wird ohnehin in den Flashspeicher
> gebracht?

Wir reden doch nicht vom Programm.
Wir reden davon, wo die Daten abgelegt sind, die dein Programm 
verwurschtet!

[Marten M. (mcgonahy148)]

Ok, jetzt bin ich definitiv gescheiter :-)

Nur bei den Sonderfunktionen und Definitionen blick ich noch ins Dunkle, 
also mit PROGMEM und der FUnktion "pgm_read_word", nicht dass mir sowas 
öfters über den Weg läuft und weiss nicht woher das kommt.

[Stefan B. (stefan)]

Marten Mcgonahy schrieb:

> Ja aber ich dachte das Programm wird ohnehin in den Flashspeicher
> gebracht?

Richtig.

Du fragst nach den Innereien, wie ein C-Programm zur Laufzeit gestartet 
wird.

Der Startcode deines C-Programms (der Teil der vor main() ausgeführt 
wird) kopiert initialisierte Variablen aus dem Flash in das anfangs 
leere SRAM. Aber PROGMEM gekennzeichnete Daten (d.h. Daten im Flash) 
werden nicht kopiert, verbrauchen also keinen SRAM Platz!

[Marten M. (mcgonahy148)]

Warum blinkt die LED beim "einfaden so komisch"?

  TCCR1A = (1<<COM1A1) | (1<<COM1A0) |(1<<WGM10); 
  TCCR1B = (1<<WGM12);
  TCCR1B = (1<<CS11)|(1<<CS10);
 } 
 
void fade(void) 
{
  unsigned char tmp;
 
  for(tmp=0; tmp<=255; tmp++){
    OCR1A = *(pwmtable+tmp);    //LED einfaden
    _delay_ms(50);
  }
 
  _delay_ms(1000);
    
  for(tmp=0; tmp<=255; tmp++){
    OCR1A = *(pwmtable+255-tmp); //LED ausfaden
    _delay_ms(50);
  }
   _delay_ms(1000);


int main(void)
{
  init_fade();
 
  while(1)
  {
    fade();
  }
}

Es flackert beim Einfaden, aber dann beim Ausfaden gehts...ähm, überseh 
ich was?

[Karl H. (kbuchegg)]

Der dürfte aus dem einfaden überhaupt nie rauskommen

  for(tmp=0; tmp<=255; tmp++){

das ist mit
  unsigned char tmp;

eine Endlosschleife.
tmp <= 255 ist für alle überhaupt möglichen tmp-Werte immer erfüllt. tmp 
kann gar keinen Wert annehmen, so dass diese Schleife jemals verlassen 
würde.

[Marten M. (mcgonahy148)]

Gibt es eigentlich ein C-Buch zu empfehlen dass im Inet kostenlos zur 
Verfügung steht? Ok...wiki...aber gibts noch was?

[Jochen F. (jamesy)]

KITT sollte das doch in der Datenbank haben! ;-)

[Marten M. (mcgonahy148)]

Ja schon, aber Kitt wird momentan repariert, und da ich erst bei seinem 
Lauflicht bin, dauert es wohl noch eine Zeit lang bis sein Steuergerät 
fertig is ;-)

[Marten M. (mcgonahy148)]

Hallo nochmals...

zum Thema KITT Lauflicht: Die LED´s die der "HauptLED" nachlaufen, 
glimmen die eigentlich aus oder sind die auf statisch feste 
Helligkeitswerte programmiert?

Ich habs jetzt mal ganz einfach mit "statischen Werten" versucht und so 
schlecht wirkt es garnicht.

/*
KITT-Lauflicht mit Hilfe von Soft-PWM realisieren
*/
 
 
#define F_CPU 16000000L                  // Systemtakt in Hz
#define F_PWM 50                        // PWM-Frequenz in Hz
#define PWM_STEPS 255                   // PWM-Schritte pro Zyklus(1..255)
#define PWM_PORT PORTA                  // Port für PWM
#define PWM_DDR DDRA                    // Datenrichtungsregister für PWM
#define blinktime 300          // Blinkzeit der Laufled LED1
#define hell_max 150          // maximale Helligkeit LED1
#define hell_s5 130
#define hell_s5 100
#define hell_s5 80
#define hell_s5 60
#define hell_s5 40
#define hell_s5 20
 
// ab hier nichts ändern, wird alles berechnet
 
#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
 
#if (T_PWM<(152+5))
    #error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif
 
#if PWM_STEPS > 255
    #error PWM_STEPS zu gross
#endif
 
// includes
 
#include <stdint.h>
#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <delay.h>
 
// globale Variablen
 
volatile uint8_t pwm_setting[8];                    // Einstellungen für die einzelnen PWM-Kanäle
 
// Timer 1 Output COMPARE A Interrupt
 
ISR(TIMER1_COMPA_vect) {
    static uint8_t pwm_cnt=0;
    uint8_t tmp=0, i=0, j=1;
 
    OCR1A += (uint16_t)T_PWM;
 
    for (; i<8; i++) {    
      if (pwm_setting[i] > pwm_cnt) tmp |= j;
            j<<=1;
  }
    PWM_PORT = tmp;                         // PWMs aktualisieren
    if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
        pwm_cnt=0;
    else
        pwm_cnt++;
}
 
int main(void) {
 
    // PWM einstellen
    
    PWM_DDR = 0xFF;         // Port als Ausgang
    
    // Timer 1 OCRA1, als variablem Timer nutzen
 
    TCCR1B = 1;             // Timer läuft mit vollem Systemtakt
    TIMSK |= (1<<OCIE1A);   // Interrupt freischalten
 
    sei();                  // Interrupts gloabl einschalten
 


/*********************************************************************/
const uint8_t LED1_t1[8]={hell_max, 0, 0, 0, 0, 0, 0, 0};
const uint8_t LED1_t2[8]={100, hell_max, 0, 0, 0, 0, 0, 0};
const uint8_t LED1_t3[8]={50, 100, hell_max, 0, 0, 0, 0, 0};
const uint8_t LED1_t4[8]={10, 50, 100, hell_max, 0, 0, 0, 0};
const uint8_t LED1_t5[8]={0, 10, 50, 100, hell_max, 0, 0, 0};
const uint8_t LED1_t6[8]={0, 0, 10, 50, 100, hell_max, 0, 0};



 
 while(1)
  {
 
    
  //Haupt-LED=LED1 Ablauf
  for (int i=0;i<=5;i++)
    {
      memcpy(pwm_setting, LED1_t1, 8);
      _delay_ms(blinktime);
      memcpy(pwm_setting, LED1_t2, 8);
      _delay_ms(blinktime);
      memcpy(pwm_setting, LED1_t3, 8);
      _delay_ms(blinktime);
      memcpy(pwm_setting, LED1_t4, 8);
      _delay_ms(blinktime);
      memcpy(pwm_setting, LED1_t5, 8);
      _delay_ms(blinktime);
      memcpy(pwm_setting, LED1_t6, 8);
      _delay_ms(blinktime);
    
      }
  
  
  }
 
 
    return 0;
}

Meine Fragen sind nun:

a.) Wie funktioniert noch gleich der Zugriff auf ein Element eines 
Vektors, denn hier is alles mit Hand geschrieben (hell_max) in den 
Vektorelementen. Wie kann ich über die Laufvariable "i" des 
for-Konstrukts auf die Elemente zugreifen?

b.) Wie würde ich ein "Nachglimmen" realisieren? Da müsste ich jedes 
einzelne Vektorelement noch in XXX Stufen abdimmen, sprich die 
Software-PWM mit z.B. 64 Helligkeitsstufen und einem Delay dazwischen. 
Wird das dann zeitlich nicht etwas kritisch?

c.) Wie berechne ich die genaue Zeit wieviel ms bzw. us er in den 
Interupt springt? Is zwar irgendwo angegeben, aber ohne zu wissen 
wieviel Rechenschritte in dem ISR sind kann ich es nicht oder?


Hat wer Ideen?


Schönen Gruß,
MG

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:

> a.) Wie funktioniert noch gleich der Zugriff auf ein Element eines
> Vektors, denn hier is alles mit Hand geschrieben (hell_max) in den
> Vektorelementen. Wie kann ich über die Laufvariable "i" des
> for-Konstrukts auf die Elemente zugreifen?

Dazu müsstest du LED1_t1 bis LED1_t6 aufgeben und dir dafür ein 2D-Array 
machen.

Oder du gehst das ganze etwas intelligenter an und gibst die LED1_t1 
(und Konsorten Array) komplett auf:

Du hast nur 1 LED die auf hell_max steht. Wenn diese Led um 1 Position 
weiterwandert, dann setzt du in pwm_setting den dazugehörenden Eintrag 
auf hell_max und alle anderen halbieren sich zb in der Helligkeit, 
sofern sie noch größer als 0 sind.

> c.) Wie berechne ich die genaue Zeit wieviel ms bzw. us er in den
> Interupt springt? Is zwar irgendwo angegeben, aber ohne zu wissen
> wieviel Rechenschritte in dem ISR sind kann ich es nicht oder?

Die Anzahl der Rechenschritte hat darauf erst mal keinen Einfluss. Du 
musst dir ausrechnen, wie oft der Timer mit dein eingestellten 
Timer-Werten in die Situation kommt, einen Interrupt auszulösen.

[Falk B. (falk)]

@  Marten Mcgonahy (mcgonahy148)

Lies mal was über Netiquette. Lange Quelltexte gehören in den 
Anhang.

>Vektorelementen. Wie kann ich über die Laufvariable "i" des
>for-Konstrukts auf die Elemente zugreifen?

Kauf dir ein C-Buch un lies es.

LED1_t1[i]=a;

>Wird das dann zeitlich nicht etwas kritisch?

Nö, der AVR schläft dabei ein.

>c.) Wie berechne ich die genaue Zeit wieviel ms bzw. us er in den
>Interupt springt?

Wozu?

> Is zwar irgendwo angegeben, aber ohne zu wissen
>wieviel Rechenschritte in dem ISR sind kann ich es nicht oder?

Wozu? Die Soft-PWM läuft doch, darum musst du dich nicht mehr 
kümmern.

MFG
Falk

[Marten M. (mcgonahy148)]

Danke Karl-Heinz...

Ich muss sagen, für dass das ich noch nicht sehr lange hier aktiv bin, 
du bist hier eine wirklich große Hilfe! Ich komm mir schon langsam etwas 
schlecht vor, weil ich einfach NUR frage und nichts weitergebe. Aber 
dafür bin ich irgendwie noch zu schwach auf der Brust :-) Aber das Forum 
lebt eben davon von Wissensweitergabe, und die Seite hier ist einfach 
wirklich gut angelaufen. Ich möchte nicht wissen wieviel Elektroniker 
und Entwickler hier rumschwirren :-)

Nun zum Thema: Also Speicherplatz einsparen kann ich wenn ich die 
Vektor/Array-Geschichten aufgebe, ok, das muss ich schon mal 
einverleiben. Dafür wird der Prozesser mehr belastet durch mehr 
Rechenschritte? Ich kenn mich hinsichtlich Optimierung eines Programmes, 
was auch besser ist für den Prozessor oder den Speicher, nciht aus. Mehr 
Speicher verbraten und den Prozessor wenig rechnen lassen oder wenig 
Speicher und die Schritte rechnen lassen. Da heutzutage ja Speicher kein 
Thema mehr is, möchte man ja den Prozessor entlasten? Oder seh ich das 
ganze falsch?

[Marten M. (mcgonahy148)]

Falk Brunner schrieb:
> @  Marten Mcgonahy (mcgonahy148)
>
> Lies mal was über Netiquette. Lange Quelltexte gehören in den
> Anhang.

Sorry, ich werd mich in Zukunft dran halten!

Falk Brunner schrieb:
>>c.) Wie berechne ich die genaue Zeit wieviel ms bzw. us er in den
>>Interupt springt?
>
> Wozu?

Ich würds gern wissen, aber es ist wohl nur von den Einstellungen des 
Timers abhängig und nicht wie hoch die Rechenschritte im ISR sind. Was 
ich aber nciht versteh, wenn die ISR lange dauert, dann funktioniert die 
Annahme halt auch nicht mehr?! Und genau dann weiss ich nicht wie ich 
die Zeiten berechnen kann. Warum? PWM und Zeiten gehört halt schon 
zusammen...

Falk Brunner schrieb:
>> Is zwar irgendwo angegeben, aber ohne zu wissen
>>wieviel Rechenschritte in dem ISR sind kann ich es nicht oder?
>
> Wozu? Die Soft-PWM läuft doch, darum musst du dich nicht mehr
> kümmern.

Wie gesagt, ich würds auch gern alles verstehen und nicht einfach nur 
copy-paste. Auch wenn mir manchmal einfache C-Grundlagen im Kopf 
abhanden gekommen sind. Übrigens, liegt irgendwo das Buch von Ulla 
Kirch-Prinz bei mir rum, so viel zum Thema Zugriff auf ein Vektorelement 
:-s

[Falk B. (falk)]

@  Marten Mcgonahy (mcgonahy148)

>Nun zum Thema: Also Speicherplatz einsparen kann ich wenn ich die
>Vektor/Array-Geschichten aufgebe, ok,

Nix OK, gespart wird da nichts, man kann es "nur" besser verwalten. Und 
Speicherplatzsparen steht heute nicht auf dem Stundenplan, also vergiss 
es für dieses Projekt.

> Dafür wird der Prozesser mehr belastet durch mehr
>Rechenschritte? Ich kenn mich hinsichtlich Optimierung eines Programmes,
>was auch besser ist für den Prozessor oder den Speicher, nciht aus.

Das ist auch im Moment vollkommen egal. Du musst erstmal die Grundlagen 
lernen.

>Speicher und die Schritte rechnen lassen. Da heutzutage ja Speicher kein
>Thema mehr is, möchte man ja den Prozessor entlasten? Oder seh ich das
>ganze falsch?

Jain. Wenn gleich Speicher auch bei Mikrocontrollern heute billig ist, 
muss man immer von Fall zu Fall sinnvoll abwägen. Dazu baucht man 
Erfahrung. Die hast du im Moment noch nicht.

>ich aber nciht versteh, wenn die ISR lange dauert, dann funktioniert die
>Annahme halt auch nicht mehr?!

Wei kommst du darauf?

> Und genau dann weiss ich nicht wie ich
>die Zeiten berechnen kann. Warum? PWM und Zeiten gehört halt schon
>zusammen...

Du bist auf dem Holzweg.

>Wie gesagt, ich würds auch gern alles verstehen und nicht einfach nur
>copy-paste.

Schön, aber warum liest du dann nicht den Artikel, aus dem du den 
Quelltext her hast? Dort ist alles haarklein erklärt.

MFG
Falk

[Marten M. (mcgonahy148)]

Falk Brunner schrieb:
>>ich aber nciht versteh, wenn die ISR lange dauert, dann funktioniert die
>>Annahme halt auch nicht mehr?!
>
> Wei kommst du darauf?

Je nach Timereinstellung springt er ja alle XXXms/us in die ISR rein. 
Wenn nun die ISR Routine aber extrem lange dauern würde, keine 
ahnung...100ms oder sonstwas, dann funktioniert doch die PWM auch nicht 
mehr?! Daher mein Schluss, bzw. meine Aussage dass PWM und Zeiten ja 
zusammenhängen! Es geht hier ja um Puls-Pausen-Verhältnis, ergo wie 
lange schalte ich die LED EIN und wie lange die LED AUS.

Falk Brunner schrieb:
> Schön, aber warum liest du dann nicht den Artikel, aus dem du den
> Quelltext her hast? Dort ist alles haarklein erklärt.

Sei mir nicht bös, und der Artikel ist ja auch gut und hilfreich, aber 
es wird, zumindest bei dem einfachen Lösungsansatz nur der Code angeben 
und nichts weiter groß erklärt! Ausser halt "m AVR-Studio kann man den 
Code simulieren. Wichtig ist hi..." unter dem Sourcecode. Daher finde 
ich NICHT dass hier alles haarklein erklärt wird.

Und, ich dank dir schön für die Antworten Falk, aber es wirkt etwas 
unfreundlich und es tut mir leid dass ich noch keine Plan von dem Ganzen 
hier hab! Ich versuchs zumindest jetzt erstmal und stell eben 
Anfängerfragen...

[Karl H. (kbuchegg)]

Marten Mcgonahy schrieb:

>>>c.) Wie berechne ich die genaue Zeit wieviel ms bzw. us er in den
>>>Interupt springt?
>>
>> Wozu?
>
> Ich würds gern wissen, aber es ist wohl nur von den Einstellungen des
> Timers abhängig und nicht wie hoch die Rechenschritte im ISR sind. Was
> ich aber nciht versteh, wenn die ISR lange dauert, dann funktioniert die
> Annahme halt auch nicht mehr?!

Logisch.
Wenn du dir eine Uhr stellst, so dass sie alle 10 Sekunden klingelt 
(einen Interrupt auslöst) und du bei jedem klingeln ein Wort sagen 
sollst, dann sagst du 6 Wörter in der Minute. Und es spielt keine Rolle, 
ob du nun 'bap' oder 'Mikrocontroller' sagst. Das ändert nichts an den 6 
mal in der Minute.
Ist dein Wort aber zu lang, wie 
"Donaudampfschifffahrtskapitänskajütenknopfunterlegscheibe" dann kann es 
natürlich dazu kommen, dass das Aussprechen länger als 10 Sekunden 
dauert und du ein Klingeln verpasst.

> Und genau dann weiss ich nicht wie ich
> die Zeiten berechnen kann.

Dann schaut man sich das Assembler Listing an, zählt Befehle zusammen 
und rechnet sich die Laufzeit aus.
Im Regelfall passiert das nicht, weil man es in einer ISR gar nicht 
soweit kommen lässt, dass es mit den verfügbaren Taktzyklen knapp wird. 
Nicht von ungefähr lautet eine Daumenregel: ISR sollten kurz sein. In 
einer ISR macht man das was Notwendig ist, aber nicht mehr. Alles was 
nicht unbedingt in einer ISR sein muss, fliegt dort raus.

> Warum? PWM und Zeiten gehört halt schon
> zusammen...

Und das spielt bei dir überhaupt keine Rolle. Die PWM läuft und du 
läufst noch nicht einmal annähernd in Gefahr, dass es knapp werden 
könnte.

> abhanden gekommen sind. Übrigens, liegt irgendwo das Buch von Ulla
> Kirch-Prinz bei mir rum, so viel zum Thema Zugriff auf ein Vektorelement
> :-s

Was soll uns das jetzt sagen?
Das du lieber dir Halbwissen anlassbedingt in einem Forum 
zusammensuchst, anstelle eines systematischen Zugangs durch ein Buch?

[Falk B. (falk)]

@  Marten Mcgonahy (mcgonahy148)

>Je nach Timereinstellung springt er ja alle XXXms/us in die ISR rein.
>Wenn nun die ISR Routine aber extrem lange dauern würde, keine
>ahnung...100ms oder sonstwas,

Das tut sie aber nicht, weil sie durchdacht ist.

> dann funktioniert doch die PWM auch nicht
>mehr?! Daher mein Schluss, bzw. meine Aussage dass PWM und Zeiten ja
>zusammenhängen!

Dein Schluss ist falsch. Und du redest wirr und drehst dich im Kreis. 
Lies den Artikel, denk in Ruhe drüber nach.
Die Einstellung der PWM-Zeit hat KEINERLEI Einfluss auf die Dauer des 
Interrupts.

> Es geht hier ja um Puls-Pausen-Verhältnis, ergo wie
>lange schalte ich die LED EIN und wie lange die LED AUS.

Du hast den Artikel nicht verstanden, auch nicht wie Soft-PWM 
funktioniert. Siehe oben.

>Sei mir nicht bös, und der Artikel ist ja auch gut und hilfreich, aber
>es wird, zumindest bei dem einfachen Lösungsansatz nur der Code angeben
>und nichts weiter groß erklärt!

Der Code ist so einfach, dass er selbsterklärend ist. Sind ja auch 
Kommentare drin!

>ich NICHT dass hier alles haarklein erklärt wird.

Wir sind nicht deine Mutti.

>Und, ich dank dir schön für die Antworten Falk, aber es wirkt etwas
>unfreundlich und es tut mir leid dass ich noch keine Plan von dem Ganzen
>hier hab! Ich versuchs zumindest jetzt erstmal und stell eben
>Anfängerfragen...

Ist OK, aber du solltest vielleicht auch mal die Hinweise 
berücksichtigen und die Sache selber INTENSIV durchdenken. Das muss 
jeder.

MFG
Falk