mikrocontroller.net

Forum: Compiler & IDEs Bitweises vergleichen von Variablen


Autor: Alex (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Ich versuche mich gerade an einem Kabeltester und bin am verzweifeln. 
Ich habe ein Kabel mit 10 Leitungen. Also habe ich 10 Ausgänge und 10 
Eingänge. Ich gebe auf die Ausgänge nacheinander ein 5V-Signal und messe 
bei den Eingängen was ankommt. Manchmal ist in den Steckern gewollt eine 
Brücke. Um sämtliche Kabelbelegungen nicht softwaretechnisch speichern 
zu müssen gibt es einen Lernmodus. Man steckt ein Musterkabel auf uns 
drückt auf einen Taster. Der Atmega8535 merkt sich das was beim Muster 
zurückkommt als Referenz. Dann soll man mit einem Taster "Messen" andere 
Kabel auf Unterschiede zum Muster durchmessen können.

Nun zu meinem Problem: Ich speichere die 10 Eingangssignale in einem 10 
Felder großen uint16_t array ab. Bei der Messung werden wie bei dem 
Lernmodus ebenso auf alle Leitungen nacheinander 5V gegeben und dann 
soll der Wert an PINC bzw. PIND mit dem gespeicherten Wert verglichen 
werden. Wenn das Programm im Debugger in die Funktion vergleiche_pin() 
reinspringt zeigt er mir für die übergebene Variable "vergleichswert" 0 
an. An PD3 liegt ebenfalls 0V an. Trotzdem springt die Result-Variable 
"res" auf 0. wieso? Mache ich beim Bitvergleich irgendwas falsch? 
Verträgt er evtl den Vergleich eines 8-Bit mit einem 16-Bit Wert nicht? 
Speichert er den 16-Bit Wert anders ab (LSB, MSB)? Ich komm nicht 
weiter!

Danke für eure Antworten!

Gruß,

Alex





void naechster_pin(volatile int akt_pin) {
//Gibt immer auf den nächsten Pin eine 1 und setzt alle anderen Pins auf 0
if (akt_pin==1) {
PORTB=0b00010000;
PORTA=0b00000000;
}

... usw. ...

if (akt_pin==10) {
PORTB=0b00000000;
PORTA=0b00010000;
}

}
//Ende function naechster_pin()



volatile uint16_t lerne_pin(void) {
//Liest die Eingänge und schreibt Bitweise 
volatile uint16_t res;

if (PIND & (1<<PD3) ) res |= (1<<0); else res &= ~(1<<0);
if (PIND & (1<<PD4) ) res |= (1<<1); else res &= ~(1<<1);
if (PIND & (1<<PD5) ) res |= (1<<2); else res &= ~(1<<2);
if (PIND & (1<<PD6) ) res |= (1<<3); else res &= ~(1<<3);
if (PIND & (1<<PD7) ) res |= (1<<4); else res &= ~(1<<4);
if (PINC & (1<<PC0) ) res |= (1<<5); else res &= ~(1<<5);
if (PINC & (1<<PC1) ) res |= (1<<6); else res &= ~(1<<6);
if (PINC & (1<<PC2) ) res |= (1<<7); else res &= ~(1<<7);
if (PINC & (1<<PC3) ) res |= (1<<8); else res &= ~(1<<8);
if (PINC & (1<<PC4) ) res |= (1<<9); else res &= ~(1<<9);

return res;

}




volatile int vergleiche_pin(volatile uint16_t vergleichswert) {
//Liest die Eingänge und vergleicht mit Speicher
volatile int res; //result
res=1;
if ( (PIND & (PD3)) !=(vergleichswert & 0b0000000000000001)) res=0;
if ( (PIND & (PD4)) !=(vergleichswert & 0b0000000000000010)) res=0;
if ( (PIND & (PD5)) !=(vergleichswert & 0b0000000000000100)) res=0;
if ( (PIND & (PD6)) !=(vergleichswert & 0b0000000000001000)) res=0;
if ( (PIND & (PD7)) !=(vergleichswert & 0b0000000000010000)) res=0;
if ( (PIND & (PC0)) !=(vergleichswert & 0b0000000000100000)) res=0;
if ( (PIND & (PD1)) !=(vergleichswert & 0b0000000001000000)) res=0;
if ( (PIND & (PD2)) !=(vergleichswert & 0b0000000010000000)) res=0;
if ( (PIND & (PD3)) !=(vergleichswert & 0b0000000100000000)) res=0;
if ( (PIND & (PD4)) !=(vergleichswert & 0b0000001000000000)) res=0;
return res;
}
//Ende function vergleiche_pin()




int main(void) {
volatile int i=0;
volatile int gelernt=0;
volatile uint16_t p[11]={1};
int j=1;
while (j=1) {
//Datenrichtungen bestimmen
DDRA = 0b11111111;
DDRB = 0b11111111;
DDRC = 0b00000000;
DDRD = 0b00000111;
PORTC = 0b01100000; //Pullup Wahltaster und 12Pin

while (!( PINC & (1<<PC6))) { //Lerntaster

for (i=1; i<11; i++) {
naechster_pin(i);
p[i-1]=lerne_pin();
}
gelernt=1;
} //Ende Lerntaster

while (!( PINC & (1<<PC5))) { //Messtaster
if (gelernt==1) {  //Abbruch wenn nicht gelernt
for (i=1; i<10; i++) {
naechster_pin(i);
if (vergleiche_pin(p[i-1])==1) {
PORTD |= (1 << PD2);  // LED OK an
PORTD &= ~(1 << PD1);  // LED FAIL aus
} else {
PORTD |= (1 << PD1);  // LED FAIL an
PORTD &= ~(1 << PD2);  // LED OK aus

}
}
} //Abbruch wenn nicht gelernt
} //Ende Lerntaster
}
}


Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
if ( (PIND & (PC0)) !=(vergleichswert & 0b0000000000100000)) res=0;

PIND -> PINC

if ( (PIND & (PD1)) !=(vergleichswert & 0b0000000001000000)) res=0;
if ( (PIND & (PD2)) !=(vergleichswert & 0b0000000010000000)) res=0;
if ( (PIND & (PD3)) !=(vergleichswert & 0b0000000100000000)) res=0;
if ( (PIND & (PD4)) !=(vergleichswert & 0b0000001000000000)) res=0;

Und hier wolltest du wohl auch eher PINC und PCx haben.
Außerdem überall "(PXx)" durch "(1<<PXx)" ersetzen.
Wird aber trotzdem nicht funktionieren, denn da die Bitpositionen von 
den Ports und in res nicht übereinstimmen, kannst du nicht mit einem 
direkten Vergleich arbeiten.

(Rest des Codes habe ich mir nicht weiter angeschaut)

PS: Du hast offensichtlich die Bedeutung von "volatile" nicht 
verstanden. Das bitte nochmal nachlesen.

Autor: Alex (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Vielen Dank für den Hinweis. Du hast aber Recht - es funktioniert 
trotzdem nicht.

volatile bedeutet doch, dass der Compiler die Variablen nicht optimieren 
(kürzen) soll, damit diese verändert werden können und kein Speicher 
überschrieben wird, oder? Deswegen habe ich jede verändernde Variable so 
deklariert. Ich werde es mir aber nochmal durchlesen.

Trotzdem bleibt mir ein Verständnisproblem. Mit
((PIND & (1<<PD1))

selektiere ich doch das Bit und es sollte als Ergebnis 0 oder 1 geben. 
Mit
(vergleichswert & 0b0000000001000000))

wird ebenfalls ein Bit ausgewertet was zu einem Ergebnis 0 oder 1 führen 
sollte. Diese sollte das Programm doch auswerten können, oder?

Autor: Fred S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Alex,

> überschrieben wird, oder? Deswegen habe ich jede verändernde Variable so
> deklariert. Ich werde es mir aber nochmal durchlesen.
Vor Deine Funktionen gehört kein "volatile", auch nicht vor die 
Variablen innerhalb der Funktionen (falls eine Variable von einem zum 
nächsten Aufruf erhalten bleiben soll, sollte sie "static" sein).  Es 
wird nicht schaden, alle globalen Variablen "volatile" zu machen. Das 
ist stark vereinfacht, sollte aber am Anfang OK sein.

> Trotzdem bleibt mir ein Verständnisproblem. Mit
>
((PIND & (1<<PDx))
> selektiere ich doch das Bit und es sollte als Ergebnis 0 oder 1 geben.
Ja, Du selektierst das Bit; nein, das Ergebnis kann zwischen 0 und 128 
liegen!
Stell Dir vor, bit 3 in PIND ist gesetzt und Du verknüpfst
PIND&(1<<PD3)
Also bekommst Du 0b1000 als Ergebnis; nicht 1 und nicht 0!

> mit
(vergleichswert & 0b0000000001000000))
> wird ebenfalls ein Bit ausgewertet was zu einem Ergebnis 0 oder 1 führen
> sollte.
Siehe oben -- gleiches Problem! Und dann vergleichst Du 8-Bit mit 
16-Bit-Werten; Gleichheit kann nur dann gegeben sein, wenn der 16-Bit 
Wert <256 ist.

Gruß

Fred

Autor: Alex (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
aah - jetzt verstehe ich es.

Ich habe das Problem mittlerweile so gelöst, dass ich wie in der 
Lernphase die Pegel an PINC und PIND in einer 16-Bit Variable speichere 
und beide Werte zum Schluß vergleiche. So funktioniert es.

Vielen Dank für die schnelle Hilfe(n).

Gruß,

Alex

Autor: Jörg Wunsch (dl8dtl) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Fred S. wrote:

> Es
> wird nicht schaden, alle globalen Variablen "volatile" zu machen.

Doch: die fehlende Optimierung kann man schon als Schaden ansehen,
das ist einfach lausig.

Selbst solche Variablen, die volatile sein müssen, cachet man u. U.
besser in einer separaten (lokalen) Variable, bspw. innerhalb einer
ISR, um die durch volatile entstehende Pessimierung der Zugriffe
abzufedern.

Autor: Fred S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Jörg,

erklär das mal bitte dem OP so, dass er es auch versteht. Ich habe extra 
dazugeschrieben, dass das "stark vereinfacht" ist und ich dies "am 
Anfang" empfehle und hatte mir sogar überlegt, eine Warnung 
dazuzuschreiben, um nicht gleich eine Flame wie Deine auszulösen. Deine 
in meinen Augen überaggressive Reaktion (als "einfach lausig" lasse ich 
meine Hilfestellung, die eindeutig der Erfahrung des OP angepasst war, 
nicht sehr gerne bezeichnen!), wo ich nicht verallgemeinert habe, finde 
ich sehr bedauerlich. Wo siehst Du ein Problem durch "fehlende 
Optimierung" beim obigen Code?

Gruß

Fred

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich kann Jörg nur beipflichten: volatile sollte man ganz bewusst 
einsetzen, auch als Anfänger. Pauschal alle externen Variablen damit zu 
schmücken, ist blanker Unsinn. Auch für Anfänger.

volatile sagt dem Compiler, daß sich diese Variable ändern kann, ohne 
das dieses für ihn aus dem Programm ersichtlich ist. Prinzipiell "weiss" 
der gcc aber immer ganz genau, ob sich der Wert einer Variable seit der 
letzten Benutzung geändert haben kann. Kann sich der Wert nicht geändert 
haben, nutzt er alle Optimierungsmöglichkeiten, z.B, den Wert in einem 
Register zu halten, anstelle den Speicher bei jeder Verwendung neu zu 
lesen.

Die einzigen Fälle, die der Compiler übersieht (weil C das per 
Definition gar nicht kennt), sind Variablen, die in einer ISR UND in 
einem Hauptprogramm verwendet werden, sowie Adressen im Speicherbereich, 
die sich selbständig ändern (IO-Register, Hardwarezähler, usw.). Dafür 
ist volatile da.

Im o.a. Programm gibt es gar keine ISR. Insofern braucht es da nirgends 
ein volatile. Die IO-Register sind in den ioxxx.h-headern sowieso 
volatile definiert.

Oliver

Autor: Jörg Wunsch (dl8dtl) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Fred S. wrote:

> ..., um nicht gleich eine Flame wie Deine auszulösen.

Naja, irgendwie übertreibst du ganz schön.

> Deine
> in meinen Augen überaggressive Reaktion (als "einfach lausig" lasse ich

Sorry.  Es war wohl leider doch etwas zu früh am morgen. :-(  Das
sollte eigentlich heißen: ,,der dabei generierte Code ist einfach
lausig''.  Das war keineswegs auf deine Hilfestellung bezogen.

> Wo siehst Du ein Problem durch "fehlende
> Optimierung" beim obigen Code?

Wenn jemand nicht optimieren will, soll er einfach mit -O0 arbeiten.

Wenn aber jemand offensichtlich keine rechte Vorstellung davon hat,
was volatile bewirkt (einerseits, warum man es manchmal braucht,
andererseits, wie schlecht der generierte Code davon wird), dann
ist es in meinen Augen halt kein guter Rat, ihm zu schreiben: ,,lass
es erstmal, kann ja nichts schaden''.  Der in meinen Augen bessere
Rat wäre es gewesen: ,,lass volatile erstmal weg, bis du weißt, warum
und wofür man es braucht''.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.