HornetStepper Class Reference

Common class to control stepper-run gauges in OpenHornet. More...

#include <Hornet_Stepper.h>

Public Member Functions
	HornetStepper (int coil1, int coil2, int coil3, int coil4, int zeroPos, int maxPos, int dirForward, unsigned int capValue=65535, int normalSpeed=300, int normalAccel=600, MapPoint *mapPoints=nullptr, uint8_t numMapPoints=0)
	Constructor for HornetStepper.
	~HornetStepper ()
	Destructor to clean up allocated arrays.
void	findZero ()
	findZero() is a function to zero the gauge
void	testFullRange (int testSpeed=20, int testAccel=10)
	testFullRange() is a function to test the range of the gauge
void	setTarget (unsigned int targetVal)
	setTarget() is a function to set the target position of the gauge
void	run ()
	run() is a function to run the stepper motor (non-blocking)

Static Public Attributes
static bool	ufcEntPressed = false
static bool	ufcClrPressed = false

Detailed Description

Common class to control stepper-run gauges in OpenHornet.

Uses the AccelStepper library to control the stepper motor.

Definition at line 100 of file Hornet_Stepper.h.

Constructor & Destructor Documentation

HornetStepper()

HornetStepper::HornetStepper ( int coil1, int coil2, int coil3, int coil4, int zeroPos, int maxPos, int dirForward, unsigned int capValue = 65535, int normalSpeed = 300, int normalAccel = 600, MapPoint * mapPoints = nullptr, uint8_t numMapPoints = 0 )

inline

Constructor for HornetStepper.

Parameters

coil1	Pin for coil 1
coil2	Pin for coil 2
coil3	Pin for coil 3
coil4	Pin for coil 4
zeroPos	Position of the zero on the dial, in steps from low mechanical stop (absolute position, e.g., 20)
maxPos	Maximum number of steps from low mech stop to high mech stop
dirForward	Direction for forward movement (1 or -1)
capValue	DCS-BIOS value to cap at (default 65535). This is needed if mech stop is lower than game maximum. Values above this will be auto-capped, preventing the needle from exceeding maxPos position.
normalSpeed	Normal operating speed
normalAccel	Normal operating acceleration
mapPoints	Optional array of MapPoint structs for non-linear mapping (nullptr for linear mapping)
numMapPoints	Number of mapping points (required if mapPoints is provided)

Definition at line 144 of file Hornet_Stepper.h.

        : stepper(AccelStepper::FULL4WIRE,
                 (dirForward == -1) ? coil3 : coil1,
                 (dirForward == -1) ? coil4 : coil2,
                 (dirForward == -1) ? coil1 : coil3,
                 (dirForward == -1) ? coil2 : coil4)
    {
        this->zeroPos = zeroPos;
        this->maxPos = maxPos;
        this->dirForward = dirForward;
        this->capValue = capValue;
        this->normalSpeed = normalSpeed;
        this->normalAccel = normalAccel;
        this->homingInProgress = false;
        this->testInProgress = false;
        
        stepper.setMaxSpeed(normalSpeed);
        stepper.setAcceleration(normalAccel);
 
        // Handle mapping array - if nullptr passed, use linear mapping
        if (mapPoints != nullptr && numMapPoints > 0) {
            // Use provided mapping array for non-linear mapping
            this->mapPoints = mapPoints;
            this->numMapPoints = numMapPoints;
            this->useMultiMap = true;
            
            // Extract input values and output positions arrays for multiMapBS
            this->inputVals = new unsigned int[numMapPoints];
            this->outputPos = new unsigned int[numMapPoints];
            for (uint8_t i = 0; i < numMapPoints; i++) {
                this->inputVals[i] = mapPoints[i].value;
                this->outputPos[i] = mapPoints[i].position;
            }
        } else {
            // Use standard linear mapping (no array needed)
            this->mapPoints = nullptr;
            this->inputVals = nullptr;
            this->outputPos = nullptr;
            this->numMapPoints = 0;
            this->useMultiMap = false;
        }
    }

~HornetStepper()

HornetStepper::~HornetStepper ( )

inline

Destructor to clean up allocated arrays.

Definition at line 196 of file Hornet_Stepper.h.

                     {
        if (useMultiMap && inputVals != nullptr) {
            delete[] inputVals;
            delete[] outputPos;
        }
    }

Member Function Documentation

findZero()

void HornetStepper::findZero ( )

inline

findZero() is a function to zero the gauge

Note

The gauge is zeroed by slowly moving the needle to mechanical zero), then to the dial zero position. You may hear clocking sounds. This is normal.

Coordinate system:

• Position 0 = mechanical zero (physical stop)
• Position zeroPos (e.g., 20) = dial zero (where gauge shows "0")

Definition at line 212 of file Hornet_Stepper.h.

                    {
        int zeroingSpeed = 20;                                         // Slow speed for zeroing operation
        int zeroingAccel = 10;
        stepper.setMaxSpeed(zeroingSpeed);
        stepper.setAcceleration(zeroingAccel);
 
        stepper.setCurrentPosition(maxPos);                           // Assume needle at max position
        stepper.runToNewPosition(mechZero);                           // Move backwards to mech stop
        stepper.setCurrentPosition(mechZero);                         // At mech stop, set coordinate sys to 0
        stepper.runToNewPosition(zeroPos);                            // Move forward to position that is 0 on dial
        
        stepper.setMaxSpeed(normalSpeed);                             // Resume normal speed and acceleration
        stepper.setAcceleration(normalAccel);
    }

Referenced by run().

testFullRange()

void HornetStepper::testFullRange ( int testSpeed = 20, int testAccel = 10 )

inline

testFullRange() is a function to test the range of the gauge

Note

During the test, the gauge is moved all the way. runToNewPosition() blocks the CPU during test.

Definition at line 233 of file Hornet_Stepper.h.

                                                               {
        testInProgress = true;
        stepper.setMaxSpeed(testSpeed);
        stepper.setAcceleration(testAccel);
 
        stepper.runToNewPosition(maxPos);
        delay(2000);
        stepper.runToNewPosition(zeroPos);
        
        stepper.setMaxSpeed(normalSpeed);
        stepper.setAcceleration(normalAccel);
        testInProgress = false;
    }

Referenced by run().

setTarget()

void HornetStepper::setTarget ( unsigned int targetVal )

inline

setTarget() is a function to set the target position of the gauge

Parameters

targetVal

The target value as pure DCS BIOS value (value range: 0-65535)

Maps DCS BIOS value to stepper position: 1) cap targetVal at capValue as needed 2) map capped value to stepper position, using multiMapBS if useMultiMap is true, otherwise use standard linear mapping 3) call the moveTo() function of AccelStepper to pass the new target position.

Definition at line 257 of file Hornet_Stepper.h.

                                           {
        // 1) Cap targetVal at capValue as needed
        unsigned int trimmedVal = min(targetVal, capValue);
        
        // 2) map capped value to stepper position
        long targetPos;
        if (useMultiMap) {
            // Use multiMap with pre-extracted arrays
            targetPos = multiMapCache<unsigned int>(trimmedVal, inputVals, outputPos, numMapPoints);
        } else {
            targetPos = map(trimmedVal, 0, capValue, zeroPos, maxPos);
        }
        
        // 3) call the moveTo() function of AccelStepper to pass the new target position.
        stepper.moveTo(targetPos);
    }

run()

void HornetStepper::run ( )

inline

run() is a function to run the stepper motor (non-blocking)

Note

This method must be called repeatedly in the main loop to perform movement. It also checks for button-triggered homing and startup test.

Definition at line 280 of file Hornet_Stepper.h.

               {
        bool shouldHome = ufcEntPressed && ufcClrPressed;
        
        if (shouldHome && !homingInProgress && !testInProgress) {
            homingInProgress = true;
            findZero();
            testFullRange();
            homingInProgress = false;
        }
        
        stepper.run();
    }

References findZero(), and testFullRange().

Member Data Documentation

ufcEntPressed

bool HornetStepper::ufcEntPressed = false

static

Definition at line 123 of file Hornet_Stepper.h.

ufcClrPressed

bool HornetStepper::ufcClrPressed = false

static

Definition at line 124 of file Hornet_Stepper.h.

---

The documentation for this class was generated from the following file:

• /github/workspace/embedded/OHC_Common/Hornet_Stepper.h