Arduinoでのビット演算

ビット演算とArduinoのスケッチで個々のビット操作を行う方法を学びます。

Author: Don Cross、Last revision: 2024/01/26

この記事は、2022年9月28日にHannes Siebeneicherにより改訂されました。

Arduino環境(もしくは他のコンピューター)でプログラミングするときに、個々のビットを操作することが有用もしくは必要となる場合がよくあります。ここでは、ビット演算が役立つ場面を、いくつか紹介します。

  • 8個までの真偽データ値を1バイトにまとめてメモリを節約します。
  • 制御レジスタやハードウェアのポートレジスタの個別のビットをオン・オフします。
  • 2の乗数のかけ算・割り算を含む演算を実行します。

この記事では、C++言語で利用できる基本的なビット演算子を、最初に紹介します。その後、一般的に有用な演算を実行するために、ビット演算子を組み合わせる方法を学びます。この記事は、CosineKittyによるビット演算のチュートリアルを基にしています。

2進法

ビット演算子をよりよく説明するために、このチュートリアルでは、ほとんどの数値を2進法で表現します。この体系では、全ての整数値は0と1の値だけを使います。これは、今日のコンピューターが内部でデータを格納する実質的な方法です。0と1はビット(bit)と呼びます。bitは、binary digitの略です。

なじみのある10進法では、例えば、572は、5*10^2 + 7*10^1 + 2*10^0を意味します。同様に、2進数の11010は、1*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 16 + 8 + 2 = 26を意味します。

このチュートリアルの残りの部分を読み進めるには、2進法がどのように計算されるのかを理解することが重要です。この領域で支援が必要な場合は、2進法に関するWikipediaの記事(二進法/Binary number)から始めるのがいいと思います。

Arduinoでは、二進数は0bという接頭語をつけて表現できます。例えば、0b11 == 3です。過去の経緯から、B0からB11111111までの定数も定義しています。これも同様に利用できます。

ビット単位のAND演算子

C++でのビット単位のAND演算子は、一つのアンパサンド(&)で、2つの整数表現間で利用されます。ビット単位のAND演算子は、両辺の整数表現の個々のビットごとに独立して演算します。この決まりによると、両方の入力が1であれば1、そうでなければ0です。これを別の表現で表すと、以下のようになります。

1
2
3
4

0 & 0 == 0
    0 & 1 == 0
    1 & 0 == 0
    1 & 1 == 1

Arduinoでは、int型は16ビットなので、2つのint表現に&を適用すると、16個のAND演算が同時に起こります。以下のようなコード片では、

1
2
3

int a =  92;    // in binary: 0000000001011100
    int b = 101;    // in binary: 0000000001100101
    int c = a & b;  // result:    0000000001000100, or 68 in decimal.

aとbの16ビットのそれぞれが、ビット単位のAND演算子により処理され、16個全てのビットがcに格納されます。その結果は、2進法で01000100で、10進法では68です。

ビット単位のAND演算子の最も一般的な使用方法のひとつは、整数値から特定のビットを選ぶというもので、マスキングとも呼ばれます。例えば、変数xの最下位ビットを取得し、yという別の変数に格納するには、以下のコードが利用できます。

1
2
3
4

int x = 5;       // binary: 101
    int y = x & 1;   // now y == 1
    x = 4;           // binary: 100
    y = x & 1;       // now y == 0

ビット単位のOR演算子

C++でのビット単位のOR演算子は、一つのバー(|)です。&演算子のように、2つの整数表現間で利用されますが、(当然ですが)結果は異なります。ビット単位のOR演算子は、両辺の整数表現の個々のビットごとに独立して演算します。2つのビットに対するビット単位のOR演算子は、一方もしくは双方が1のときは1で、そうでなければ0です。

これを別の表現で表すと、以下のようになります。

1
2
3
4

0 | 0 == 0
    0 | 1 == 1
    1 | 0 == 1
    1 | 1 == 1

ビット単位のOR演算子のC++コードでの使用例は以下の通りです。

1
2
3

int a =  92;    // in binary: 0000000001011100
    int b = 101;    // in binary: 0000000001100101
    int c = a | b;  // result:    0000000001111101, or 125 in decimal.

ビット単位のOR演算子は、与えられた式で指定したビットをオンにする(1に設定する)のによく使われます。例えば、aからbに、最下位ビットを1にしてコピーするには、以下のコードを使います。

1

b = a | 1;

ビット単位のXOR演算子

ビット単位のXOR演算子という、少し毛色の変わった演算子がC++にあります。英語でXORは通常、“eks-or"と発音します。ビット単位のXOR演算子は、キャレット記号^で表します。この演算子はビット単位のOR演算子|に似ていますが、どちらかの入力ビットが1のときに1と評価されるところが異なる点です。双方とも0もしくは1の場合、ビット単位のXOR演算子は0と評価されます。

1
2
3
4

0 ^ 0 == 0
    0 ^ 1 == 1
    1 ^ 0 == 1
    1 ^ 1 == 0

ビット単位のXOR演算子を他の表現で行えば、入力が異なる場合は1で、同じ場合は0ということになります。

以下に簡単なコード例を示します。

1
2
3

int x = 12;     // binary: 1100
    int y = 10;     // binary: 1010
    int z = x ^ y;  // binary: 0110, or decimal 6

^演算子は、数値表現の他の値を変更せず、一部のビットをトグル(0を1に、1を0にする)するのによく使われます。例えば、

1

y = x ^ 1;   // toggle the lowest bit in x, and store the result in y.

ビット単位のNOT演算子

C++でのビット単位のNOTは、チルダ記号(~)です。&や|とは違い、演算子右側の一つのオペランドに適用されます。ビット単位のNOT演算子は、ビットを反対の値(0は1に、1は0)に変更します。例えば、

1
2

int a = 103;    // binary:  0000000001100111
    int b = ~a;     // binary:  1111111110011000 = -104

この演算の結果が-104のような負数になることに驚くかもしれません。これは、intの最上位ビットが、いわゆる符号ビットであるためです。最上位ビットが1のとき数値は負であると解釈されます。正負をこのように表現することは、2の補数表現と呼ばれます。詳細は、Wikipedia article on two’s complement/2の補数を参照してください。

余談ですが、任意の整数xについて、~xは、-x-1となることは興味深いです。

後述するように、符号付整数の符号ビットは、予期しないことを引き起こすこともあります。

ビットシフト演算子

C++には、左シフト演算子<<と右シフト演算子>>の、2つのビットシフト演算子があります。これらの演算子は、演算子の左側のオペランドを右側の数値分だけ、左あるいは右にシフトします。例えば、

1
2
3

int a = 5;        // binary: 0000000000000101
    int b = a << 3;   // binary: 0000000000101000, or 40 in decimal
    int c = b >> 3;   // binary: 0000000000000101, or back to 5 like we started with

x << yで、xをyビット分左にシフトすると、xの左のyビットは失われ、文字通り失われます。

1
2

int a = 5;        // binary: 0000000000000101
    int b = a << 14;  // binary: 0100000000000000 - the first 1 in 101 was discarded

どのビットも左シフト演算子によって失われないとき、左シフト演算子は、左オペランドを2の右オペランド乗すると考えることができます。例えば、2のべき乗は以下のようにあらわすことができます。

1
2
3
4
5
6
7
8
9

1 <<  0  ==    1
    1 <<  1  ==    2
    1 <<  2  ==    4
    1 <<  3  ==    8
    ...
    1 <<  8  ==  256
    1 <<  9  ==  512
    1 << 10  == 1024
    ...

xの最上位ビットが1のとき、x >> yで、xをyビット分右にシフトすると、その結果はxのデータ型に依存します。xがint型の場合、先述したように、最上位ビットは符号ビットで、xが負かそうでないかを決めます。この場合、歴史的な理由により、符号ビットは下位ビットにコピーされます。

1
2

int x = -16;     // binary: 1111111111110000
    int y = x >> 3;  // binary: 1111111111111110

符号拡張と呼ばれるこの動作は、望まない動作の場合もあります。そうではなく、左から0を埋めたい場合もあると思います。unsigned int表現の場合は、右シフトの規則は異なるので、キャスト演算子を使い、最上位ビットをコピーするのを防ぐことができます。

1
2

int x = -16;               // binary: 1111111111110000
    int y = unsigned(x) >> 3;  // binary: 0001111111111110

符号拡張に注意すれば、右シフト演算子>>を2のべき乗での除算に使うことができます。例えば、

1
2

int x = 1000;
    int y = x >> 3;   // integer division of 1000 by 8, causing y = 125.

代入演算子

プログラミングでは、変数xの値に対して演算を行い、変更された値をxに書き戻すことがよくあります。多くのプログラミング言語では、例えば、xの値を7増加させるには、以下のようなコードを使います。

1

x = x + 7;    // increase x by 7

プログラミングではこのようなことはよく起こるので、C++では短縮した特別な代入演算子を用意しています。上記のコード片は、以下のように簡潔に記述することができます。

1

x += 7;    // increase x by 7

ビット単位のANDやビット単位のOR、左シフト、右シフトにも全て、省略した代入演算子があります。以下に例を示します。

1
2
3
4
5
6

int x = 1;  // binary: 0000000000000001
    x <<= 3;    // binary: 0000000000001000
    x |= 3;     // binary: 0000000000001011 - because 3 is 11 in binary
    x &= 1;     // binary: 0000000000000001
    x ^= 4;     // binary: 0000000000000101 - toggle using binary mask 100
    x ^= 4;     // binary: 0000000000000001 - toggle with mask 100 again

ビット単位のNOT演算子~には、省略形の代入演算子はありません。xの全てのビットを反転させるには、以下のようにする必要があります。

1

x = ~x;    // toggle all bits in x and store back in x

注意事項: ビット単位の演算子と論理(ブール)演算子

C++でのビット演算と論理演算はとても混乱を起こしやすいです。例えば、ビット単位のAND演算子&と、論理AND演算子&&は、以下の2つの理由により全く異なります。

  • 双方は数値を同じようには計算しません。ビット単位のAND演算子&はオペランドの個々のビットを独立して演算します。一方、論理&&は、双方のオペランドを、一つの論理値(true==1かfalse==0)に変換し、trueかfalseの一つの値を返却します。例えば、4 && 2 == 0です。4は2進数では100、2は2進数では010で、それぞれのビットで同じ位置が1になっていないからです。しかし、4 && 2 == trueで、trueは数値としては1です。4は0ではなく、2も０ではないので、双方ともtrueだからです。
  • ビット単位の演算子は常に双方のオペランドを評価します。一方、論理演算子はいわゆる短絡評価(short-cut evaluation/short-circuit evaluation)を行います。これは、例えば、出力がメモリ上に何かの値を出力したり修正したりするなど、オペランドが副作用を伴うときにだけ影響がでます。よく似た2つの行が全く異なる振る舞いをする例を示します。
1
2
3
4
5
6

int fred (int x)
    {
        Serial.print ("fred ");
        Serial.println (x, DEC);
        return x;
    }
1
2
3
4

void setup()
    {
        Serial.begin (9600);
    }
1
2
3
4
5

void loop()
    {
        delay(1000);    // wait 1 second, so output is not flooded with serial data!
        int x = fred(0) & fred(1);
    }

このプログラムをコンパイル・アップロードし、Arduino GUIのシリアル出力を見ると、1秒ごとに以下の行が出力されています。

1
2

fred 0
    fred 1

これは、fred(0)とfred(1)の両方が呼ばれ、出力が生成され、戻り値の0と1がビット単位でAND演算され、xに0が格納されるからです。以下の行を編集し、

1

int x = fred(0) & fred(1);

ビット単位の&を論理演算の&&に変更します。

1

int x = fred(0) && fred(1);

そして、コンパイル・アップロードし、プログラムを再度実行すると、1秒ごとに1行だけが出力されることに驚くかもしれません。

1

fred 0

なぜこのようなことがおこるのでしょうか? これは、論理&&が短絡評価を使っているからです。左側のオペランドがゼロ(false)であれば、式の結果がfalseになることは明らかなので、右側のオペランドを評価する必要がないからです。言い換えれば、int x = fred(0) && fred(1);は、以下と同じです。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int x;
    if (fred(0) == 0) {
        x = false;  // stores 0 in x
    } else {
        if (fred(1) == 0) {
            x = false;  // stores 0 in x
        } else {
            x = true;   // stores 1 in x
        }
    }

明らかに、論理&&は、この複雑なロジックを簡潔に表す方法です。

ビット単位のANDと論理ANDは、ビット単位のORと論理ORとは異なる点があります。ビット単位のOR演算子|は常に双方のオペランドを評価します。一方、論理OR演算子||は、左側のオペランドがfalse(ゼロ)のときだけ、右側のオペランドを評価します。また、ビット単位の|演算子は双方のオペランドの個々のビットを独立して演算します。一方、論理||は、双方のオペランドを、true(非ゼロ)かfalse(ゼロ)として扱い、評価した結果、true(どちらかのオペランドが非ゼロ)か、false(双方のオペランドがゼロ)を返します。

まとめ: よくある問題を解決する

Arduino環境でC++の文法を使い、有用なタスクを実行するために、さまざまなビット単位の演算子を組み合わせる方法を見ていきましょう。

Atmega8マイクロコントローラーのポートレジスタについて

Atmega8のデジタルピンに読み書きするときは通常、Arduino環境が提供する組込み関数のdigitalRead()やdigitalWrite()を使います。setup()関数で、デジタルピンの2番から13番を出力に設定し、11と12、13番ピンをHIGHにし、残りの全てのピンをLOWにすることを考えます。通常は以下のようにします。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void setup()
    {
        int pin;
        for (pin=2; pin <= 13; ++pin) {
            pinMode (pin, OUTPUT);
        }
        for (pin=2; pin <= 10; ++pin) {
            digitalWrite (pin, LOW);
        }
        for (pin=11; pin <= 13; ++pin) {
            digitalWrite (pin, HIGH);
        }
    }

Atmega8のハードウェアポートに直接アクセスと、ビット単位の演算子を使う方法もあります。

1
2
3
4
5
6

void setup()
    {
        // set pins 1 (serial transmit) and 2..7 as output,
        // but leave pin 0 (serial receive) as input
        // (otherwise serial port will stop working!) ...
        DDRD = B11111110;  // digital pins 7,6,5,4,3,2,1,0

1
2

// set pins 8..13 as output...
        DDRB = B00111111;  // digital pins -,-,13,12,11,10,9,8

1
2

// Turn off digital output pins 2..7 ...
        PORTD &= B00000011;   // turns off 2..7, but leaves pins 0 and 1 alone

1
2
3

// Write simultaneously to pins 8..13...
        PORTB = B00111000;   // turns on 13,12,11; turns off 10,9,8
    }

制御レジスタのDDRDとDDRBの8ビットそれぞれが、デジタルピンを出力(1)にするか入力(0)にするかを決める、という事実をこのコードは利用しています。Atmega8に14番ピンや15番ピンはないので、DDRBの上位2ビットは使いません。同様に、ポートレジスタのPORTBとPORTDは、最後にデジタルピンに書き込まれた値である、HIGH(1)かLOW(0)を保持しています。

一般に、この種の方法はいいアイデアではありません。なぜでしょうか? いくつか理由があります。

  • コードのデバッグやメンテナンスが難しくなり、他の人が理解するのも難しくなります。コードを実行するのは数マイクロ秒ですが、動かない原因を見つけ、修正するのに何時間もかかります。時間は貴重ですよね? しかし、コンピューターに供給する電力のコストで測ると、コンピューター時間は安いものです。通常は、一番わかりやすい方法でコードを書くのが最もいい方法です。
  • コードに移植性が損なわれます。digitalRead()とdigitalWrite()を使えば、全てのAtmeマイクロコントローラーで動作するコードを書くのは容易です。一方、制御レジスタやポートレジスタはマイクロコントローラーによっては異なる可能性があります。
  • ポートへの直接アクセスは、意図しない障害を引き起こす可能性があります。DDRD = B11111110;という行に注目してください。これは、0番ピンを入力のままにしておくことを意図しています。0番ピンを出力にすることによって、誤ってシリアルピンが動作しなくなる可能性があります。突然シリアルデータを受信できなくなったら、混乱します。

この機能を本当に使う必要があるか、よく考えてください。直接ポートにアクセスすることの利点もあります。

  • プログラムメモリが少ない状況で動作させているとき、コード量を削減するためにこれらのトリックを使うことができます。ハードウェアピンのいくつかに同時に書き込むときには、forループを使ってピンを個別に設定するよりも、ポートレジスタを利用した方がコード量が圧倒的に少なくなります。場合によっては、これが、フラッシュメモリに入るか入らないかを決めることになるときもあります。
  • 複数の出力ピンを同時に設定する必要があるかもしれません。digitalWrite(10,HIGH);の後に、digitalWrite(11,HIGH);とすると、10番ピンは11番ピンよりも、数マイクロ秒先にHIGHになり、タイミングに制約のある外部に接続したデジタル回路を混乱させる可能性があります。一方、PORTB |= B1100;とすることで、両方のピンを全く同時にHIGHにすることができます。
  • ピンを、マイクロ秒以下という高速にオン・オフすることができます。lib/targets/arduino/wiring.にあるソースコードを見ると、digitalRead()やdigitalWrite()は、何十行もあることがわかります。これは、多量の機械語命令にコンパイルされます。それぞれの機械語命令は16MHzで1サイクル必要なので、時間に制約のあるアプリケーションでは、時間がかかりすぎる場合もあります。直接ポートにアクセスすると、同じ操作を、より少ないクロックサイクルで実行することができます。

より高度な例: 割り込みを禁止する

学習したことをもとに、上級プログラマが時折コード中で行っている不思議なことを理解しましょう。以下のことは何を意味しているのでしょうか?

1
2

// Disable the interrupt.
      GICR &= ~(1 << INT0);

これは、Arduino 0007の実行時ライブラリにある実際のコードで、lib\targets\arduino\winterrupts.cというファイルに記述されています。まず、GICRとINT0が何を意味しているかを知る必要があります。GICRは、あるCPU割り込みが有効(1)か禁止(0)かを定義する制御レジスタです。Arduinoの標準ヘッダファイルでINT0を調べると、様々な定義が見つかります。利用しているマイクロコントローラーにより、いかのどちらかです。

1

#define INT0   6

もしくは

1

#define INT0   0

あるプロセッサでは、以下のように変換され、

1

GICR &= ~(1 << 0);

他のプロセッサでは、以下のように変換されます。

1

GICR &= ~(1 << 6);

後者の方が理解しやすいので、後者について見ていきましょう。まず、(1 << 6)という値は、1を6ビット左シフトすることを意味し、64です。この文脈では、この数値を2進数で表現した01000000で見る方が有用です。次に、ビット単位のNOT演算子~がこの値に適用され、全てのビットが反転し、10111111になります。そして、ビット単位のAND代入演算子が使われるので、コードは以下と同じ作用を持っています。

1

GICR = GICR & B10111111;

これは、最上位から2番目のビットをオフにし、他のビットはそのままにしておくという効果があります。

INT0が0と定義されているコンピューターでは、コードは以下のように解釈されます。

1

GICR = GICR & B11111110;

これは、最下位ビットをオフにし、他のビットはそのままにしておきます。これは、Arduino環境の実行時ライブラリの1行のソースコードが、多くのマイクロコントローラーをサポートする方法の例です。

複数のデータを1バイトに詰め込んでメモリを節約する

個々のデータの値はtrueかfalseで、多くのデータがあるという状況がよくあります。一例は、LEDグリッドを構築し、個々のLEDをオン・オフし、記号を表示したりする場合です。例えば、5x7のビットマップでXという文字は以下のようなものです。

このようなイメージを格納する単純な方法、整数の配列を用いることです。この方法でのコードは以下のようになります。

1
2
3
4
5
6
7

const prog_uint8_t BitMap[5][7] = {   // store in program memory to save RAM
        {1,1,0,0,0,1,1},
        {0,0,1,0,1,0,0},
        {0,0,0,1,0,0,0},
        {0,0,1,0,1,0,0},
        {1,1,0,0,0,1,1}
    };
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void DisplayBitMap()
    {
        for (byte x=0; x<5; ++x) {
            for (byte y=0; y<7; ++y) {
                byte data = pgm_read_byte (&BitMap[x][y]);   // fetch data from program memory
                if (data) {
                    // turn on the LED at location (x,y)
                } else {
                    // turn off the LED at location (x,y)
                }
            }
        }
    }

これが、プログラムで使う唯一のビットマップであれば、これはこの問題に対する簡単で効率的な解です。1ピクセルに1バイトのプログラムメモリ(Atmega8では約7kバイト利用可能です)を使うので、合計35バイトです。これはそんなに悪くありません。しかし、ASCII文字セットの96個の印字可能な文字が必要な場合はどうでしょうか? このとき、96*35=3360バイト消費し、プログラムコードに使えるフラッシュメモリはとても少なくなってしまいます。

ビットマップを格納するより効率的な方法があります。上記の2次元配列を、1次元のバイト配列に置き換えます。各バイトは8ビットなので、下位7ビットで、5x7のビットマップの行を表します。

1
2
3
4
5
6
7

const prog_uint8_t BitMap[5] = {   // store in program memory to save RAM
        B1100011,
        B0010100,
        B0001000,
        B0010100,
        B1100011
    };

(ここでは、Arduino 0007からリ湯可能な、事前定義された2進定数を使っています)。これにより、各ビットマップを35バイトではなく5バイト使用するだけになります。しかし、この小容量のデータ形式をどのように使えばいいのでしょうか?　DisplayBitMap()をBitMapの個々のバイト内のビットにアクセスするように書き換えてみます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void DisplayBitMap()
    {
        for (byte x=0; x<5; ++x) {
            byte data = pgm_read_byte (&BitMap[x]);   // fetch data from program memory
            for (byte y=0; y<7; ++y) {
                if (data & (1<<y)) {
                    // turn on the LED at location (x,y)
                } else {
                    // turn off the LED at location (x,y)
                }
            }
        }
    }

理解するべき重要な行は、以下の行です。

1

if (data & (1<<y)) {

(1 << y)という式は、data内でアクセスしたいビットを選択します。そして、ビット単位のAND、data & (1<<y)がアクセスしたいビットを検査します。ビットが設定されていれば、非ゼロ値となり、ifがtrueになります。一方、ビットがゼロであれば、falseと扱われ、elseが実行されます。

クイックリファレンス

このクイックリファレンスでは、いかに図に示すように、16ビット整数のビットを、最下位ビットを第0ビット、最上位ビット(整数が符号有の場合は符号ビット)を第15ビットとして表します。

変数nは、常に0から15までと仮定しています。

1

y = (x >> n) & 1;    // n=0..15.  stores nth bit of x in y.  y becomes 0 or 1.

1

x &= ~(1 << n);      // forces nth bit of x to be 0.  all other bits left alone.

1

x &= (1<<(n+1))-1;   // leaves alone the lowest n bits of x; all higher bits set to 0.

1

x |= (1 << n);       // forces nth bit of x to be 1.  all other bits left alone.

1

x ^= (1 << n);       // toggles nth bit of x.  all other bits left alone.

1

x = ~x;              // toggles ALL the bits in x.

ビット単位の&と論理&&の両方を使う興味深い関数があります。これは、与えられた32ビットの正数xが、2の累乗(1、2、4、8、16、32、64、…)のときだけtrueを返します。例えば、IsPowerOfTwo(64)はtrueを返しますが、IsPowerOfTwo(65)はfalse を返します。この関数がどのように動作するのかを見るために、2の累乗の例として64を使ってみます。64は2進数で1000000です。1000000から1を引くと、0111111になります。びっとたんい&を適用すると、結果は0000000です。一方、同様のことを65(2進数で1000001)に適用すると、1000001 & 1000000 == 1000000となり、非ゼロです。

1
2
3
4

bool IsPowerOfTwo (long x)
    {
        return (x > 0) && (x & (x-1) == 0);
    }

以下は、16ビット整数xを2進数で表したとき、何個のビットが1かを数えて返却する関数です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int CountSetBits (int x)
    {
        int count = 0;
        for (int n=0; n<16; ++n) {
            if (x & (1<<n)) {
                ++count;
            }
        }
        return count;
    }

別の方法も示します。

1
2
3
4
5
6
7

int CountSetBits (int x)
    {
        unsigned int count;
        for (count = 0; x; count++)
            x &= x - 1;
        return count;
    }

ビット操作に関連する様々な方法はこちらを参照してください。

オリジナルのページ

https://docs.arduino.cc/learn/programming/bit-math/

最終更新日

February 4, 2024

inserted by FC2 system