28BYJ-48 સ્ટેપર મોટર: તમારે જે જાણવાની જરૂર છે તે બધું

El 28BYJ-48 એ યુનિપોલર સ્ટેપર મોટર છે ઓછી કિંમત અને ઉચ્ચ ચોકસાઇ, ઇલેક્ટ્રોનિક્સ પ્રોજેક્ટ્સ માટે આદર્શ, 3D પ્રિન્ટર, CNC મશીનો અને રોબોટિક્સ માટે. તેનું કોમ્પેક્ટ કદ, ઓછો પાવર વપરાશ અને ઉપયોગમાં સરળતા તેને ઇલેક્ટ્રોનિક્સ શોખીનો અને વ્યાવસાયિકો માટે લોકપ્રિય પસંદગી બનાવે છે.

વધુમાં, આ એન્જિન સાથે, એ ULN2003 સાથે મોડ્યુલ, તમારા નિયંત્રણ માટે. આ રીતે, અમારી પાસે માઇક્રોકન્ટ્રોલર અથવા બોર્ડનો ઉપયોગ કરીને આ સિસ્ટમનો સંપૂર્ણ ઉપયોગ કરવા સક્ષમ થવા માટે જરૂરી બધું છે Arduino અથવા સમાન.

28BYJ-48 સ્ટેપર મોટર શું છે?

Un સ્ટેપર મોટર એ ઇલેક્ટ્રિક મોટરનો એક પ્રકાર છે જે સતત પરિભ્રમણને બદલે નાના અલગ કોણીય પગલાઓમાં આગળ વધે છે. તે ઇલેક્ટ્રોમેગ્નેટના સમૂહનો ઉપયોગ કરીને કાર્ય કરે છે જે ચોક્કસ ક્રમમાં સક્રિય થાય છે. જુદા જુદા ઇલેક્ટ્રોમેગ્નેટને સક્રિય કરીને, એક ચુંબકીય ક્ષેત્ર બનાવવામાં આવે છે જે મોટરના રોટરને આકર્ષે છે, જેના કારણે તે એક સમયે એક પગલું ફેરવે છે. ક્રાંતિ દીઠ પગલાઓની સંખ્યા અને ચળવળની ચોકસાઇ ચોક્કસ મોટર ડિઝાઇન અને ઉપયોગમાં લેવાતા નિયંત્રણ ક્રમ પર આધારિત છે.

સ્ટેપર મોટર્સમાં અમારી પાસે બે પ્રકાર છે:

• યુનિપોલર- તેમની પાસે કોઇલનો એક જ સમૂહ હોય છે અને વર્તમાનને રિવર્સ કરવા અને મોટરને બંને દિશામાં ફેરવવા માટે ખાસ નિયંત્રકની જરૂર પડે છે.
• બાયપોલર- તેમની પાસે સ્વતંત્ર કોઇલના બે સેટ છે, જે તેમને વિશેષ નિયંત્રકની જરૂર વગર બંને દિશામાં ફેરવવા દે છે.

28BYJ-28 ના કિસ્સામાં તે યુનિપોલર પ્રકાર છે, જેમ કે મેં અગાઉ ઉલ્લેખ કર્યો છે. અને, આ જૂથની અંદર, તે નીચેના દ્વારા વર્ગીકૃત થયેલ છે વિશિષ્ટતાઓ:

• યુનિપોલર સ્ટેપર: માત્ર 4 કેબલ સાથે સરળ નિયંત્રણ.
• સંકલિત રીડ્યુસર: ઉચ્ચ ચોકસાઇ (0.088° પ્રતિ પગલું) અને ટોર્ક (3 N·cm) આપે છે.
• ઓછો વપરાશ: 83 mA (5V મોડેલ) અથવા 32 mA (12V મોડેલ).
• ખોરાક: 5V અથવા 12V (મોડેલ પર આધાર રાખીને).
• આર્થિક ભાવ: પ્રતિ યુનિટ €1.2 થી, અથવા જો તેમાં ULN2003 મોડ્યુલ શામેલ હોય તો થોડું વધારે.

રીલેન્ડ સન 28BYJ-48...

3,57 â,¬

ઓફર જુઓ

HiLetgo 5pcs ULN2003...

13,99 â,¬

ઓફર જુઓ

ELEGOO 5 સેટ 28BYJ-48...

14,39 â,¬

ઓફર જુઓ

આ માટે શક્ય કાર્યક્રમો, મેં તેમાંથી કેટલાકનો ઉલ્લેખ પહેલા જ કર્યો છે, પરંતુ અહીં હું તમને તમારા પ્રોજેક્ટ્સ માટે કેટલાક વિચારો આપું છું:

• હાઇડ્રોલિક અને ન્યુમેટિક વાલ્વનું નિયંત્રણ.
• આર્ટિક્યુલેટેડ રોબોટ્સ અને રોબોટિક આર્મ્સ.
• સેન્સર સ્થિતિ.
• સ્કેનર્સ માટે ફરતી કોષ્ટકો.
• 3d પ્રિન્ટર.
• CNC મશીનો.

સ્ટેપર મોટર એકલા કામ કરતી નથી, તેને બીજા તત્વની જરૂર છે. આ બાબતે, 28BYJ-48 એક સંકલિત ULN2003 સાથે બોર્ડ દ્વારા નિયંત્રિત થાય છે, જે મોટર કોઇલને પાવર કરવા માટે Arduino આઉટપુટના પ્રવાહને વિસ્તૃત કરવાની મંજૂરી આપે છે. કોઇલને યોગ્ય ક્રમમાં સક્રિય કરીને, મોટર ખૂબ જ ચોકસાઇ સાથે પગલું-દર-પગલે ફરે છે.

નિયંત્રણ સિક્વન્સ અને તબક્કાઓના પ્રકાર

ત્યાં છે 28BYJ-48 માટે વિવિધ નિયંત્રણ સિક્વન્સ, સૌથી સામાન્ય છે:

• સંપૂર્ણ તરંગ ક્રમ: એક જ સમયે તમામ કોઇલને સક્રિય કરે છે.
• અડધા પગલાનો ક્રમ: એક જ સમયે બે સંલગ્ન કોઇલ સક્રિય કરે છે.
• માઇક્રોસ્કોપિક સ્ટેપ સિક્વન્સ: એક સમયે એક કોઇલ સક્રિય કરે છે.

ચાલો જોઈએ તબક્કાઓ વિગતવાર:

• ક્રમ 1-તબક્કો: 1-તબક્કાના ક્રમમાં આપણે એક સમયે એક જ કોઇલ ચાલુ કરીએ છીએ. આ ઇગ્નીશન સિક્વન્સને ટેબલ પર લઈ જવાથી, એન્જિન પિનઆઉટમાં નીચેની બાબતો જનરેટ કરવી પડશે:

• 2-તબક્કાનો ક્રમ: આપણે દરેક તબક્કામાં બે સહસંબંધિત કોઇલ ચાલુ કરીએ છીએ, તેથી ઉત્પન્ન થયેલ ચુંબકીય ક્ષેત્ર વધારે છે (41% વધુ) જેથી મોટરમાં વધુ ટોર્ક હોય છે, એટલે કે, આપણે વધુ તાકાત મેળવીએ છીએ. નકારાત્મક બિંદુ તરીકે, આપણે ઉર્જાનો વપરાશ બમણો કરીએ છીએ. ટેબલ માટે, તે હશે:

• અર્ધ-પગલાની ક્રમ: આ એક બીજો તબક્કો છે જે અમે જોવા જઈ રહ્યા છીએ, તમે અનુભવી શકો છો કે તમને જેમાં સૌથી વધુ રસ છે. અહીં આપણે એક અને બે કોઇલને વૈકલ્પિક રીતે ચાલુ કરીએ છીએ, અડધા પગલાની ચોકસાઈ હાંસલ કરીએ છીએ. તેનો ઉપયોગ એપ્લીકેશનમાં થાય છે જ્યાં ઉચ્ચતમ ચોકસાઇની જરૂર હોય છે, જો કે જ્યારે એપ્લિકેશન ટોર્ક મર્યાદા પર હોય ત્યારે સમસ્યાઓ આવી શકે છે. કોષ્ટક સ્વરૂપમાં ક્રમ વ્યક્ત કરવાથી પરિણામ મળે છે:

Arduino સાથે 28BYJ-28

પ્રથમ વસ્તુ એ યોગ્ય રીતે કનેક્ટ કરવાની છે મોડ્યુલ અને મોટર 28byj-48 અમારા Arduino બોર્ડ પર, આ કરવા માટે, તમારે ફક્ત નીચેના જોડાણો બનાવવા પડશે:

• પિન - ULN2003 થી Arduino ના GND સુધી.
• ULN2003 નો પિન + Vcc (5v અથવા અન્ય કિસ્સાઓમાં, જો તે 12v મોટર છે, તો તે વોલ્ટેજ સાથેનો પાવર સપ્લાય વાપરવો પડશે) Arduino માંથી.
• ULN1 ના IN2, IN3, IN4 અને IN2003 એ Arduino ના ડિજિટલ ઇનપુટ્સ D8, D9, D10 અને D11 માટે.
• 28byj-48 મોટર, તેને ફક્ત ULN2003 મોડ્યુલ પરના પોર્ટ સાથે જોડો.

હવે તમે કનેક્ટ થયા છો, પછીની વસ્તુ ઉપયોગ કરવાની છે Arduino IDE માં ઉદાહરણ, જેનો તમે પ્રયોગ કરવા અથવા તેને તમારી રુચિ પ્રમાણે સંશોધિત કરવા માટે ઉપયોગ કરી શકો છો. આ ઉદાહરણમાં, તમામ તબક્કા કોષ્ટકો પર ટિપ્પણી કરવામાં આવી છે, જેમ કે // લાઇનની સામે, તમે જાણો છો... જો તમે તેમાંથી એકનો ઉપયોગ કરવા માંગતા હો, તો સૂચનાઓની સામે ફક્ત // કાઢી નાખો.

//Definir los pines
const int motorPin1 = 8;    // 28BYJ48 In1
const int motorPin2 = 9;    // 28BYJ48 In2
const int motorPin3 = 10;   // 28BYJ48 In3
const int motorPin4 = 11;   // 28BYJ48 In4
                   
//Definición de variables
int motorSpeed = 1200;   //Velocidad del motor
int stepCounter = 0;     //Contador de pasos
int stepsPerRev = 4076;  //Pasos para un giro completo

//Tablas de secuencia (descomentar la que necesites)
//Secuencia 1-fase
//const int numSteps = 4;
//const int stepsLookup[4] = { B1000, B0100, B0010, B0001 };

//Secuencia 2-fases
//const int numSteps = 4;
//const int stepsLookup[4] = { B1100, B0110, B0011, B1001 };

//Secuencia media fase
//const int numSteps = 8;
//const int stepsLookup[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };

void setup()
{
  //Declarar los pines usados como salida
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    clockwise();
    delayMicroseconds(motorSpeed);
  }
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    anticlockwise();
    delayMicroseconds(motorSpeed);
  }
  delay(1000);
}

void clockwise()
{
  stepCounter++;
  if (stepCounter >= numSteps) stepCounter = 0;
  setOutput(stepCounter);
}

void anticlockwise()
{
  stepCounter--;
  if (stepCounter < 0) stepCounter = numSteps - 1;
  setOutput(stepCounter);
}

void setOutput(int step)
{
  digitalWrite(motorPin1, bitRead(stepsLookup[step], 0));
  digitalWrite(motorPin2, bitRead(stepsLookup[step], 1));
  digitalWrite(motorPin3, bitRead(stepsLookup[step], 2));
  digitalWrite(motorPin4, bitRead(stepsLookup[step], 3));
}