Automatyczna rolka kulkowa z Arduino i jednym serwomechanizmem: 3 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:27

Jest to prosty mały projekt Arduino i serwomechanizmu, którego ukończenie zajmuje około dwóch godzin. Wykorzystuje serwo do podnoszenia jednego końca nakrętki słoika, aby obrócić stalową kulkę wokół wewnętrznego obwodu. Jest samoczynny, może zmieniać prędkość i może kręcić dwiema (lub więcej?) kulkami naraz. Fajna budowa i praca. Parametry czasowe mogą być odtwarzane dla prawdopodobnie jeszcze większych prędkości. Kilka czujników Halla z kulką magnetyczną można wykorzystać, aby uczynić z niej inteligentniejszą maszynę, która może określić najlepsze parametry.

Powinienem wspomnieć, że ktoś tutaj na instructables.com ma bardziej wyrafinowaną maszynę do wałków kulkowych:

Potrzebne materiały:

Arduino Uno (lub dowolne Arduino)

Osłona serwomechanizmu (opcjonalnie)

serwo 9g

nakrętka słoika

Stalowa piłka

trochę złomu drewna

Krok 1: Zrób podstawę i uchwyt na nasadkę na zawiasach

Podstawa to tylko kawałek drewna, na którym można zamontować zawiasowy kawałek drewna. Drewno na zawiasach powinno być większe niż nasadka słoika, której użyjesz i mieć wystarczająco dużo miejsca na zawiasy i zamontowanie serwomechanizmu.

Użyłem małych plastikowych zawiasów do samolotów RC i po prostu przykleiłem je na gorąco do drewna na zawiasach i podstawy.

Krok 2: Zrób dłuższe ramię serwomechanizmu i podłącz serwo

Aby zrobić dłuższe ramię serwomechanizmu, po prostu przymocowałem do ramienia serwomechanizmu 5-centymetrowy kawałek drewna za pomocą kilku małych śrubek i nakrętek. Ramię serwa powinno znajdować się pod kątem 90 stopni na serwo, gdy jest ono poziome względem podstawy.

Właśnie przykleiłem serwo na gorąco do zawiasowego uchwytu na drewno, ale odkryłem, że jeśli pozwolisz mu pracować dłużej niż kilka minut, serwo podgrzeje gorący klej i puści drewno. Więc lepsza metoda mocowania jest gwarantowana.

Krok 3: Załaduj i uruchom szkic

Przymocowałem moje serwo do pinu 7 za pomocą tarczy, ponieważ jest to po prostu wygodne i kosztują tylko kilka dolców. Jeśli nie masz osłony, podłącz przewód sygnałowy serwomechanizmu do styku 7 na Arduino, czerwony przewód do 5 V na Arduino, a przewód uziemienia do GND na Arduino. Arduino powinno dostarczać prąd wystarczający do obsługi serwomechanizmu. Używam nakładki, ponieważ łatwo jest zastosować zewnętrzne napięcie tylko dla serwomechanizmu.

Oto szkic. Napisałem procedurę kontrolera prędkości serwomechanizmu, aby zmienić prędkość serwomechanizmu, ponieważ prawdopodobnie nie będzie działał dobrze przy pełnej prędkości.

Możesz zmienić opóźnienie, aby uzyskać różne prędkości toczenia piłki. Możesz również zmienić trzeci parametr funkcji myServo(), aby zmienić również prędkość.

//////////////////////////////////////////////// //////////////////////////////////////////////// ////////////// // stworzony przez Jima Demello, Uniwersytet Shangluo, 2017

// możesz używać, manipulować, robić co chcesz z tym kodem, moje imię nie jest wymagane

// Ta procedura pozwala na interpolację dowolnej liczby serw, po prostu dodaj nowe linie, jeśli liczba serw przekracza 4

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

#włączać

Serwo myservo1, myservo2; // utwórz obiekt servo do sterowania serwo

int servoRead(int servoNumber) {

int serwoPrąd;

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

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

zwrot serwoprądu;

}

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(kąt);

if (servoNum == 2) myservo2.write(kąt);

opóźnienie(w tymOpóźnienie); }

}

else if (curAngle > newAngle) {

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

if (servoNum == 1) myservo1.write(kąt);

if (servoNum == 2) myservo2.write(kąt);

opóźnienie(w tymOpóźnienie); }

}

}

void interpolate2Servos(int servo1, int servo1Position, int servo2, int servo2Position, int numberSteps, int timeDelay){

int serwo1Prąd, serwo2Prąd;

servo1Current = servoRead(servo1);

servo2Current = servoRead(servo2);

// Serial.print("Servo3Pos i aktualny "); Serial.print(serwo3Pozycja); Serial.print(" "); Serial.println(servo3Current);

// Serial.print("Servo4Pos i prąd "); Serial.print(servo4Position); Serial.print(" "); Serial.println(servo4Current);

// Serial.print("Servo5Pos i Current "); Serial.print(serwo5Pozycja); Serial.print(" "); Serial.println(serwo5Current);

// Serial.print("Servo6Pos i Current "); Serial.print(serwo6Pozycja); Serial.print(" "); Serial.println(servo6Current);

// Serial.println(" ");

int cOffset = (servo1Position - servo1Current); cOffset = abs(cOffset)/liczbaKroków;

int dOffset = (servo2Position - servo2Current); dOffset = abs(dOffset)/liczba kroków;

int cCałkowitePrzesunięcie=0, dCałkowitePrzesunięcie=0;

cOffsetTotal = serwo1Prąd;

dOffsetTotal = prąd serwo2;

dla (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(" Przesunięcie a i b "); Serial.print(aOffsetTotal); Serial.print(" ");Serial.println(bOffsetTotal); opóźnienie(10);

opóźnienie(czasOpóźnienie);

}// koniec dla

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

// zadbaj o resztki modulo //

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

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

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

}

intopóźnienieczasu = 100;

int opóźnienie serwo = 100;

int degGap = 10;

// To jest stopień początkowy (musi być mniejszy niż stopień końcowy)

int degStart = 0;

// To są stopnie końcowe (musi być większe niż stopień początkowy)

wewn. stopnie konc = 360;

//To jest promień okręgu

promień wewnętrzny = 8;

pusta konfiguracja()

{

Serial.początek(9600);

opóźnienie (100);

myservo1.attach(7); // dołącza serwo na pin 7 do obiektu serwo

myservo1.write(90);

myservo2.attach(8); // dołącza serwo na pin 8 do obiektu serwa

myservo2.write(90);

opóźnienie (1000); // czeka, aż serwo tam dotrze

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

opóźnienie (1000);

}

pusta pętla () {

czasOpóźnienie = 15; // działa na 10

serwoOpóźnienie = 4;

spin4();

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

//opóźnienie(1000);

// wyjście(0); //pause program - naciśnij reset, aby kontynuować

}

nieważne spin3() {

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

opóźnienie(opóźnienie czasu);

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

opóźnienie(opóźnienie czasu);

}

nieważne spin2() {

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

opóźnienie(opóźnienie czasu);

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

opóźnienie(opóźnienie czasu);

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

opóźnienie(opóźnienie czasu);

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

opóźnienie(opóźnienie czasu);

}

nieważne spin1() {

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

stopnie zmiennoprzecinkowe = (stopniePoczątek * 3,141592/180); // zamień stopnie na radiany

float xPos = 90 + (cos(deg) * promień);

// xPos = round(xPos);

float yPos = 90 + (sin(deg) * promień);

// rPoz = round(yPoz);

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); // neutralny

myservo1.write(xPos);

myservo2.write(yPos);

opóźnienie(opóźnienie czasu);

if (stopnie Początek >= stopnie Koniec) {

stopnie start = 0;

jeśli (degGap > 180)

degGap = 180;

//degGap = 0;

w przeciwnym razie

degGap = degGap + 2;

degGap = degGap - 2;

// degStart = degStart +degGap;

}

degStart = degStart + degGap;

}

nieważne spin4() {

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

zmiennoprzecinkowe j = 20 * (cos ((3,14 * i)/180)) + 90;

pływak k = 20 * (sin ((3,14 * i)/180)) + 90;

myservo1.write(j);

myservo2.write(k);

Serial.print(j);

Serial.print(", ");

Serial.println(k);

opóźnienie (100);

}

}