stepper.h

Go to the documentation of this file.

 
/*
 * SPDX-FileCopyrightText: Copyright (c) 2024 Carl Zeiss Meditec AG
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_STEPPER_H_
#define ZEPHYR_INCLUDE_DRIVERS_STEPPER_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum micro_step_resolution {
        STEPPER_FULL_STEP = 1,
        STEPPER_MICRO_STEP_2 = 2,
        STEPPER_MICRO_STEP_4 = 4,
        STEPPER_MICRO_STEP_8 = 8,
        STEPPER_MICRO_STEP_16 = 16,
        STEPPER_MICRO_STEP_32 = 32,
        STEPPER_MICRO_STEP_64 = 64,
        STEPPER_MICRO_STEP_128 = 128,
        STEPPER_MICRO_STEP_256 = 256,
};
 
enum stepper_direction {
        STEPPER_DIRECTION_POSITIVE = 0,
        STEPPER_DIRECTION_NEGATIVE,
};
 
enum stepper_run_mode {
        STEPPER_HOLD_MODE = 0,
        STEPPER_POSITION_MODE,
        STEPPER_VELOCITY_MODE,
};
 
enum stepper_signal_result {
        STEPPER_SIGNAL_STEPS_COMPLETED = 0,
};
 
typedef int (*stepper_enable_t)(const struct device *dev, const bool enable);
 
typedef int (*stepper_move_t)(const struct device *dev, const int32_t micro_steps,
                              struct k_poll_signal *async);
 
typedef int (*stepper_set_max_velocity_t)(const struct device *dev,
                                          const uint32_t micro_steps_per_second);
 
typedef int (*stepper_set_micro_step_res_t)(const struct device *dev,
                                            const enum micro_step_resolution resolution);
 
typedef int (*stepper_get_micro_step_res_t)(const struct device *dev,
                                            enum micro_step_resolution *resolution);
typedef int (*stepper_set_actual_position_t)(const struct device *dev, const int32_t value);
 
typedef int (*stepper_get_actual_position_t)(const struct device *dev, int32_t *value);
 
typedef int (*stepper_set_target_position_t)(const struct device *dev, const int32_t value,
                                             struct k_poll_signal *async);
 
typedef int (*stepper_is_moving_t)(const struct device *dev, bool *is_moving);
 
typedef int (*stepper_enable_constant_velocity_mode_t)(const struct device *dev,
                                                       const enum stepper_direction direction,
                                                       const uint32_t value);
 
__subsystem struct stepper_driver_api {
        stepper_enable_t enable;
        stepper_move_t move;
        stepper_set_max_velocity_t set_max_velocity;
        stepper_set_micro_step_res_t set_micro_step_res;
        stepper_get_micro_step_res_t get_micro_step_res;
        stepper_set_actual_position_t set_actual_position;
        stepper_get_actual_position_t get_actual_position;
        stepper_set_target_position_t set_target_position;
        stepper_is_moving_t is_moving;
        stepper_enable_constant_velocity_mode_t enable_constant_velocity_mode;
};
 
__syscall int stepper_enable(const struct device *dev, const bool enable);
 
static inline int z_impl_stepper_enable(const struct device *dev, const bool enable)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        return api->enable(dev, enable);
}
 
__syscall int stepper_move(const struct device *dev, int32_t micro_steps,
                           struct k_poll_signal *async);
 
static inline int z_impl_stepper_move(const struct device *dev, const int32_t micro_steps,
                                      struct k_poll_signal *async)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        return api->move(dev, micro_steps, async);
}
 
__syscall int stepper_set_max_velocity(const struct device *dev, uint32_t micro_steps_per_second);
 
static inline int z_impl_stepper_set_max_velocity(const struct device *dev,
                                                  const uint32_t micro_steps_per_second)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        return api->set_max_velocity(dev, micro_steps_per_second);
}
 
__syscall int stepper_set_micro_step_res(const struct device *dev,
                                         enum micro_step_resolution resolution);
 
static inline int z_impl_stepper_set_micro_step_res(const struct device *dev,
                                                    enum micro_step_resolution resolution)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_micro_step_res == NULL) {
                return -ENOSYS;
        }
        return api->set_micro_step_res(dev, resolution);
}
 
__syscall int stepper_get_micro_step_res(const struct device *dev,
                                         enum micro_step_resolution *resolution);
 
static inline int z_impl_stepper_get_micro_step_res(const struct device *dev,
                                                    enum micro_step_resolution *resolution)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->get_micro_step_res == NULL) {
                return -ENOSYS;
        }
        return api->get_micro_step_res(dev, resolution);
}
 
__syscall int stepper_set_actual_position(const struct device *dev, int32_t value);
 
static inline int z_impl_stepper_set_actual_position(const struct device *dev, const int32_t value)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_actual_position == NULL) {
                return -ENOSYS;
        }
        return api->set_actual_position(dev, value);
}
 
__syscall int stepper_get_actual_position(const struct device *dev, int32_t *value);
 
static inline int z_impl_stepper_get_actual_position(const struct device *dev, int32_t *value)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->get_actual_position == NULL) {
                return -ENOSYS;
        }
        return api->get_actual_position(dev, value);
}
 
__syscall int stepper_set_target_position(const struct device *dev, int32_t value,
                                          struct k_poll_signal *async);
 
static inline int z_impl_stepper_set_target_position(const struct device *dev, const int32_t value,
                                                     struct k_poll_signal *async)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_target_position == NULL) {
                return -ENOSYS;
        }
        return api->set_target_position(dev, value, async);
}
 
__syscall int stepper_is_moving(const struct device *dev, bool *is_moving);
 
static inline int z_impl_stepper_is_moving(const struct device *dev, bool *is_moving)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->is_moving == NULL) {
                return -ENOSYS;
        }
        return api->is_moving(dev, is_moving);
}
 
__syscall int stepper_enable_constant_velocity_mode(const struct device *dev,
                                                    enum stepper_direction direction,
                                                    uint32_t value);
 
static inline int z_impl_stepper_enable_constant_velocity_mode(
        const struct device *dev, const enum stepper_direction direction, const uint32_t value)
{
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->enable_constant_velocity_mode == NULL) {
                return -ENOSYS;
        }
        return api->enable_constant_velocity_mode(dev, direction, value);
}
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/stepper.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_STEPPER_H_ */