It should also be noted that there can be atomicity issues when using AVR raw port i/o.
Some forms of malfunction can be not so obvious, particularly to less experienced code writers and there are some cases than can trip up even advanced users.
This is because the AVR has very limited capabilities when it comes to setting and clearing bits. i.e. it can only atomically set/clear a single bit and even when it can, the address range that this can be done is very limited.
Some AVRs have registers, including i/o port registers that are outside of the range that supports bit set/clear instructions.
As a result, if interrupts are involved or multiple bits are being set/cleared or there is an attempt to set a single bit in a register that is outside the supported range it is possible that an attempt to set/clear bits can result in register corruption.
Consider this:
PORTB |= 0b00000001;
compiles into a single atomic SBI instruction with no concerns when using with ISR code that also modifies PORTB bits.
But this is not:
PORTB |= 0b00000011;
This second example of attempting to set multiple bits can cause register corruption if an ISR is also modifying PORTB.
This second example is also much slower than doing each bit separately which sets each bit atomically.
But while each bit is set atomically, there is no way on an AVR to set multiple bits in a register atomically without setting all the bits in the register.
PORTB |= 0b00000001;
PORTB |= 0b00000010;
Also, not all AVR registers support bit set and bit clear instructions.
This one can trip up even and advance user.
i.e. bit set/clear instructions not supported for any register above G.
For example on a Atmega 1280/2560
PORTK |= 0b00000001;
While it looks the same at the C source level, it will not generate the same instructions as a register a lower address such as 'H' or lower
since this K register is outside the supported range it will generate multiple AVR instructions and is not atomic.
Another thing due to the AVR limited instructions for setting/clearing bits, is if anything but a constant is used to set the bit, the compiler is unable to generate atomic code.
Example:
PORTB |= 1; // atomic
POTBB |= bitvalue; // not atomic if bitvalue is not a constant.
Some other processors have more powerful instructions that are not as limited.
--- bill