stepper.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*!****************************************************************************
 *  @file       stepper.h
 *  @brief      STEPPER_MODULE Module
 *
 *
 *  @anchor stepper_h
 *  # Overview
 *
 *  Does stuff
 *
 *  <hr>
 ******************************************************************************/
#ifndef STEPPER_H
#define STEPPER_H

#include <stdint.h>

#include <ti/devices/msp/msp.h>

/* Include the IQmath Library */
#include <ti/iqmath/include/IQmathLib.h>

#ifdef __cplusplus
extern "C" {
#endif

#define STEPPER_INDEXER_MAX_COUNT   (1024)

#define STEPPER_INDEXER_0_BY_8      (0)

#define STEPPER_INDEXER_1_BY_8      (STEPPER_INDEXER_MAX_COUNT >> 3)

#define STEPPER_INDEXER_2_BY_8      (2 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_INDEXER_3_BY_8      (3 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_INDEXER_4_BY_8      (4 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_INDEXER_5_BY_8      (5 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_INDEXER_6_BY_8      (6 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_INDEXER_7_BY_8      (7 * STEPPER_INDEXER_1_BY_8)

#define STEPPER_2PI                 (6.2831853071f)

typedef enum {
    STEPPER_STEP_INC_DEC_FULL_STEP = 256,
    STEPPER_STEP_INC_DEC_HALF_STEP = 128,
    STEPPER_STEP_INC_DEC_1BY4_STEP = 64,
    STEPPER_STEP_INC_DEC_1BY8_STEP = 32,
    STEPPER_STEP_INC_DEC_1BY16_STEP = 16,
    STEPPER_STEP_INC_DEC_1BY32_STEP = 8,
    STEPPER_STEP_INC_DEC_1BY64_STEP = 4,
    STEPPER_STEP_INC_DEC_1BY128_STEP = 2,
    STEPPER_STEP_INC_DEC_1BY256_STEP = 1,
}STEPPER_STEP_INC_DEC;

typedef enum {
    STEPPER_DRIVE_DISABLE = 0,
    STEPPER_DRIVE_DECAY,
    STEPPER_DRIVE_FORWARD,
    STEPPER_DRIVE_REVERSE,
}STEPPER_DRIVE;

typedef enum {
    STEPPER_STEP_TYPE_CIR = 0,
    STEPPER_STEP_TYPE_NONCIR,
}STEPPER_STEP_TYPE;

typedef enum {
    STEPPER_DIR_FORWARD = 0,
    STEPPER_DIR_REVERSE,
}STEPPER_DIR;

typedef struct {
    int16_t counter;
    STEPPER_DIR dir;
    STEPPER_STEP_INC_DEC indexIncDec;
    STEPPER_STEP_TYPE stepType;
    STEPPER_DRIVE IaDrive;
    STEPPER_DRIVE IbDrive;
#ifdef __HAS_2_DAC

    _iq15 IaCurrRef;
    _iq15 IbCurrRef;
#endif
}INDEXER_Instance;

extern _iq18 angleSf;

void STEPPER_init(void);

__STATIC_INLINE void STEPPER_setIndexerDir(
                                    INDEXER_Instance *handle, STEPPER_DIR dir)
{
    handle->dir = dir;
}

__STATIC_INLINE void STEPPER_setIndexerIncVal(
                    INDEXER_Instance *handle, STEPPER_STEP_INC_DEC incDecVal)
{
    handle->indexIncDec = incDecVal;
}

__STATIC_INLINE void STEPPER_setStepType(
                        INDEXER_Instance *handle, STEPPER_STEP_TYPE stepType)
{
    handle->stepType = stepType;
}

__STATIC_INLINE void STEPPER_setMotorDrives(INDEXER_Instance *handle,
                                            STEPPER_DRIVE IaDrive,
                                            STEPPER_DRIVE IbDrive)
{
    handle->IaDrive = IaDrive;
    handle->IbDrive = IbDrive;
}

__STATIC_INLINE void STEPPER_cirStepPhaseGen(INDEXER_Instance *handle)
{
    int16_t counter = handle->counter;
    if(counter >= STEPPER_INDEXER_0_BY_8 && counter < STEPPER_INDEXER_2_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_FORWARD, STEPPER_DRIVE_FORWARD);
    }
    else if(counter >= STEPPER_INDEXER_2_BY_8 && counter < STEPPER_INDEXER_4_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_FORWARD, STEPPER_DRIVE_REVERSE);
    }
    else if(counter >= STEPPER_INDEXER_4_BY_8 && counter < STEPPER_INDEXER_6_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_REVERSE, STEPPER_DRIVE_REVERSE);
    }
    else if(counter >= STEPPER_INDEXER_6_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_REVERSE, STEPPER_DRIVE_FORWARD);
    }
    else
    {
        /* This is expected to be empty*/
    }
}

__STATIC_INLINE void STEPPER_nonCirPhaseGen(INDEXER_Instance *handle)
{
    int16_t counter = handle->counter;
    if(counter >= STEPPER_INDEXER_0_BY_8 && counter < STEPPER_INDEXER_1_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_FORWARD, STEPPER_DRIVE_FORWARD);
    }
    if(counter >= STEPPER_INDEXER_1_BY_8 && counter < STEPPER_INDEXER_2_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_FORWARD, STEPPER_DRIVE_DECAY);
    }
    else if(counter >= STEPPER_INDEXER_2_BY_8 && counter < STEPPER_INDEXER_3_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_FORWARD, STEPPER_DRIVE_REVERSE);
    }
    else if(counter >= STEPPER_INDEXER_3_BY_8 && counter < STEPPER_INDEXER_4_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_DECAY, STEPPER_DRIVE_REVERSE);
    }
    else if(counter >= STEPPER_INDEXER_4_BY_8 && counter < STEPPER_INDEXER_5_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_REVERSE, STEPPER_DRIVE_REVERSE);
    }
    else if(counter >= STEPPER_INDEXER_5_BY_8 && counter < STEPPER_INDEXER_6_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_REVERSE, STEPPER_DRIVE_DECAY);
    }
    else if(counter >= STEPPER_INDEXER_6_BY_8 && counter < STEPPER_INDEXER_7_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_REVERSE, STEPPER_DRIVE_FORWARD);
    }
    else if(counter >= STEPPER_INDEXER_7_BY_8)
    {
        STEPPER_setMotorDrives(
                        handle, STEPPER_DRIVE_DECAY, STEPPER_DRIVE_FORWARD);
    }
    else
    {
        /* This is expected to be empty*/
    }
}

/*
* The current reference is used in case of drivers which has independent vref
* for each motor phase. This is disabled when not using such drivers
*/
#ifdef __HAS_2_DAC

__STATIC_INLINE void STEPPER_currRefGen(INDEXER_Instance *handle)
{
    uint32_t countValue = handle->counter;
    _iq15 angle = _IQ15mpy(_IQ15(countValue), angleSf);
    handle->IaCurrRef = _IQ15abs(_IQ15cos(angle));
    handle->IbCurrRef = _IQ15abs(_IQ15sin(angle));
}
#endif

__STATIC_INLINE void STEPPER_indexer(INDEXER_Instance *handle)
{
    if(handle->dir == STEPPER_DIR_FORWARD)
    {
        handle->counter += handle->indexIncDec;
    }
    else
    {
        handle->counter -= handle->indexIncDec;
    }

    if(handle->counter < 0)
    {
        handle->counter = (STEPPER_INDEXER_MAX_COUNT + handle->counter);
    }

    if(handle->counter >= STEPPER_INDEXER_MAX_COUNT - 1)
    {
        handle->counter = 0;
    }

    if(handle->stepType == STEPPER_STEP_TYPE_CIR)
    {
        STEPPER_cirStepPhaseGen(handle);
    }
    else if(handle->stepType == STEPPER_STEP_TYPE_NONCIR)
    {
        STEPPER_nonCirPhaseGen(handle);
    }
    else
    {
        /* This is expected to be empty*/
    }
}

#ifdef __cplusplus
}
#endif
#endif /* STEPPER_H */