In C, assuming unsigned or two’s complement, !~x or ~x == 0 serves as a bitwise AND; it is 1 if and only if each bit of x is 1.

!!x or x != 0 serves as a bitwise OR; it is 1 if any bit of x is 1.

The negations, not properly called NAND or NOR since they do not apply a NAND or NOR in a bitwise fashion but rather apply a NOT to the bitwise AND or OR, are simply !!~x or ~x != 0 and !x or x == 0.

There is no bitwise XOR in the operations specified by the C standard. GCC has __builtin_parity which can provide this.

The above apply to the full width of x. Narrower widths can be implemented by setting the extra bits to identity elements (1 for AND, 0 for OR and XOR).

| performs a bitwise OR on the two operands it is passed.

For example,

byte b = 0x0A | 0x50;

If you look at the underlying bits for 0x0A and 0x50, they are 0b00001010 and 0b01010000 respectively. When combined with the OR operator the result in b is 0b01011010, or 0x5A in hexadecimal.

|= is analogous to operators like += and -= in that it will perform a bitwise OR on the two operands then store the result in the left operand.

byte b = 0x0A;
b |= 0x50;

// after this b = 0x5A

That's not a question, that's a whole bunch. :)

1. You use bitwise operators when you want to view a number as a collection of bits, rather than an integer. It's much easier to say "I want this bit-pattern shifted two bits to the left" than to create the mathematically equivalent operation. They're conceptually different; if you think of the number as bits, using a bit-operator makes more sense.
2. The & 0xffff makes sure the value is 16 bits, by masking off all higher bits. This assumes the system's unsigned long is at least 16 bits wide, which is a pretty safe assumption. The & (bitwise AND) is often used for this purpose. Look at the truth table for logical conjunction and think "false is 0, true is 1" to see how this works.
3. The & before the hexadecimal constant is C's bitwise AND operator, which is used to do the masking I describe above. Basically, for single-bit variables a & b, the result is 1 if and only if both a and b are 1. The operator applies this logic to each pair of bits in its input terms.
4. The ~ operator is C's bitwise inversion, it "flips" the bits of its argument. It is commonly used to create masks.