Índice:
2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58
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);
}
}