Managing all PWM pins on TC1

[pmnlla]

In the Arduino Servo library, all of the PWM pins are controlled through TC1. The stepper library uses TC2.
However, in avr-hal, the only PWM capability is the 2 pins per timer that have been assigned at compilation time. i.e. pins 9, 10 for TC1.
Is it possible to assign TC1 to time all 6 PWM pins? This way, it is possible to have16 bit PWM for all 6 pins, rather than 8 bit for 4 and 16 bit for 2.

In examples/uno-manual-servo.rs, one controls pin D9 through its register, as depicted in the atmega328p datasheets. See https://github.com/Rahix/avr-hal/blob/main/examples/arduino-uno/src/bin/uno-manual-servo.rs. and attached image.

is it possible to control all PWM pins only using TC1?

[Rahix]

There is a fundamental difference between our PWM implementation and the one in the Arduino Servo library: While we use hardware PWM where the timer directly drives the output pin, the Servo library implements a software variant: A timer triggers an interrupt and the interrupt routine then toggles pins as needed. This is what allows them to control arbitrary pins as PWM signals (but limits the PWM frequency, which isn't a problem for Servo control).

You could implement this by hand using avr-hal, by manually setting up the timer and interrupt as needed. See https://github.com/Rahix/avr-hal/blob/main/examples/arduino-uno/src/bin/uno-millis.rs for some timer code.

However, in the long run, it would of course be nice to provide a library/crate similar to the Arduino Servo one which takes care of all the underlying details behind this. It's a bit tricky to implement such a library due to the need of defining an interrupt routine and due to avr-hal currently missing a proper generic timer abstraction.

[pmnlla]

Good to know.
I likely won't have an Uno to write for for a while. I finished the project that involved using one and probably won't have that class... ever again. However, I might buy some hardware for myself so I can try to implement this.

If I do, this will likely be my second ever project written in Rust, and thus won't be the absolute best.

However, my biggest issue with the avr-hal abstractions right now is that most of the methods provided to certain objects don't work well when their types are associated with generics. This is something I observed while trying to write a servo class that uses simple_pwm PwmPinOpt objects, but due to the need for each one to be provided a different timer, I had to substitute the timer with generics in my class. Thus, simple-pwn failed to work.

Theoretically, would this be an issue once a "proper" generic timer abstraction is released? and can I assume that, by then, I could use TC1 as a timer that, rather than toggling output pins, sends interrupts to the CPU? And in the interrupt routine, would it be possible to dynamically locate servos only using their pin number as a u8?

[pmnlla]

@Rahix got a small update for you.

I've started to make a simple interrupt routine for TC0 in my spare time. By encapsulating all the Pinmode::Output type pin ports in a structure with their period widths, and making a vector of those, they're easy to iterate through in code and are well abstracted through the Downgrade() function.

However, while looking at the uno-millis.rs example you provided, I'm not sure the timer will interrupt the CPU as close enough intervals to be able to precisely manipulate the servo positions. The closest I can get to is using Prescale8 with a 250 timer count, which means the toggle function runs once every 0.125ms. This is with the timer running at 2mHz, with the atemga328 running at 8mhz, which means we send an interrupt every 4 cycles.

Ideally, what we would want to do, is to send an interrupt to the processor every 50ms. This turns all the pins on for at least 1ms. It then loops through all the pins, deciding when the toggle each one in small millisecond fraction intervals, ideally 1/180th of a millisecond. Once all the pins are off, we resume normal execution. This sounds to me like it would work, but how do we make the processor wait exactly 1/180th of a millisecond? Would we be able to use TC1 for this? How would we ignore its interrupts for 48ms at a time?

my very much WIP implementation is in a repository on my profile. I haven't bothered to make it easy to understand as it's still a WIP. Here it is.

[pmnlla]

Update? I've come up with the idea to swap to TC1, trigger an interrupt every 180th of a millisecond, and after 180 interrupts we configure the timer to 49ms to give us some room to execute code. after that 49ms interrupt we swap it back to 180th of a millisecond.

Will try to implement this.

I still have no testing hardware, but might borrow an Uno today to see if I can get something working. This is also a good time to mention this would be exclusive to the Unos, and probably not run as a crate. It would be a good place to start though.