What are the common/advised practices when using interrupt service routines to modify register values?

[K4LCIFER]

The issue that I'm currently running into is how to best go about modifying a register's value from the triggering of an interrupt service routine. For example, say there's a button that, when pressed, is to change the compare value of a timer. There's two important aspects of this (at least for the atmega328p):

1. The pin change interrupts only detect a change in the pins value, and not only a rising or falling edge, so the pin's value must be read at the beginning of the interrupt to detect whether it's high or low to know if it was pressed or released.
2. The compare value of the timer must be updated.

Both of these would need to be done within the ISR for the button's pin.

Coming from C, I would just directly read, and modify the requisite registers within the ISR, while not thinking too much of it (taking care to avoid data races), but this is proving to be a little more involved in Rust. For example:

1. I cannot modify the peripherals in the ISR if they are defined within the scope of the main function as

   fn main() -> ! {
   let peripherals = atmega_hal::Peripherals.take().unwrap();
   }

   as they would then be out of scope in any ISR.
2. I've come across atmega_hal::Peripherals::steal(), and I thought to maybe just steal the peripherals within the ISR; however, I don't quite understand if this is the correct way to use it, and it also feels rather messy and bloated.
3. Declaring the peripherals globaly as static mut feels like possibly the worst solution, and arguably very against the philosophy of Rust, and would result in unsafe being used everywhere, which, imo, is extremely messy.
4. I could maybe use avr_device::interrupt::Mutex to grab the peripherals globally along with Critical Sections of avr_device::interrupt::free, but I've been unable to find good documentation for this to use it properly, and I have yet to be able to resolve it nicely with the borrow checker. And, regardless, it feels little messy to have these Critical Sections strewn about anytime a register is to be modified.

So I'm wondering how interrupts are advised to be, or are commonly done in this context. I've yet to come across any examples of ISR's directly modifying register values from avr-hal. I've seen a handful for other embedded targets, but I haven't been able to successfully port their practices over.

[Rahix]

With the bare avr-device runtime, there are basically two options:

1. The preferred option is usually your (4), to put the peripheral into a Mutex and then access it from that mutex inside the ISR. This is by far the safest way as you do not have to think about possible race conditions, etc.
2. Where the above is too unwieldy or has performance issues, you can perform unsafe register accesses directly. Of course, you should be really sure that you are doing it correctly and without potential race conditions. For example:

   unsafe {
       (*avr_hal::pac::TC0::ptr()).ocr0a.write(|w| w.bits(0x00));
   }

   An example where we use this are the atomic GPIO pin writes in the port module