PWM | A PHP library for accessing the PWM pins on a Raspberry Pi

Ok, I'm working on a software solution that works really good.

I create an "hard written" values table which is a kind of gauge to fix the LED frequency.

My gauge contains 26 values (the first 13 values are "0" and the last 13 values are "1"). I browse this gauge with a sample of 13 values depending on the intensity I want (the values in my sample start at gauge[intensity] to gauge[intensity + 12]).

(When intensity is 0, my sample contains only 13 times 0. When intensity is 1, my sample contains only 12 times 0 and one 1.). Based on these values, I turn on or off my LEDs to modulate the intensity.

The easiest way to output a high speed clock like this is with the MCO peripheral, rather than a timer. Fortunately for you the MCO pin is PA8. Perhaps the person who designed your board knew this and intended you to use MCO. Read the reference manual to see how.

If you do want to use a timer to do 22MHz, then as you have correctly identified you cannot get a 50% duty-cycle on your PWM. I would recommend starting with a 40% or 60%, with an output-compare value of 2-out-of-5 or 3-out-of-5, not 1 as you have above.

There is no detail in the PCA9959 datasheet about what the required mark-space ratio of the clock is, but I guess anything other than 50% could be a problem. You would be better to divide the clock by an even number. Either just divide 110MHz by 6 and output 18.33MHz, or else slow your core down a bit and divide by 4 (reduce the N parameter of your PLL).

Whether you use MCO or PWM don't forget to set the GPIO pin mode to the fastest slew rate available. Maybe the 8MHz you are measuring is the result of aliasing a faster clock that has been through the wrong GPIO mode. You could test this using a scope with at least 100MHz bandwidth.

In Chisel 3, RegInit is referring to a register with reset. There is experimental support for treating an asynchronous reset line as an "initial" line instead, but I want to caution that it's not something I would recommend using in typical digital design.

As you are probably aware, initial values are not universally supported in actual hardware. They are supported by some (but not all) FPGAs, and are not supported at all in ASICs. Thus writing code that relies on initial values is inherently unportable which runs counter to the ethos of Chisel for constructing resuable hardware generators.

That being said, they can make certain designs use resources on certain FPGAs much more efficiently, so we do have a way to do this:

I didn't find anything in the reference manual but finally got to test the behaviour on actual hardware:

• Setting the ARR to a value lower than the current counter value doesn't create an interrupt/update event/etc, the timer keeps counting up
• Manually creating an update event automatically restarts the counter
• Setting the ARR to the current counter value creates an update event

I don't want to restart the counter when setting the ARR value to something higher than the counter value. The solution is to create a manual update event when the ARR value is lower than the counter value. There shouldn't be a problem with the counter reaching ARR while setting it because that automatically creates an update event.

This seems to work as expected:

This code seems severely over-engineered, which is always the biggest danger whenever you allow C++. The language tends to encourage making things needlessly complicated just for the heck of it, instead of utilizing the KISS principle.

The hard requirements are: on the given hardware, the CPU works fastest with 8 bit types but the PWM register is 16 bits. Period.

Therefore any variable describing period or duty cycle needs to be exactly 16 bits. It doesn't make sense to declare it as uint_fast16_t because the corresponding hardware registers will always be exactly 16 bits, no more, no less.

In general the uint_fast types are only helpful if planning to port this to a 32 bit system somehow, but it is very unlikely that there will exist a 32 bit MCU with an identical PWM peripheral. Thus in this case uint_fast is just useless noise, because the code will never get ported.

The cast to uint8_t supposedly truncates the 16 bit value to the 8 least significant bits. If so, the cast is incorrect, it should never be static_cast but static_cast. I'm otherwise not quite following what the code is supposed to do, update the duty cycle somewhere, I would assume.

Furthermore, disabling the interrupt mask as a re-entrancy protection feature probably doesn't make sense, as this can cause unexpected timing problems. If this class is to be used from inside an ISR then another protection mechanism might be more suitable, such as a semaphore or atomic access/inline asm. PWM in particular is picky with when/how you change the duty cycle, or you might get glitches.

Overall, I would strongly recommend not to use C++ on an ancient, severely resource-confined 8 bit microcontroller. Or to use ancient 8 bit microcontrollers instead of ARM when learning embedded systems, 8-bitters are much harder to program in C (or C++) than 32-bitters.

You can create global callback object (visible to the ISR) that should register the actual action to be taken. Generally the callable needs to be visible to the ISR, i.e. it needs to live int ISR's scope.

noexcept suggests you're on C++11 or higher. If not, you'll need to fall back to boost or do some more typing...

That's easy: You are missing a semicolon within nginx/default.conf, you have to write:

Since your colors are the keys of kwargs, which is a regular dictionary, you can do

Hi I don't have your setup so I couldn't test fully. But I think you want a background loop, and use global state to manage interaction with tree (since there is physically one tree.)