exploringBB::PWM Class Reference

A class to control a basic PWM output – you must know the exact sysfs filename for the PWM output. More...

#include <PWM.h>

Inheritance diagram for exploringBB::PWM:

Public Types
enum	POLARITY { ACTIVE_LOW =0, ACTIVE_HIGH =1 }

Public Member Functions
	PWM (string pinName)
virtual int	setPeriod (unsigned int period_ns)
virtual unsigned int	getPeriod ()
virtual int	setFrequency (float frequency_hz)
virtual float	getFrequency ()
virtual int	setDutyCycle (unsigned int duration_ns)
virtual int	setDutyCycle (float percentage)
virtual unsigned int	getDutyCycle ()
virtual float	getDutyCyclePercent ()
virtual int	setPolarity (PWM::POLARITY)
virtual void	invertPolarity ()
virtual PWM::POLARITY	getPolarity ()
virtual void	setAnalogFrequency (float frequency_hz)
virtual int	calibrateAnalogMax (float analogMax)
virtual int	analogWrite (float voltage)
virtual int	run ()
virtual bool	isRunning ()
virtual int	stop ()
virtual	~PWM ()

Detailed Description

A class to control a basic PWM output – you must know the exact sysfs filename for the PWM output.

Member Enumeration Documentation

enum exploringBB::PWM::POLARITY

Enumerator
ACTIVE_LOW
ACTIVE_HIGH

{ ACTIVE_LOW=0, ACTIVE_HIGH=1 };

Constructor & Destructor Documentation

exploringBB::PWM::PWM

(

string

pinName

)

                       {
        this->name = pinName;
        this->path = PWM_PATH + this->name + "/";
        this->analogFrequency = 100000;
        this->analogMax = 3.3;
}

exploringBB::PWM::~PWM ( )

virtual

{}

Member Function Documentation

int exploringBB::PWM::analogWrite ( float  voltage )

virtual

                                 {
        if ((voltage<0.0f)||(voltage>3.3f)) return -1;
        this->setFrequency(this->analogFrequency);
        this->setPolarity(PWM::ACTIVE_LOW);
        this->setDutyCycle((100.0f*voltage)/this->analogMax);
        return this->run();
}

int exploringBB::PWM::calibrateAnalogMax ( float  analogMax )

virtual

                                          { //must be between 3.2 and 3.4
        if((analogMax<3.2f) || (analogMax>3.4f)) return -1;
        else this->analogMax = analogMax;
        return 0;
}

unsigned int exploringBB::PWM::getDutyCycle ( )

virtual

                              {
        return atoi(read(this->path, PWM_DUTY).c_str());
}

float exploringBB::PWM::getDutyCyclePercent ( )

virtual

                              {
        unsigned int period_ns = this->getPeriod();
        unsigned int duty_ns = this->getDutyCycle();
        return 100.0f * (float)duty_ns/(float)period_ns;
}

float exploringBB::PWM::getFrequency ( )

virtual

                       {
        return this->period_nsToFrequency(this->getPeriod());
}

unsigned int exploringBB::PWM::getPeriod ( )

virtual

                           {
        return atoi(read(this->path, PWM_PERIOD).c_str());
}

PWM::POLARITY exploringBB::PWM::getPolarity ( )

virtual

                            {
        if (atoi(read(this->path, PWM_POLARITY).c_str())==0) return PWM::ACTIVE_LOW;
        else return PWM::ACTIVE_HIGH;
}

void exploringBB::PWM::invertPolarity ( )

virtual

                        {
        if (this->getPolarity()==PWM::ACTIVE_LOW) this->setPolarity(PWM::ACTIVE_HIGH);
        else this->setPolarity(PWM::ACTIVE_LOW);
}

bool exploringBB::PWM::isRunning ( )

virtual

                   {
        string running = read(this->path, PWM_RUN);
        return (running=="1");
}

int exploringBB::PWM::run ( )

virtual

            {
        return write(this->path, PWM_RUN, 1);
}

virtual void exploringBB::PWM::setAnalogFrequency ( float  frequency_hz )

inlinevirtual

{ this->analogFrequency = frequency_hz; }

int exploringBB::PWM::setDutyCycle ( unsigned int  duration_ns )

virtual

                                         {
        return write(this->path, PWM_DUTY, duty_ns);
}

int exploringBB::PWM::setDutyCycle ( float  percentage )

virtual

                                     {
        if ((percentage>100.0f)||(percentage<0.0f)) return -1;
        unsigned int period_ns = this->getPeriod();
        float duty_ns = period_ns * (percentage/100.0f);
        this->setDutyCycle((unsigned int) duty_ns );
        return 0;
}

int exploringBB::PWM::setFrequency ( float  frequency_hz )

virtual

                                       {
        return this->setPeriod(this->frequencyToPeriod_ns(frequency_hz));
}

int exploringBB::PWM::setPeriod ( unsigned int  period_ns )

virtual

                                        {
        return write(this->path, PWM_PERIOD, period_ns);
}

int exploringBB::PWM::setPolarity ( PWM::POLARITY  polarity )

virtual

                                        {
        return write(this->path, PWM_POLARITY, polarity);
}

int exploringBB::PWM::stop ( )

virtual

             {
        return write(this->path, PWM_RUN, 0);
}

---

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

• /home/molloyd/exploringBB/library/gpio/PWM.h
• /home/molloyd/exploringBB/library/gpio/PWM.cpp