Safely updating duty cycle values during playback

RE: Safely updating duty cycle values during playback

Karl Ylvisaker — Tue, 08 Mar 2022 15:17:50 GMT

Hello again,

[quote user="Andy Gould"]Thanks for the update.[/quote]

No problem at all, I am happy to help!

[quote user="Andy Gould"]Is the only way to do this using NRFX, to cache the new values until that NRFX_PWM_EVT_END_SEQ0/1 occurs, and then update then? [/quote]

Yes, this is how you should do this, update the sequence as part of the END_SEQ event handling. The NRFX_PWM_EVT_FINISHED event will only be generated once a sequence playback has completed the specified number of times - generated when the LOOPSDONE event has been generated - while the SEQEND events are generated for each sequence end.

[quote user="Andy Gould"]I presume that the safe window is defined as between SEQSTARTED and SEQEND?[/quote]

No, that would be the unsafe window - the values should not be changed between SEQSTARTED and SEQEND, instead it should be between SEQEND and SEQSTARTED.

[quote user="Andy Gould"]

But these events are not available in NRFX?

Is there a reason why some of these events are not exposed at the NRFX layer?

[/quote]

These events are not exposed to the application layer, no - they are used by the driver directly, and then the driver will forward relevant NRFX events to the application layer event handler based on these. These

Best regards,
Karl

RE: Safely updating duty cycle values during playback

Andy Gould — Tue, 08 Mar 2022 10:40:04 GMT

Thanks for the update. What I am not clear on, is at what point it becomes unsafe to change the values.... So. If I have an external trigger ( for example, an ADC read), that provides values for the PWM duty cycle, and when it completes, I want to update the PWM duty cycles. I know that the NRFX_PWM_EVT_END_SEQ0 or NRFX_PWM_EVT_END_SEQ1 Indicates that it is safe to update the values, but I'm not clear what event I should subscribe to that indicates that it is unsafe. nrfx_pwm_evt_type_t only contains

Enumerator
NRFX_PWM_EVT_FINISHED	Sequence playback finished.
NRFX_PWM_EVT_END_SEQ0	End of sequence 0 reached. Its data can be safely modified now.
NRFX_PWM_EVT_END_SEQ1	End of sequence 1 reached. Its data can be safely modified now.
NRFX_PWM_EVT_STOPPED	The PWM peripheral has been stopped.

And NRFX_PWM_EVT_FINISHED appears to occur at the same time as NRFX_PWM_EVT_END_SEQ0/1.

Is the only way to do this using NRFX, to cache the new values until that NRFX_PWM_EVT_END_SEQ0/1 occurs, and then update then?

I notice that NRF has a more compete set of events:

Enumerator
NRF_PWM_EVENT_STOPPED	Response to STOP task, emitted when PWM pulses are no longer generated.
NRF_PWM_EVENT_SEQSTARTED0	First PWM period started on sequence 0.
NRF_PWM_EVENT_SEQSTARTED1	First PWM period started on sequence 1.
NRF_PWM_EVENT_SEQEND0	Emitted at the end of every sequence 0 when its last value has been read from RAM.
NRF_PWM_EVENT_SEQEND1	Emitted at the end of every sequence 1 when its last value has been read from RAM.
NRF_PWM_EVENT_PWMPERIODEND	Emitted at the end of each PWM period.
NRF_PWM_EVENT_LOOPSDONE	Concatenated sequences have been played the requested number of times.

I presume that the safe window is defined as between SEQSTARTED and SEQEND? But these events are not available in NRFX?

Is there a reason why some of these events are not exposed at the NRFX layer?

RE: Safely updating duty cycle values during playback

Karl Ylvisaker — Tue, 08 Mar 2022 10:10:07 GMT

Hello,

Thank you for your patience with this.

[quote user=""]When the sequence is set (by a call to nrf_pwm_sequence_set), the provided duty cycle values are not copied. The values pointer is stored in the internal register of the peripheral, and the values are loaded from RAM during the sequence playback. Therefore, you must ensure that the values do not change before and during the sequence playback (for example, the values cannot be placed in a local variable that is allocated on stack).[/quote]

To clarify this, this means that you must ensure that the pointer you provide actually points to the values for the playback at the time of the playback - for example, if the values only persist through the scope of an 'update_pwm' function, they may be overwritten by the time the playback actually happens, which is not a valid way to operate the PWM peripheral.
On the other hand, if your playback sequence values are persistent throughout the duration of your PWM peripheral's operation - such as in the case of global variables - it will ensure that the pointer you provide to the PWM peripheral always points to the valid playback sequence values.

[quote user=""]Does this mean that the user can update duty cycles using this function at any time, without worrying about a safe window?[/quote]

No, because this function only update's the PWM's pointer - it does not perform any check to see if the location of the values will persist until the playback occurs.
The issue arises if you supply a pointer that points to non-persistent playback sequence values. The 'safe window' in this case would therefor be the time in which you can guarantee that the sequence playback values that you have provided the pointer for does not change / are actually stored at the location.

Please do not hesitate to let me know if any part of this still should be unclear! :)

Best regards,
Karl