BlackLib::BlackPWM Class Reference

Interacts with end user, to use PWM. More...

#include <BlackPWM.h>

Inheritance diagram for BlackLib::BlackPWM:

Public Types

enum  flags {
  periodFileErr = 0,
  dutyFileErr = 1,
  runFileErr = 2,
  polarityFileErr = 3,
  outOfRangeErr = 4,
  dtErr = 5,
  dtSubSystemErr = 6,
  pwmTestErr = 7,
  cpmgrErr = 9,
  ocpErr = 10
}
 

Public Member Functions

 BlackPWM (pwmName pwm)
 Constructor of BlackPWM class. More...
 
virtual ~BlackPWM ()
 Destructor of BlackPWM class. More...
 
std::string getValue ()
 Reads percentage value of duty cycle. More...
 
std::string getPeriodValue ()
 Reads period value of pwm signal. More...
 
std::string getDutyValue ()
 Reads duty value of pwm signal. More...
 
std::string getRunValue ()
 Reads run value of pwm signal. More...
 
std::string getPolarityValue ()
 Reads polarity value of pwm signal. More...
 
float getNumericValue ()
 Reads numeric percentage value of duty cycle. More...
 
int64_t getNumericPeriodValue ()
 Reads numeric period value of pwm signal. More...
 
int64_t getNumericDutyValue ()
 Reads numeric duty value of pwm signal. More...
 
bool setDutyPercent (float percentage)
 Sets percentage value of duty cycle. More...
 
bool setPeriodTime (uint64_t period, timeType tType=nanosecond)
 Sets period value of pwm signal. More...
 
bool setSpaceRatioTime (uint64_t space, timeType tType=nanosecond)
 Sets space time value of pwm signal. More...
 
bool setLoadRatioTime (uint64_t load, timeType tType=nanosecond)
 Sets load time value of pwm signal. More...
 
bool setPolarity (polarityType polarity)
 Sets polarity of pwm signal. More...
 
bool setRunState (runValue state)
 Sets run value of pwm signal. More...
 
void toggleRunState ()
 Toggles run state of pwm signal. More...
 
void tooglePolarity ()
 Toggles polarity type of pwm signal. More...
 
bool isRunning ()
 Checks run state of pwm signal. More...
 
bool isPolarityStraight ()
 Checks polarity of pwm signal. More...
 
bool isPolarityReverse ()
 Checks polarity of pwm signal. More...
 
bool fail ()
 Is used for general debugging. More...
 
bool fail (BlackPWM::flags f)
 Is used for specific debugging. More...
 

Private Attributes

errorPWMpwmErrors
 is used to hold the errors of BlackPWM class More...
 
std::string periodPath
 is used to hold the period file path More...
 
std::string dutyPath
 is used to hold the duty file path More...
 
std::string runPath
 is used to hold the run file path More...
 
std::string polarityPath
 is used to hold the polarity file path More...
 

Additional Inherited Members

- Private Member Functions inherited from BlackLib::BlackCorePWM
 BlackCorePWM (pwmName pwm)
 Constructor of BlackCorePWM class. More...
 
virtual ~BlackCorePWM ()
 Destructor of BlackCorePWM class. More...
 
std::string getPeriodFilePath ()
 Exports pwm period file name to derived class. More...
 
std::string getDutyFilePath ()
 Exports pwm duty file name to derived class. More...
 
std::string getRunFilePath ()
 Exports pwm run file name to derived class. More...
 
std::string getPolarityFilePath ()
 Exports pwm polarity file name to derived class. More...
 
errorCorePWMgetErrorsFromCorePWM ()
 Exports errorCorePWM struct to derived class. More...
 

Detailed Description

Interacts with end user, to use PWM.

This class is end node to use PWM. End users interact with PWM signal from this class. It includes public functions to set and get properties of PWM.

Example
EXAMPLE PROJECT FILE TREE:

   myPwmProject
   |-> src
       |-> BlackLib
           |-> BlackDirectory
               |-> BlackDirectory.cpp
               |-> BlackDirectory.h
           |-> BlackThread
               |-> BlackThread.cpp
               |-> BlackThread.h
           |-> BlackMutex
               |-> BlackMutex.cpp
               |-> BlackMutex.h
           |-> BlackTime
               |-> BlackTime.cpp
               |-> BlackTime.h
           |-> BlackADC
               |-> BlackADC.cpp
               |-> BlackADC.h
           |-> BlackGPIO
               |-> BlackGPIO.cpp
               |-> BlackGPIO.h
           |-> BlackI2C
               |-> BlackI2C.cpp
               |-> BlackI2C.h
           |-> BlackPWM
               |-> BlackPWM.cpp
               |-> BlackPWM.h
           |-> BlackSPI
               |-> BlackSPI.cpp
               |-> BlackSPI.h
           |-> BlackUART
               |-> BlackUART.cpp
               |-> BlackUART.h
           |-> BlackCore.cpp
           |-> BlackCore.h
           |-> BlackDef.h
           |-> BlackErr.h
           |-> BlackLib.h
       |-> myPwmProject.cpp


If BlackLib source files are located in your project like above example project file tree, you have to include BlackPWM.h or another source files with adding this line to your project file (myPwmProject.cpp at the example):
#include "BlackLib/BlackPWM/BlackPWM.h"


If BlackLib source files are located at same level with your project file (myPwmProject.cpp at the example), you have to include BlackPWM.h or another source files with adding this line to your project file:

// Filename: myPwmProject.cpp
// Author: Yiğit Yüce - ygtyce@gmail.com
#include <iostream>
#include "BlackLib/BlackPWM/BlackPWM.h"
int main()
{
std::cout << myPwm.getValue();
return 0;
}


You can use "using namespace BlackLib" also. You can get rid of writing "BlackLib::", with using this method.
// Filename: myPwmProject.cpp
// Author: Yiğit Yüce - ygtyce@gmail.com
#include <iostream>
#include "BlackLib/BlackPWM/BlackPWM.h"
using namespace BlackLib;
int main()
{
std::cout << myPwm.getValue();
return 0;
}



Pwm Definition
  1 ...............................________............................________
       :        :        :        |        |        :        :        |        |
       :   (1)  :   (2)  :   (3)  |   (4)  |        :        :        |        |
  0 ...:________:________:________|        |________:________:________|        |
       :        :        :        :        :        :        :        :        :
       <-----------t1------------> <--t2--> <-----------t1-----------> <--t2-->


t1 represents "space time" ==> 3 units at the figure
t2 represents "load time" ==> 1 unit at the figure
(t1+t2) represents "period time" ==> 4 units at the figure
(t2/(t1+t2)) represents "duty ratio" ==> 0.25 at the figure

Member Enumeration Documentation

This enum is used to define PWM debugging flags.

Enumerator
periodFileErr 

enumeration for errorPWM::periodFileError status

dutyFileErr 

enumeration for errorPWM::dutyFileError status

runFileErr 

enumeration for errorPWM::runFileError status

polarityFileErr 

enumeration for errorPWM::polarityFileError status

outOfRangeErr 

enumeration for errorPWM::outOfRange status

dtErr 

enumeration for errorCorePWM::dtError status

dtSubSystemErr 

enumeration for errorCorePWM::dtSsError status

pwmTestErr 

enumeration for errorCorePWM::pwmTestError status

cpmgrErr 

enumeration for errorCore::capeMgrError status

ocpErr 

enumeration for errorCore::ocpError status

Constructor & Destructor Documentation

BlackLib::BlackPWM::BlackPWM ( pwmName  pwm)

Constructor of BlackPWM class.

This function initializes BlackCorePWM class with entered parameter and errorPWM struct. Then it sets file paths of period, duty, polarity and run files.

Parameters
[in]pwmpwm name (enum)
Example
See also
pwmName
BlackLib::BlackPWM::~BlackPWM ( )
virtual

Destructor of BlackPWM class.

This function deletes errorPWM struct pointer.

Member Function Documentation

bool BlackLib::BlackPWM::fail ( )

Is used for general debugging.

Returns
True if any error occured, else false.
Example
myPwm.getValue();
if( myPwm.fail() )
{
std::cout << "ERROR OCCURED" << std::endl;
}
else
{
std::cout << "EVERYTHING IS OK" << std::endl;
}
// Possible Output:
// EVERYTHING IS OK
See also
errorPWM
bool BlackLib::BlackPWM::fail ( BlackPWM::flags  f)

Is used for specific debugging.

You can use this function, after call BlackPWM member functions in your code. The input parameter is used for finding out status of selected error.

Parameters
[in]fspecific error type (enum)
Returns
Value of selected error.
Example
if( myPwm.fail(BlackLib::BlackPWM::dtErr) or
{
std::cout << "BlackPWM INITIALIZATION FAILED" << std::endl;
}
myPwm.getValue();
{
std::cout << "Duty and/or period file reading is failed." << std::endl;
}
myPwm.setDutyPercent(110.5);
{
std::cout << "Your percentage is huge." << std::endl;
}
{
std::cout << "Duty file reading or range value is failed." << std::endl;
}
{
std::cout << "Period file reading or range value is failed." << std::endl;
}
// Possible Output:
// Your percentage is huge.
// Duty file reading or range value is failed.
// Period file reading or range value is failed.
See also
errorPWM
std::string BlackLib::BlackPWM::getDutyValue ( )

Reads duty value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::dutyPath variable. This file holds pwm duty value at nanosecond (ns) level.

Returns
string type duty value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_STRING.
Example
// if new period value is less than the current duty value, the new period value setting
// operation couldn't execute. So firstly duty value is set to zero for safe steps.
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(900000);
myPwm.setDutyPercent(50.0);
std::string val = myPwm.getDutyValue();
std::cout << "Pwm duty time: " << val << " nanoseconds";
// Possible Output:
// Pwm duty time: 450000 nanoseconds
int64_t BlackLib::BlackPWM::getNumericDutyValue ( )
inline

Reads numeric duty value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::dutyPath variable. This file holds pwm duty value at nanosecond (ns) level.

Returns
int64_t (long int) type duty value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_INT.
Warning
Any alphabetic character existence in period file can crash your application.
Example
// if new period value is less than the current duty value, the new period value setting
// operation couldn't execute. So firstly duty value is set to zero for safe steps.
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(214000);
// space ratio time = duty value, also duty value must be less than current period time
myPwm.setSpaceRatioTime(200000, BlackLib::nanosecond);
long int val = myPwm.getNumericDutyValue();
std::cout << "Pwm duty time: " << val << " nanoseconds";
// Possible Output:
// Pwm period time: 200000 nanoseconds
int64_t BlackLib::BlackPWM::getNumericPeriodValue ( )
inline

Reads numeric period value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::periodPath variable. This file holds pwm period value at nanosecond (ns) level.

Returns
int64_t (long int) type period value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_INT.
Warning
Any alphabetic character existence in period file can crash your application.
Example
// if new period value is less than the current duty value, the new period value setting
// operation couldn't execute. So firstly duty value is set to zero for safe steps.
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(214000);
long int val = myPwm.getNumericPeriodValue();
std::cout << "Pwm period time: " << val << " nanoseconds";
// Possible Output:
// Pwm period time: 214000 nanoseconds
float BlackLib::BlackPWM::getNumericValue ( )

Reads numeric percentage value of duty cycle.

This function calls getNumericPeriodValue() and getNumericDutyValue() inline functions, for finding out the period and duty values of pwm. After do that, it calculates percentage value of time that stays at "1".

Returns
Float type percentage value.
Example
myPwm.setDutyPercent(21.0);
float val = myPwm.getNumericValue();
std::cout << "Pwm duty ratio: " << val << "%";
// Possible Output:
// Pwm duty ratio: 21.0%
See also
getNumericPeriodValue()
getNumericDutyValue()
std::string BlackLib::BlackPWM::getPeriodValue ( )

Reads period value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::periodPath variable. This file holds pwm period value at nanosecond (ns) level.

Returns
string type period value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_STRING.
Example
// if new period value is less than the current duty value, the new period value setting
// operation couldn't execute. So firstly duty value is set to zero for safe steps.
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(214000);
std::string val = myPwm.getPeriodValue();
std::cout << "Pwm period time: " << val << " nanoseconds";
// Possible Output:
// Pwm period time: 214000 nanoseconds
std::string BlackLib::BlackPWM::getPolarityValue ( )

Reads polarity value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::polarityPath variable. This file holds pwm polarity value.

Returns
String type polarity value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_STRING.
Example
myPwm.setPolarity(BlackLib::straight);
std::string val1 = myPwm.getPolarityValue();
myPwm.setPolarity(BlackLib::reverse);
std::string val2 = myPwm.getPolarityValue();
std::cout << "Polarity value 1: " << val1 << std::endl;
std::cout << "Polarity value 2: " << val2 << std::endl;
// Possible Output:
// Polarity value 1: 0
// Polarity value 2: 1
std::string BlackLib::BlackPWM::getRunValue ( )

Reads run value of pwm signal.

This function reads specified file from path, where defined at BlackPWM::runPath variable. This file holds pwm run value.

Returns
string type run value. If file opening fails, it returns BlackLib::FILE_COULD_NOT_OPEN_STRING.
Example
myPwm.setRunState(BlackLib::run);
std::string val1 = myPwm.getRunValue();
myPwm.setRunState(BlackLib::stop);
std::string val2 = myPwm.getRunValue();
std::cout << "Run value 1: " << val1 << std::endl;
std::cout << "Run value 2: " << val2 << std::endl;
// Possible Output:
// Run value 1: 1
// Run value 2: 0
std::string BlackLib::BlackPWM::getValue ( )
virtual

Reads percentage value of duty cycle.

This function calls getNumericPeriodValue() and getNumericDutyValue() inline functions for finding out period and duty values of pwm. After do that, it calculates percentage value of time that stays at "1".

Returns
String type percentage value.
Example
myPwm.setDutyPercent(21.0);
std::string val = myPwm.getValue();
std::cout << "Pwm duty ratio: " << val << "%";
// Possible Output:
// Pwm duty ratio: 21%
See also
getNumericPeriodValue()
getNumericDutyValue()

Implements BlackLib::BlackCorePWM.

bool BlackLib::BlackPWM::isPolarityReverse ( )

Checks polarity of pwm signal.

This function calls getPolarityValue() function and evaluates return value.

Returns
True if return value equals to 1, else false.
Example
myPwm.setPolarity(BlackLib::straight);
std::cout << "Polarity value 1: " << std::boolalpha << myPwm.isPolarityReverse() << std::endl;
myPwm.setPolarity(BlackLib::reverse);
std::cout << "Polarity value 2: " << std::boolalpha << myPwm.isPolarityReverse() << std::endl;
// Possible Output:
// Polarity value 1: false
// Polarity value 2: true
See also
getPolarityValue()
bool BlackLib::BlackPWM::isPolarityStraight ( )

Checks polarity of pwm signal.

This function calls getPolarityValue() function and evaluates return value.

Returns
True if return value not equals to 1, else false.
Example
myPwm.setPolarity(BlackLib::straight);
std::cout << "Polarity value 1: " << std::boolalpha << myPwm.isPolarityStraight() << std::endl;
myPwm.setPolarity(BlackLib::reverse);
std::cout << "Polarity value 2: " << std::boolalpha << myPwm.isPolarityStraight() << std::endl;
// Possible Output:
// Polarity value 1: true
// Polarity value 2: false
See also
getPolarityValue()
bool BlackLib::BlackPWM::isRunning ( )

Checks run state of pwm signal.

This function calls getRunValue() function and evaluates return value.

Returns
True if return value equals to 1, else false.
Example
myPwm.setRunState(BlackLib::run);
std::cout << "Run value 1: " << std::boolalpha << myPwm.isRunning() << std::endl;
myPwm.setRunState(BlackLib::stop);
std::cout << "Run value 2: " << std::boolalpha << myPwm.isRunning() << std::endl;
// Possible Output:
// Run value 1: true
// Run value 2: false
See also
getRunValue()
bool BlackLib::BlackPWM::setDutyPercent ( float  percentage)

Sets percentage value of duty cycle.

If input parameter is in range (from 0.0 to 100.0), this function changes duty value without changing period value. For calculating new duty value, the current period multiplies by (1 - entered percentage/100) value. After do that, this calculated value is saved to duty file.

Parameters
[in]percentagenew percantage value(float)
Returns
True if setting new value is successful, else false.
Example
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(500000, BlackLib::nanosecond);
myPwm.setDutyPercent(20.0);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
std::cout << "Pwm duty time : " << myPwm.getDutyValue() << " nanoseconds \n";
std::cout << "Pwm duty ratio : " << myPwm.getValue() << "%";
// Possible Output:
// Pwm period time: 500000 nanoseconds
// Pwm duty time : 400000 nanoseconds
// Pwm duty ratio : 20.0%
See also
getNumericPeriodValue()
Note
This function can do very little rounding error at new duty value. For example if your current duty value is $ 10^6 $, this rounding error equals maximum $ 0.5 / 10^6 = 5*10^-7 $
bool BlackLib::BlackPWM::setLoadRatioTime ( uint64_t  load,
timeType  tType = nanosecond 
)

Sets load time value of pwm signal.

If input parameter's nanosecond equivalent is in range (from 0 to 10^9), this function changes duty value by saving (current period value - calculated input value) to duty file. Users can select time type of entered space time value like picosecond, nanosecond, microsecond, milisecond and second. This parameter's default value is nanosecond.

Parameters
[in]loadnew load time
[in]tTypetime type of your new period value(enum)
Returns
True if setting new value is successful, else false.
See also
BlackLib::timeType
Example
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(500000, BlackLib::nanosecond);
myPwm.setLoadRatioTime(125000);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
std::cout << "Pwm duty time : " << myPwm.getDutyValue() << " nanoseconds \n";
std::cout << "Pwm duty ratio : " << myPwm.getValue() << "%";
// Possible Output:
// Pwm period time: 500000 nanoseconds
// Pwm duty time : 375000 nanoseconds
// Pwm duty ratio : 25.0%
Warning
If your entered load time's nanosecond equivalent value is greater than the current period time, the new value could not set. This feature is Beaglebone's default.
bool BlackLib::BlackPWM::setPeriodTime ( uint64_t  period,
timeType  tType = nanosecond 
)

Sets period value of pwm signal.

If input parameter's nanosecond equivalent is in range (from 0 to 10^9), this function changes period value by saving calculated input parameter to period file. Users can select time type of entered period value like picosecond, nanosecond, microsecond, milisecond and second. This parameter's default value is nanosecond.

Parameters
[in]periodnew period value
[in]tTypetime type of your new period value(enum)
Returns
True if setting new period value is successful, else false.
Example
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(300000000, BlackLib::picosecond);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
myPwm.setPeriodTime(500000, BlackLib::nanosecond);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
myPwm.setPeriodTime(700, BlackLib::microsecond);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
myPwm.setPeriodTime(1, BlackLib::milisecond);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
// Possible Output:
// Pwm period time: 300000 nanoseconds
// Pwm period time: 500000 nanoseconds
// Pwm period time: 700000 nanoseconds
// Pwm period time: 1000000 nanoseconds
See also
BlackLib::timeType
bool BlackLib::BlackPWM::setPolarity ( polarityType  polarity)

Sets polarity of pwm signal.

The input parameter is converted to 1 or 0 and this value is saved to polarity file.

Parameters
[in]polaritynew polarity value(enum)
Returns
True if setting new polarity is successful, else false.
Example
myPwm.setPolarity(BlackLib::straight);
std::string val1 = myPwm.getPolarityValue();
myPwm.setPolarity(BlackLib::reverse);
std::string val2 = myPwm.getPolarityValue();
std::cout << "Polarity value 1: " << val1 << std::endl;
std::cout << "Polarity value 2: " << val2 << std::endl;
// Possible Output:
// Polarity value 1: 0
// Polarity value 2: 1
See also
polarityType
bool BlackLib::BlackPWM::setRunState ( runValue  state)

Sets run value of pwm signal.

The input parameter is converted to 1 or 0 and this value is saved to run file.

Parameters
[in]statenew run value(enum)
Returns
True if setting new run value is successful, else false.
Example
myPwm.setRunState(BlackLib::run);
std::string val1 = myPwm.getRunValue();
myPwm.setRunState(BlackLib::stop);
std::string val2 = myPwm.getRunValue();
std::cout << "Run value 1: " << val1 << std::endl;
std::cout << "Run value 2: " << val2 << std::endl;
// Possible Output:
// Run value 1: 1
// Run value 2: 0
See also
runValue
bool BlackLib::BlackPWM::setSpaceRatioTime ( uint64_t  space,
timeType  tType = nanosecond 
)

Sets space time value of pwm signal.

If input parameter's nanosecond equivalent is in range (from 0 to 10^9), this function changes duty value by saving calculated input parameter to duty file. Users can select time type of entered space time value like picosecond, nanosecond, microsecond, milisecond and second. This parameter's default value is nanosecond.

Parameters
[in]spacenew space time
[in]tTypetime type of your new period value(enum)
Returns
True if setting new value is successful, else false.
See also
BlackLib::timeType
Example
myPwm.setDutyPercent(100.0);
myPwm.setPeriodTime(500000, BlackLib::nanosecond);
myPwm.setSpaceRatioTime(125000);
std::cout << "Pwm period time: " << myPwm.getPeriodValue() << " nanoseconds \n";
std::cout << "Pwm duty time : " << myPwm.getDutyValue() << " nanoseconds \n";
std::cout << "Pwm duty ratio : " << myPwm.getValue() << "%";
// Possible Output:
// Pwm period time: 500000 nanoseconds
// Pwm duty time : 125000 nanoseconds
// Pwm duty ratio : 75.0%
Warning
If your entered space time's nanosecond equivalent value is greater than the current period time, the new value could not set. This feature is Beaglebone's default.
void BlackLib::BlackPWM::toggleRunState ( )

Toggles run state of pwm signal.

This function sets run value to 1 or 0, by value of current state. This new value is saved to run file.

Example
myPwm.setRunState(BlackLib::run);
std::string val1 = myPwm.getRunValue();
myPwm.toggleRunState();
std::string val2 = myPwm.getRunValue();
std::cout << "Run value 1: " << val1 << std::endl;
std::cout << "Run value 2: " << val2 << std::endl;
// Possible Output:
// Run value 1: 1
// Run value 2: 0
void BlackLib::BlackPWM::tooglePolarity ( )

Toggles polarity type of pwm signal.

This function sets polarity value to 1 or 0, by value of current polarity. This new value is saved to polarity file.

Example
myPwm.setPolarity(BlackLib::straight);
std::string val1 = myPwm.getPolarityValue();
myPwm.tooglePolarity();
std::string val2 = myPwm.getPolarityValue();
std::cout << "Polarity value 1: " << val1 << std::endl;
std::cout << "Polarity value 2: " << val2 << std::endl;
// Possible Output:
// Polarity value 1: 0
// Polarity value 2: 1

Member Data Documentation

std::string BlackLib::BlackPWM::dutyPath
private

is used to hold the duty file path

std::string BlackLib::BlackPWM::periodPath
private

is used to hold the period file path

std::string BlackLib::BlackPWM::polarityPath
private

is used to hold the polarity file path

errorPWM* BlackLib::BlackPWM::pwmErrors
private

is used to hold the errors of BlackPWM class

std::string BlackLib::BlackPWM::runPath
private

is used to hold the run file path


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