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 மாட்யூலைச் சேர்த்தால் இன்னும் கொஞ்சம்.

Reland Sun 28BYJ-48...

3,57 €

சலுகையைப் பார்க்கவும்

HiLetgo 5pcs ULN2003...

13,99 €

சலுகையைப் பார்க்கவும்

ELEGOO 5 செட் 28BYJ-48...

14,39 €

சலுகையைப் பார்க்கவும்

பொறுத்தவரை சாத்தியமான பயன்பாடுகள், நான் ஏற்கனவே அவற்றில் சிலவற்றை ஏற்கனவே குறிப்பிட்டுள்ளேன், ஆனால் உங்கள் திட்டங்களுக்கான சில யோசனைகளை மீண்டும் இங்கு தருகிறேன்:

• ஹைட்ராலிக் மற்றும் நியூமேடிக் வால்வுகளின் கட்டுப்பாடு.
• வெளிப்படுத்தப்பட்ட ரோபோக்கள் மற்றும் ரோபோ கைகள்.
• சென்சார் பொருத்துதல்.
• ஸ்கேனர்களுக்கான சுழலும் அட்டவணைகள்.
• 3டி பிரிண்டர்கள்.
• CNC இயந்திரங்கள்.

ஸ்டெப்பர் மோட்டார் தனியாக வேலை செய்யாது, அதற்கு மற்றொரு உறுப்பு தேவைப்படுகிறது. இந்நிலையில், 28BYJ-48 ஒரு ஒருங்கிணைந்த ULN2003 கொண்ட பலகையால் கட்டுப்படுத்தப்படுகிறது., இது ஆர்டுயினோ வெளியீடுகளின் மின்னோட்டத்தை மோட்டார் சுருள்களுக்கு ஆற்றலைப் பெருக்க அனுமதிக்கிறது. சரியான வரிசையில் சுருள்களை செயல்படுத்துவதன் மூலம், மோட்டார் மிகவும் துல்லியமாக படிப்படியாக சுழலும்.

கட்டுப்பாட்டு வரிசைகள் மற்றும் கட்டங்களின் வகைகள்

உள்ளன 28BYJ-48க்கான பல்வேறு கட்டுப்பாட்டு வரிசைகள், மிகவும் பொதுவானவை:

• முழு அலை வரிசை: அனைத்து சுருள்களையும் ஒரே நேரத்தில் செயல்படுத்துகிறது.
• அரை படி வரிசை: ஒரே நேரத்தில் இரண்டு அருகில் உள்ள சுருள்களை செயல்படுத்துகிறது.
• நுண்ணிய படி வரிசை: ஒரு நேரத்தில் ஒரு சுருளை செயல்படுத்துகிறது.

பார்ப்போம் கட்டங்கள் விவரம்:

• வரிசை 1-கட்டம்: 1-கட்ட வரிசையில் நாம் ஒரு நேரத்தில் ஒரு சுருளை இயக்குகிறோம். இந்த பற்றவைப்பு வரிசையை ஒரு அட்டவணையில் எடுத்துக்கொண்டால், பின்வருவனவற்றை என்ஜின் பின்அவுட்டில் உருவாக்க வேண்டும்:

• 2-கட்ட வரிசை: நாம் ஒவ்வொரு கட்டத்திலும் இரண்டு தொடர்பு சுருள்களை இயக்குகிறோம், அதனால் உருவாக்கப்பட்ட காந்தப்புலம் அதிகமாக உள்ளது (41% அதிகமாக) எனவே மோட்டார் அதிக முறுக்குவிசை கொண்டது, அதாவது அதிக வலிமையைப் பெறுகிறோம். எதிர்மறை புள்ளியாக, ஆற்றல் நுகர்வு இரட்டிப்பாகும். அட்டவணையைப் பொறுத்தவரை, அது இருக்கும்:

• அரை-படி வரிசை: இது நாங்கள் பார்க்கப் போகும் மற்றொரு நிலை, உங்களுக்கு மிகவும் விருப்பமானதை நீங்கள் அனுபவிக்கலாம். இங்கே நாம் ஒன்று மற்றும் இரண்டு சுருள்களை மாறி மாறி இயக்கி, அரை படியின் துல்லியத்தை அடைகிறோம். அதிக துல்லியம் தேவைப்படும் பயன்பாடுகளில் இது பயன்படுத்தப்படுகிறது, இருப்பினும் பயன்பாடு முறுக்கு வரம்பில் இருக்கும்போது சிக்கல்கள் இருக்கலாம். அட்டவணை படிவத்தில் வரிசையை வெளிப்படுத்துவதன் விளைவாக:

Arduino உடன் 28BYJ-28

முதல் விஷயம் சரியாக இணைக்க வேண்டும் தொகுதி மற்றும் மோட்டார் 28byj-48 எங்கள் Arduino போர்டுக்கு, இதைச் செய்ய, நீங்கள் பின்வரும் இணைப்புகளை உருவாக்க வேண்டும்:

• பின் - ULN2003 இலிருந்து Arduino இன் GND வரை.
• Arduino இலிருந்து ULN2003 இன் பின் + Vcc (5v அல்லது பிற சந்தர்ப்பங்களில், அது 12v மோட்டாராக இருந்தால், அந்த மின்னழுத்தத்துடன் கூடிய மின்சாரம் பயன்படுத்தப்பட வேண்டும்).
• 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));
}