Creating your own DC motor control library

When creating a library, you may notice some features:

The file begins with the #ifndef ServoS directive, which checks whether this library has been included previously. If we have not connected it anywhere before, then the code located between #define MotorS and #endif will be added to the program

In addition, we define several functions with the same name but different arguments. This is due to the fact that when using libraries, calling a function with fewer than the defined number of arguments will result in an error. It will not be possible to set default argument values; more precisely, for each case you will need to describe a separate function. Therefore, we have two functions each SetSpeed(int newspeed) and SetSpeed(int newspeed, int smooth)

Now all that remains is to deal with the MotorS.cpp file. Here is the code for the functions described in the header file. In this case, we need to indicate which class the called functions belong to. Since our library uses the MotorClass class, all functions will relate to it. In the case of a constructor whose name matches the name of the class, it will look like MotorClass:: MotorClass (), the remaining functions will look like MotorClass::FunctionName();

/* Custom servo control library */
#include "MotorS.h" // Include the header file
MotorClass::MotorClass(int pE, int pI) // Class constructor. The first argument is the speed control pin number, the second is the direction
{
pinE=pE; // Set control pins for speed
pinI=pI; // And rotation directions
pinMode(pinE, OUTPUT); // Set the operation of the corresponding pins as outputs
pinMode(pinI, OUTPUT);
Power=0; // by default the engine is stopped
SpeedChanging=false; // by default the engine is not accelerated
}
void MotorClass::RunMotor(int motorpower) // Set the speed and direction of rotation of the motor
// Negative value - rotation in the opposite direction
{
Direction=(motorpower>0)?HIGH:LOW; // If a positive speed is specified, a HIGH signal is sent to the direction output
digitalWrite(pinI,Direction); // for negative - LOW
digitalWrite(pinE,abs(Power)); // Apply a signal to the speed control output that corresponds to the desired speed
}
void MotorClass::SetSpeed(int newspeed) // Set the motor speed as a percentage of the maximum.
{
Power=(int)newspeed/2.55; // Since the speed varies from 0 to 100%, and the power ranges from 0 to 255,
// calculate the required power value
RunMotor(Power);
}
void MotorClass::SetSpeed(int newspeed, int smooth) // Smoothly change the motor speed as a percentage of the maximum.
// Negative value - rotation in the opposite direction
// The smoothness of the change is controlled by the smooth value (time per step of speed change, in ms)
{
ReqPower=(int)newspeed/2.55; // Since the speed varies from 0 to 100%, and the power ranges from 0 to 255, we calculate the desired value
if (ReqPower>=Power) // In what direction will the power change?
StartPowerStep=1; // increase by 1 (1/255 of full)
else
StartPowerStep=-1; // decrease by 1 (1/255 of full)
StartTimeStep=smooth;
StartTimer=millis(); // Start counting down the time to change the speed
SpeedChanging=true; // set the speed change mode for subsequent processing in the UpdateSpeed() function
}
void MotorClass::UpdateSpeed() // Processing actions that should be performed with a delay
{
if (SpeedChanging) // If the speed changing mode is set
if ((millis()-StartTimer)>= StartTimeStep) // If more time has passed since the previous speed change than specified
{
if (Power!=ReqPower) // Not yet reached the required speed
{
Power+=StartPowerStep; // change the speed
RunMotor(Power); // give a command to the engine
StartTimer=millis(); // set the timer to start counting for the next power change
}
else // If the required speed is reached
SpeedChanging=false; // Turn off speed change mode
   }
}

To use our library we will use previous example, in which we connected two motors:

In the program code, we will replace the entire part that was responsible for the description of our MotorClass class with the library connection function #include "MotorS.h". The size of the data loaded into the controller will practically not change (after all, we are, in fact, adding code from the library to the one that is displayed in the edit field). But working with such a program is much easier, because we don’t need to copy all the control variables and functions every time we want to control the motors. Here’s what we got:

/* Control of DC motors with a user library with support for smooth speed changes */
#include "MotorS.h" // Include the library for working with DC motors
MotorClass M1(5,4); // The first motor is controlled by outputs 5 and 4 (speed and direction respectively)
MotorClass M2(6,7); // The second motor is controlled by outputs 6 and 7
void setup()
{
M1.SetSpeed(50); //First engine - turn on at 50% speed
M1.SetSpeed(-100, 2); // Second engine - turn on 100% speed smoothly
}
void loop()
{
M1.UpdateSpeed(); // Handle speed changes of the first motor
M2.UpdateSpeed(); // Handle speed changes of the second motor
}

The result of the program, compared to the usual use of the class, has not changed - the first engine will accelerate to half the maximum speed as quickly as possible, the second will rotate in the opposite direction, and it will take half a second to accelerate from zero to maximum.

All that remains is to take care of highlighting the functions we created in the Arduino IDE. To do this, let’s create a file keywords.txt in the folder with our library (the path to it should look something like “/Arduino/libraries/MotorS/keywords.txt”) In this file we’ll write the names of our class and its method , marking them with "KEYWORD1"

For the class name and "KEYWORD2" for methods:

Let's put information about the keywords that need to be highlighted there:

# Syntax highlighting for the MotorS library
MotorClass KEYWORD1
RunMotor KEYWORD2
SetSpeed KEYWORD2
UpdateSpeed KEYWORD2

A tab sign is placed between the word and its type, and a line feed is placed between the lines.

Let's restart the Arduino IDE again, now our class and its functions are highlighted in the appropriate color:

Without keywords.txt:

Using keywords.txt:

Now the code is more legible, and using your own library is no different from using standard libraries