Abfrage auf Null oder "Nicht"!?

Variante 1 und Variante 2 machen verschiende dinge, da macht ein 
vergleich keinen sinn.

Schau dir doch selber den ASM code an.

Mure schrieb:
> Die jeweilige Funktion VarianteX, kann durch Interrupts mehrfach
> aufgerufen werden. Des Wegen die Sperre.

Du hast in diesem Zusammenhang hoffentlich an einen Cache-Flush gedacht, 
oder?

Stefan Ernst schrieb:
> Was, wenn der Interrupt
> zwischen dem "if" und dem "i = 1;" auftritt?

Äh. Gute Frage! - Nächste Frage! Wie löse ich das Problem?

Stefan Ernst schrieb:
> Edit: Allerdings machen Variante 3 und 4 was anderes.

Nochmal Äh! - Richtig erkannt. Falsch von mir getippt!

void Variante3()
{
  if(i != 1)
   {
     i = 1;
     /* Code ausführen */
     i = 0;
   }
}


void Variante4()
{
  if(i > 0)
   {
     return;
   }

  i = 1;
  /* Code ausführen */
  i = 0;
}

Doof schrieb:
> Du hast in diesem Zusammenhang hoffentlich an einen Cache-Flush gedacht,
> oder?

Ein was!? - Nö! Bin wohl doofer als du...

Stefan Ernst schrieb:
>> Variante 1 und Variante 2 machen verschiende dinge
>
> Nö. "!i" und "i == 0" sind identisch.

Das stimmt schon, aber es trotzdem Varianten dabei, die nicht dasselbe 
tun.

Beispiele:

> void Variante4()
> {
>   if(i > 0)
>    {
>      i = 1;
>      /* Code ausführen */
>      i = 0;
>    }
> }
hier wird bei i>0, also auch bei i==1 der Code ausgeführt,
und

> void Variante6()
> {
>   if(i == 1)
>    {
>      return;
>    }
>
>   i = 1;
>   /* Code ausführen */
>   i = 0;
> }

hier kommt bei i==1 'return' und der Code wird nicht ausgeführt.

Ja aber eine Semaphore und Mutex macht doch auch nichts anderes, als 
sich ein Flag zu setzten ... Mein Flag ist halt "i = 1".
Ich sehe hier den unterschied nicht.

Hm. Kurz nachgedacht. - Wäre dann:

1

void Variante7()

2

{

3

 i++;

4

 if(i == 1)

5

  {

6

    /* Code ausführen */

7

  }

8

 i--;

9

10

 return;

11

}

besser!?

Dann müsste man noch i als volatile definieren, dass auch bei der 
if-Abfrage diese neu eingelesen werden muss:

1

volatile unsigned char i;

2

void Variante7()

3

{

4

 i++;

5

 if(i == 1)

6

  {

7

    /* Code ausführen */

8

  }

9

 i--;

10

11

 return;

12

}

Stefan Ernst schrieb:
> Was ich in meinen Post ja auch ergänzt hatte. ;-)

Jaja, nachdem ich meinen geschrieben hatte ... :-)

Mure schrieb:
> Dann müsste man noch i als volatile definieren

Solange i++ nicht mit einer atomaren Operation errechnet werden kann, 
nutzt volatile überhaupt nichts, denn dann kann da immer noch ein 
Interrupt dazwischenfunken.

Es nutzt nichts, da muust du die Doku zu deinem Compiler und deinem 
Prozessor lesen, und dafür sorgen, daß i++ oder i=1, oder was auch 
immer, nicht unterbrochen werden kann.

Oliver

Oliver schrieb:
> Es nutzt nichts, da muust du die Doku zu deinem Compiler und deinem
> Prozessor lesen, und dafür sorgen, daß i++ oder i=1, oder was auch
> immer, nicht unterbrochen werden kann.

Ich google schon wie blöde. Finde aber für nen MSP430 keinen Code für ne 
Mutex...

Du bräuchtest eine Konstruktion wie diese

1

void funktion(...)

2

{

3

  Disable_Interrupts();

4

  if (lock == 0)

5

  {

6

    lock = 1;

7

    Enable_Interrupts();

8

    // Dein Code

9

    lock = 0;

10

    return;

11

  }

12

  Enable_Interrupts();

13

  // return

14

}

Setzt voraus, daß die Zuweisung

1

    lock = 0;

atomar abläuft.

P. M. schrieb:
> Kann man recht einfach auch selber schreiben.

Wenn man weiß wie's geht. Assembler kann ich leider nicht ...


P. M. schrieb:
> der mache die Zuweisung
> an i einfach atomar, indem du Interrupts kurz ausschaltest.

Quasi so was:

1

#define EnterMutex(_myMutex)   _DINT(); /* Disable Global interrupt */ \

2

                               _myMutex++; \

3

                               if(_myMutex != 1){ \

4

                                  goto _LeaveMutex; \

5

                               } \

6

                               _EINT(); /* Enable Global interrupt */\

7

8

#define LeaveMutex(_myMutex)   _DINT(); /* Disable Global interrupt */ \

9

                               _myMutex--; \

10

                               _EINT(); /* Enable Global interrupt */\

11

12

13

unsigned char i;

14

void Variante7()

15

{

16

  EnterMutex(i);

17

  /* Code ausführen */

18

  LeaveMutex(i);

19

20

 return;

21

}

Aber streng genommen müsste ich den Zustand von Global Interrupt Flag 
abfragen, bevor ich es setze. Ich glaube es ist möglich, das die Mutex 
betreten wird (Main-Loop), wenn der globale Interrupt deaktiviert ist.

Bronco schrieb:
> Du bräuchtest eine Konstruktion wie diese ...

Sieht eigentlich wie meine aus.

Mure schrieb:
> Bronco schrieb:
>> Du bräuchtest eine Konstruktion wie diese ...
>
> Sieht eigentlich wie meine aus.

Ah! - Da fehlt das Label!

1

#define LeaveMutex(_myMutex) _LeaveMutex: 

2

                                _DINT(); /* Disable Global interrupt */ \

3

                                _myMutex--; \

4

                                _EINT(); /* Enable Global interrupt */\

Wieso ist es jetzt hier plötzlich so "still"?!?

Mure schrieb:
> Bronco schrieb:
>> Du bräuchtest eine Konstruktion wie diese ...
> Sieht eigentlich wie meine aus.
Mure schrieb:
> goto _LeaveMutex; \


Nein, in meiner Konstruktion wäre ganz gewiß kein GOTO!

Kan asta schrieb:
> Ich weiß ne Lösung!
>
> Der C-Chef sagt, so geht das:
> (i == 0) ? i = 1 : i = 0;
>
> Eine Zeile, ein Befehl, alles atomar.
Das ist aber gelogen...

Bronco schrieb:
> Nein, in meiner Konstruktion wäre ganz gewiß kein GOTO!

Richtig, aber was ist daran so schlimm?

Sven P. schrieb:
>> Eine Zeile, ein Befehl, alles atomar.
> Das ist aber gelogen...

Det habe ich mich grad auch gefragt.

Mure schrieb:
> Sven P. schrieb:
>>> Eine Zeile, ein Befehl, alles atomar.

Die gilt nur für Basic Interpreter, die arbeiten nähmlich alles Zeile 
für
Zeile ab. Teilweise sogar für Compiler.

Ach ja klar, bei der Syntax der vorangegagenen Beispiele habe ich auch 
sofort an Basic gedacht... und zwar an genau eines der zehntausend 
verschiedenen Dialekte, welches zeilenweise tut :-)

Sven P. schrieb:
> bei der Syntax der vorangegagenen Beispiele habe ich auch
> sofort an Basic gedacht

Jetzt mal ohne SCh***. - Gibt es Basic für die 
Mikrocontroller-Porgrammierung?

Rufus Τ. Firefly schrieb:
> Bascom.

http://www.mcselec.com/index.php?option=com_content&task=view&id=14&Itemid=41
Was es nicht alles gibt ....
Aber Bascom scheint es nur für AVR zu geben.

Gruß
Mure

Zurück zum ursprünglichen Problem:
Richtig schlau bin ich jetzt aber noch immer nicht!

Wie macht man jetzt am Besten eine Mutex für den MSP?
Und zwar so, dass ich diese als Funktion oder Makro habe und in beliebig 
vielen Codeabschnitten einsetzen kann?!?

Gruß
Mure

Mure schrieb:
> Sven P. schrieb:
>>> Eine Zeile, ein Befehl, alles atomar.
>> Das ist aber gelogen...
>
> Det habe ich mich grad auch gefragt.

Hey Mure,

falls Du das wirklich nicht weißt:
Atomar bedeutet, daß es für die CPU ein ununterbrechbarer Vorgang ist.
Das sind z.B. einzelne Maschinen/Assembler-Befehle.
C-Code wird vom C-Compiler in Maschinen-Code umgewandelt.
D.h. ein C-Befehl ergibt oft in mehrere Maschinen-Befehle und ist 
damit nicht atomar!

Bsp:
8-Bit Microcontroller macht

1

uint32_t x:

2

x++;

Das x++ erzeugt in vier Assembler-Befehle, weil die CPU pro Befehl nur 
jeweils 8 der 32Bit berechnen kann.

So ist es ein sehr typischer Fehler, auf Variablen aus dem Interrupt 
heraus zuzugreifen, dabei solche Befehlsblöcke zu unterbrechnen und 
damit den Variableninhalt zu zerstören.

Falls Du IAR verwendest: lies mal "Monitor"-Funktionen in der Doku nach.

Bronco schrieb:
> Atomar bedeutet, daß es für die CPU ein ununterbrechbarer Vorgang ist.

Habe ich inzwischen verstanden. Deswegen wird ja auch der GIE 
deaktiviert.
Aber mit meinem Makro warst du aber nicht zufrieden.

Bronco schrieb:
> Falls Du IAR verwendest

Nein. Habe Code Composer Studio.