Codeunterbrechung bei Interrupt

Matthias schrieb:
> Wird der Code dann mit dem Befehl nach delay
> fortgesetzt oder wird die restliche Zeit nach Unterbrechung pausiert?
Hallo,
Gemeint ist Maschinencode. Maschinencode "delay" gibt es nicht. Programm 
wird ab nächster Maschinenoperation fortgesetzt. Mit welchen 
Maschinencoden wird "delay" bei dir realisiert, solltest du in 
Disassembler kucken.
http://www.avr-asm-tutorial.net/avr_de/beginner/commands.html

Wenn das Delay aus der bei avrlibc-üblichen "Verbrauch n-Clock-Cycles" 
Warteschleife besteht, dann wird es um die Interrupt-Laufzeit länger.

Für exakte Verzögerungen könnte man z.B. einen Timer benutzen und in 
einer Schleife auf eines von dessen "Interrupt-Flags" warten. Ohne 
allerdings diese Interrupts freizuschalten. Läuft der μC mit 1MHz und 
Timer0 läuft mit Teiler 1, dann setzt er nach 256μs das 
Timer0-Overflow-Flag.

Matthias schrieb:
> void loop() {
>   digitalWrite(PIN, HIGH);
>   delay(10000);
>   digitalWrite(PIN, LOW);
> }

Hallo,
das ist C-Code. Sie wird vom Compiler in Maschinencode umgesetzt. Die 
Maschinencode ist, womit Mikrocontroller arbeitet. Er hat keine Ahnung 
von loop und von delay - das ist nur für deine Bequemlichkeit so 
geschrieben. Nach ISR wird nächste Maschinencode gemacht.

Willst du wirklich etwas außer "loop" machen, mit ISR usw, dann solltest 
du bessere Vorstellung von Mikrocontroller haben. Kenntnisse nur von 
Arduino-IDE reichen nicht aus, du solltest wissen, was C ist und was 
Assembler ist. Arduino ist für einfache Sachen konzipiert, für Menschen, 
die nichts außer "loop" machen wollen.

Kommt drauf an, wie das Delay implementiert ist. Wenn mit einem Timer, 
dann verlängert sich das Delay nicht. Wenn mit einer Zählschleife, dann 
addiert sich die Zeit des Interrupts. Da typisch Interrupts <1% der 
CPU-Zeit benötigen, ist das in der Regel kein Problem. Eine genaue Uhr 
kann man mit Delay eh nicht machen.

Matthias schrieb:

1

> void loop() {

2

>   digitalWrite(PIN, HIGH);

3

>   delay(10000);

4

>   digitalWrite(PIN, LOW);

5

> }

> Sind die ersten Gehversuche in dieser Materie ;-)

Das sieht man. Dieser Code wird vermutlich nicht das tun, was du 
erwartest. Der Pin wird zwar am Ende der Schleife auf LOW gesetzt, aber 
unmittelbar darauf am Anfang der Schleife wieder auf HIGH. Weder mit dem 
Auge noch mit den meisten Meßmitteln [1] wirst du überhaupt sehen, daß 
der Pin alle 10 Sekunden mal für ein paar Mikrosekunden auf LOW geht.


[1] keine Change mit jeglichem Multimeter. Auch ein Oszilloskop hilft 
nur bedingt. Am besten ist noch ein Logikprüfstift mit 
Impulsverlängerung.

Wolfgang schrieb:
> Axel S. schrieb:
>> Auch ein Oszilloskop hilft nur bedingt.
>
> Quatsch, umgehen können muss man mit dem Oszilloskop allerdings schon.

Axel hat vielleicht an einen µC mit GHz-Takt gedacht. Dann sind die 
Ansprüche an einen Oszi schon ziemlich groß und das "bedingt" passt ;-)

Matthias schrieb:
> Achso...Attiny85/Attiny84

Wie ist es dir gelungen, Arduino mit Attiny85 zu machen?

Wolfgang schrieb:
> Guck es dir einfach an.

Genau, einfach mal in den SourceCode von delay() schauen. Wenn man nicht 
die Arduino IDE sondern Visual Studio Code mit PlatformIO verwendet geht 
das sehr einfach mit einem Mausclick, ansonsten muss man eben mit grep 
suchen und wird dann hier fündig: 
https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c#L106:
void delay(unsigned long ms)
{
  uint32_t start = micros();

  while (ms > 0) {
    yield();
    while ( ms > 0 && (micros() - start) >= 1000) {
      ms--;
      start += 1000;
    }
  }
}

Georg schrieb:
> Das würde bedeuten, dass der Interrupt erst nach Abarbeitung des Delays
> auftreten kann

Wenn das so sein muß - es gibt nichts einfacher.
Vor delay cli() schreiben und danach sei().

Die Funktionen '_delay_ms() und '_delay_us()' der AVRLib sind, sofern 
sie nicht in der ISR selber stehen, immer unterbrechbar. ISR beim AVR 
sind ja ohne besondere Massnahmen 'blockierend', d.h., sie können selber 
nicht mehr unterbrochen werden. Ein '_delay_ms()' in einer ISR ist 
deswegen tabu.
AVRGCC und die AVRLib erlauben allerdings unterbrechbare Sonderformen 
der ISR.

Maxim B. schrieb:
> Wenn das so sein muß - es gibt nichts einfacher.
> Vor delay cli() schreiben und danach sei().

Das ist keine gute Idee:
Du bringst die Zeitverwaltung durcheinander, da die von millis() und 
micros() zurückgelieferte Zeit nicht mehr durch die Timer IRQs erhöht 
wird und quasi stehen bleibt. Möglicherweise funktioniert delay() dann 
überhaupt nicht mehr, da es selbst micros() verwendet.

IRQs dürfen immer nur so kurz wie möglich gesperrt werden.

  Michael

Michael D. schrieb:
> Das ist keine gute Idee:
> Du bringst die Zeitverwaltung durcheinander, da die von millis() und
> micros()

Ich bin der Meinung, daß IDE Arduino in sich keine gute Idee ist, da 
keine Debug-Mittel integriert. Weder JTAG-Emulator noch Simulator sind 
möglich. Wenn man so IDE benutzt, kann man kaum noch etwas schlechter 
machen.

Hi
Nun, einige Antworten sind ja schon in die richtige Richtung, bei 
anderen bezweifle ich, das die Schreiber wissen, was ein Interrupt 
ist.(gut, es gibt verschiedene Arten, aber bei einem µC ist es so 
ziemlich immer gleich)
Ein Programm wird nach Maschinencode abgearbeitet. Maschinencode ist 
nicht Assembler oder gar eine andere Sprache, sondern ganz schlicht 
elektrische Zustände, gespeichert in einem (elektrisch) adressierten 
Speicher ausgedrückt für die Programmierer in "1" und "0". Diese sind 
dann 8, 16 oder auch mal 32 Bit breit. Diese Bitmuster werden im 
Controller in der Befehlsmatrix zu einem Befehl umgesetzt. 
(Oberflächlich erklärt) Nun zum Interrupt. Einige Hardwarekomponenten 
sind in der Lage, den Programmablauf zu stören, also einzugreifen und 
das Adressregister für die Befehlsspeicher einfach auf einen anderen 
Speicherbereich zu setzen. Dort steht dann entweder der Programmcode für 
die Interruptbearbeitung, oder einfach ein Rücksprung. Ablauf ist etwa 
so:
Interrupt löst aus:
Adresse vom Adressregister für den Programmbereich wird 
zwischengespeichert.
Adresse wird auf einen festen Wert passend zum Interrupt im 
Programmspeicher gesetzt. (Stichwort Interruptvektortabelle)
Dort steht entweder ein Sprungbefehl zur Bearbeitung 
(Interruptserviceroutine oder ISR) mit abschließendem "Return from 
Interrupt" oder nur ein "Return from Interrupt" (RETI) der die Adresse 
des letzten Befehles wieder in das Adressregister für das Programm 
schreibt. (Rücksprung)
Nun ist ein Delay ein Befehl, der entweder in einer Schleife eine Anzahl 
unnützer Befehle (NOP) ausführt, um Zeit totzuschlagen oder auch eine 
etwas aufwändigere Programmierung über Zeitregister (Timer). Ersteres 
ist eine berechnete Anzahl von Wiederholungen, da der Controller für 
jede Bearbeitung Zeit benötigt. Etwa so:
Befehl lesen und Adressrregister erhöhen (nächste Befehlsadresse)
 Adresse liefert Befehl Befehl: tu nix (NOP)
Dieser Schritt kann auch ausgelassen werden, entsprechend mehr 
Schleifendurchläufe braucht es dann.
Weiter:
Befehl lesen und Adressrregister erhöhen (nächste Befehlsadresse)
Adresse liefert Befehl: Erhöhe einen Zähler (INC was auch immer)
Befehl lesen und Adressrregister erhöhen (nächste Befehlsadresse)
Adresse liefert Befehl: Vergleiche Zähler mit Vorgabe (CP was auch 
immer)
Befehl lesen und Adressrregister erhöhen (nächste Befehlsadresse)
Adresse liefert Befehl: Sprung wenn Flag (Flag ist ein Bit und wird beim 
Vergleich je nach Ergebnis gesetzt)
Entweder wird also wieder mit dieser Befehlsfolge erneut gearbeitet und 
Zeit vertrödelt, wenn die vorgegebene Anzahl der Schleifendurchläufe 
noch nicht erreicht ist oder die "normale" Programmbearbeitung 
fortgesetzt. Ein Interrupt schiebt sich, egal wo, einfach dazwischen und 
ob in einer Schleife oder den laufenden Programmcode, (Auch letztlich 
eine Schleife) der Controller landet immer wieder beim nächsten Befehl 
vor der Interruptauslösung. (Wenn man nicht irgendeinen Blödsinn in der 
ISR programmiert....) Allerdings verlängert sich in diesem Fall die Zeit 
um die Befehlsverarbeitungszeit in der ISR. Es ist möglich, das ein 
Interrupt mehrfach in einer Schleife erzeugt wird und somit auch 
entsprechend große Abweichungen der Delay-Zeit entsteht. Das Delay über 
Timer erzeugt selbst einen Interrupt mit einer eigenen ISR und bremst 
den Programmzyklus nicht aus. In C-Programmen wird die Bearbeitung so 
nicht deutlich. Da ich mit C nix am Hut hab, kann ich noch nicht mal 
sagen, ob der Programmierer weiß, das ein Delay eine 
programmzyklusverlängernde Wirkung hat oder einen Interrupt auslöst. Das 
könnt ihr besser.
Gruß oldmaX