stepper.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024 Carl Zeiss Meditec AG
 * SPDX-FileCopyrightText: Copyright (c) 2024 Jilay Sandeep Pandya
 * 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 stepper_direction {
        STEPPER_DIRECTION_NEGATIVE = 0,
        STEPPER_DIRECTION_POSITIVE = 1,
};

enum stepper_run_mode {
        STEPPER_RUN_MODE_HOLD = 0,
        STEPPER_RUN_MODE_POSITION = 1,
        STEPPER_RUN_MODE_VELOCITY = 2,
};

enum stepper_event {
        STEPPER_EVENT_STEPS_COMPLETED = 0,
        STEPPER_EVENT_LEFT_END_STOP_DETECTED = 1,
        STEPPER_EVENT_RIGHT_END_STOP_DETECTED = 2,
        STEPPER_EVENT_STOPPED = 3,
};


typedef int (*stepper_set_reference_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 void (*stepper_event_callback_t)(const struct device *dev, const enum stepper_event event,
                                         void *user_data);

typedef int (*stepper_set_event_callback_t)(const struct device *dev,
                                            stepper_event_callback_t callback, void *user_data);

typedef int (*stepper_set_microstep_interval_t)(const struct device *dev,
                                                const uint64_t microstep_interval_ns);
typedef int (*stepper_move_by_t)(const struct device *dev, const int32_t micro_steps);

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

typedef int (*stepper_run_t)(const struct device *dev, const enum stepper_direction direction);

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

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

__subsystem struct stepper_driver_api {
        stepper_set_reference_position_t set_reference_position;
        stepper_get_actual_position_t get_actual_position;
        stepper_set_event_callback_t set_event_callback;
        stepper_set_microstep_interval_t set_microstep_interval;
        stepper_move_by_t move_by;
        stepper_move_to_t move_to;
        stepper_run_t run;
        stepper_stop_t stop;
        stepper_is_moving_t is_moving;
};


__syscall int stepper_set_reference_position(const struct device *dev, int32_t value);
 
static inline int z_impl_stepper_set_reference_position(const struct device *dev,
                                                        const int32_t value)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_reference_position == NULL) {
                return -ENOSYS;
        }
        return api->set_reference_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)
{
        __ASSERT_NO_MSG(dev != NULL);
        __ASSERT_NO_MSG(value != NULL);
        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_event_callback(const struct device *dev,
                                         stepper_event_callback_t callback, void *user_data);
 
static inline int z_impl_stepper_set_event_callback(const struct device *dev,
                                                    stepper_event_callback_t callback,
                                                    void *user_data)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_event_callback == NULL) {
                return -ENOSYS;
        }
        return api->set_event_callback(dev, callback, user_data);
}

__syscall int stepper_set_microstep_interval(const struct device *dev,
                                             uint64_t microstep_interval_ns);
 
static inline int z_impl_stepper_set_microstep_interval(const struct device *dev,
                                                        const uint64_t microstep_interval_ns)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->set_microstep_interval == NULL) {
                return -ENOSYS;
        }
        return api->set_microstep_interval(dev, microstep_interval_ns);
}

__syscall int stepper_move_by(const struct device *dev, int32_t micro_steps);
 
static inline int z_impl_stepper_move_by(const struct device *dev, const int32_t micro_steps)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        return api->move_by(dev, micro_steps);
}

__syscall int stepper_move_to(const struct device *dev, int32_t micro_steps);
 
static inline int z_impl_stepper_move_to(const struct device *dev, const int32_t micro_steps)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        return api->move_to(dev, micro_steps);
}

__syscall int stepper_run(const struct device *dev, enum stepper_direction direction);
 
static inline int z_impl_stepper_run(const struct device *dev,
                                     const enum stepper_direction direction)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->run == NULL) {
                return -ENOSYS;
        }
        return api->run(dev, direction);
}

__syscall int stepper_stop(const struct device *dev);
 
static inline int z_impl_stepper_stop(const struct device *dev)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_driver_api *api = (const struct stepper_driver_api *)dev->api;
 
        if (api->stop == NULL) {
                return -ENOSYS;
        }
        return api->stop(dev);
}

__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)
{
        __ASSERT_NO_MSG(dev != NULL);
        __ASSERT_NO_MSG(is_moving != NULL);
        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);
}



enum stepper_drv_micro_step_resolution {
        STEPPER_DRV_MICRO_STEP_1 = 1,
        STEPPER_DRV_MICRO_STEP_2 = 2,
        STEPPER_DRV_MICRO_STEP_4 = 4,
        STEPPER_DRV_MICRO_STEP_8 = 8,
        STEPPER_DRV_MICRO_STEP_16 = 16,
        STEPPER_DRV_MICRO_STEP_32 = 32,
        STEPPER_DRV_MICRO_STEP_64 = 64,
        STEPPER_DRV_MICRO_STEP_128 = 128,
        STEPPER_DRV_MICRO_STEP_256 = 256,
};

#define MICRO_STEP_RES_INDEX(res) LOG2(res)
 
#define VALID_MICRO_STEP_RES(res)                                                                  \
        ((res) == STEPPER_DRV_MICRO_STEP_1 || (res) == STEPPER_DRV_MICRO_STEP_2 ||                 \
         (res) == STEPPER_DRV_MICRO_STEP_4 || (res) == STEPPER_DRV_MICRO_STEP_8 ||                 \
         (res) == STEPPER_DRV_MICRO_STEP_16 || (res) == STEPPER_DRV_MICRO_STEP_32 ||               \
         (res) == STEPPER_DRV_MICRO_STEP_64 || (res) == STEPPER_DRV_MICRO_STEP_128 ||              \
         (res) == STEPPER_DRV_MICRO_STEP_256)
 
enum stepper_drv_event {
        STEPPER_DRV_EVENT_STALL_DETECTED = 0,
        STEPPER_DRV_EVENT_FAULT_DETECTED = 1,
};


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

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

typedef int (*stepper_drv_set_micro_step_res_t)(
        const struct device *dev, const enum stepper_drv_micro_step_resolution resolution);

typedef int (*stepper_drv_get_micro_step_res_t)(const struct device *dev,
                                                enum stepper_drv_micro_step_resolution *resolution);

typedef void (*stepper_drv_event_cb_t)(const struct device *dev, const enum stepper_drv_event event,
                                       void *user_data);

typedef int (*stepper_drv_set_event_callback_t)(const struct device *dev,
                                                stepper_drv_event_cb_t callback, void *user_data);

__subsystem struct stepper_drv_driver_api {
        stepper_drv_enable_t enable;
        stepper_drv_disable_t disable;
        stepper_drv_set_micro_step_res_t set_micro_step_res;
        stepper_drv_get_micro_step_res_t get_micro_step_res;
        stepper_drv_set_event_callback_t set_event_cb;
};


__syscall int stepper_drv_enable(const struct device *dev);
 
static inline int z_impl_stepper_drv_enable(const struct device *dev)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_drv_driver_api *api = (const struct stepper_drv_driver_api *)dev->api;
 
        return api->enable(dev);
}

__syscall int stepper_drv_disable(const struct device *dev);
 
static inline int z_impl_stepper_drv_disable(const struct device *dev)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_drv_driver_api *api = (const struct stepper_drv_driver_api *)dev->api;
 
        return api->disable(dev);
}

__syscall int stepper_drv_set_micro_step_res(const struct device *dev,
                                             enum stepper_drv_micro_step_resolution res);
 
static inline int z_impl_stepper_drv_set_micro_step_res(const struct device *dev,
                                                        enum stepper_drv_micro_step_resolution res)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_drv_driver_api *api = (const struct stepper_drv_driver_api *)dev->api;
 
        if (!VALID_MICRO_STEP_RES(res)) {
                return -EINVAL;
        }
        return api->set_micro_step_res(dev, res);
}

__syscall int stepper_drv_get_micro_step_res(const struct device *dev,
                                             enum stepper_drv_micro_step_resolution *res);
 
static inline int z_impl_stepper_drv_get_micro_step_res(const struct device *dev,
                                                        enum stepper_drv_micro_step_resolution *res)
{
        __ASSERT_NO_MSG(dev != NULL);
        __ASSERT_NO_MSG(res != NULL);
        const struct stepper_drv_driver_api *api = (const struct stepper_drv_driver_api *)dev->api;
 
        return api->get_micro_step_res(dev, res);
}

__syscall int stepper_drv_set_event_cb(const struct device *dev, stepper_drv_event_cb_t callback,
                                       void *user_data);
 
static inline int z_impl_stepper_drv_set_event_cb(const struct device *dev,
                                                  stepper_drv_event_cb_t cb, void *user_data)
{
        __ASSERT_NO_MSG(dev != NULL);
        const struct stepper_drv_driver_api *api = (const struct stepper_drv_driver_api *)dev->api;
 
        if (api->set_event_cb == NULL) {
                return -ENOSYS;
        }
 
        return api->set_event_cb(dev, cb, user_data);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/stepper.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_STEPPER_H_ */