michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers/samples/tests: remove usage of deprecated PWM APIs

Browse source 
Use the new API calls that remove pin naming.

Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
This commit is contained in:
Gerard Marull-Paretas 2022-04-01 11:22:31 +02:00 • committed by Carles Cufí
commit 10ee44c94b
11 changed files with 68 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

8
drivers/led/led_pwm.c
View file

@ -56,8 +56,8 @@ static int led_pwm_blink(const struct device *dev, uint32_t led,
led_pwm = &config->led[led];
return pwm_pin_set_usec(led_pwm->dev, led_pwm->channel,
period_usec, pulse_usec, led_pwm->flags);
return pwm_set_usec(led_pwm->dev, led_pwm->channel, period_usec,
pulse_usec, led_pwm->flags);
}
static int led_pwm_set_brightness(const struct device *dev,
@ -75,8 +75,8 @@ static int led_pwm_set_brightness(const struct device *dev,
pulse = led_pwm->period * value / 100;
return pwm_pin_set_nsec(led_pwm->dev, led_pwm->channel,
led_pwm->period, pulse, led_pwm->flags);
return pwm_set_nsec(led_pwm->dev, led_pwm->channel, led_pwm->period,
pulse, led_pwm->flags);
}
static int led_pwm_on(const struct device *dev, uint32_t led)

6
drivers/pwm/pwm_shell.c
View file

@ -52,7 +52,7 @@ static int cmd_cycles(const struct shell *shell, size_t argc, char **argv)
flags = strtoul(argv[args_indx.flags], NULL, 0);
}
err = pwm_pin_set_cycles(dev, channel, period, pulse, flags);
err = pwm_set_cycles(dev, channel, period, pulse, flags);
if (err) {
shell_error(shell, "failed to setup PWM (err %d)",
err);
@ -85,7 +85,7 @@ static int cmd_usec(const struct shell *shell, size_t argc, char **argv)
flags = strtoul(argv[args_indx.flags], NULL, 0);
}
err = pwm_pin_set_usec(dev, channel, period, pulse, flags);
err = pwm_set_cycles_usec(dev, channel, period, pulse, flags);
if (err) {
shell_error(shell, "failed to setup PWM (err %d)", err);
return err;
@ -117,7 +117,7 @@ static int cmd_nsec(const struct shell *shell, size_t argc, char **argv)
flags = strtoul(argv[args_indx.flags], NULL, 0);
}
err = pwm_pin_set_nsec(dev, channel, period, pulse, flags);
err = pwm_set_cycles_nsec(dev, channel, period, pulse, flags);
if (err) {
shell_error(shell, "failed to setup PWM (err %d)", err);
return err;

8
samples/basic/blinky_pwm/src/main.c
View file

@ -55,8 +55,8 @@ void main(void)
*/
printk("Calibrating for channel %d...\n", PWM_CHANNEL);
max_period = MAX_PERIOD_USEC;
while (pwm_pin_set_usec(pwm, PWM_CHANNEL,
max_period, max_period / 2U, PWM_FLAGS)) {
while (pwm_set_usec(pwm, PWM_CHANNEL, max_period, max_period / 2U,
PWM_FLAGS)) {
max_period /= 2U;
if (max_period < (4U * MIN_PERIOD_USEC)) {
printk("Error: PWM device "
@ -71,8 +71,8 @@ void main(void)
period = max_period;
while (1) {
ret = pwm_pin_set_usec(pwm, PWM_CHANNEL,
period, period / 2U, PWM_FLAGS);
ret = pwm_set_usec(pwm, PWM_CHANNEL, period, period / 2U,
PWM_FLAGS);
if (ret) {
printk("Error %d: failed to set pulse width\n", ret);
return;

4
samples/basic/fade_led/src/main.c
View file

@ -53,8 +53,8 @@ void main(void)
}
while (1) {
ret = pwm_pin_set_usec(pwm, PWM_CHANNEL, PERIOD_USEC,
pulse_width, PWM_FLAGS);
ret = pwm_set_usec(pwm, PWM_CHANNEL, PERIOD_USEC, pulse_width,
PWM_FLAGS);
if (ret) {
printk("Error %d: failed to set pulse width\n", ret);
return;

3
samples/basic/rgb_led/src/main.c
View file

@ -64,8 +64,7 @@
static int pwm_set(const struct device *pwm_dev, uint32_t pwm_pin,
uint32_t pulse_width, pwm_flags_t flags)
{
return pwm_pin_set_usec(pwm_dev, pwm_pin, PERIOD_USEC,
pulse_width, flags);
return pwm_set_usec(pwm_dev, pwm_pin, PERIOD_USEC, pulse_width, flags);
}
enum { RED, GREEN, BLUE };

2
samples/basic/servo_motor/src/main.c
View file

@ -49,7 +49,7 @@ void main(void)
}
while (1) {
ret = pwm_pin_set_usec(pwm, 0, PERIOD_USEC, pulse_width, 0);
ret = pwm_set_usec(pwm, 0, PERIOD_USEC, pulse_width, 0);
if (ret < 0) {
printk("Error %d: failed to set pulse width\n", ret);
return;

5
samples/bluetooth/mesh_demo/src/microbit.c
View file

@ -129,14 +129,13 @@ void board_play_tune(const char *str)
}
if (period) {
pwm_pin_set_usec(pwm, BUZZER_PWM_CHANNEL,
period, period / 2U, 0);
pwm_set_usec(pwm, BUZZER_PWM_CHANNEL, period, period / 2U, 0);
}
k_sleep(K_MSEC(duration));
/* Disable the PWM */
pwm_pin_set_usec(pwm, BUZZER_PWM_CHANNEL, 0, 0, 0);
pwm_set_usec(pwm, BUZZER_PWM_CHANNEL, 0, 0, 0);
}
}

2
samples/boards/bbc_microbit/pong/src/main.c
View file

@ -120,7 +120,7 @@ static enum sound_state {
static inline void beep(int period)
{
pwm_pin_set_usec(pwm, SOUND_PWM_CHANNEL, period, period / 2, 0);
pwm_set_usec(pwm, SOUND_PWM_CHANNEL, period, period / 2, 0);
}
static void sound_set(enum sound_state state)

4
samples/boards/bbc_microbit/sound/src/main.c
View file

@ -33,11 +33,11 @@ static void beep(struct k_work *work)
/* The "period / 2" pulse duration gives 50% duty cycle, which
* should result in the maximum sound volume.
*/
pwm_pin_set_usec(pwm, BUZZER_PWM_CHANNEL, period, period / 2U, 0);
pwm_set_usec(pwm, BUZZER_PWM_CHANNEL, period, period / 2U, 0);
k_sleep(BEEP_DURATION);
/* Disable the PWM */
pwm_pin_set_usec(pwm, BUZZER_PWM_CHANNEL, 0, 0, 0);
pwm_set_usec(pwm, BUZZER_PWM_CHANNEL, 0, 0, 0);
/* Ensure there's a clear silent period between two tones */
k_sleep(K_MSEC(50));

16
tests/drivers/pwm/pwm_api/src/test_pwm.c
View file

@ -12,8 +12,8 @@
* @details
* - Test Steps
* -# Bind PWM_0 port 0.
* -# Set PWM period and pulse using pwm_pin_set_cycles(),
* pwm_pin_set_usec(), or pwm_pin_set_nsec().
* -# Set PWM period and pulse using pwm_set_cycles(),
* pwm_set_usec(), or pwm_set_nsec().
* -# Use multimeter or other instruments to measure the output
* from PWM_OUT_0.
* - Expected Results
@ -116,20 +116,20 @@ static int test_task(uint32_t port, uint32_t period, uint32_t pulse, uint8_t uni
}
if (unit == UNIT_CYCLES) {
/* Verify pwm_pin_set_cycles() */
if (pwm_pin_set_cycles(pwm_dev, port, period, pulse, 0)) {
/* Verify pwm_set_cycles() */
if (pwm_set_cycles(pwm_dev, port, period, pulse, 0)) {
TC_PRINT("Fail to set the period and pulse width\n");
return TC_FAIL;
}
} else if (unit == UNIT_USECS) {
/* Verify pwm_pin_set_usec() */
if (pwm_pin_set_usec(pwm_dev, port, period, pulse, 0)) {
/* Verify pwm_set_usec() */
if (pwm_set_usec(pwm_dev, port, period, pulse, 0)) {
TC_PRINT("Fail to set the period and pulse width\n");
return TC_FAIL;
}
} else { /* unit == UNIT_NSECS */
/* Verify pwm_pin_set_nsec() */
if (pwm_pin_set_nsec(pwm_dev, port, period, pulse, 0)) {
/* Verify pwm_set_nsec() */
if (pwm_set_nsec(pwm_dev, port, period, pulse, 0)) {
TC_PRINT("Fail to set the period and pulse width\n");
return TC_FAIL;
}

91
tests/drivers/pwm/pwm_loopback/src/test_pwm_loopback.c
View file

@ -50,17 +50,17 @@ void test_capture(uint32_t period, uint32_t pulse, enum test_pwm_unit unit,
case TEST_PWM_UNIT_NSEC:
TC_PRINT("Testing PWM capture @ %u/%u nsec\n",
pulse, period);
err = pwm_pin_set_nsec(out.dev, out.pwm, period,
pulse, out.flags ^=
(flags & PWM_POLARITY_MASK));
err = pwm_set_nsec(out.dev, out.pwm, period,
pulse, out.flags ^=
(flags & PWM_POLARITY_MASK));
break;
case TEST_PWM_UNIT_USEC:
TC_PRINT("Testing PWM capture @ %u/%u usec\n",
pulse, period);
err = pwm_pin_set_usec(out.dev, out.pwm, period,
pulse, out.flags ^=
(flags & PWM_POLARITY_MASK));
err = pwm_set_usec(out.dev, out.pwm, period,
pulse, out.flags ^=
(flags & PWM_POLARITY_MASK));
break;
default:
@ -72,15 +72,13 @@ void test_capture(uint32_t period, uint32_t pulse, enum test_pwm_unit unit,
switch (unit) {
case TEST_PWM_UNIT_NSEC:
err = pwm_pin_capture_nsec(in.dev, in.pwm, flags,
&period_capture, &pulse_capture,
K_NSEC(period * 10));
err = pwm_capture_nsec(in.dev, in.pwm, flags, &period_capture,
&pulse_capture, K_NSEC(period * 10));
break;
case TEST_PWM_UNIT_USEC:
err = pwm_pin_capture_usec(in.dev, in.pwm, flags,
&period_capture, &pulse_capture,
K_USEC(period * 10));
err = pwm_capture_usec(in.dev, in.pwm, flags, &period_capture,
&pulse_capture, K_USEC(period * 10));
break;
default:
@ -166,18 +164,17 @@ void test_capture_timeout(void)
get_test_pwms(&out, &in);
err = pwm_pin_set_cycles(out.dev, out.pwm, 100, 0, out.flags);
err = pwm_set_cycles(out.dev, out.pwm, 100, 0, out.flags);
zassert_equal(err, 0, "failed to set pwm output (err %d)", err);
err = pwm_pin_capture_cycles(in.dev, in.pwm,
PWM_CAPTURE_TYPE_PULSE,
&period, &pulse, K_MSEC(1000));
err = pwm_capture_cycles(in.dev, in.pwm, PWM_CAPTURE_TYPE_PULSE,
&period, &pulse, K_MSEC(1000));
if (err == -ENOTSUP) {
TC_PRINT("Pulse capture not supported, "
"trying period capture\n");
err = pwm_pin_capture_cycles(in.dev, in.pwm,
PWM_CAPTURE_TYPE_PERIOD,
&period, &pulse, K_MSEC(1000));
err = pwm_capture_cycles(in.dev, in.pwm,
PWM_CAPTURE_TYPE_PERIOD, &period,
&pulse, K_MSEC(1000));
}
zassert_equal(err, -EAGAIN, "pwm capture did not timeout (err %d)",
@ -238,42 +235,40 @@ void test_continuous_capture(void)
memset(buffer, 0, sizeof(buffer));
k_sem_init(&data.sem, 0, 1);
err = pwm_pin_set_usec(out.dev, out.pwm, period_usec, pulse_usec,
err = pwm_set_usec(out.dev, out.pwm, period_usec, pulse_usec,
out.flags);
zassert_equal(err, 0, "failed to set pwm output (err %d)", err);
err = pwm_pin_configure_capture(in.dev, in.pwm,
in.flags |
PWM_CAPTURE_MODE_CONTINUOUS |
PWM_CAPTURE_TYPE_PULSE,
continuous_capture_callback,
&data);
err = pwm_configure_capture(in.dev, in.pwm,
in.flags |
PWM_CAPTURE_MODE_CONTINUOUS |
PWM_CAPTURE_TYPE_PULSE,
continuous_capture_callback, &data);
if (err == -ENOTSUP) {
TC_PRINT("Pulse capture not supported, "
"trying period capture\n");
err = pwm_pin_configure_capture(in.dev, in.pwm,
in.flags |
PWM_CAPTURE_MODE_CONTINUOUS |
PWM_CAPTURE_TYPE_PERIOD,
continuous_capture_callback,
&data);
err = pwm_configure_capture(in.dev, in.pwm,
in.flags |
PWM_CAPTURE_MODE_CONTINUOUS |
PWM_CAPTURE_TYPE_PERIOD,
continuous_capture_callback, &data);
zassert_equal(err, 0, "failed to configure pwm input (err %d)",
err);
data.pulse_capture = false;
}
err = pwm_pin_enable_capture(in.dev, in.pwm);
err = pwm_enable_capture(in.dev, in.pwm);
zassert_equal(err, 0, "failed to enable pwm capture (err %d)", err);
err = k_sem_take(&data.sem, K_USEC(period_usec * data.buffer_len * 10));
zassert_equal(err, 0, "pwm capture timed out (err %d)", err);
zassert_equal(data.status, 0, "pwm capture failed (err %d)", err);
err = pwm_pin_disable_capture(in.dev, in.pwm);
err = pwm_disable_capture(in.dev, in.pwm);
zassert_equal(err, 0, "failed to disable pwm capture (err %d)", err);
for (i = 0; i < data.buffer_len; i++) {
err = pwm_pin_cycles_to_usec(in.dev, in.pwm, buffer[i], &usec);
err = pwm_cycles_to_usec(in.dev, in.pwm, buffer[i], &usec);
zassert_equal(err, 0, "failed to calculate usec (err %d)", err);
if (data.pulse_capture) {
@ -306,38 +301,32 @@ void test_capture_busy(void)
memset(buffer, 0, sizeof(buffer));
k_sem_init(&data.sem, 0, 1);
err = pwm_pin_set_cycles(out.dev, out.pwm, 100, 0, out.flags);
err = pwm_set_cycles(out.dev, out.pwm, 100, 0, out.flags);
zassert_equal(err, 0, "failed to set pwm output (err %d)", err);
err = pwm_pin_configure_capture(in.dev, in.pwm,
in.flags | flags,
continuous_capture_callback,
&data);
err = pwm_configure_capture(in.dev, in.pwm, in.flags | flags,
continuous_capture_callback, &data);
if (err == -ENOTSUP) {
TC_PRINT("Pulse capture not supported, "
"trying period capture\n");
flags = PWM_CAPTURE_MODE_SINGLE | PWM_CAPTURE_TYPE_PERIOD;
err = pwm_pin_configure_capture(in.dev, in.pwm,
in.flags | flags,
continuous_capture_callback,
&data);
err = pwm_configure_capture(in.dev, in.pwm, in.flags | flags,
continuous_capture_callback, &data);
zassert_equal(err, 0, "failed to configure pwm input (err %d)",
err);
data.pulse_capture = false;
}
err = pwm_pin_enable_capture(in.dev, in.pwm);
err = pwm_enable_capture(in.dev, in.pwm);
zassert_equal(err, 0, "failed to enable pwm capture (err %d)", err);
err = pwm_pin_configure_capture(in.dev, in.pwm,
in.flags | flags,
continuous_capture_callback,
&data);
err = pwm_configure_capture(in.dev, in.pwm, in.flags | flags,
continuous_capture_callback, &data);
zassert_equal(err, -EBUSY, "pwm capture not busy (err %d)", err);
err = pwm_pin_enable_capture(in.dev, in.pwm);
err = pwm_enable_capture(in.dev, in.pwm);
zassert_equal(err, -EBUSY, "pwm capture not busy (err %d)", err);
err = pwm_pin_disable_capture(in.dev, in.pwm);
err = pwm_disable_capture(in.dev, in.pwm);
zassert_equal(err, 0, "failed to disable pwm capture (err %d)", err);
}