bits binair hex ra ra wat doe ik niet goed &

[babbelkwebbel Profiel Privébericht]

Beste Allemaal,

Ik ben bezig met de MCP23017 controller, de bedoeling hier mee is dat ik 4 raam magneet schakelaars
in lees om te bepalen of een raam open dan wel dicht is.
Ik lees de waarde van de schakelaars in de variable inputs, hier laat ik vervolgens de bitwise AND functie op los, om 1 voor 1 te testen welke raam open of dicht is, echter na een zondag middag stoeien er mee, krijg ik het niet voor elkaar, ben er zeker van dat het probleem ergens in 1 van deze regels zit
if ((inputs) & 1 == 1), zodra ik schakelaar 1 bedien krijg ik de output zoals onder aan het programma staat, en wat ik niet snap is de uitkomst van de AND functie, wie geeft mee even het zetje in de goede richting, kennelijk kijk ik er overheen.

bij voorbaat dank
Erik,
cpp code

/* TEST PROGRAM WITH THE mcp23017 i2c 16 LINE I/O controller */

#include "Wire.h"
byte inputs=0;
int window_bedroom=0;
int window_laundryroom=0;
int window_serverroom=0;

 
void setup()
{
  Serial.begin(115200);
  Wire.begin(); // wake up I2C bus
 
  Wire.beginTransmission(0x20);
  Wire.write(0x00); // IODIRA register
  Wire.write(0x00); // set all of bank A to outputs
  Wire.endTransmission();

  
  
}
 
void loop()
{
  
  Wire.beginTransmission(0x20);                             // read the inputs of bank B
  Wire.write(0x13);
  Wire.endTransmission();
  Wire.requestFrom(0x20, 1);
  inputs=Wire.read();
 
  
  Wire.beginTransmission(0x20);                             // now send the input data to bank A
  Wire.write(0x12);                                         // GPIOA
  Wire.write(inputs);                                       // bank A
  Wire.endTransmission();
  inputs=~inputs;                                           // inverts bits  
  Serial.println (inputs, BIN);                             // print BIN format
  Serial.println (inputs, DEC);                             // print DEC format
  Serial.println ("         ");                             // print blank line
  
  if(inputs > 0)                                            // if inputs == 0, all windows are closed
    { Serial.println ("window(s) are open!!!  ");
      Serial.println ("                             ");    

      if ((inputs) & 1 == 1)                                // check of window open is ( switch binair value is 0001 
      {                                                     // BITWISE AND with 0001 = 0001 as result decimal 1  
      Serial.print   ("left window bedroom open  ");  
      Serial.print   ("value left window switch 1 = ");
      Serial.println (inputs);
      Serial.println ("                             ");
      }
    
      if ((inputs) & 2 == 2)                                // check of window open is ( switch binair value is 0010
      {                                                     // BITWISE AND with 0010 = 0010 as result decimal 2
      Serial.print   ("right window bedroom open  ");  
      Serial.print   ("value right window switch 2 = ");
      Serial.println (inputs);
      Serial.println ("                             ");
      }

      if ((inputs) & 4 == 4)                                // check of window open is ( switch binair value is 0100
      {                                                     // BITWISE AND with 0100 = 0100 as result decimal 4
      Serial.print   ("window serverroom open  ");          
      Serial.print   ("value window switch 4 = ");            
      Serial.println (inputs);
      Serial.println ("                             ");
      }

      if ((inputs) & 8 == 8)                                // check of window open is ( switch binair value is 1000
      {                                                     // BITWISE AND with 1000 = 1000 as result decimal 8
      Serial.print   ("window laundryroom open  ");  
      Serial.print   ("value window switch 8 = ");
      Serial.println (inputs);
      Serial.println ("                             ");
      }
    
    }  
    delay(1000); 
    }

/* AND THIS IS THE OUTPUT !!!

window(s) are open!!!!!

left window bedroom open value left window switch 1 = 1

right window bedroom open value right window switch 2 = 1

window serverroom open value window switch 4 = 1

window laundryroom open value window switch 8 = 1

*/

[shooter Profiel Privébericht]

byte vier=4; zou ik erbij zetten dan weet je zeker dat het een byte is want nu is het dus een int.
ook voor de andere.

Code: Alles selecteren

if ((inputs & 4) == 4) // heb hier een haakje verplaatst
want nu staat er eigenlijk 4==4 en dan inputs & 4 check of window open is ( switch binair value is 0100
{ // BITWISE AND with 0100 = 0100 as result decimal 4 ja dat klopt
Serial.print ("window serverroom open ");
Serial.print ("value window switch 4 = ");
Serial.println (inputs); de uitkomst is hier geen 1 maar de byte die binen komt.

Serial.println (" ");
}

[shooter Profiel Privébericht]

oja netheidsdingetje geef de inverted inputs een andere naam, dat is bij debuggen wel handig.

[babbelkwebbel Profiel Privébericht]

Hallo Paul,

Bedankt voor het mee denken, het werkt inderdaad nu goed zoals het bedacht was, alleen de uitvoering liet even op zich wachten!.
En zo simpel haakje, en het maar niet zien, goed daar ben ik een halve zondag mee bezig geweest.

Nogmaals bedankt
Groet Erik,

[nicoverduin Profiel PrivéberichtWebsite]

De moeite waard om te bewaren : http://en.cppreference.com/w/c/language ... precedence

[babbelkwebbel Profiel Privébericht]

Hallo Nico,

Wat je noemt een stevig stuk materie, die bewaar ik voor de vakantie, wel even snel doorgebladerd, maar net zo snel weer gesloten anders zit ik weer tot diep in de nacht te lezen.

Bedankt voor je post en reactie.

Groet Erik,

[nicoverduin Profiel PrivéberichtWebsite]

Of consequent haakjes gebruiken. Zit je altijd goed. Net als algebra vroeger.

[shooter Profiel Privébericht]

if ((inputs & 4) == 4)
dit is niet echt leesbaar
makkelijker is dan
boolean raam2=((inputs&4)==4)
mag zelfs inputs&4 zijn want 0 is false en de rest is true (niet erg netjes maar werkt wel)
enz voor
dan kun je zeggen if (raam2) {} zelfs hier moeten haakjes (nou ja eigenlijk niet, maar is wel netter.) sorry bijna een haakje vergeten

[nicoverduin Profiel PrivéberichtWebsite]

Zelf zou ik voor bitRead() gekozen hebben. Hier ff een voorbeeld om een getal van 1 tot 255 te laten lopen en dan per bit uitprinten.
cpp code

#include "Arduino.h"

byte waarde = 1;		// we beginnen bij 1

void setup(){
	Serial.begin(9600);
}
void loop(){
	//
	// voer uit zolang we niet bij 256 zijn (overflow in dit geval)
	//
	while (waarde != 0) {
		//
		// print de bitjes uit waarbij we elk bitje apart uitlezen uit de byte
		//
		for (int8_t i = 7; i >= 0; i--) {
			Serial.print(bitRead(waarde, i));
		}
		Serial.println();
		//
		// verhoog de waarde
		//
		waarde++;
	}
}

Jij zou in jouw programma dan als volgt kunnen aftesten:

Dit:
cpp code

if ((inputs) & 4 == 4)                                // check of window open is ( switch binair value is 0100
      {                                                     // BITWISE AND with 0100 = 0100 as result decimal 4
      Serial.print   ("window serverroom open  ");          
      Serial.print   ("value window switch 4 = ");            
      Serial.println (inputs);
      Serial.println ("                             ");
      }

wordt dan:

cpp code

if (bitRead(inputs,3))                                       // omdat true = 1 kunnen we volstaan met deze test. En binary indexen beginnen bij 0 niet 1.
{                                                                    // BITWISE AND with 0100 = 0100 as result decimal 4
      Serial.print   ("window serverroom open  ");          
      Serial.print   ("value window switch 4 = ");            
      Serial.println (inputs);
      Serial.println ("                             ");
}

En als je bovenin jouw programma zou zetten

cpp code

const int WINDOW_SERVER_ROOM = 3;

krijg je

cpp code

if (bitRead(inputs,WINDOW_SERVER_ROOM))         // omdat true = 1 kunnen we volstaan met deze test. En binary indexen beginnen bij 0 niet 1.
{                                                                    // BITWISE AND with 0100 = 0100 as result decimal 4
      Serial.print   ("window serverroom open  ");          
      Serial.print   ("value window switch 4 = ");            
      Serial.println (inputs);
      Serial.println ("                             ");
}

Een ander alternatief is gebruik maken van bitwise schuiven maar dat word nog ff te complex

[shooter Profiel Privébericht]

het ging er mij om dat inputs niet 1 is maar een byte waar ze allemaal instaan.

ja ik vind bitread eigenlijk ook wel mooier.