bitWrite() funktioniert nicht?

International Deutsch
1

Hallo

Ich habe jeweils Arrays definiert, in denen der 9-Bit Wert steht für jeden Winkel. Nun wollte ich 9 Sensoren (0 oder 1) auslesen und jeweils für jede Bit-Stelle mit bitWrite() speichern, diese dann mit dem passenden Array am seriellen Monitor anzeigen lassen welcher Winkel gerade ist.
Irgendwie scheint das mit dem bitWrite() nicht zu funktionieren. Liegt es an den 9 Bits anstelle 8 oder 16? Kann man das auch anders "abgleichen" und anzeigen lassen?

Hier mal der Testcode den ich bis jetzt habe:

//definition of pin numbers for the 9 sensors
const byte sensor[9] = {2,3,4,5,6,7,8,9,10};

//angle decodings for 9-Bit single track Gray code
int angle[360];

//designations for storing signals
byte sensorValue = 0b000000000;

void setup() {
  //angles for decoding the Gray code
  angle[0b000000001]=0;
  angle[0b000000101]=1;
  angle[0b100000101]=2;
  angle[0b110000101]=3;
  angle[0b010000101]=4;
  angle[0b010000111]=5;
  angle[0b010000011]=6;
  angle[0b011000011]=7;
  angle[0b001000011]=8;
  angle[0b001000001]=9;
  angle[0b001100001]=10;
  angle[0b000100001]=11;
  angle[0b000110001]=12;
  angle[0b001110001]=13;
  angle[0b001010001]=14;
  angle[0b011010001]=15;
  angle[0b010010001]=16;
  angle[0b010110001]=17;
  angle[0b011110001]=18;
  angle[0b011111001]=19;
  angle[0b001111001]=20;
  angle[0b001101001]=21;
  angle[0b101101001]=22;
  angle[0b111101001]=23;
  angle[0b110101001]=24;
  angle[0b110111001]=25;
  angle[0b110111011]=26;
  angle[0b110101011]=27;
  angle[0b010101011]=28;
  angle[0b011101011]=29;
  angle[0b111101011]=30;
  angle[0b101101011]=31;
  angle[0b101101111]=32;
  angle[0b111101111]=33;
  angle[0b111001111]=34;
  angle[0b110001111]=35;
  angle[0b100001111]=36;
  angle[0b000001111]=37;
  angle[0b000000111]=38;
  angle[0b000000011]=39;
  angle[0b000000010]=40;
  angle[0b000001010]=41;
  angle[0b000001011]=42;
  angle[0b100001011]=43;
  angle[0b100001010]=44;
  angle[0b100001110]=45;
  angle[0b100000110]=46;
  angle[0b110000110]=47;
  angle[0b010000110]=48;
  angle[0b010000010]=49;
  angle[0b011000010]=50;
  angle[0b001000010]=51;
  angle[0b001100010]=52;
  angle[0b011100010]=53;
  angle[0b010100010]=54;
  angle[0b110100010]=55;
  angle[0b100100010]=56;
  angle[0b101100010]=57;
  angle[0b111100010]=58;
  angle[0b111110010]=59;
  angle[0b011110010]=60;
  angle[0b011010010]=61;
  angle[0b011010011]=62;
  angle[0b111010011]=63;
  angle[0b101010011]=64;
  angle[0b101110011]=65;
  angle[0b101110111]=66;
  angle[0b101010111]=67;
  angle[0b101010110]=68;
  angle[0b111010110]=69;
  angle[0b111010111]=70;
  angle[0b011010111]=71;
  angle[0b011011111]=72;
  angle[0b111011111]=73;
  angle[0b110011111]=74;
  angle[0b100011111]=75;
  angle[0b000011111]=76;
  angle[0b000011110]=77;
  angle[0b000001110]=78;
  angle[0b000000110]=79;
  angle[0b000000100]=80;
  angle[0b000010100]=81;
  angle[0b000010110]=82;
  angle[0b000010111]=83;
  angle[0b000010101]=84;
  angle[0b000011101]=85;
  angle[0b000001101]=86;
  angle[0b100001101]=87;
  angle[0b100001100]=88;
  angle[0b100000100]=89;
  angle[0b110000100]=90;
  angle[0b010000100]=91;
  angle[0b011000100]=92;
  angle[0b111000100]=93;
  angle[0b101000100]=94;
  angle[0b101000101]=95;
  angle[0b001000101]=96;
  angle[0b011000101]=97;
  angle[0b111000101]=98;
  angle[0b111100101]=99;
  angle[0b111100100]=100;
  angle[0b110100100]=101;
  angle[0b110100110]=102;
  angle[0b110100111]=103;
  angle[0b010100111]=104;
  angle[0b011100111]=105;
  angle[0b011101111]=106;
  angle[0b010101111]=107;
  angle[0b010101101]=108;
  angle[0b110101101]=109;
  angle[0b110101111]=110;
  angle[0b110101110]=111;
  angle[0b110111110]=112;
  angle[0b110111111]=113;
  angle[0b100111111]=114;
  angle[0b000111111]=115;
  angle[0b000111110]=116;
  angle[0b000111100]=117;
  angle[0b000011100]=118;
  angle[0b000001100]=119;
  angle[0b000001000]=120;
  angle[0b000101000]=121;
  angle[0b000101100]=122;
  angle[0b000101110]=123;
  angle[0b000101010]=124;
  angle[0b000111010]=125;
  angle[0b000011010]=126;
  angle[0b000011011]=127;
  angle[0b000011001]=128;
  angle[0b000001001]=129;
  angle[0b100001001]=130;
  angle[0b100001000]=131;
  angle[0b110001000]=132;
  angle[0b110001001]=133;
  angle[0b010001001]=134;
  angle[0b010001011]=135;
  angle[0b010001010]=136;
  angle[0b110001010]=137;
  angle[0b110001011]=138;
  angle[0b111001011]=139;
  angle[0b111001001]=140;
  angle[0b101001001]=141;
  angle[0b101001101]=142;
  angle[0b101001111]=143;
  angle[0b101001110]=144;
  angle[0b111001110]=145;
  angle[0b111011110]=146;
  angle[0b101011110]=147;
  angle[0b101011010]=148;
  angle[0b101011011]=149;
  angle[0b101011111]=150;
  angle[0b101011101]=151;
  angle[0b101111101]=152;
  angle[0b101111111]=153;
  angle[0b001111111]=154;
  angle[0b001111110]=155;
  angle[0b001111100]=156;
  angle[0b001111000]=157;
  angle[0b000111000]=158;
  angle[0b000011000]=159;
  angle[0b000010000]=160;
  angle[0b001010000]=161;
  angle[0b001011000]=162;
  angle[0b001011100]=163;
  angle[0b001010100]=164;
  angle[0b001110100]=165;
  angle[0b000110100]=166;
  angle[0b000110110]=167;
  angle[0b000110010]=168;
  angle[0b000010010]=169;
  angle[0b000010011]=170;
  angle[0b000010001]=171;
  angle[0b100010001]=172;
  angle[0b100010011]=173;
  angle[0b100010010]=174;
  angle[0b100010110]=175;
  angle[0b100010100]=176;
  angle[0b100010101]=177;
  angle[0b100010111]=178;
  angle[0b110010111]=179;
  angle[0b110010011]=180;
  angle[0b010010011]=181;
  angle[0b010011011]=182;
  angle[0b010011111]=183;
  angle[0b010011101]=184;
  angle[0b110011101]=185;
  angle[0b110111101]=186;
  angle[0b010111101]=187;
  angle[0b010110101]=188;
  angle[0b010110111]=189;
  angle[0b010111111]=190;
  angle[0b010111011]=191;
  angle[0b011111011]=192;
  angle[0b011111111]=193;
  angle[0b011111110]=194;
  angle[0b011111100]=195;
  angle[0b011111000]=196;
  angle[0b011110000]=197;
  angle[0b001110000]=198;
  angle[0b000110000]=199;
  angle[0b000100000]=200;
  angle[0b010100000]=201;
  angle[0b010110000]=202;
  angle[0b010111000]=203;
  angle[0b010101000]=204;
  angle[0b011101000]=205;
  angle[0b001101000]=206;
  angle[0b001101100]=207;
  angle[0b001100100]=208;
  angle[0b000100100]=209;
  angle[0b000100110]=210;
  angle[0b000100010]=211;
  angle[0b000100011]=212;
  angle[0b000100111]=213;
  angle[0b000100101]=214;
  angle[0b000101101]=215;
  angle[0b000101001]=216;
  angle[0b000101011]=217;
  angle[0b000101111]=218;
  angle[0b100101111]=219;
  angle[0b100100111]=220;
  angle[0b100100110]=221;
  angle[0b100110110]=222;
  angle[0b100111110]=223;
  angle[0b100111010]=224;
  angle[0b100111011]=225;
  angle[0b101111011]=226;
  angle[0b101111010]=227;
  angle[0b101101010]=228;
  angle[0b101101110]=229;
  angle[0b101111110]=230;
  angle[0b101110110]=231;
  angle[0b111110110]=232;
  angle[0b111111110]=233;
  angle[0b111111100]=234;
  angle[0b111111000]=235;
  angle[0b111110000]=236;
  angle[0b111100000]=237;
  angle[0b011100000]=238;
  angle[0b001100000]=239;
  angle[0b001000000]=240;
  angle[0b101000000]=241;
  angle[0b101100000]=242;
  angle[0b101110000]=243;
  angle[0b101010000]=244;
  angle[0b111010000]=245;
  angle[0b011010000]=246;
  angle[0b011011000]=247;
  angle[0b011001000]=248;
  angle[0b001001000]=249;
  angle[0b001001100]=250;
  angle[0b001000100]=251;
  angle[0b001000110]=252;
  angle[0b001001110]=253;
  angle[0b001001010]=254;
  angle[0b001011010]=255;
  angle[0b001010010]=256;
  angle[0b001010110]=257;
  angle[0b001011110]=258;
  angle[0b001011111]=259;
  angle[0b001001111]=260;
  angle[0b001001101]=261;
  angle[0b001101101]=262;
  angle[0b001111101]=263;
  angle[0b001110101]=264;
  angle[0b001110111]=265;
  angle[0b011110111]=266;
  angle[0b011110101]=267;
  angle[0b011010101]=268;
  angle[0b011011101]=269;
  angle[0b011111101]=270;
  angle[0b011101101]=271;
  angle[0b111101101]=272;
  angle[0b111111101]=273;
  angle[0b111111001]=274;
  angle[0b111110001]=275;
  angle[0b111100001]=276;
  angle[0b111000001]=277;
  angle[0b111000000]=278;
  angle[0b011000000]=279;
  angle[0b010000000]=280;
  angle[0b010000001]=281;
  angle[0b011000001]=282;
  angle[0b011100001]=283;
  angle[0b010100001]=284;
  angle[0b110100001]=285;
  angle[0b110100000]=286;
  angle[0b110110000]=287;
  angle[0b110010000]=288;
  angle[0b010010000]=289;
  angle[0b010011000]=290;
  angle[0b010001000]=291;
  angle[0b010001100]=292;
  angle[0b010011100]=293;
  angle[0b010010100]=294;
  angle[0b010110100]=295;
  angle[0b010100100]=296;
  angle[0b010101100]=297;
  angle[0b010111100]=298;
  angle[0b010111110]=299;
  angle[0b010011110]=300;
  angle[0b010011010]=301;
  angle[0b011011010]=302;
  angle[0b011111010]=303;
  angle[0b011101010]=304;
  angle[0b011101110]=305;
  angle[0b111101110]=306;
  angle[0b111101010]=307;
  angle[0b110101010]=308;
  angle[0b110111010]=309;
  angle[0b111111010]=310;
  angle[0b111011010]=311;
  angle[0b111011011]=312;
  angle[0b111111011]=313;
  angle[0b111110011]=314;
  angle[0b111100011]=315;
  angle[0b111000011]=316;
  angle[0b110000011]=317;
  angle[0b110000001]=318;
  angle[0b110000000]=319;
  angle[0b100000000]=320;
  angle[0b100000010]=321;
  angle[0b110000010]=322;
  angle[0b111000010]=323;
  angle[0b101000010]=324;
  angle[0b101000011]=325;
  angle[0b101000001]=326;
  angle[0b101100001]=327;
  angle[0b100100001]=328;
  angle[0b100100000]=329;
  angle[0b100110000]=330;
  angle[0b100010000]=331;
  angle[0b100011000]=332;
  angle[0b100111000]=333;
  angle[0b100101000]=334;
  angle[0b101101000]=335;
  angle[0b101001000]=336;
  angle[0b101011000]=337;
  angle[0b101111000]=338;
  angle[0b101111100]=339;
  angle[0b100111100]=340;
  angle[0b100110100]=341;
  angle[0b110110100]=342;
  angle[0b111110100]=343;
  angle[0b111010100]=344;
  angle[0b111011100]=345;
  angle[0b111011101]=346;
  angle[0b111010101]=347;
  angle[0b101010101]=348;
  angle[0b101110101]=349;
  angle[0b111110101]=350;
  angle[0b110110101]=351;
  angle[0b110110111]=352;
  angle[0b111110111]=353;
  angle[0b111100111]=354;
  angle[0b111000111]=355;
  angle[0b110000111]=356;
  angle[0b100000111]=357;
  angle[0b100000011]=358;
  angle[0b100000001]=359;
  
  Serial.begin(9600);

  for(byte i=0; i < 9; i++){
    pinMode(sensor[i], INPUT_PULLUP);
  }

}

void loop() {
  for(byte i=0; i < 9; i++){
    bitWrite(sensorValue, i, digitalRead(sensor[8-i]));   //write the sensor values 0 or 1 from right to left into the binary number
  }
  Serial.print("Angle = ");
  Serial.print(angle[sensorValue]);
  Serial.println("°");

}
2

Es gibt nur 8 oder 16 Bit-Variablen für Dein Vorhaben also 16 Bit.
bitWrite funktioniert nur auf existierenden Variablen, nicht auf Phantasiekonstrukten.

Also nimm einfach uint16_t (oder unsigned int). Auch wenn Du 9 Stellen für ein Byte hinschreibst, passen nur 8 Bit rein.

Gruß Tommy

3

Kann es sein, dass ich sonst was falsch gemacht habe mit dem bitWrite()? Ich habe jetzt einfach sensorValue als uint16_t deklariert. Der Rest hat ja keinen Einfluss, oder?

Übersehe ich was, weil am seriellen Monitor gar nichts angezeigt wird? Sollte ja eigentlich immer was kommen, unabhängig vom bitWrite()!?

4

Dann baue doch einfach mal einen minimalen Sketch mit Bitwrite ohne Sensor und lass Dir den Inhalt der Variablen seriell ausgeben. Bei > 360 Beiträgen sollten doch mittlerweise ein paar Erkenntnisse da sein.

Gruß Tommy

5

Ups, 0b111111110 = 510.

6

Ist das Dein ernst?

7

Nein. Das ist keine Binärzahl sondern eine Graycode.
Grüße Uwe

8

Hab ich auch gesehen.... habs als int deklariert, so gehts.

9

Ich habe jetzt getestet und erweitert. So läufts wie es soll:

//definition of pin numbers for the 9 sensors
const byte sensor = 2;

//angle decodings for 9-Bit single track Gray code
int angle[360];

//designations for storing signals
int sensorValue = 0b000000000;

void setup() {
  angle[0b111111111] = 25;
  Serial.begin(9600);

  pinMode(sensor, INPUT_PULLUP);

}

void loop() {
  for(byte i=0; i < 9; i++){
    bitWrite(sensorValue, i, digitalRead(sensor));   //write the sensor values 0 or 1 from right to left into the binary number
  }
  Serial.print("Angle = ");
  Serial.print(angle[sensorValue]);
  Serial.println("°");

}

Morgen mal vergleichen wo der Hase begraben liegt...

Edit: Habe gerade festgestellt, dass wenn ich die Pins als array deklariere wie oben im ersten Beitrag gepostet, dann spinnt die Ausgabe total. Sie wechselt ohne auch nur irgendwas zu machen zwischen den Werten HIGH und LOW. An was liegt das?
Wie kann man sonst die Pins deklarieren, sodass man sie unten im bitWrite() einsetzen kann, dass sie hochgezählt wird?

10

Jetzt muß ich mich bei Whandall Entschuldigen weil ich ihn falsch verstanden habe und er völlig recht hatte.

Ja, das ist ein böser Fehler.

Das Array hat zwar nur 360 Elemente aber der Index hat 9 Bit also müssen damit nicht Elemente außerhalb des Arrays angesprochen werden es mit 512 Elemente definiert sein.

vieleicht ist es besser kein Array für die Umrechnung GRAY-Code zu Winkel zu verwenden sondern umzurechnen.

Grüße Uwe

11

Den Gedankengang mag ich noch nachempfinden.
Das was Du hier machst widerspricht doch aber Deiner Vorgabe!

Ich denke Du hast 9 (!) Sensoren, die alle einen Wert liefern?

Du bist in dem anderen Thread schon mit unvollständigen und schlußendlich nicht verwertbaren Informationen rumgekommen.

Nun machst Du hier einen neuen Thread auf.

Warum kommst Du nicht endlich damit rum was Du willst, anstelle nur ein Ratespiel draus zu machen?
Wer 9bit in einem Byte abbilden will....
... sucht Hausaufgabenhilfe?

12

Nein.
So kann es gar nicht laufen wie es soll - es läuft sogar gar nicht, weil es nicht mal kompiliert.

Liest Du eigentlich, was @Whandall schrieb?
Du versuchst, Speicher zu beschreiben, der 150 Byte hinter dem Array liegt.

Wenn ich versuche, den Sketch aus #9 zu kompilieren, kommt das hier:

C:\Daten\Projects\Sketchbook\sketches\forum\sketch_feb09a\sketch_feb09a.ino: In function 'void setup()':
sketch_feb09a:11:20: error: array subscript is above array bounds [-Werror=array-bounds]
   angle[0b111111111] = 25;
                    ^
cc1plus.exe: some warnings being treated as errors
exit status 1
array subscript is above array bounds [-Werror=array-bounds]

Edit: Device "ESP 32 Dev Module", beim "Uno" meckert er merkwürdigerweise nicht (IDE 1.8.16).

13

Jetzt sehe ich den Fehler auch! Wie blöd.... Ich hatte nur die 360 Elemente im Kopf, aber dass der Wert selbst eigentlich 510, resp. für 10 Bitstellen dann 512 ist...... Danke!

Hatte ich auch versucht, aber das Problem, dieser Gray Code ist nicht ganz typisch. Damit er auf einer Scheibe ohne wiederholung laufen kann, musste ich diesen manuell versuchen zu zeichnen. Ich weiss nicht wie ich da eine Formel für das finden soll. War gestern schon am versuchen herauszufinden, ob es ein Muster gibt mit dem man das berechnen könnte. Darum ist der Abgleich mit einer Tabelle wohl am einfachsten.

14

Nein, das war nur der Testsketch von gestern Abend um ihn auf ein Minimum zu reduzieren und dann habe ich Stück für Stück wieder hinzugefügt, um zu sehen was nicht läuft. Sobald die Pindeklaration kommt mit dem Array, dann macht der Pin 2 willkürlich HIGH und LOW.

Ich dachte, das passt nicht ganz zum andern Fragethema. Dort ging es ja hauptsächlich um die Pins analog einzulesen.

Habe ich doch versucht!? Ich möchte eine Scheibe mit einer schwarz/weiss Skala die an neun Stellen abgelesen wird. Somit kann ich den Winkel der Scheibenstellung wissen.

15

Ja wie Du auch ganz unten geschrieben hast, ich habe mit einem Uno getestet, da meckert die IDE nicht. Darum habe ich auch nicht weiters nachgesucht. Aber das löst das Problem nicht, sprich es ändert sich nichts, dass keine Ausgabe kommt am seriellen Monitor.
P.S. Habe ein Micro, Nano, Mini, Mini Pro und Uno versucht zu kompilieren, da meckert die IDE bei keinem.....??

16

Hier mal alle Pins ohne Array gelistet. Warum funktioniert es so, aber sobald ich die Pins als Array nehme und unten das bitWrite() mit digitalRead(sensor[i]) nehme, dann läuft nichts mehr?

So gehts:

//definition of pin numbers for the 9 sensors
const byte sensor = 2;
const byte sensor2 = 3;
const byte sensor3 = 4;
const byte sensor4 = 5;
const byte sensor5 = 6;
const byte sensor6 = 7;
const byte sensor7 = 8;
const byte sensor8 = 9;
const byte sensor9 = 10;

//angle decodings for 9-Bit single track Gray code
int angle[512];

//designations for storing signals
int sensorValue = 0b000000000;

void setup() {
  angle[0b111111111] = 25;
  angle[0b011111111] = 120;
  
  Serial.begin(9600);

  pinMode(sensor, INPUT_PULLUP);
  pinMode(sensor2, INPUT_PULLUP);
  pinMode(sensor3, INPUT_PULLUP);
  pinMode(sensor4, INPUT_PULLUP);
  pinMode(sensor5, INPUT_PULLUP);
  pinMode(sensor6, INPUT_PULLUP);
  pinMode(sensor7, INPUT_PULLUP);
  pinMode(sensor8, INPUT_PULLUP);
  pinMode(sensor9, INPUT_PULLUP);


}

void loop() {
  //for(byte i=0; i < 9; i++){
    bitWrite(sensorValue, 0, digitalRead(sensor9));   //write the sensor values 0 or 1 from right to left into the binary number
    bitWrite(sensorValue, 1, digitalRead(sensor8));
    bitWrite(sensorValue, 2, digitalRead(sensor7));
    bitWrite(sensorValue, 3, digitalRead(sensor6));
    bitWrite(sensorValue, 4, digitalRead(sensor5));
    bitWrite(sensorValue, 5, digitalRead(sensor4));
    bitWrite(sensorValue, 6, digitalRead(sensor3));
    bitWrite(sensorValue, 7, digitalRead(sensor2));
    bitWrite(sensorValue, 8, digitalRead(sensor));
  //}
  Serial.print("Angle = ");
  Serial.print(angle[sensorValue]);
  Serial.println("°");

}
17

Das wird wohl an den jeweils verwendeten Compilerversionen und -settings liegen.

Du solltest nachdem der Index aus den Bits zusammengestellt wurde, wenigstens auf Deine Arraygrenze prüfen bevor du zugreifst.

18

Sowas?

if(sensorValue <= 511){
    Serial.print("Angle = ");
    Serial.print(angle[sensorValue]);
    Serial.println("°");
  }
19

Nee, eben nicht <= 512, sondern < 360. Mehr Elemente hat der Array angle ja nicht.

20

Aber ich muss doch den Element-Wert prüfen, ob dieser innerhalb der zulässigen Anzahl Bits steht? Die Anzahl Elemente 360 kann ich doch nicht prüfen, weil ich ja immer nur ein Element habe, welches angezeigt wird.
Höchstens sowas wäre noch möglich, aber ob dies Sinn macht, wenn ich schon den Element-Wert prüfe?

if(sensorValue <= 511 && angle[sensorValue] < 360)