Represents a DC motor controller (H-bridge) with some combination of PWM and on/off control pins. 2024: what does 'TwoPin' class name mean? is that just a historic artifact? More...

#include <dc_motor.h>

Inheritance diagram for TwoPinDcMotor:

[legend]

Collaboration diagram for TwoPinDcMotor:

[legend]

Public Types
enum class	ControlType { PwmDirectionPins , PwmEnablePin }

Public Member Functions
	TwoPinDcMotor (OutputPin &disable)

void	configure (IPwm &enable, IPwm &dir1, IPwm &dir2, bool isInverted)

virtual bool	set (float duty) override

float	get () const override
	Get the current motor duty cycle.

bool	isOpenDirection () const override

void	enable () override

void	disable (const char *msg) override

void	setType (ControlType type)

Public Member Functions inherited from DcMotor
const char *	msg () const

Private Attributes
IPwm *	m_enable = nullptr

IPwm *	m_dir1 = nullptr

IPwm *	m_dir2 = nullptr

OutputPin *const	m_disable

float	m_value = 0

bool	m_isInverted = false

ControlType	m_type = ControlType::PwmDirectionPins

Additional Inherited Members
Protected Attributes inherited from DcMotor
const char *	m_msg = nullptr

Detailed Description

Represents a DC motor controller (H-bridge) with some combination of PWM and on/off control pins. 2024: what does 'TwoPin' class name mean? is that just a historic artifact?

Definition at line 55 of file dc_motor.h.

Member Enumeration Documentation

◆ ControlType

enum class TwoPinDcMotor::ControlType

strong

Enumerator

PwmDirectionPins

For example TLE7209 - two control wires: PWM on both wires - one to open, another to close

PwmEnablePin

The control/enable pin is used for PWM and disable, and the two direction pins are used to set the polarity of each half of the H bridge. setting {dir1,dir2} = 10 should, turn the motor one direction (positive duty), and = 01 should turn the other way (negative duty).

For example VNH2SP30 - three control wires: PWM on 'enable' PIN, two binary pins for direction

TLE9201 with two wire control also uses this mode PWM on one pin, open/close using one binary direction pin, second direction pin unused

Definition at line 58 of file dc_motor.h.

    {
        /**
         * For example TLE7209 - two control wires:
         * PWM on both wires - one to open, another to close
         */
        PwmDirectionPins,
        /**
          * The control/enable pin is used for PWM and disable, and the two direction pins are used
          * to set the polarity of each half of the H bridge.  setting {dir1,dir2} = 10 should,
          * turn the motor one direction (positive duty), and = 01 should turn the other way (negative
          * duty).
         *
         * For example VNH2SP30 - three control wires:
         * PWM on 'enable' PIN, two binary pins for direction
         *
         * TLE9201 with two wire control also uses this mode
         * PWM on one pin, open/close using one binary direction pin, second direction pin unused
         */
        PwmEnablePin,
    };

Constructor & Destructor Documentation

◆ TwoPinDcMotor()

TwoPinDcMotor::TwoPinDcMotor ( OutputPin & disable )

Parameters

enable	IPwm driver for enable pin, for PWM speed control.
dir1	Enable 1 or direction 1 pin. Gets set high to rotate forward.
dir2	Enable 2 or direction 2 pin. Gets set high to rotate backward.

Definition at line 13 of file dc_motor.cpp.

    : m_disable(&disablePin)
{
    disable("init");
}

Here is the call graph for this function:

Member Function Documentation

◆ configure()

void TwoPinDcMotor::configure	(	IPwm &	enable,
		IPwm &	dir1,
		IPwm &	dir2,
		bool	isInverted
	)

Definition at line 19 of file dc_motor.cpp.

                                                                                   {
    m_enable = &enable;
    m_dir1 = &dir1;
    m_dir2 = &dir2;
    m_isInverted = isInverted;
}

Referenced by DcHardware::start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable()

void TwoPinDcMotor::disable ( const char * msg )

overridevirtual

Implements DcMotor.

Definition at line 34 of file dc_motor.cpp.

                                           {
    m_msg = msg;
    if (m_disable) {
        m_disable->setValue(true);
    }
 
    // Also set the duty to zero
    set(0);
}

Referenced by TwoPinDcMotor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable()

void TwoPinDcMotor::enable ( )

overridevirtual

Implements DcMotor.

Definition at line 26 of file dc_motor.cpp.

                           {
    if (m_disable) {
        m_disable->setValue(false);
    }
 
    m_msg = nullptr;
}

Referenced by configure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get()

float TwoPinDcMotor::get ( ) const

overridevirtual

Get the current motor duty cycle.

Returns: The current duty cycle setting. +1.0f represents full power forward, and -1.0f represents full power backward.

Implements DcMotor.

Definition at line 48 of file dc_motor.cpp.

                               {
    return m_value;
}

Referenced by showDcMotorInfo(), and updateTunerStudioState().

Here is the caller graph for this function:

◆ isOpenDirection()

bool TwoPinDcMotor::isOpenDirection ( ) const

overridevirtual

Implements DcMotor.

Definition at line 44 of file dc_motor.cpp.

                                          {
    return m_value >= 0;
}

Referenced by showDcMotorInfo().

Here is the caller graph for this function:

◆ set()

bool TwoPinDcMotor::set ( float duty )

overridevirtual

Parameters

duty	value between -1.0 and 1.0

Implements DcMotor.

Definition at line 55 of file dc_motor.cpp.

{
    m_value = duty;
 
    // For low voltage, voltageRatio will be >1 to boost duty so that motor current stays the same
    // At high voltage, the inverse will be true to keep behavior always the same.
    float voltageRatio = 14 / Sensor::get(SensorType::BatteryVoltage).value_or(14);
    duty *= voltageRatio;
 
    // If not init, don't try to set
    if (!m_dir1 || !m_dir2 || !m_enable) {
        if (m_disable) {
            m_disable->setValue(true);
        }
 
        return false;
    }
 
    bool isPositive = duty > 0;
 
    if (!isPositive) {
        duty = -duty;
    }
 
    // below here 'duty' is a not negative
 
    // Clamp to 100%
    if (duty > 1.0f) {
        duty = 1.0f;
    }
    // Disable for very small duty
    else if (duty < 0.01f)
    {
        duty = 0.0f;
    }
 
    // If we're in two pin mode, force 100%, else use this pin to PWM
    float enableDuty = m_type == ControlType::PwmEnablePin ? duty : 1;
 
    // Direction pins get 100% duty unless we're in PwmDirectionPins mode
    float dirDuty = m_type == ControlType::PwmDirectionPins ? duty : 1;
 
    m_enable->setSimplePwmDutyCycle(enableDuty);
    float recipDuty = 0;
    if (m_isInverted) {
        dirDuty = 1.0f - dirDuty;
        recipDuty = 1.0f;
    }
 
    m_dir1->setSimplePwmDutyCycle(isPositive ? dirDuty : recipDuty);
    m_dir2->setSimplePwmDutyCycle(isPositive ? recipDuty : dirDuty);
 
    // This motor has no fault detection, so always return false (indicate success).
    return false;
}

Referenced by disable(), and setDcMotorDuty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setType()

void TwoPinDcMotor::setType ( ControlType type )

inline

Definition at line 106 of file dc_motor.h.

106{ m_type = type; }

Referenced by DcHardware::start().

Here is the caller graph for this function:

Field Documentation

◆ m_dir1

IPwm* TwoPinDcMotor::m_dir1 = nullptr

private

Definition at line 82 of file dc_motor.h.

Referenced by configure(), and set().

◆ m_dir2

IPwm* TwoPinDcMotor::m_dir2 = nullptr

private

Definition at line 83 of file dc_motor.h.

Referenced by configure(), and set().

◆ m_disable

OutputPin* const TwoPinDcMotor::m_disable

private

Definition at line 84 of file dc_motor.h.

Referenced by disable(), enable(), and set().

◆ m_enable

IPwm* TwoPinDcMotor::m_enable = nullptr

private

Definition at line 81 of file dc_motor.h.

Referenced by configure(), and set().

◆ m_isInverted

bool TwoPinDcMotor::m_isInverted = false

private

Definition at line 86 of file dc_motor.h.

Referenced by configure(), and set().

◆ m_type

ControlType TwoPinDcMotor::m_type = ControlType::PwmDirectionPins

private

Definition at line 88 of file dc_motor.h.

Referenced by set(), and setType().

◆ m_value

float TwoPinDcMotor::m_value = 0

private

Definition at line 85 of file dc_motor.h.

Referenced by get(), isOpenDirection(), and set().

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

controllers/system/dc_motor.h
controllers/system/dc_motor.cpp

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ ControlType

Constructor & Destructor Documentation

◆ TwoPinDcMotor()

Member Function Documentation

◆ configure()

◆ disable()

◆ enable()

◆ get()

◆ isOpenDirection()

◆ set()

◆ setType()

Field Documentation

◆ m_dir1

◆ m_dir2

◆ m_disable

◆ m_enable

◆ m_isInverted

◆ m_type

◆ m_value