Rola cu bilă automată cu Arduino și un servo: 3 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Acesta este un mic proiect Arduino și servo simplu, care durează aproximativ două ore. Folosește un servo pentru a ridica un capăt al capacului borcanului, astfel încât să rotească o bilă de oțel în jurul circumferinței interioare. Se pornește de la sine, poate schimba viteza și poate învârti două (sau mai multe?) Bile simultan. Distractiv să construiești și să lucrezi. Parametrii de sincronizare pot fi redați cu viteze probabil chiar mai mari. Câțiva senzori de efect de hală cu bilă magnetică ar putea fi folosiți pentru a-l transforma într-o mașină mai inteligentă care poate da seama de cei mai buni parametri.

Ar trebui să menționez că cineva de aici, la instructables.com, are o mașină de rulat cu bile mai sofisticată:

Materiale necesare:

Arduino Uno (sau orice Arduino)

Scut servo (opțional)

Servo de 9g

capac de borcan

bila de otel

niște resturi de lemn

Pasul 1: Faceți suportul de bază și capacul articulat

Baza este doar o bucată de lemn pe care să montați bucata de lemn articulată. Lemnul articulat trebuie să fie mai mare decât un capac de borcan pe care îl veți folosi și să aibă suficient spațiu pentru balamale și pentru a monta servo-ul.

Am folosit balamale mici din plastic pentru aeronave RC și le-am lipit la lemnul articulat și la bază.

Pasul 2: Faceți mai mult brațul servo și atașați servo

Pentru a face un braț servo mai lung, tocmai am atașat o bucată de lemn de 5 centimetri la brațul servo cu câteva șuruburi mici și piulițe. Brațul servo ar trebui să fie la 90 de grade pe servo atunci când este orizontal față de bază.

Tocmai am lipit servo-ul de suportul de lemn articulat, dar am constatat că, dacă îl lăsați să ruleze mai mult de câteva minute, servo-ul va încălzi adezivul fierbinte și îl va elibera din lemn. Deci, o metodă de atașare mai bună este justificată.

Pasul 3: Încărcați și rulați Sketch

Mi-am atașat servo-ul la pinul 7 folosind un scut, deoarece este convenabil și costă doar câțiva dolari. Dacă nu aveți un scut, atașați firul de semnal servo la pinul 7 de pe Arduino, firul roșu la 5v pe Arduino și firul de masă la GND pe Arduino. Arduino ar trebui să furnizeze suficient curent pentru a opera servo-ul. Folosesc scutul, deoarece este ușor de utilizat o tensiune externă doar pentru servo.

Iată schița. Am scris o rutină de control al vitezei servo pentru a modifica viteza servoului, deoarece probabil că nu va funcționa bine la viteză maximă.

Puteți modifica temporizarea pentru a obține viteze diferite de rulare a mingii. De asemenea, ați putea modifica al treilea parametru al funcției myServo () pentru a schimba și viteza.

////////////////////////////////////////////////////// ////////////////////////////////////////////////////// ////////////// // creat de Jim Demello, Universitatea Shangluo, 2017

// ești liber să folosești, să manipulezi, să faci orice vrei cu acest cod, numele meu nu este obligatoriu

// Această rutină permite interpolarea oricărui număr de servouri, trebuie doar să adăugați linii noi dacă numărul de servouri depășește 4

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

Servo myservo1, myservo2; // creați un obiect servo pentru a controla un servo

int servoRead (int servoNumber) {

int servoCurrent;

if (servoNumber == 1) {servoCurrent = myservo1.read (); }

if (servoNumber == 2) {servoCurrent = myservo2.read (); }

retur servoCurrent;

}

void servoWrite (int servoNumber, int offset) {

if (servoNumber == 1) {myservo1.write (offset); }

if (servoNumber == 2) {myservo2.write (offset); }

}

void myServo (int newAngle, int angleInc, int incDelay, int servoNum) {

int curAngle;

if (servoNum == 1) {curAngle = myservo1.read (); }

if (servoNum == 2) {curAngle = myservo2.read (); }

if (curAngle <newAngle) {

for (int angle = curAngle; angle <newAngle; angle + = angleInc) {

if (servoNum == 1) myservo1.write (angle);

if (servoNum == 2) myservo2.write (angle);

întârziere (incDelay); }

}

else if (curAngle> newAngle) {

for (int angle = curAngle; angle> newAngle; angle - = angleInc) {

if (servoNum == 1) myservo1.write (angle);

if (servoNum == 2) myservo2.write (angle);

întârziere (incDelay); }

}

}

void interpolate2Servos (int servo1, int servo1Position, int servo2, int servo2Poziție, int numberSteps, int timeDelay) {

int servo1Current, servo2Current;

servo1Current = servoRead (servo1);

servo2Current = servoRead (servo2);

// Serial.print ("Servo3Pos and Current"); Serial.print (servo3Position); Serial.print (""); Serial.println (servo3Current);

// Serial.print ("Servo4Pos and Current"); Serial.print (servo4Position); Serial.print (""); Serial.println (servo4Current);

// Serial.print ("Servo5Pos and Current"); Serial.print (servo5Position); Serial.print (""); Serial.println (servo5Current);

// Serial.print ("Servo6Pos and Current"); Serial.print (servo6Position); Serial.print (""); Serial.println (servo6Current);

// Serial.println ("");

int cOffset = (servo1Position - servo1Current); cOffset = abs (cOffset) / numberSteps;

int dOffset = (servo2Position - servo2Current); dOffset = abs (dOffset) / numberSteps;

int cOffsetTotal = 0, dOffsetTotal = 0;

cOffsetTotal = servo1Current;

dOffsetTotal = servo2Current;

pentru (int x = 0; x

if (servo1Position> servo1Current) {cOffsetTotal = cOffsetTotal + cOffset; }

else {cOffsetTotal = cOffsetTotal - cOffset; }

if (servo2Position> servo2Current) {dOffsetTotal = dOffsetTotal + dOffset; }

else {dOffsetTotal = dOffsetTotal - dOffset; }

if (servo1Position! = servo1Current) servoWrite (servo1, cOffsetTotal);

if (servo2Position! = servo2Current) servoWrite (servo2, dOffsetTotal);

// Serial.print ("a și b Offset"); Serial.print (aOffsetTotal); Serial.print (""); Serial.println (bOffsetTotal); întârziere (10);

întârziere (timeDelay);

} // sfârșit pentru

//////////////////////////////////////

// îngrijiți resturile modulo //

/////////////////////////////////////

if (servo1Position! = servo1Current) servoWrite (servo1, servo1Position);

if (servo2Position! = servo2Current) servoWrite (servo2, servo2Position);

}

int timingDelay = 100;

int servoDelay = 100;

int degGap = 10;

// Acesta este gradul inițial (trebuie să fie mai mic decât gradul final)

int degStart = 0;

// Acesta este gradul final (trebuie să fie mai mare decât gradul de început)

int degEnd = 360;

// Aceasta este raza cercului

raza int = 8;

configurare nulă ()

{

Serial.begin (9600);

întârziere (100);

myservo1.attach (7); // atașează servo pe pinul 7 la obiectul servo

myservo1.write (90);

myservo2.attach (8); // atașează servo pe pinul 8 la obiectul servo

myservo2.write (90);

întârziere (1000); // așteaptă să ajungă servo

interpolate2Servos (1, 90, 2, 90, 10, 60); // neutru

întârziere (1000);

}

bucla nulă () {

timingDelay = 15; // funcționează la 10

servoDelay = 4;

spin4 ();

// interpolate2Servos (1, 90, 2, 90, 1, 60); // neutru

// întârziere (1000);

// ieșire (0); // pauză program - apăsați reset pentru a continua

}

nul spin3 () {

interpolate2Servos (1, 90, 2, 110, 1, 60); // neutru

întârziere (timingDelay);

interpolate2Servos (1, 90, 2, 80, 1, 60); // neutru

întârziere (timingDelay);

}

void spin2 () {

// interpolate2Servos (1, 80, 2, 90, 1, 50); // neutru

întârziere (timingDelay);

interpolate2Servos (1, 80, 2, 80, 1, 60); // neutru

întârziere (timingDelay);

interpolate2Servos (1, 110, 2, 80, 1, 60); // neutru

întârziere (timingDelay);

// interpolate2Servos (1, 110, 2, 110, 1, 60); // neutru

întârziere (timingDelay);

}

void spin1 () {

// int deg = (degStart / (180 / 3.14));

float deg = (degStart * 3.141592 / 180); // convertește grade în radiani

float xPos = 90 + (cos (deg) * raza);

// xPos = rotund (xPos);

floare yPos = 90 + (sin (deg) * raza);

// yPos = rotund (yPos);

Serial.print ("degGap ="); Serial.print (degGap); Serial.print ("deg ="); Serial.print (deg); Serial.print ("cos ="); Serial.print (cos (deg)); Serial.print ("degStart ="); Serial.print (degStart); Serial.print ("x ="); Serial.print (xPos); Serial.print ("y ="); Serial. println (yPos);

// interpolate2Servos (1, xPos, 2, yPos, 1, servoDelay); // neutru

myservo1.write (xPos);

myservo2.write (yPos);

întârziere (timingDelay);

if (degStart> = degEnd) {

degStart = 0;

dacă (degGap> 180)

degGap = 180;

// degGap = 0;

altceva

degGap = degGap + 2;

degGap = degGap - 2;

// degStart = degStart + degGap;

}

degStart = degStart + degGap;

}

void spin4 () {

for (int i = 0; i <= 360; i ++) {

float j = 20 * (cos ((3.14 * i) / 180)) + 90;

float k = 20 * (sin ((3.14 * i) / 180)) + 90;

myservo1.write (j);

myservo2.write (k);

Serial.print (j);

Serial.print (",");

Serial.println (k);

întârziere (100);

}

}