Arduino Lesson 21 – 28BYJ-48 Stepper Motor with ULN2003 Driver

උපාංග පිලිබද දැනුම

ස්ටෙපර් මෝටර යනු වඩාත් නිවැරදිව ස්ථාන පාලනය සඳහා විශිෂ්ට මෝටර වර්ගයක් වේ. ඒවා විශේෂ බුරුසු රහිත මෝටරයක් ​​වන අතර එය සම්පූර්ණ භ්‍රමණය සමාන “පියවර” ගණනකට බෙදා ඇත. ඒවා සාමාන්‍යයෙන් ඩෙස්ක්ටොප් මුද්‍රණ යන්ත්‍ර, ත්‍රිමාණ මුද්‍රණ යන්ත්‍ර, සීඑන්සී යන්ත්‍ර  සහ නිශ්චිත ස්ථානගත පාලනයක් අවශ්‍ය ඕනෑම දෙයක් තුළ දක්නට ලැබේ.

ස්ටෙපර් මෝටර ගැන ඉගෙන ගැනීමට මිල අඩු ක්‍රමයක් වන්නේ 28BYJ-48 ස්ටෙපර් මෝටර භාවිතා කිරීමයි. මේවා සාමාන්‍යයෙන් පැමිණෙන්නේ ULN2003 මත පදනම් වූ ධාවක පුවරුවක් සමග වන අතර එමඟින් ඒවා පහසුවෙන් භාවිතා කිරමට පුළුවන.

අඟල් ඉහළට සුවඳ ඇදගෙන, අකුළන ශක්තියට, කොග්ජෙට් රෝදයේ ආසන්නතම ඔප්පුව ආකර්ෂණය කර මෝටරය එක් පියවරක් ධාවනය කරයි.

HIGH ලෙස යවන සෑම ස්පන්දනයක්ම, දඟරයට ශක්තියක් ලබා දෙන අතර, රෝදයේ ආසන්නතම දත් ආකර්ෂණය කර මෝටරය එක් පියවරක් ධාවනය කරයි.

ඔබ මෙම දඟර ස්පන්දනය කරන ආකාරය මෝටරයේ හැසිරීමට බෙහෙවින් බලපායි.

• ස්පන්දන අනුක්‍රමය මෝටරයේ භ්‍රමණය වන දිශාව තීරණය කරයි.
• ස්පන්දන වාර ගණන මෝටරයේ වේගය තීරණය කරයි.
• ස්පන්දන ගණන තීරණය කරන්නේ මෝටරය කොතරම් දුරට හැරෙනු ඇත්ද යන්නයි

The 28BYJ-48 Stepper Motor

28BYJ-48 වයර් 5කින් සමන්විත යනු එක් 5 වෝල්ටීයතාවයක් මගින් පාලනය කරන unipolar stepper motor වර්ගයේ එකකි.

මෙම මෝටරයේ ඇති සිත්ගන්නා කරුණ නම් පසුගිය දශක කිහිපය තුළ මිනිසුන් එය ගණන් කළ නොහැකි තරම් යෙදුම්වල භාවිතා කිරීමයි. එය වායුසමීකරණ යන්ත්‍ර, වැද්දුම් යන්ත්‍ර සහ තවත් බොහෝ යෙදුම්වල භාවිතා වේ.

මෙම මෝටරයන්හි ඇති හොඳම දේ නම් ඒවා නිවැරදිව ස්ථානගත කළ හැකි වීමයි, වරකට එක් ‘පියවරක්’

අනෙක් වාසිය නම් ඒවා චලනය කිරීමේදී සාපේක්ෂව නිරවද්‍ය වන අතර මෝටරය ස්පර්ශ බුරුසු (contact brushes) භාවිතා නොකරන බැවින් ඒවා තරමක් විශ්වාසදායක වීමයි.

මෝටරයට විදුලිය සපයන තාක් කල් පවත්වා ගෙන යනු ලබන ස්ථාවර තත්වයේ වුවද ඒවා සාමාන්‍යයෙන් හොඳ ව්‍යවර්ථයක් ලබා දේ.

එකම අවාසිය නම් මේවා භාවිතයේදී බලය වැඩිපුර ලබාගන්නා අතර චලනය නොවන විට පවා බලය පරිභෝජනය කිරීමයි.

මෝටරයට විදුලිය සපයන තාක් කල් පවත්වා ගෙන යනු ලබන ස්ථාවර තත්වයේ වුවද ඒවා සාමාන්‍යයෙන් හොඳ ව්‍යවර්ථයක්(torque) ලබා දේ.

28BYJ-48 Gear Reduction Ratio

According to the data sheet, when the 28BYJ-48 motor runs in full step mode, each step corresponds to a rotation of 11.25°. That means there are 32 steps per revolution (360°/11.25° = 32).

In addition, the motor has a 1/64 reduction gear set. (Actually its 1/63.68395 but for most purposes 1/64 is a good enough approximation)

What this means is that there are actually 32*63.68395 steps per revolution = 2037.8864 ~ 2038 steps!

28BYJ-48 බල පරිභෝජනය

මෝටරයේ බල පරිභෝජනය 240mA පමණ වේ. මෝටරය අධික බලයක් ලබා ගන්නා හෙයින්, ආර්ඩුයිනෝ වෙතින් එම බලය ඇද ගැනීමට වඩා බාහිර 5V බල සැපයුමකින් එය සෘජුවම බල ගැන්වීම වඩාත් සුදුසුය.

The ULN2003 Driver Board

ස්ටේපර් මෝටර් සමග එය ක්‍රියාකරවීමට ULN2003 driver බෝර්ඩ් එක භාවිතා කරයි.

ULN2003 driver බෝර්ඩ් එක ඩාර්ලින්ටන් ට්‍රාන්සිස්ටර යුගල 7 කින් සමන්විත වන වඩාත් වඩාත් ජනප්‍රිය මෝටර් පාලක IC වලින් එකකි, සෑම යුගලයක්ම 500mA සහ 50V දක්වා දරාගැනීමේ හැකියාවක්  ඇත. මෙම පුවරුවේදී  යුගල හතෙන් හතරක් භාවිතා වේ.

පුවරුවට මෝටර් පරිපූර්ණ ලෙස ගැලපෙන සම්බන්ධක වයර් ඇති අතර එමඟින් මෝටරය පුවරුවට සම්බන්ධ කිරීම ඉතා පහසු වේ. පාලන යෙදවුම් හතරක් සඳහා වයර් සම්බන්ධතා මෙන්ම බල සැපයුම් සම්බන්ධතා ද එහි ඇත.

පාලක ආදාන හතරෙහි (පියවරේ තත්වය දැක්වීමට) ක්‍රියාකාරීත්වය පෙන්වන LED හතරක් පුවරුවේ ඇත. ඒවා මගින් පියවර තබන විට ලස්සන දර්ශනයක් සපයයි. තවද ස්ටෙපර් මෝටරයට බලය ලබාදීමට හා නැවත්වීමට පුවරුව මත ඔන් / ඕෆ් ජම්පර්යක් තිබේ.

ULN2003 Stepper Driver Board පින් පවතින ආකරය

ULN2003 stepper driver බෝර්ඩ් එකේ පින් පවතින ආකාරය පහත දැක්වේ.

28BYJ-48 Stepper Motor සහ ULN2003 Driver ආර්ඩුයිනෝ සමග සම්බන්ධ කිරීම.

දැන් අපි ස්ටේපෙර් මෝටරය පිළිබඳ සෑම දෙයක්ම දන්නා නිසා, අපට එය අපගේ ආර්ඩුයිනෝ බෝර්ඩ් එක සම්බන්ධ කිරීම ආරම්භ කළ හැකිය. ULN2003 මෝටර් ධාවකයට බල සැපයුම සම්බන්ධ කිරීමෙන් ආරම්භ කිරීම කළ හැකිය.

ආර්ඩුයිනෝ වෙතින් ස්ටෙපර් මෝටරය කෙලින්ම බල ගැන්විය හැකි බව සලකන්න. කෙසේ වෙතත්, මෙය එතරම් හොද  දෙයක් නොවන අතර මෝටරය මගින්  එහි බල සැපයුම් ක්‍රියාවලියට බාධා ඇති කළ හැකි අතර එමගින්  ආර්ඩුයිනෝ බෝර්ඩ් එකට හානි කළ හැකිය. එබැවින්, ඔබේ ස්ටෙපර් මෝටරයට බලය සැපයීම සඳහා වෙනම 5V බල සැපයුමක් භාවිතා කරන්න.

ඊළඟට එම බල සැපයුමේ සිට ආර්ඩුයිනෝ බෝර්ඩ් එකේ GND සමග සම්බන්ධ කරන්න. මේ දෙක අතර එකම වෝල්ටීයතා යොමු කිරීමක් ඇති කිරීම සඳහා මෙය ඉතා වැදගත් වේ.

දැන් ඩ්‍රයිවර් බෝර්ඩ් එකේ IN1, IN2, IN3, IN4 පිළිවෙලින් ආර්ඩුයිනෝ බෝර්ඩ් එකේ ඩිජිටල් පින් 8, 9, 10 සහ 11 සමඟ සම්බන්ධ කරන්න. අවසාන වශයෙන්, ස්ටෙපර් මෝටරයේ සිට ඩ්‍රයිවර් බෝර්ඩ් දක්වා මෝටරයට කේබලය සම්බන්ධ කරන්න. ඔබ රැහැන් සම්බන්ධතා අවසන් වූ විට පහත රූපසටහනට සමානව තිබිය යුතුය.

Sketch 21.1.1 – Using Built-in Stepper Library

අපගේ පළමු අත්හදා බැලීම සඳහා අපි ඔබේ Arduino IDE එකට ඇතුලත් කර ඇති ආර්ඩුයිනෝ Stepper Library  භාවිතා කළෙමු.

Arduino Stepper Library : https://www.arduino.cc/en/reference/stepper

ස්ටෙපර් library එක අපි භාවිතා කරන පියවර අනුපිළිවෙල ගැන සැලකිලිමත් වන අතර ඒකීය ධ්‍රැවීය හා ද්වි ධ්‍රැව යන විවිධාකාර ස්ටෙපර් මෝටර පාලනය කිරීම හැකිය.

අපි යොදා ගත් ස්ටෙපර් මෝටරය දක්ෂිණාවර්තව හා වාමාවර්තව වේගයෙන් චලනය කිරීම සදහා කේත සටහන පහත දැක්වේ.

//Includes the Arduino Stepper Library
#include <Stepper.h>

// Defines the number of steps per rotation
const int stepsPerRevolution = 2038;

// Creates an instance of stepper class
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);

void setup() {
    // Nothing to do (Stepper Library sets pins as outputs)
}

void loop() {
    // Rotate CW slowly
    myStepper.setSpeed(100);
    myStepper.step(stepsPerRevolution);
    delay(1000);
    
    // Rotate CCW quickly
    myStepper.setSpeed(700);
    myStepper.step(-stepsPerRevolution);
    delay(1000);
}

Code එක පිලිබදව පැහැදිලි කිරීම:

කේත සටහන ආරම්භ වන්නේ අර්ඩුයිනෝ Stepper  Library එක ඇතුලත් කිරීමෙනි.

#include <Stepper.h>

ඊළඟට, stepsPerRevolution ලෙස නියතයක් නිර්මාණය කර  මෝටරය විසින් ගනු ලබන සම්පුරණ ‘පියවර’  ගණන අර්ථ දක්වන්නෙමු. අපගේ ප්‍රෝග්‍රෑම් එකේ එය 2038 වේ.

const int stepsPerRevolution = 2038;

28BYJ-48 යුනිපෝලර් ස්ටෙපර් මෝටරයට IN1-IN3-IN2-IN4 හි පියවර අනුක්‍රමයන් ආදාන 4 ක් ඇත. එය ආර්ඩුයිනෝ බෝර්ඩ් එකේ 8, 10, 9, 11 පින් සමග අනුපිළිවෙලින් MyStepper නමින් ස්ටෙපර් library හි වස්තුවක් නිර්මාණය කර අපි මෝටරය ධාවනය කිරීමට එය භාවිතා කරමු.

ඔබට මෙම හරිම විදියට අර්ථ නොදක්වුවතොත් මෝටරය නිසියාකාරව ක්‍රියාත්මක නොවන බව මතක තබා ගන්න

Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);

ස්ටෙපර් library අභ්‍යන්තරව I/O පින් හතර ප්‍රතිදානයන් ලෙස සකසන බැවින්  setup ෆන්ෂන් එක තුළ කිසිම කේතයක් අඩංගු නොවේ.

void setup() {
}

loop ෆන්ෂන් එකේදී, අපි ස්ටෙපර් මෝටරය චලනය කිරීමට අපේක්‍ෂා කරන වේගය සැකසීමට setSpeed() ෆන්ෂන් එක භාවිතා කරන අතර පසුව step() ෆන්ෂන් එක  භාවිතා කර එය භ්‍රමණය කළ යුතු පියවර කීයක් දැයි සදහන් කළ යුතුය. step() ෆන්ෂන් එකට සෘණ ලබා විට මෝටරයේ භ්‍රමණය වන දිශාව ආපසු හරවයි.

පළමු කේත සටහන ස්ටේපර් මෝටරය දක්ෂිණාවර්තව හරවයි. දෙවැන්න මෝටරය ප්‍රතිවිරුද්ධ දිශාවට වඩා වේගයෙන් හරවනු ඇත.

void loop() {
    // Rotate CW slowly
    myStepper.setSpeed(100);
    myStepper.step(stepsPerRevolution);
    delay(1000);
    
    // Rotate CCW quickly
    myStepper.setSpeed(700);
    myStepper.step(-stepsPerRevolution);
    delay(1000);
}

AccelStepper library එක භාවිතා කිරීම

ආර්ඩුයිනෝ Stepper Library ය සරල, තනි මෝටර් යෙදුම් සඳහා මනාව ගැලපේ. නමුත් ඔබට බහු පියවර පාලනය කිරීමට අවශ්‍ය වූ විට, ඔබට වඩා හොඳ Library යක් අවශ්‍ය වේ.

	Library info : http://www.airspayce.com/mikem/arduino/AccelStepper/
	Download Zip file : https://github.com/adafruit/Adafruit-Motor-Shield-library

එබැවින්, අපගේ ඊළඟ අත්හදා බැලීම සඳහා අපි වඩාත් දියුණු කරන කරන ලද  AccelStepper library නම්  භාවිතා කරමු. එය සම්මත අර්ඩුයිනෝ  Stepper  library යේ ක්‍රම කිහිපයකින් සැලකිය යුතු ලෙස වැඩි දියුණු කර තිබේ:

• එය ත්වරණය හා අවපාතයට සහාය වේ.
• එය අඩ-පියවර ධාවනයට සහාය වේ.
• එය එක් එක් ස්ටෙපර් මත ස්වාධීනව සමගාමී පියවරක් සහිතව එකවර ස්ටෙපර් කිහිපයක්  සඳහා සහය දක්වයි.

මෙම library එක ආර්ඩුයිනෝ  IDE හි ඇතුළත් කර නොමැති බැවින් ඔබට එය පළමුව ස්ථාපනය කිරීමට අවශ්‍ය වනු ඇත.

library එක ස්ථාපනය කිරීම සඳහා Sketch > Include Library > Manage Libraries… වෙත යන්න. Library Manager මගින්  Library දර්ශකය බාගත වන තෙක් බලා සිටින සිටින්න.

‘Accelstepper’ ටයිප් කිරීමෙන් ඔබගේ සෙවුමක් දන්න. පළමු ප්‍රවේශය මත ක්ලික් කරන්න, පසුව ඉන්ස්ට්‍රෝල් ක්ලික් කරන්න.

Sketch 21.1.2

ස්ටෙපර් මෝටරය එක් දිශාවකට වේගවත් කර පසුව වේගය අඩුවී සාමාන්‍යය තත්වයට පත්වන කේත සටහනක් පහත දැක්වේ. මෝටරය එසේ  කළ පසු එය භ්‍රමණය වන දිශාව වෙනස් කරයි. එම ක්‍රියාවලිය නැවත නැවතත් සිදු  කරයි.

#include <AccelStepper.h>   // Include the AccelStepper Library

#define FULLSTEP 4   // Define step constant

// Creates an instance
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
AccelStepper myStepper(FULLSTEP, 8, 10, 9, 11);

void setup() {
    // set the maximum speed, acceleration factor,
    // initial speed and the target position
    myStepper.setMaxSpeed(1000.0);
    myStepper.setAcceleration(50.0);
    myStepper.setSpeed(200);
    myStepper.moveTo(2038);
}

void loop() {
    // Change direction once the motor reaches target position
    if (myStepper.distanceToGo() == 0) 
        myStepper.moveTo(-myStepper.currentPosition());

    // Move the motor one step
    myStepper.run();
}

Code එක පිලිබදව පැහැදිලි කිරීම:

AccelStepper library එක ඇතුලත් කිරීමෙන් ඉහත කේත සටහන ආරම්භ වේ..

#include <AccelStepper.h>

දැන් අපි අපගේ මෝටරය සම්පූර්ණ පියවරෙන් ධාවනය කිරීමට යන බැවින්, අපි මේ සඳහා නියතයක් අර්ථ දක්වන්නෙමු. ඔබට පියවරෙන් පියවර මෝටරය ධාවනය කිරීමට අවශ්‍ය නම් නියතය 8 ලෙස සකසන්න.

#define FULLSTEP 4

ඊළඟට, අපි 8, 10, 9, 11 යන අනුපිළිවෙලින් MyStepper නමින් ස්ටෙපර් library යේ උදාහරණයක් නිර්මාණය කරමු (මෙම මෝටර සඳහා පියවර අනුක්‍රමය IN1-IN3-IN2-IN4 බව මතක තබා ගන්න). නැවතත්, ඔබ මෙය නිවැරදිව සකස් නොකළහොත් මෝටරය නිසියාකාරව ක්‍රියාත්මක නොවන බව මතක තබාගන්න

AccelStepper myStepper(FULLSTEP, 8, 10, 9, 11);

setup ෆන්ෂන් එකේදී අපි මුලින්ම මෝටරයේ උපරිම වේගය 1000 දක්වා සකසා ඇති අතර එය මෙම මෝටරයට යා හැකි තරම් වේගයක් වේ. පසුව අපි ස්ටෙපර් මෝටරයේ චලනයන් සඳහා ත්වරණය සහ අවපීඩනය එකතු කිරීම සඳහා මෝටරයට ත්වරණ සාධකයක් සකස් කරමු.

ඊළඟට අපි නිත්‍ය වේගය 200 ක් සහ අපි එය පියවර 2038 ක් දක්වා ගෙනයන්නෙමු. (ඔබට මතක ඇති පරිදි 28BYJ-48 එහි ආම්පන්න සමඟ පියවර 2038 ක් දක්වා ගමන් කරයි).

void setup() {
    myStepper.setMaxSpeed(1000.0);
    myStepper.setAcceleration(50.0);
    myStepper.setSpeed(200);
    myStepper.moveTo(2038);
}

loop ෆන්ෂන් එකේදී, මෝටරය ඉලක්කගත ස්ථානයට ළඟා වන තෙක් (distanceToGo මගින් කියවීමෙන්) කොපමණ දුරක් ගමන් කළ යුතු දැයි පරීක්ෂා කිරීමට අපි If ප්‍රකාශයක් භාවිතා කරමු (moveTo විසින් සකසා ඇත). distanceToGo බිංදුවට ළඟා වූ පසු අපි මෝටරය ප්‍රතිවිරුද්ධ දිශාවට ගෙනයමු.

loop ෆන්ෂන් පහල කොටසේ අපි run()) ෆන්ෂන් වඩාත්ම වැදගත් කාර්යය සිදුකරයි, මන්ද මෙම ෆන්ෂන් එක ක්‍රියාත්මක වන තෙක් එම පියවර ක්‍රියාත්මක නොවේ.

void loop() {
    // Change direction once the motor reaches target position
    if (myStepper.distanceToGo() == 0) 
        myStepper.moveTo(-myStepper.currentPosition());

    // Move the motor one step
    myStepper.run();
}

Project 21.2 – Stepper මෝටර් දෙකක් සමගාමීව පාලනය කිරීම.

අපගේ මීළඟ අත්හදා බැලීම සඳහා, අපි මෝටර දෙකක් එකවර ධාවනය කිරීම සඳහා තවත් 28BYJ-48 ස්ටෙපර් මෝටර් එකක් සහ ULN2003 මෝටර් ධාවකයක් අපගේ ආඩුයිනෝ බෝර්ඩ් එක හා සම්බන්ධ කරමු.

ඔබ කලින් කළ රැහැන් සම්බන්ධතා ඒවා ලෙස තබා නව උපාංග පහත පරිදි වයර් කරන්න: නැවත වරක් අපි වෙනම 5V බල සැපයුමක්  ULN2003 ධාවක මණ්ඩලයට විදුලිය සැපයීම සඳහා භාවිතා කරමු.

දැන් දෙවන ධාවක මණ්ඩලයේ IN1, IN2, IN3, IN4 පිළිවෙලින් ආර්ඩුයිනෝ බෝර්ඩ් එකෙහි  ඩිජිටල් පින්  4, 5, 6 සහ 7 සමඟ සම්බන්ධ කරන්න.

පහත රූපයේ දැක්වෙන්නේ රැහැන් සම්බන්ධ කළ යුතු ආකාරයයි.

Sketch 21.2

පහත දැක්වෙන්නේ එක් මෝටරයක් සම්පූර්ණ පියවර වලින් සහ දෙවැන්න පියවරෙන් අඩක් බැගින් ධාවනය කරන කේත සටහනයි. මෝටරයන් එක් විප්ලවයක් සිදු කළ විට ඒවායේ භ්‍රමණය වන දිශාව වෙනස් වේ. යම් ත්වරණයක් හා අවපාතයක් ද සිදුවේ.

#include <AccelStepper.h> // Include the AccelStepper Library

// Define step constants
#define FULLSTEP 4
#define HALFSTEP 8

// Creates two instances
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
AccelStepper stepper1(HALFSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);

void setup() {
    // set the maximum speed, acceleration factor,
    // initial speed and the target position for motor 1
    stepper1.setMaxSpeed(1000.0);
    stepper1.setAcceleration(50.0);
    stepper1.setSpeed(200);
    stepper1.moveTo(2038);

    // set the same for motor 2
    stepper2.setMaxSpeed(1000.0);
    stepper2.setAcceleration(50.0);
    stepper2.setSpeed(200);
    stepper2.moveTo(-2038);
}

void loop() {
    // Change direction once the motor reaches target position
    if (stepper1.distanceToGo() == 0) 
        stepper1.moveTo(-stepper1.currentPosition());
    if (stepper2.distanceToGo() == 0) 
        stepper2.moveTo(-stepper2.currentPosition());

    // Move the motor one step
    stepper1.run();
    stepper2.run();
}

Code එක පිලිබදව පැහැදිලි කිරීම:

අපි AccelStepper Library ප්‍රෝග්‍රෑම් එකට ඇතුළත් කිරීමෙන් ආරම්භ කරමු.

#include <AccelStepper.h>

දැන් අපි එක් මෝටරයක් සම්පූර්ණ පියවරක් සහ දෙවැන්න අඩ පියවරෙන් පියවර ධාවනය කරන්නෙමු. ඒ සඳහා නියත දෙකක් අපි අර්ථ දක්වන්නෙමු.

#define FULLSTEP 4
#define HALFSTEP 8

ඊළඟට, අපි එක් එක් මෝටරයට  වස්තු දෙකක් නිර්මාණය කරමු. මේවා සැකසීමට අපි අපගේ පින් අර්ථ දැක්වීම් සහ පියවර අර්ථ දැක්වීම් භාවිතා කරමු.

#define FULLSTEP 4
#define HALFSTEP 8
AccelStepper stepper1(HALFSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);

setup ෆන්ෂන් එකේදී අපි මුලින්ම පළමු ස්ටේපර් මෝටර් එකෙහි උපරිම වේගය දහසක් දක්වා සකස් කරමු. පසුව අපි ස්ටෙපර් මෝටරයේ චලනයන් සඳහා ත්වරණය සහ අවපීඩනය එකතු කිරීම සඳහා මෝටරයට ත්වරණ සාධකයක් එකතු කරමු.

ඊළඟට අපි නිත්‍ය වේගය 200 ක් සහ අපි එය පියවර 2038 දක්වා ගෙනයන්නෙමු. (ඔබට මතක ඇති පරිදි 28BYJ-48 එහි ආම්පන්න සමඟ පියවර 2038 ක් ගමන් කරයි).

අපි ස්ටෙපර් මෝටර් 2 සඳහා හරියටම එකම දේ කරන්නෙමු, එය ප්‍රතිවිරුද්ධ දිශාවට ගමන් කිරීමට අපට අවශ්‍ය නිසා එය -2038 වෙත යාමට උපදෙස්  ලබාදෙමු.

void setup() {
    // settings for motor 1
    stepper1.setMaxSpeed(1000.0);
    stepper1.setAcceleration(50.0);
    stepper1.setSpeed(200);
    stepper1.moveTo(2038);

    // settings for motor 2
    stepper2.setMaxSpeed(1000.0);
    stepper2.setAcceleration(50.0);
    stepper2.setSpeed(200);
    stepper2.moveTo(-2038);
}

loop ෆන්ෂන් එකේදී, If statements දෙකක් භාවිතා කරයි. අපි අදාළ මෝටරය එහි ඉලක්කගත ස්ථාන කරා ළඟා වන තෙක් (distanceToGo කියවීමෙන්) කොපමණ දුරක් ගමන් කළ යුතුදැයි පරීක්ෂා කිරීම සඳහාද අනෙක් මෝටරය distanceToGo බිංදුවට ළඟා වූ පසු, එහි චලනය වන ස්ථානය වත්මන් ස්ථානයේ කලින් ගමන්කලඅගයේ විරුද්ධ අගයට සමානව ප්‍රතිවිරුද්ධ දිශාවට ගමන් කිරීමට පටන් ගනී.

අවසාන වශයෙන් අපි run() ෆන්ෂන් ඇමතීමෙන් ඒවා ක්‍රියාත්මක කරමු.

void loop() {
    // Change direction once the motor reaches target position
    if (stepper1.distanceToGo() == 0) 
        stepper1.moveTo(-stepper1.currentPosition());
    if (stepper2.distanceToGo() == 0) 
        stepper2.moveTo(-stepper2.currentPosition());

    // Move the motor one step
    stepper1.run();
    stepper2.run();
}