Effizientes Programmieren mit Mikrocontroller

OP #1564694
Lesenswert?

Hallo,

ich suche ein Buch oder Tutorial, welches erklärt wie man einen 
Mikrocontroller optimal ausnutzt.
Also wenn der Controller mehrere Funktionen abarbeiten soll, dass dieser 
zb. nicht so lange in Delay-Schleifen hängt weil er ja in dieser Zeit 
andere Aufgaben erledigen kann.

Gibt es dazu irgendwelche Techniken ??

Gruß
Andre
Gast #1564783
Lesenswert?

Na, ich fing auch mal klein an.

Mit Büchern wie Mikrocontroller-Kochbuch von Andreas Roth, und aus dem 
Elektor-Verlag. Bevor es Internet gab.

Heute, würde ich alles wichtige im Internet finden, wenn nicht sogar 
hier im Forum.
#1564799
Lesenswert?

Nunu Stone schrieb:

> Also wenn der Controller mehrere Funktionen abarbeiten soll, dass dieser
> zb. nicht so lange in Delay-Schleifen hängt weil er ja in dieser Zeit
> andere Aufgaben erledigen kann.
>
> Gibt es dazu irgendwelche Techniken ??

Keine _delay_xx Funktionen benutzen?


Im Ernst, die Technik heißt hier im Forum 'Jobflags benutzen'.

Für jede Aufgabe gbt es ein Flag, das anzeigt, ob diese Arbeit (der Job) 
jetzt gerade erledigt werden muss.

In der Hauptschleife steht dann
1
int main()
2
{
3
  ...
4

5
  while( 1 ) {
6

7
    if( Job1_Needs_to_be_done ) {
8
      perform Job1;
9
      Job1_Needs_to_be_done = FALSE;
10
    }
11
 
12
    if( Job2_Needs_to_be_done ) {
13
      perform Job2;
14
      Job2_Needs_to_be_done = FALSE;
15
    }
16

17
    ...
18

19
    if( Jobn_Needs_to_be_done ) {
20
      perform Jobn;
21
      Jobn_Needs_to_be_done = FALSE;
22
    }
23
  }
24
}

Um einen Job zur Auführung zu bringen, wird sein Jobflag auf TRUE 
gesetzt. Meistens passiert das in einer Interrupt Routine, die zb von 
einem Timer angestossen wird. Das muss aber nicht so sein. Im Grunde 
kann jeder Code so ein Jobflag auf TRUE setzen.

Wichtig ist, dass kein Job den Prozessor mehr als eine gewisse Zeit 
blockieren darf. Warteschleifen sind tabu.
Wenn ein Job tatsächlich mal etwas länger dauern wird, dann muss man ihn 
eben auf ein paar Teiljobs aufteilen, wobei dann ein Job den nächsten 
aktiviert. Wenn ein Job zwischendurch auf etwas warten muss, dann teilt 
man das auf 3 Jobs auf

     Job 1: den Teil vor der Warteschleife. Ist der Teil fertig, wird
     am Ende der Job 2 mittels Jobflag aktiviert und Job 1
     deaktiviert sich.

     Job 2: seine Aufgabe ist es, das Ende der Warterei zu erkennen.
     Erkennt er es, dann aktiviert er mittels Jobflag den Job 3 und
     deaktiviert sich selbst. Ist das Ende der Warterei nicht in Sicht
     dann bleibt der Job aktiviert, so dass beim nächsten Durchlauf
     durch die while Schleife er wieder zum Zug kommt, und erneut auf
     das Ende der Warterei prüft.

     Job 3: Alles was nach der Warterei passieren muss.


Das ganze geht dann auch schon in den Bereich der Statemachines hinein 
und oft hat nman eine Mischung aus beidem: einer Statemachine 
(Zustandsmaschine) und Jobflags.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren