stepper_ctrl.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2025 Jilay Sandeep Pandya
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_STEPPER_CTRL_H_
#define ZEPHYR_INCLUDE_DRIVERS_STEPPER_CTRL_H_

 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum stepper_ctrl_direction {
        STEPPER_CTRL_DIRECTION_NEGATIVE = 0,
        STEPPER_CTRL_DIRECTION_POSITIVE = 1,
};

enum stepper_ctrl_run_mode {
        STEPPER_CTRL_RUN_MODE_HOLD = 0,
        STEPPER_CTRL_RUN_MODE_POSITION = 1,
        STEPPER_CTRL_RUN_MODE_VELOCITY = 2,
};

enum stepper_ctrl_event {
        STEPPER_CTRL_EVENT_STEPS_COMPLETED = 0,
        STEPPER_CTRL_EVENT_LEFT_END_STOP_DETECTED = 1,
        STEPPER_CTRL_EVENT_RIGHT_END_STOP_DETECTED = 2,
        STEPPER_CTRL_EVENT_STOPPED = 3,
};

struct stepper_ctrl_ramp {
        uint32_t acceleration_max;
        uint32_t speed_max;
        uint32_t deceleration_max;
};

typedef void (*stepper_ctrl_event_callback_t)(const struct device *dev,
                                              const enum stepper_ctrl_event event, void *user_data);


typedef int (*stepper_ctrl_set_reference_position_t)(const struct device *dev, const int32_t value);

typedef int (*stepper_ctrl_get_actual_position_t)(const struct device *dev, int32_t *value);

typedef int (*stepper_ctrl_set_event_cb_t)(const struct device *dev,
                                           stepper_ctrl_event_callback_t callback, void *user_data);

typedef int (*stepper_ctrl_set_microstep_interval_t)(const struct device *dev,
                                                     const uint64_t microstep_interval_ns);

typedef int (*stepper_ctrl_configure_ramp_t)(const struct device *dev,
                                             const struct stepper_ctrl_ramp *ramp);

typedef int (*stepper_ctrl_move_by_t)(const struct device *dev, const int32_t micro_steps);

typedef int (*stepper_ctrl_move_to_t)(const struct device *dev, const int32_t micro_steps);

typedef int (*stepper_ctrl_run_t)(const struct device *dev,
                                  const enum stepper_ctrl_direction direction);

typedef int (*stepper_ctrl_stop_t)(const struct device *dev);

typedef int (*stepper_ctrl_is_moving_t)(const struct device *dev, bool *is_moving);

__subsystem struct stepper_ctrl_driver_api {
        stepper_ctrl_set_reference_position_t set_reference_position;
        stepper_ctrl_get_actual_position_t get_actual_position;
        stepper_ctrl_set_event_cb_t set_event_cb;
        stepper_ctrl_set_microstep_interval_t set_microstep_interval;
        stepper_ctrl_configure_ramp_t configure_ramp;
        stepper_ctrl_move_by_t move_by;
        stepper_ctrl_move_to_t move_to;
        stepper_ctrl_run_t run;
        stepper_ctrl_stop_t stop;
        stepper_ctrl_is_moving_t is_moving;
};


__syscall int stepper_ctrl_set_reference_position(const struct device *dev, const int32_t value);
 
static inline int z_impl_stepper_ctrl_set_reference_position(const struct device *dev,
                                                             const int32_t value)
{
        if (DEVICE_API_GET(stepper_ctrl, dev)->set_reference_position == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->set_reference_position(dev, value);
}

 
__syscall int stepper_ctrl_get_actual_position(const struct device *dev, int32_t *value);
 
static inline int z_impl_stepper_ctrl_get_actual_position(const struct device *dev, int32_t *value)
{
        __ASSERT_NO_MSG(value != NULL);
 
        if (DEVICE_API_GET(stepper_ctrl, dev)->get_actual_position == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->get_actual_position(dev, value);
}

 
__syscall int stepper_ctrl_set_event_cb(const struct device *dev,
                                        stepper_ctrl_event_callback_t callback, void *user_data);
 
static inline int z_impl_stepper_ctrl_set_event_cb(const struct device *dev,
                                                   stepper_ctrl_event_callback_t callback,
                                                   void *user_data)
{
        if (DEVICE_API_GET(stepper_ctrl, dev)->set_event_cb == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->set_event_cb(dev, callback, user_data);
}

__syscall int stepper_ctrl_set_microstep_interval(const struct device *dev,
                                                  const uint64_t microstep_interval_ns);
 
static inline int z_impl_stepper_ctrl_set_microstep_interval(const struct device *dev,
                                                             const uint64_t microstep_interval_ns)
{
        if (DEVICE_API_GET(stepper_ctrl, dev)->set_microstep_interval == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->set_microstep_interval(dev,
                                                                      microstep_interval_ns);
}

__syscall int stepper_ctrl_configure_ramp(const struct device *dev,
                                          const struct stepper_ctrl_ramp *ramp);
 
static inline int z_impl_stepper_ctrl_configure_ramp(const struct device *dev,
        const struct stepper_ctrl_ramp *ramp)
{
        __ASSERT_NO_MSG(ramp != NULL);
 
        if (DEVICE_API_GET(stepper_ctrl, dev)->configure_ramp == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->configure_ramp(dev, ramp);
}
__syscall int stepper_ctrl_move_by(const struct device *dev, const int32_t micro_steps);
 
static inline int z_impl_stepper_ctrl_move_by(const struct device *dev, const int32_t micro_steps)
{
        return DEVICE_API_GET(stepper_ctrl, dev)->move_by(dev, micro_steps);
}

__syscall int stepper_ctrl_move_to(const struct device *dev, const int32_t micro_steps);
 
static inline int z_impl_stepper_ctrl_move_to(const struct device *dev, const int32_t micro_steps)
{
        return DEVICE_API_GET(stepper_ctrl, dev)->move_to(dev, micro_steps);
}

__syscall int stepper_ctrl_run(const struct device *dev,
                               const enum stepper_ctrl_direction direction);
 
static inline int z_impl_stepper_ctrl_run(const struct device *dev,
                                          const enum stepper_ctrl_direction direction)
{
        if (DEVICE_API_GET(stepper_ctrl, dev)->run == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->run(dev, direction);
}

__syscall int stepper_ctrl_stop(const struct device *dev);
 
static inline int z_impl_stepper_ctrl_stop(const struct device *dev)
{
        if (DEVICE_API_GET(stepper_ctrl, dev)->stop == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->stop(dev);
}

__syscall int stepper_ctrl_is_moving(const struct device *dev, bool *is_moving);
 
static inline int z_impl_stepper_ctrl_is_moving(const struct device *dev, bool *is_moving)
{
        __ASSERT_NO_MSG(is_moving != NULL);
        if (DEVICE_API_GET(stepper_ctrl, dev)->is_moving == NULL) {
                return -ENOSYS;
        }
        return DEVICE_API_GET(stepper_ctrl, dev)->is_moving(dev, is_moving);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/stepper_ctrl.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_STEPPER_CTRL_H_ */