Rolo de esferas automatizado com Arduino e um servo: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este é um projeto simples de Arduino e servo que leva cerca de duas horas para ser concluído. Ele usa um servo para levantar uma extremidade da tampa de um jarro de modo a girar uma bola de aço ao redor da circunferência interna. É de partida automática, pode mudar a velocidade e pode girar duas (ou mais?) Bolas de uma vez. Divertido de construir e trabalhar. Os parâmetros de tempo podem ser reproduzidos para velocidades provavelmente ainda mais rápidas. Alguns sensores de efeito Hall com uma bola magnética podem ser usados para torná-lo uma máquina mais inteligente que pode descobrir os melhores parâmetros.

Devo mencionar que alguém aqui em instructables.com tem uma máquina de rolos esféricos mais sofisticada:

Materiais necessários:

Arduino Uno (ou qualquer Arduino)

Escudo do servo (opcional)

Servo 9g

tampa do frasco

bola de aço

alguns restos de madeira

Etapa 1: Faça a base e o suporte para tampa articulada

A base é apenas um pedaço de madeira para montar o pedaço de madeira com dobradiças. A madeira com dobradiças deve ser maior do que a tampa de uma jarra que você usará e ter espaço suficiente para as dobradiças e para montar o servo.

Usei pequenas dobradiças de avião de rc de plástico e apenas as colei na madeira com dobradiças e na base.

Etapa 2: Faça o braço do servo mais longo e anexe o servo

Para fazer um braço servo mais longo, eu apenas fixei um pedaço de madeira de 5 centímetros no braço servo com alguns pequenos parafusos e porcas. O braço do servo deve estar a 90 graus no servo quando estiver horizontal em relação à base.

Acabei de colar o servo a quente no suporte de madeira com dobradiças, mas descobri que se você deixá-lo rodar por mais de alguns minutos, o servo vai aquecer a cola quente e soltar da madeira. Portanto, um método de fixação melhor é garantido.

Etapa 3: carregar e executar o esboço

Eu conectei meu servo ao pino 7 usando um escudo porque é apenas conveniente e eles custam apenas alguns dólares. Se você não tiver uma blindagem, conecte o fio de sinal do servo ao pino 7 no Arduino, o fio vermelho a 5v no Arduino e o fio terra ao GND no Arduino. O arduino deve fornecer corrente suficiente para operar o servo. Eu uso a blindagem porque é fácil usar uma tensão externa apenas para o servo.

Aqui está o esboço. Eu escrevi uma rotina de controlador de velocidade do servo para alterar a velocidade do servo porque provavelmente não funcionará bem na velocidade total.

Você pode alterar o timingDelay para obter diferentes velocidades de rolamento da bola. Você também pode alterar o terceiro parâmetro da função myServo () para alterar a velocidade também.

//////////////////////////////////////////////////////// //////////////////////////////////////////////////////// ////////////// // criado por Jim Demello, Shangluo University, 2017

// você é livre para usar, manipular, fazer o que quiser com este código, meu nome não é obrigatório

// Esta rotina permite que qualquer número de servos seja interpolado, basta adicionar novas linhas se o número de servos exceder 4

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

#incluir

Servo myservo1, myservo2; // cria um objeto servo para controlar um servo

int servoRead (int servoNumber) {

int servoCurrent;

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

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

return 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) {

para (ângulo interno = ângulo angular; ângulo <ângulo novo; ângulo + = ânguloInc) {

if (servoNum == 1) myservo1.write (ângulo);

if (servoNum == 2) myservo2.write (ângulo);

atraso (incDelay); }

}

else if (curAngle> newAngle) {

para (ângulo interno = ângulo angular; ângulo> novo ângulo; ângulo - = ânguloInc) {

if (servoNum == 1) myservo1.write (ângulo);

if (servoNum == 2) myservo2.write (ângulo);

atraso (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 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;

para (int x = 0; x

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

else {cOffsetTotal = cOffsetTotal - cOffset; }

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

senão {dOffsetTotal = dOffsetTotal - dOffset; }

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

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

// Serial.print ("a e b Offset"); Serial.print (aOffsetTotal); Serial.print (""); Serial.println (bOffsetTotal); atraso (10);

atraso (timeDelay);

} // fim para

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

// cuidar dos restos do módulo //

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

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

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

}

int timingDelay = 100;

int servoDelay = 100;

int degGap = 10;

// Este é o grau inicial (deve ser menor que o grau final)

int degStart = 0;

// Este é o grau final (deve ser maior do que o grau inicial)

int degEnd = 360;

// Este é o raio do círculo

raio interno = 8;

void setup ()

{

Serial.begin (9600);

atraso (100);

myservo1.attach (7); // anexa o servo no pino 7 ao objeto servo

myservo1.write (90);

myservo2.attach (8); // anexa o servo no pino 8 ao objeto servo

myservo2.write (90);

atraso (1000); // espera que o servo chegue lá

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

atraso (1000);

}

void loop () {

timingDelay = 15; // trabalha às 10

servoDelay = 4;

spin4 ();

// interpola2Servos (1, 90, 2, 90, 1, 60); // neutro

// delay (1000);

// exit (0); // pausa o programa - pressione reset para continuar

}

void spin3 () {

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

atraso (timingDelay);

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

atraso (timingDelay);

}

void spin2 () {

// interpola2Servos (1, 80, 2, 90, 1, 50); // neutro

atraso (timingDelay);

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

atraso (timingDelay);

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

atraso (timingDelay);

// interpola2Servos (1, 110, 2, 110, 1, 60); // neutro

atraso (timingDelay);

}

void spin1 () {

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

float deg = (degStart * 3,141592 / 180); // converter graus em radianos

float xPos = 90 + (cos (graus) * raio);

// xPos = round (xPos);

float yPos = 90 + (sin (graus) * raio);

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

// interpola2Servos (1, xPos, 2, yPos, 1, servoDelay); // neutro

myservo1.write (xPos);

myservo2.write (yPos);

atraso (timingDelay);

if (degStart> = degEnd) {

degStart = 0;

if (degGap> 180)

degGap = 180;

// degGap = 0;

outro

degGap = degGap + 2;

degGap = degGap - 2;

// degStart = degStart + degGap;

}

degStart = degStart + degGap;

}

void spin4 () {

para (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);

atraso (100);

}

}