Automatiserad kulrulle med Arduino och en servo: 3 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:37

Detta är ett enkelt litet Arduino- och servoprojekt som tar cirka två timmar att slutföra. Den använder en servo för att lyfta ena änden av ett burklock för att snurra en stålkula runt insidan. Det är självstartande, kan ändra hastighet och kan snurra två (eller fler?) Bollar samtidigt. Roligt att bygga och få igång. Tidsparametrarna kan spelas med för troligen ännu snabbare hastigheter. Några hall -effektsensorer med magnetkula kan användas för att göra det till en smartare maskin som kan räkna ut de bästa parametrarna.

Jag bör nämna att någon här på instructables.com har en mer sofistikerad bollvalsmaskin:

Material behövs:

Arduino Uno (eller någon Arduino)

Servosköld (tillval)

9g servo

burklock

stål boll

lite skrot

Steg 1: Gör bas- och gångjärnshållare

Basen är bara en träbit att montera det gångjärniga trästycket på. Det gångjärniga träet ska vara större än ett burklock som du kommer att använda och ha tillräckligt med plats för gångjärnen och för att montera servon.

Jag använde små rc -flygplansgångjärn av plast och limde dem precis till det gångjärniga träet och basen.

Steg 2: Gör längre servoarm och fäst servo

För att göra en längre servoarm fästde jag bara en 5 centimeter träbit på servoarmen med ett par små skruvar och muttrar. Servoarmen ska vara 90 grader på servon när den är horisontell mot basen.

Jag har precis varmlimmat servon till den gångjärniga trähållaren men jag upptäckte att om du låter den gå längre än några minuter, kommer servon att värma upp det heta limet och släppa det från träet. Så en bättre fästmetod är motiverad.

Steg 3: Ladda och kör skiss

Jag fäst min servo på stift 7 med hjälp av en sköld eftersom det bara är bekvämt och de kostar bara några dollar. Om du inte har en skärm, fäst sedan servosignaltråden till stift 7 på Arduino, den röda ledningen till 5v på Arduino och jordledningen till GND på Arduino. Arduino ska ge tillräckligt med ström för att driva servon. Jag använder skölden eftersom det är lätt att använda en extern spänning bara för servon.

Här är skissen. Jag skrev en servohastighetsregleringsrutin för att ändra hastigheten på servon eftersom den förmodligen inte fungerar bra vid full hastighet.

Du kan ändra timingDelay för att få olika bollhastigheter. Du kan också ändra den tredje parametern i funktionen myServo () för att också ändra hastighet.

/////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// //////////////// // skapad av Jim Demello, Shangluo University, 2017

// du är fri att använda, manipulera, gör vad du vill med denna kod, mitt namn krävs inte

// Denna rutin gör att valfritt antal servon kan interpoleras, lägg bara till nya rader om antalet servon överstiger 4

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

#omfatta

Servo myservo1, myservo2; // skapa servoobjekt för att styra ett 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) {

för (int vinkel = curAngle; vinkel <newAngle; vinkel += vinkelInc) {

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

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

fördröjning (incDelay); }

}

else if (curAngle> newAngle) {

för (int vinkel = curAngle; vinkel> newAngle; vinkel -= vinkelInc) {

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

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

fördröjning (incDelay); }

}

}

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

int servo1Current, servo2Current;

servo1Current = servoRead (servo1);

servo2Current = servoRead (servo2);

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

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

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

// Serial.print ("Servo6Pos och 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;

för (int x = 0; x

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

annars {cOffsetTotal = cOffsetTotal - cOffset; }

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

annars {dOffsetTotal = dOffsetTotal - dOffset; }

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

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

// Serial.print ("a och b Offset"); Serial.print (aOffsetTotal); Serial.print (""); Serial.println (bOffsetTotal); fördröjning (10);

delay (timeDelay);

} // slut för

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

// ta hand om modulo rester //

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

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

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

}

int timingDelay = 100;

int servoDelay = 100;

int degGap = 10;

// Detta är startgraden (måste vara mindre än slutgraden)

int degStart = 0;

// Detta är slutgraderna (måste vara större än startgraden)

int degEnd = 360;

// Detta är cirkelradien

int radie = 8;

void setup ()

{

Serial.begin (9600);

fördröjning (100);

myservo1.attach (7); // fäster servon på stift 7 på servoobjektet

myservo1.write (90);

myservo2.attach (8); // fäster servon på stift 8 på servoobjektet

myservo2.write (90);

fördröjning (1000); // väntar på att servon kommer dit

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

fördröjning (1000);

}

void loop () {

timingDelay = 15; // fungerar vid 10

servoDelay = 4;

spin4 ();

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

// fördröjning (1000);

// exit (0); // pausa programmet - tryck på reset för att fortsätta

}

void spin3 () {

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

fördröjning (timingDelay);

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

fördröjning (timingDelay);

}

void spin2 () {

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

fördröjning (timingDelay);

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

delay (timingDelay);

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

fördröjning (timingDelay);

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

fördröjning (timingDelay);

}

void spin1 () {

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

float deg = (degStart * 3.141592 / 180); // konvertera grader till radianer

flyta xPos = 90 + (cos (deg) * radie);

// xPos = rund (xPos);

float yPos = 90 + (sin (deg) * radie);

// yPos = rund (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); // neutral

myservo1.write (xPos);

myservo2.write (yPos);

fördröjning (timingDelay);

if (degStart> = degEnd) {

degStart = 0;

om (degGap> 180)

degGap = 180;

// degGap = 0;

annan

degGap = degGap + 2;

degGap = degGap - 2;

// degStart = degStart +degGap;

}

degStart = degStart + degGap;

}

void spin4 () {

för (int i = 0; i <= 360; i ++) {

flottör 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);

fördröjning (100);

}

}