Betriebsystem auf ARM4

[Michael W. (Gast)]

Ich habe ein System unter uCOS oder freeRTOS Betriebssystem auf einem 
leistungsfähigen ARM4 zu implementieren.
In einer Funktion nehme ich eine HW-Ressource des Controllers in 
Anspruch, um eine AES Verschlüsselung durchzuführen. Dabei muss ich 
warten, bis ein Zwischenergebnis da ist, und kann dann weitermachen.

Das Vorliegen des Zwischenergebnisses wird durch ein Status Flag 
signalisiert.
Nun kann ich ja nur schlecht in einer Schleife warten, bis das Ergebnis 
da ist (es gibt ja andere Prozesse, die drankommen wollen, außerdem ist 
das Verschlüsseln niederprior).

Also lasse ich mich über einen Interrupt darüber informieren, dass die 
HW fertig ist.

Mein Code sieht so aus:

Rufe_HW_auf_um_etwas_zu_tun();

Take_semaphore();
// hier wird auf freien (binären) semaphor gewartet. Andere tasks kommen 
inzwischen dran

mache_weiter()...


In der Interrupt Routine:

wenn (flag gesetzt):
   give_semaphore();
   return;


uCOS und freeRTOS unterstützen definitiv "give semaphore" aus einer 
interrupt routine, und es wird auch empfohlen den beschriebenen Ablauf 
so zu machen.

Habe das getestet : 10 parallele Tasks greifen so alle 10ms auf die 
gleiche Funktion zu. Kein einziger Fehler, seit 2 Tagen.


Trotzdem habe ich etwas Skrupel, da einige Kollegen meinen, dass man das 
so nicht so macht. Ohne OS würde ich das natürlich auch anders machen, 
aber wenn schon OS, warum dann nicht so? Ist das so wirklich vollkommner 
Mist ? Wie dann? Ich sehe irgendwie nicht ein, wieso man hier mit 
selbstgestrickten Verriegelungen arbeiten soll, wenn ich ein OS habe, 
das genau das für mich macht. Sind Semaphore denn Teufelswerk?


Danke !

[Peter (Gast)]

Alternativ kannst Du die Berechnung in einen Task schieben und über eine 
MSG die Daten (Pointer darauf) übergeben. Wenn Die Berechnung fertig ist 
einfach dem MSG Sender eine Rückantwort senden das Du fertig bist.

Peter

[Dr. Sommer (Gast)]

ARM4? Was soll das denn sein? Laut Internet gibts nur ARM3, ARM6, ... 
aber die sind auch uralt.

[(prx) A. K. (prx)]

Und wenn es einen ARM4 gegeben haben sollte, dann wäre er für heutige 
Verhältnisse nicht leistungsfähig.

[123 (Gast)]

Arm4 = cortex m4?

Und was gefällt den Kollegen daran nicht?
Wie wûrden die das machen?

[(prx) A. K. (prx)]

Michael W. schrieb:
> Sind Semaphore denn Teufelswerk?

Nein.

[Michael W. (Gast)]

123 schrieb:
> Arm4 = cortex m4?

Ja sorry

>
> Und was gefällt den Kollegen daran nicht?
> Wie wûrden die das machen?

Heißt das nun, es ist ok wie ich es mache?

[Christian K. (the_kirsch)]

Berechnung in einen Task auslagern
nach dem Start der Berechnung Task schlafen legen

ISR benutzen, die den Task nach Beendigung der Kryptoroutine wieder 
weckt.

http://www.freertos.org/xSemaphoreCreateBinary.html
Den Task mit xSemaphoreTake(handle) schlafen legen
und in der ISR xSemaphoreGiveFromISR(handle) zum aufwecken

[Michael W. (Gast)]

ich verstehe die Antwort nun nicht, denn genau so mache ich es ja...
ich habe nur abstrakte funktionsnamen verwendet, um mich bei der Antwort 
nicht an freeRTOS zu binden.
Das würde heißen, mindestens einer auf der Welt würde es auch so machen. 
Das reicht aus, um mich zu bestärken.

[Christian K. (the_kirsch)]

Michael W. schrieb:
> Das würde heißen, mindestens einer auf der Welt würde es auch so machen.
> Das reicht aus, um mich zu bestärken.


Dann ist ja alles Gut.

Ich hatte auch mal das Problem, eine ISR mit einem Task zu 
synchronisieren.
Hatte das zuerst mit xTaskNotifyWait()/xTaskNotifyFromISR() gelöst.

nur hatte ich da eine Verzögerung von bis zu 30ms bis der Task 
aufgewacht ist. Hatte dann irgendwo auf der FreeRTOS Seite gelesen das 
der empfohlene Weg über Binary-Semaphore geht. Mit der Einschränkung es 
geht nur mit ISRs bis zu einer Prio von 4.

Hatte in den sauren Apfel gebissen und die Prio meiner ISR runter 
gesetzt. Dafür wacht der Task jetzt aber sofort auf.