Binäres UND oder logisches UND

> while((DATA == 64) && (Abbruch <= 2500))

prüft nicht, ob das Bit 2**6 gesetzt ist, sondern ob DATA == 64 ist. Es 
werden alle Bits in die Prüfung einbezogen.

Wenn du nur das Bit 64 testen willst, dann mußt du

   while((DATA & 64) && (Abbruch <= 2500))

schreiben.

Das sollte in dem Fall eigentlich überhaupt keinen Unterschied machen, 
weil die beiden Ausdrücke in den Klammern jeweils einen Wahrheitswert 
zurückgeben. Und ob man den jetzt logisch oder bitweise verundet sollte 
eigentlich fast egal sein (zwei Einsen bitweise miteinander verknüpft 
geben auch ne Eins zurück).

Was für Datentypen sind das überhaupt?

EDIT:
Ansonsten gilt natürlich das, was Uhu anspricht...

Da brauchen mir mehr code...

Erste Ideen:

Vielleicht "while((DATA = 64)& (Abbruch <= 2500))" geschrieben?
Evtl Abbruch nicht volatile, und wird in der Schleife nur von einem IRQ 
verändert?

Msp 430_crew wrote:

> Ich Frage das 6.Bit von meinem Port ab.
...
> while((DATA == 64)

Nein, genau das machst Du nicht !

Falls DATA 8-bittig ist, fragst Du alle 8 Bit ab, ob sie 0100.0000 sind 
und nichts anderes.


Kann sein, daß der andere Ausdruck ne etwas andere Laufzeit erzeugt und 
damit der erste Test übersprungen wird und der Wert schon 0100.0001 ist, 
also wieder ungleich.

0011.1111 - Test
0100.0000 - CPU gerade busy
0100.0001 - nächster Test: immer noch falsch


Peter

@johnny:

Ist nicht egal, der compiler darf

if (a!=b)

als

if (a-b)

implementieren,

und

if ((a-b) & 0x01)

ist was ganz anderes als

if ((a-b) && 0x01)

/Ernst

Ernst Bachmann wrote:
> @johnny:
>
> Ist nicht egal, der compiler darf
>
> if (a!=b)
>
> als
>
> if (a-b)
>
> implementieren,
Ah so. wieder was gelernt.

> und
>
> if ((a-b) & 0x01)
>
> ist was ganz anderes als
>
> if ((a-b) && 0x01)
Da hast Du wohl Recht...

Ernst Bachmann wrote:

> Ist nicht egal, der compiler darf
>
> if (a!=b)
>
> als
>
> if (a-b)
>
> implementieren,

Darf er nicht, das ist Mumpitz.

Er darf für "wahr" immer nur 1 liefern !

Selber muß er aber alle Werte !=0 als wahr auswerten.

Also:

1

c = a != b; // c = 0 oder 1

aber:

1

c = a - b; // c = irgendwas

Er kann natürlich optimieren, wenn der logische Wert nur als 
Sprungbedingung ausgewertet wird und keine Zuweisung erfolgt.

Edit:
Da hab ich mir also selber widersprochen.

Beim if darf er das, sonst nicht.


Peter

Peter Dannegger wrote:
> Ernst Bachmann wrote:
>
>> Ist nicht egal, der compiler darf
>> [...]
>> implementieren,
>
> Darf er nicht, das ist Mumpitz.
Hmmm... Wat denn nu?

Sorry ich hab mich falsch ausgedrückt. Also ich definiere Data so, dass 
ich mir das 7.Bit also PORT 1.6 in Data speichere.

Wenn ich das Binäre UND nehme dann geht es, beim logischen nicht.

1

2

#define DATA  (P1IN & BIT6)   //Port 1.6 kann nur 1 oder 0 sein

3

4

while((DATA == 64)& (Abbruch <= 2000))//funzt

5

{Abbruch++  //Zählvariable

6

}

7

while((DATA == 64)&& (Abbruch <= 2000))//funzt nicht

8

{Abbruch++  //Zählvariable

9

}

SORRY für meinen erste FALSCHANGABE

Danke für Eure Hilfe

Funzt bei mit auch nicht: Syntaxfehler.

Wie wäre es denn, wenn Du endlich mal damit herausrückst, was für 
Datentypen das sein sollen. Und wie "BIT6" definiert ist. Außerdem ist 
unter der Voraussetzung, dass DATA sowieso nur 0 oder 64 sein kann, die 
Abfrage "==64" überflüssig.

Johannes M. wrote:
> Wie wäre es denn, wenn Du endlich mal damit herausrückst, was für
> Datentypen das sein sollen. Und wie "BIT6" definiert ist. Außerdem ist
> unter der Voraussetzung, dass DATA sowieso nur 0 oder 64 sein kann, die
> Abfrage "==64" überflüssig.

Ach man, ich meinte natürlich das ACK meines Sensors kommt soll die 
Datenleitung auf LOW gezogen werden. Die Datenleitung ist an PORT 1.6.

Er soll solange in der while Schleife bleiben, wie noch kein ACK 
gekommen ist.

Abbruch ist ein usigned int und BIT6 = 0x0040.
Ich möchte doch nur das 7.Bit aus meinem Register P1IN Register 
auslesen. Wenn dieses von HIGH auf LOW wechselt möchte ich die Schleife 
verlassen

Ist dies nicht der Fall, so soll die Zeitbedingung greifen.

Normaler weise überprüfe ich doch ob der das BIT gesetzt ist -> also ob 
der linke Part wahr ist. Wenn dies der Fall ist und die Zeit noch 
kleiner als 2500 ist, also wahr ist soll er in der Schleife bleiben.

Hab mich wieder falsch ausgedrückt ...Sorry

Patti

Also bei einer längeren Zeit schafft er es die Schleife zu verlassen. 
Abbruch wird in der Funktion zum Anfang deklariert.

Es scheint nur an dem && Operator zu liegen. Aber das ist mir nich klar.

x == 10 && y==11 ist wahr wenn x=10 und Y=11 aber x==10 & y==11  wäre 
doch sogar der selbe Fall ind der Konstallation?

Wenn die Funktion genau umgedreht wär, wäre mir das klar.