bartoszek/zephyr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

drivers: stepper: rename gpio_steppper_controller to h_bridge_stepper

Browse Source 
rename gpio stepper to h bridge stepper
minor correction in stepper_stop, stepper_stop shall cancel all active
movements and should not be concerned about keeping the coils energized
or not, since that is a concern of a motion controller and not a stepper
driver.

Signed-off-by: Jilay Pandya <jilay.pandya@outlook.com>
This commit is contained in:
Jilay Pandya 2025-05-17 10:49:48 +02:00 committed by Alberto Escolar
parent b42013ada8
commit 3ce26616c9
11 changed files with 154 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/stepper/CMakeLists.txt
View File

@ -14,5 +14,5 @@ zephyr_library()
zephyr_library_property(ALLOW_EMPTY TRUE)
zephyr_library_sources_ifdef(CONFIG_FAKE_STEPPER fake_stepper_controller.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_STEPPER gpio_stepper_controller.c)
zephyr_library_sources_ifdef(CONFIG_H_BRIDGE_STEPPER h_bridge_stepper.c)
zephyr_library_sources_ifdef(CONFIG_STEPPER_SHELL stepper_shell.c)

2
drivers/stepper/Kconfig
View File

@ -32,7 +32,7 @@ comment "Stepper Drivers"
# zephyr-keep-sorted-start
rsource "Kconfig.fake"
rsource "Kconfig.gpio"
rsource "Kconfig.h_bridge"
rsource "adi_tmc/Kconfig"
rsource "allegro/Kconfig"
rsource "ti/Kconfig"

4
drivers/stepper/Kconfig.gpio → drivers/stepper/Kconfig.h_bridge
View File

@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright (c) 2024 Jilay Sandeep Pandya
# SPDX-License-Identifier: Apache-2.0
config GPIO_STEPPER
config H_BRIDGE_STEPPER
bool "Activate driver for gpio stepper control"
depends on DT_HAS_ZEPHYR_GPIO_STEPPER_ENABLED
depends on DT_HAS_ZEPHYR_H_BRIDGE_STEPPER_ENABLED
default y

232
drivers/stepper/gpio_stepper_controller.c → drivers/stepper/h_bridge_stepper.c
View File

@ -4,16 +4,15 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT zephyr_gpio_stepper
#define DT_DRV_COMPAT zephyr_h_bridge_stepper
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys_clock.h>
#include <zephyr/drivers/stepper.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(gpio_stepper_motor_controller, CONFIG_STEPPER_LOG_LEVEL);
LOG_MODULE_REGISTER(h_bridge_stepper, CONFIG_STEPPER_LOG_LEVEL);
#define MAX_MICRO_STEP_RES STEPPER_MICRO_STEP_2
#define NUM_CONTROL_PINS 4
@ -23,13 +22,13 @@ static const uint8_t
{1u, 1u, 0u, 0u}, {0u, 1u, 0u, 0u}, {0u, 1u, 1u, 0u}, {0u, 0u, 1u, 0u},
{0u, 0u, 1u, 1u}, {0u, 0u, 0u, 1u}, {1u, 0u, 0u, 1u}, {1u, 0u, 0u, 0u}};
struct gpio_stepper_config {
struct h_bridge_stepper_config {
const struct gpio_dt_spec en_pin;
const struct gpio_dt_spec *control_pins;
bool invert_direction;
};
struct gpio_stepper_data {
struct h_bridge_stepper_data {
const struct device *dev;
struct k_spinlock lock;
enum stepper_direction direction;
@ -46,19 +45,25 @@ struct gpio_stepper_data {
static int stepper_motor_set_coil_charge(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
const struct gpio_stepper_config *config = dev->config;
struct h_bridge_stepper_data *data = dev->data;
const struct h_bridge_stepper_config *config = dev->config;
int ret;
for (int i = 0; i < NUM_CONTROL_PINS; i++) {
(void)gpio_pin_set_dt(&config->control_pins[i],
ret = gpio_pin_set_dt(&config->control_pins[i],
half_step_lookup_table[data->coil_charge][i]);
if (ret < 0) {
LOG_ERR("Failed to set control pin %d: %d", i, ret);
return ret;
}
}
return 0;
}
static void increment_coil_charge(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (data->coil_charge == NUM_CONTROL_PINS * MAX_MICRO_STEP_RES - data->step_gap) {
data->coil_charge = 0;
@ -69,7 +74,7 @@ static void increment_coil_charge(const struct device *dev)
static void decrement_coil_charge(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (data->coil_charge == 0) {
data->coil_charge = NUM_CONTROL_PINS * MAX_MICRO_STEP_RES - data->step_gap;
@ -78,25 +83,10 @@ static void decrement_coil_charge(const struct device *dev)
}
}
static int energize_coils(const struct device *dev, const bool energized)
{
const struct gpio_stepper_config *config = dev->config;
for (int i = 0; i < NUM_CONTROL_PINS; i++) {
const int err = gpio_pin_set_dt(&config->control_pins[i], energized);
if (err != 0) {
LOG_ERR("Failed to power down coil %d", i);
return err;
}
}
return 0;
}
static void update_coil_charge(const struct device *dev)
{
const struct gpio_stepper_config *config = dev->config;
struct gpio_stepper_data *data = dev->data;
const struct h_bridge_stepper_config *config = dev->config;
struct h_bridge_stepper_data *data = dev->data;
if (data->direction == STEPPER_DIRECTION_POSITIVE) {
config->invert_direction ? decrement_coil_charge(dev) : increment_coil_charge(dev);
@ -109,7 +99,7 @@ static void update_coil_charge(const struct device *dev)
static void update_remaining_steps(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (data->step_count > 0) {
data->step_count--;
@ -120,7 +110,7 @@ static void update_remaining_steps(const struct device *dev)
static void update_direction_from_step_count(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (data->step_count > 0) {
data->direction = STEPPER_DIRECTION_POSITIVE;
@ -133,10 +123,16 @@ static void update_direction_from_step_count(const struct device *dev)
static void position_mode_task(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
int ret;
update_remaining_steps(dev);
(void)stepper_motor_set_coil_charge(dev);
ret = stepper_motor_set_coil_charge(dev);
if (ret < 0) {
LOG_ERR("Failed to set coil charge: %d", ret);
return;
}
update_coil_charge(dev);
if (data->step_count) {
(void)k_work_reschedule(&data->stepper_dwork, K_NSEC(data->delay_in_ns));
@ -151,9 +147,15 @@ static void position_mode_task(const struct device *dev)
static void velocity_mode_task(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
int ret;
ret = stepper_motor_set_coil_charge(dev);
if (ret < 0) {
LOG_ERR("Failed to set coil charge: %d", ret);
return;
}
(void)stepper_motor_set_coil_charge(dev);
update_coil_charge(dev);
(void)k_work_reschedule(&data->stepper_dwork, K_NSEC(data->delay_in_ns));
}
@ -161,8 +163,8 @@ static void velocity_mode_task(const struct device *dev)
static void stepper_work_step_handler(struct k_work *work)
{
struct k_work_delayable *dwork = k_work_delayable_from_work(work);
struct gpio_stepper_data *data =
CONTAINER_OF(dwork, struct gpio_stepper_data, stepper_dwork);
struct h_bridge_stepper_data *data =
CONTAINER_OF(dwork, struct h_bridge_stepper_data, stepper_dwork);
K_SPINLOCK(&data->lock) {
switch (data->run_mode) {
@ -179,9 +181,9 @@ static void stepper_work_step_handler(struct k_work *work)
}
}
static int gpio_stepper_move_by(const struct device *dev, int32_t micro_steps)
static int h_bridge_stepper_move_by(const struct device *dev, int32_t micro_steps)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (data->delay_in_ns == 0) {
LOG_ERR("Step interval not set or invalid step interval set");
@ -196,9 +198,9 @@ static int gpio_stepper_move_by(const struct device *dev, int32_t micro_steps)
return 0;
}
static int gpio_stepper_set_reference_position(const struct device *dev, int32_t position)
static int h_bridge_stepper_set_reference_position(const struct device *dev, int32_t position)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
K_SPINLOCK(&data->lock) {
data->actual_position = position;
@ -206,9 +208,9 @@ static int gpio_stepper_set_reference_position(const struct device *dev, int32_t
return 0;
}
static int gpio_stepper_get_actual_position(const struct device *dev, int32_t *position)
static int h_bridge_stepper_get_actual_position(const struct device *dev, int32_t *position)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
K_SPINLOCK(&data->lock) {
*position = data->actual_position;
@ -216,30 +218,30 @@ static int gpio_stepper_get_actual_position(const struct device *dev, int32_t *p
return 0;
}
static int gpio_stepper_move_to(const struct device *dev, int32_t micro_steps)
static int h_bridge_stepper_move_to(const struct device *dev, int32_t micro_steps)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
int32_t steps_to_move;
K_SPINLOCK(&data->lock) {
steps_to_move = micro_steps - data->actual_position;
}
return gpio_stepper_move_by(dev, steps_to_move);
return h_bridge_stepper_move_by(dev, steps_to_move);
}
static int gpio_stepper_is_moving(const struct device *dev, bool *is_moving)
static int h_bridge_stepper_is_moving(const struct device *dev, bool *is_moving)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
*is_moving = k_work_delayable_is_pending(&data->stepper_dwork);
LOG_DBG("Motor is %s moving", *is_moving ? "" : "not");
return 0;
}
static int gpio_stepper_set_microstep_interval(const struct device *dev,
uint64_t microstep_interval_ns)
static int h_bridge_stepper_set_microstep_interval(const struct device *dev,
uint64_t microstep_interval_ns)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
if (microstep_interval_ns == 0) {
LOG_ERR("Step interval is invalid.");
@ -253,9 +255,9 @@ static int gpio_stepper_set_microstep_interval(const struct device *dev,
return 0;
}
static int gpio_stepper_run(const struct device *dev, const enum stepper_direction direction)
static int h_bridge_stepper_run(const struct device *dev, const enum stepper_direction direction)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
K_SPINLOCK(&data->lock) {
data->run_mode = STEPPER_RUN_MODE_VELOCITY;
@ -265,10 +267,10 @@ static int gpio_stepper_run(const struct device *dev, const enum stepper_directi
return 0;
}
static int gpio_stepper_set_micro_step_res(const struct device *dev,
enum stepper_micro_step_resolution micro_step_res)
static int h_bridge_stepper_set_micro_step_res(const struct device *dev,
enum stepper_micro_step_resolution micro_step_res)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
int err = 0;
K_SPINLOCK(&data->lock) {
@ -285,30 +287,30 @@ static int gpio_stepper_set_micro_step_res(const struct device *dev,
return err;
}
static int gpio_stepper_get_micro_step_res(const struct device *dev,
enum stepper_micro_step_resolution *micro_step_res)
static int h_bridge_stepper_get_micro_step_res(const struct device *dev,
enum stepper_micro_step_resolution *micro_step_res)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
*micro_step_res = MAX_MICRO_STEP_RES >> (data->step_gap - 1);
return 0;
}
static int gpio_stepper_set_event_callback(const struct device *dev,
stepper_event_callback_t callback, void *user_data)
static int h_bridge_stepper_set_event_callback(const struct device *dev,
stepper_event_callback_t callback, void *user_data)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
K_SPINLOCK(&data->lock) {
data->callback = callback;
data->event_cb_user_data = user_data;
}
data->event_cb_user_data = user_data;
return 0;
}
static int gpio_stepper_enable(const struct device *dev)
static int h_bridge_stepper_enable(const struct device *dev)
{
const struct gpio_stepper_config *config = dev->config;
struct gpio_stepper_data *data = dev->data;
const struct h_bridge_stepper_config *config = dev->config;
struct h_bridge_stepper_data *data = dev->data;
int err;
K_SPINLOCK(&data->lock) {
@ -322,14 +324,13 @@ static int gpio_stepper_enable(const struct device *dev)
return err;
}
static int gpio_stepper_disable(const struct device *dev)
static int h_bridge_stepper_disable(const struct device *dev)
{
const struct gpio_stepper_config *config = dev->config;
struct gpio_stepper_data *data = dev->data;
const struct h_bridge_stepper_config *config = dev->config;
struct h_bridge_stepper_data *data = dev->data;
int err;
K_SPINLOCK(&data->lock) {
(void)energize_coils(dev, false);
if (config->en_pin.port != NULL) {
err = gpio_pin_set_dt(&config->en_pin, 0);
} else {
@ -341,14 +342,13 @@ static int gpio_stepper_disable(const struct device *dev)
return err;
}
static int gpio_stepper_stop(const struct device *dev)
static int h_bridge_stepper_stop(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
struct h_bridge_stepper_data *data = dev->data;
int err;
K_SPINLOCK(&data->lock) {
(void)k_work_cancel_delayable(&data->stepper_dwork);
err = energize_coils(dev, true);
err = k_work_cancel_delayable(&data->stepper_dwork);
if (data->callback && !err) {
data->callback(data->dev, STEPPER_EVENT_STOPPED, data->event_cb_user_data);
@ -357,52 +357,68 @@ static int gpio_stepper_stop(const struct device *dev)
return err;
}
static int gpio_stepper_init(const struct device *dev)
static int h_bridge_stepper_init(const struct device *dev)
{
struct gpio_stepper_data *data = dev->data;
const struct gpio_stepper_config *config = dev->config;
struct h_bridge_stepper_data *data = dev->data;
const struct h_bridge_stepper_config *config = dev->config;
int err;
data->dev = dev;
LOG_DBG("Initializing %s gpio_stepper with %d pin", dev->name, NUM_CONTROL_PINS);
LOG_DBG("Initializing %s h_bridge_stepper with %d pin", dev->name, NUM_CONTROL_PINS);
for (uint8_t n_pin = 0; n_pin < NUM_CONTROL_PINS; n_pin++) {
(void)gpio_pin_configure_dt(&config->control_pins[n_pin], GPIO_OUTPUT_INACTIVE);
}
if (config->en_pin.port != NULL) {
if (!gpio_is_ready_dt(&config->en_pin)) {
LOG_ERR("Enable Pin is not ready");
return -ENODEV;
}
err = gpio_pin_configure_dt(&config->en_pin, GPIO_OUTPUT_INACTIVE);
if (err != 0) {
LOG_ERR("%s: Failed to configure en_pin (error: %d)", dev->name, err);
return err;
}
}
k_work_init_delayable(&data->stepper_dwork, stepper_work_step_handler);
return 0;
}
static DEVICE_API(stepper, gpio_stepper_api) = {
.enable = gpio_stepper_enable,
.disable = gpio_stepper_disable,
.set_micro_step_res = gpio_stepper_set_micro_step_res,
.get_micro_step_res = gpio_stepper_get_micro_step_res,
.set_reference_position = gpio_stepper_set_reference_position,
.get_actual_position = gpio_stepper_get_actual_position,
.set_event_callback = gpio_stepper_set_event_callback,
.set_microstep_interval = gpio_stepper_set_microstep_interval,
.move_by = gpio_stepper_move_by,
.move_to = gpio_stepper_move_to,
.run = gpio_stepper_run,
.stop = gpio_stepper_stop,
.is_moving = gpio_stepper_is_moving,
static DEVICE_API(stepper, h_bridge_stepper_api) = {
.enable = h_bridge_stepper_enable,
.disable = h_bridge_stepper_disable,
.set_micro_step_res = h_bridge_stepper_set_micro_step_res,
.get_micro_step_res = h_bridge_stepper_get_micro_step_res,
.set_reference_position = h_bridge_stepper_set_reference_position,
.get_actual_position = h_bridge_stepper_get_actual_position,
.set_event_callback = h_bridge_stepper_set_event_callback,
.set_microstep_interval = h_bridge_stepper_set_microstep_interval,
.move_by = h_bridge_stepper_move_by,
.move_to = h_bridge_stepper_move_to,
.run = h_bridge_stepper_run,
.stop = h_bridge_stepper_stop,
.is_moving = h_bridge_stepper_is_moving,
};
#define GPIO_STEPPER_DEFINE(inst) \
static const struct gpio_dt_spec gpio_stepper_motor_control_pins_##inst[] = { \
DT_INST_FOREACH_PROP_ELEM_SEP(inst, gpios, GPIO_DT_SPEC_GET_BY_IDX, (,)), \
}; \
BUILD_ASSERT(ARRAY_SIZE(gpio_stepper_motor_control_pins_##inst) == 4, \
"gpio_stepper_controller driver currently supports only 4 wire configuration"); \
static const struct gpio_stepper_config gpio_stepper_config_##inst = { \
.invert_direction = DT_INST_PROP(inst, invert_direction), \
.control_pins = gpio_stepper_motor_control_pins_##inst}; \
static struct gpio_stepper_data gpio_stepper_data_##inst = { \
.step_gap = MAX_MICRO_STEP_RES >> (DT_INST_PROP(inst, micro_step_res) - 1), \
}; \
BUILD_ASSERT(DT_INST_PROP(inst, micro_step_res) <= STEPPER_MICRO_STEP_2, \
"gpio_stepper_controller driver supports up to 2 micro steps"); \
DEVICE_DT_INST_DEFINE(inst, gpio_stepper_init, NULL, &gpio_stepper_data_##inst, \
&gpio_stepper_config_##inst, POST_KERNEL, \
CONFIG_STEPPER_INIT_PRIORITY, &gpio_stepper_api);
#define H_BRIDGE_STEPPER_DEFINE(inst) \
static const struct gpio_dt_spec h_bridge_stepper_motor_control_pins_##inst[] = { \
DT_INST_FOREACH_PROP_ELEM_SEP(inst, gpios, GPIO_DT_SPEC_GET_BY_IDX, (,)), \
}; \
BUILD_ASSERT(ARRAY_SIZE(h_bridge_stepper_motor_control_pins_##inst) == 4, \
"h_bridge stepper driver currently supports only 4 wire configuration"); \
static const struct h_bridge_stepper_config h_bridge_stepper_config_##inst = { \
.en_pin = GPIO_DT_SPEC_INST_GET_OR(inst, en_gpios, {0}), \
.invert_direction = DT_INST_PROP(inst, invert_direction), \
.control_pins = h_bridge_stepper_motor_control_pins_##inst}; \
static struct h_bridge_stepper_data h_bridge_stepper_data_##inst = { \
.step_gap = MAX_MICRO_STEP_RES >> (DT_INST_PROP(inst, micro_step_res) - 1), \
}; \
BUILD_ASSERT(DT_INST_PROP(inst, micro_step_res) <= STEPPER_MICRO_STEP_2, \
"h_bridge stepper driver supports up to 2 micro steps"); \
DEVICE_DT_INST_DEFINE(inst, h_bridge_stepper_init, NULL, &h_bridge_stepper_data_##inst, \
&h_bridge_stepper_config_##inst, POST_KERNEL, \
CONFIG_STEPPER_INIT_PRIORITY, &h_bridge_stepper_api);
DT_INST_FOREACH_STATUS_OKAY(GPIO_STEPPER_DEFINE)
DT_INST_FOREACH_STATUS_OKAY(H_BRIDGE_STEPPER_DEFINE)

5
dts/bindings/stepper/zephyr,gpio-stepper.yaml → dts/bindings/stepper/zephyr,h-bridge-stepper.yaml
View File

@ -8,14 +8,15 @@ description: |
Example:
/* Lead A is connected Lead C and Lead B is connected to Lead D*/
stepper: stepper {
compatible = "zephyr,gpio-stepper";
compatible = "zephyr,h-bridge-stepper";
en-gpios = <&gpioa 6 GPIO_ACTIVE_HIGH>;
gpios = <&gpioa 9 GPIO_ACTIVE_HIGH>, /* Lead A1/A */
<&gpioc 7 GPIO_ACTIVE_HIGH>, /* Lead B1/B */
<&gpiob 0 GPIO_ACTIVE_HIGH>, /* Lead A2/C */
<&gpioa 7 GPIO_ACTIVE_HIGH>; /* Lead B2/D */
};
compatible: "zephyr,gpio-stepper"
compatible: "zephyr,h-bridge-stepper"
include: stepper-controller.yaml

2
include/zephyr/drivers/stepper.h
View File

@ -503,7 +503,7 @@ static inline int z_impl_stepper_run(const struct device *dev,
/**
* @brief Stop the stepper
* @details Cancel all active movements, however keep the coils energized.
* @details Cancel all active movements.
*
* @param dev pointer to the stepper driver instance
*

7
samples/drivers/stepper/generic/boards/nucleo_g071rb.overlay
View File

@ -1,14 +1,15 @@
/ {
aliases {
stepper = &gpio_stepper;
stepper = &h_bridge_stepper;
};
};
/ {
gpio_stepper: gpio_stepper {
compatible = "zephyr,gpio-stepper";
h_bridge_stepper: h_bridge_stepper {
compatible = "zephyr,h-bridge-stepper";
status = "okay";
micro-step-res = <2>;
en-gpios = <&gpioa 6 GPIO_ACTIVE_HIGH>; /* D12 */
gpios = <&gpioa 9 GPIO_ACTIVE_HIGH>, /* D8 */
<&gpioc 7 GPIO_ACTIVE_HIGH>, /* D9 */
<&gpiob 0 GPIO_ACTIVE_HIGH>, /* D10 */

5
tests/drivers/build_all/stepper/gpio.dtsi
View File

@ -45,10 +45,11 @@ ti_drv84xx: ti_drv84xx {
counter = <&counter0>;
};
zephyr_gpio_stepper: zephyr_gpio_stepper {
compatible = "zephyr,gpio-stepper";
zephyr_h_bridge_stepper: zephyr_h_bridge_stepper {
compatible = "zephyr,h-bridge-stepper";
status = "okay";
micro-step-res = <1>;
en-gpios = <&test_gpio 0 0>;
gpios = <&test_gpio 0 0>,
<&test_gpio 0 0>,
<&test_gpio 0 0>,

13
tests/drivers/stepper/stepper_api/boards/native_sim_zephyr_gpio_stepper.overlay → tests/drivers/stepper/stepper_api/boards/native_sim_zephyr_h_bridge_stepper.overlay
View File

@ -7,18 +7,19 @@
/ {
aliases {
stepper = &zephyr_gpio_stepper;
stepper = &zephyr_h_bridge_stepper;
};
};
/ {
zephyr_gpio_stepper: zephyr_gpio_stepper {
compatible = "zephyr,gpio-stepper";
zephyr_h_bridge_stepper: zephyr_h_bridge_stepper {
compatible = "zephyr,h-bridge-stepper";
status = "okay";
micro-step-res = <1>;
en-gpios = <&gpio1 0 0>;
gpios = <&gpio1 0 0>,
<&gpio2 0 0>,
<&gpio3 0 0>,
<&gpio4 0 0>;
<&gpio2 0 0>,
<&gpio3 0 0>,
<&gpio4 0 0>;
};
};

12
tests/drivers/stepper/stepper_api/boards/qemu_x86_64_zephyr_gpio_stepper.overlay → tests/drivers/stepper/stepper_api/boards/qemu_x86_64_zephyr_h_bridge_stepper.overlay
View File

@ -7,7 +7,7 @@
/ {
aliases {
stepper = &zephyr_gpio_stepper;
stepper = &zephyr_h_bridge_stepper;
};
};
@ -42,13 +42,13 @@
};
/ {
zephyr_gpio_stepper: zephyr_gpio_stepper {
compatible = "zephyr,gpio-stepper";
zephyr_h_bridge_stepper: zephyr_h_bridge_stepper {
compatible = "zephyr,h-bridge-stepper";
status = "okay";
micro-step-res = <2>;
gpios = <&gpio1 0 0>,
<&gpio2 0 0>,
<&gpio3 0 0>,
<&gpio4 0 0>;
<&gpio2 0 0>,
<&gpio3 0 0>,
<&gpio4 0 0>;
};
};

4
tests/drivers/stepper/stepper_api/testcase.yaml
View File

@ -63,8 +63,8 @@ tests:
- native_sim/native/64
drivers.stepper.stepper_api.zephyr_gpio_stepper:
extra_args:
- platform:native_sim/native/64:DTC_OVERLAY_FILE="boards/native_sim_zephyr_gpio_stepper.overlay"
- platform:qemu_x86_64/atom:DTC_OVERLAY_FILE="boards/qemu_x86_64_zephyr_gpio_stepper.overlay"
- platform:native_sim/native/64:DTC_OVERLAY_FILE="boards/native_sim_zephyr_h_bridge_stepper.overlay"
- platform:qemu_x86_64/atom:DTC_OVERLAY_FILE="boards/qemu_x86_64_zephyr_h_bridge_stepper.overlay"
extra_configs:
- CONFIG_GPIO=y
platform_allow: