LusoRobótica - Robótica em Português
Robótica => Tutoriais => Tópico iniciado por: guibot em 22 de Julho de 2009, 21:29
-
Aqui fica um novo vídeo, em que o Njay nos demonstra outra maneira de modificar motores servos :)
http://www.youtube.com/watch?v=VmLm1gl8glM
-
certo.. tá bem explicado e tal.. só que, a meu ver, o problema começa kd se liga o servo ao arduino e o servo treme.. e kd o abres de novo e tentas acertar o potenciometro e nunca chegas ao ponto ideal em que o servo pára por completo.. k acho que era disso k o pessoal se queixa kd os modificam..
(já me aconteceu acertar à primeira e tb nunca conseguir acertar com o centro..)
-
O vídeo está muito bom, parabéns!
Só acrescentaria a calibração. Com o servo aberto, ligar a um PWM de 50% e afinar o potenciómetro com uma chave até ele parar e ficar sem tremer. Nesta altura, é k se mete a cola e se fecha o servo.
-
Quando queres parar, desligas o pino do PWM e tá o problema resolvido.
Esse problema também pode acontecer com resistências, não é exclusivo de potenciómetros.
-
Nós modificámos 2, um deles ficou perfeito, nos 90º parava por completo.
O outro tivemos que subir mais um ou dois graus para faze-lo parar completamente.
Na biblioteca MegaServo há a possibilidade de fazer detach() do servo, nunca experimentei mas isto deve desligá-lo.
-
Martelar código nunca foi boa prática, é bem melhor meter logo o hardware a 100% pois mais tarde ou mais cedo vai ser preciso fazer ajustes por software.
-
hmm.. n sabia disso (de desligar o pwm)..
mas outra duvida: quando acontece ele n ficar calibrado ao centro, kd se pedem velocidades máximas pra um e pro outro lado, as velocidades serão as mesmas?
-
sim, mas nota que os motores dc "normais" nunca atingem a mesma velocidade em ambos os sentidos, são mesmo feitos para girarem com mais velocidade num dos sentidos.
-
é possível.. nunca testei e n sabia disso.. :)
-
Martelar código nunca foi boa prática, é bem melhor meter logo o hardware a 100% pois mais tarde ou mais cedo vai ser preciso fazer ajustes por software.
Não é martelar código. O hardware não é perfeito, e o software tem flexibilidade para contornar as pequenas imperfeições do hardware (mundo real). Um dia ele leva uma pancada maior, ou fica esquecido num automóvel por onde passam 45ºC ou simplesmente está calor e o potênciómetro muda ligeiramente, mesmo estando colado. Aí vais ter à mesma que fazer um ajuste de software.
mas outra duvida: quando acontece ele n ficar calibrado ao centro, kd se pedem velocidades máximas pra um e pro outro lado, as velocidades serão as mesmas?
Parece-me que sim, que são exactamente iguais, até porque basta desviar um bocadinho o PWM do ponto em que ele está parado para ele atingir a velocidade máxima. Quanto a essa assimetria de que fala o guibot, nunca ouvi falar e não me parece que assim seja; se por acaso assim for, essa "limitação" não deve estar na mecânica. Para que iriamos querer um servo (normal) que rodasse para um lado mais depressa do que para o outro? Não faz sentido...
Actualização:
A velocidade do motor no servo depende de quão afastado ele está (ou pensa que está) do seu ponto de equilibrio. Só quando ele se aproxima muito do ponto de equilibrio é que começa a reduzir a velocidade, caso contrário anda à valocidade máxima.
Há motores DC que são fabricados para rodarem "melhor" para um dos lados, mas geralmente estamos a falar de motores "maiores" (industriais ou de veículos eléctricos), mas num servo isso não faz sentido...
-
Só comentei pois quem o queria calibrar sem ser a olhometro fica com ele bom de origem. Cada um é livre de tomas as filosofias que quiser. pode ser boa prática parar o PWM, agora utilizar isso para não o calibrar, não me parece correcto!
-
Podes sempre efectuar mais 2 operações na modificação acima e ficas com um ponto de ajuste manual, que é
1) furar duma ponta à outra a engrenagem preta (broca de 2mm)
2) fazer um corte no veio do potenciómetro para que lá encaixe uma chave de fendas
Com isto tens o teu ponto de ajuste (calibração).
Não entendo o que queres dizer com parar o PWM não ser boa prática de calibração. Parar o PWM é só para garantir que quando é suposto ele estar parado, ele está mesmo parado e não a tremer. A calibração tens que a fazer à mesma, ou rodando o eixo do potênciómetro ou ajustando os valores no software; mexer no software é a minha versão favorita, pois quanto menos se mexer no hardware melhor (furar e cortar cria particulas que não dão saúde às engrenagens se não forem muito bem removidas, e além disso é mais trabalho).
Não sei bem como é que o analogWrite configura o periférico de PWM, mas no teu Smalluino provavelmente só deves precisar de trocar isto
analogWrite(motorXXX, 127);
por isto
analogWrite(motorXXX, 0);
para um servo deixar de ter o problema de ficar a tremer quando pára.
-
Como eu disse anteriormente, as calibrações são sempre necessárias, mas se já tivermos um hardware bom à partida, os ajustes serão menores e por isso ficas com mais margem para ajustes.
Para além de tudo isso, dá para configurar o tempo máximo e mínimo dos pulsos e assim ajustar o meio para o sitio certo! Mas lá está, quanto mais software, mais pesado o micro vai ficar para fazer uma tarefa que devia de ser simples se o hardware estivesse bom!
Deixo um código meu de teste de servos onde faço esse ajuste:
#include <Servo.h>
Servo myservo1;
Servo myservo2;
Servo myservo3;
int min = 544;
int max = 2600;
void setup()
{
myservo1.attach(9, min, max) ;
myservo2.attach(10, min, max);
myservo3.attach(11, min, max);
}
void loop()
{
myservo1.write(90);
myservo2.write(90);
myservo3.write(90);
delay(1000);
myservo1.write(0);
myservo2.write(0);
myservo3.write(0);
delay(1000);
myservo1.write(180);
myservo2.write(180);
myservo3.write(180);
delay(1000);
}
-
Como eu disse anteriormente, as calibrações são sempre necessárias, mas se já tivermos um hardware bom à partida, os ajustes serão menores e por isso ficas com mais margem para ajustes.
Para ajustes maiores ou menores, o software é o mesmo. Não tens menos software por teres ajustes menores...
Para além de tudo isso, dá para configurar o tempo máximo e mínimo dos pulsos e assim ajustar o meio para o sitio certo! Mas lá está, quanto mais software, mais pesado o micro vai ficar para fazer uma tarefa que devia de ser simples se o hardware
Não tanto quanto isso. Podes ter um sketch que faz a calibração e guarda o valor central em EEPROM para cada servo, e depois a tua aplicação vai lá ler. A leitura de um valor da EEPROM são meia dúzia de instruções. No teu Smalluino tens valores constantes para o PWM, só que também não tens a flexibilidade de ter um controle progressivo da velocidade; quando o quiseres fazer vais ter que substituir os valores constantes por variáveis e aí o único código que a calibração por software tem "a mais" é a 1/2 dúzia de instruções para ler da EEPROM. Se um dia precisares de re-calibrar, só tens que carregar o sketch de calibração, efectuá-la, e depois os novos valores ficam guardados em EEPROM, não sendo necessário sequer alterar e re-compilar o sketch do robot.
-
Njay.. parece que não falamos a mesma língua... se não tiveres calibração o código é nenhum. É óbvio que para valores diferentes o custo vai ser igual sendo maior ou menor, mas como eu disse, quanto mais alterares por software, menos podes alterar no futuro se os erros forem acumulando!
Existem mil e uma alternativas, a ideia aqui é o keep it simple. Se um membro quer que o servo fique bom, quer algo simples. É como estares a dizer que para levar uma mala de viagem de carro de 100km, em vez de meter na bagageira, vais levar um atrelado pois se quiseres meter mais malas, é fácil.
Vamos lá a ser objectivos e em vez de discutir o sexo dos anjos, ajudar quem se está a iniciar, afinal era para isso que servia este post. Podemos abordar melhor esse assunto com outra finalidade noutro tópico ;)
-
São pontos de vista, não somos obrigados a concordar um com o outro :)
Entretanto com a discussão e alguma pressa que tinha de ir a certo sítio esqueci-me de agradecer ao guibot pela filmagem e edição do video. Desculpa e Obrigado!! :)
-
sim esta um bom trabalho mas ainda nao tiras-te a minha duvida da calibração.
eu ainda acho que o servo nao esta calibrado e os testes de software???
isso é que eu queria ver sff.
:)
-
Quanto a essa assimetria de que fala o guibot, nunca ouvi falar e não me parece que assim seja; se por acaso assim for, essa "limitação" não deve estar na mecânica. Para que iriamos querer um servo (normal) que rodasse para um lado mais depressa do que para o outro? Não faz sentido...
basta fazeres a seguinte experiência, pega num motor dc e mete-o a andar na velocidade máxima para um lado e na velocidade máxima para o outro, e vê o resultado ;)
-
Quanto a essa assimetria de que fala o guibot, nunca ouvi falar e não me parece que assim seja; se por acaso assim for, essa "limitação" não deve estar na mecânica. Para que iriamos querer um servo (normal) que rodasse para um lado mais depressa do que para o outro? Não faz sentido...
basta fazeres a seguinte experiência, pega num motor dc e mete-o a andar na velocidade máxima para um lado e na velocidade máxima para o outro, e vê o resultado ;)
Isto é verdade e acontece porque também já me deparei com isso, no entanto isso deve-se à fraca qualidade dos motores.
-
está fixe o video :)
Dá para mudar servos de rotação continua, para rotação de 180º??
-
está fixe o video :)
Dá para mudar servos de rotação continua, para rotação de 180º??
Se conseguires arranjar aquela engrenagem principal sem ser moída, consegues
-
Dá para mudar servos de rotação continua, para rotação de 180º??
Depende do servo.
Se o servo tiver sido modificado desta maneira é só substituir a peça preta, a que tem o batente e aquele buraquinho adaptado ao eixo do potenciómetro.
Existem outros métodos de modificação de servos em que o processo é mesmo irreversível, nestes casos mais vale comprar um novo.
-
Comprar aquela engrenagem nova ou simplesmente colá-la ao potenciómetro.
Vou mesmo ter que fazer essa experiência da velocidade dos motores. Até porque conheço bem alguns por dentro e não vejo nenhuma razão mecânica para terem velocidades (à excepção de pequenas assimetrias causadas por diferenças de fabrico) diferentes para um lado ou para o outro.
-
Comprar aquela engrenagem nova ou simplesmente colá-la ao potenciómetro.
E refazer o batente, pois não sei se a força do servo não será suficiente para partir o potenciómetro( a vantagem de baixar o potenciómetro como eu fiz e que basta puxa-lo para cima e refazer o batente).
Vou mesmo ter que fazer essa experiência da velocidade dos motores. Até porque conheço bem alguns por dentro e não vejo nenhuma razão mecânica para terem velocidades (à excepção de pequenas assimetrias causadas por diferenças de fabrico) diferentes para um lado ou para o outro.
Eu nunca notei diferenças nos motores nem nos pequeninos, nem nos grandes.
-
Vou mesmo ter que fazer essa experiência da velocidade dos motores. Até porque conheço bem alguns por dentro e não vejo nenhuma razão mecânica para terem velocidades (à excepção de pequenas assimetrias causadas por diferenças de fabrico) diferentes para um lado ou para o outro.
Para além de me deparar com este "fenómeno" sempre que testo um motor dc , li uma explicação técnica sobre isto à bastante tempo mas a consigo localizar agora..
-
Vou ver se na empresa se ainda temos um conta-rotações estroboscopio para fazer a experiência, visto que a olho nunca notei diferença.
-
pois obrigado, talvez fure com o dremel, e ponho um parafuso, ou dois.
-
Vou ver se na empresa se ainda temos um conta-rotações estroboscopio para fazer a experiência, visto que a olho nunca notei diferença.
Pequenas diferenças há de certeza, porque depende do posisionamento das escovas e apesar do desenho tipico ser simétrico há sempre diferenças de fabrico.
-
sim esta um bom trabalho mas ainda nao tiras-te a minha duvida da calibração.
eu ainda acho que o servo nao esta calibrado e os testes de software???
isso é que eu queria ver sff.
:)
AVISO: este deve ser o maior post que já viram por aqui :)
Para a "calibração" usei um programa que escrevi num AVR mais pequeno. Esse programa gera PWM com um ciclo activo controlado por porta série.
Para mim, e no caso desta modificação, a calibração é encontrar o tempo de impulso a HIGH que faz o servo ficar parado. Chamemos-lhe o "ponto "zero". O ponto zero é um número, que depende da biblioteca de software que estamos a usar para gerar o PWM ou controlo de servos. Quando calibramos com uma determinada biblioteca, ficamos com um número de "ponto zero" que só funciona nessa biblioteca, porque esse número pode mapear-se de formas diferentes no periodo de impulso a HIGH; 127 numa biblioteca pode corresponder a 1.5ms e noutra pode corresponder a 2ms.
Comecei por modificar um servo A, usando um método de ferro de soldar. A coisa nitidamente não correu bem e nem sequer testei esse servo.
Aí dei com o método deste video e modifiquei um servo B. A coisa aparentemente correu bem mas acho que danifiquei o interior da engrenagem preta, porque notei que o eixo ficou ligeiramente mais dificil de rodar. Considerei-o "perdido" e nem sequer o testei.
Com o conhecimento adquirido nas 2 modificações anteriores então alterei mais 2 servos. Estes então testei com o dispositivo que referi mais acima e tinham pontos de paragem perfeitos. Fiz imensos testes de os levar à velocidade máxima em ambos os extremos, pará-los, avançar muito muito devagar numa direcção, voltar para trás e fazer o mesmo na outra direcção, etc. Sempre apresentaram um ponto de paragem perfeito. Foram vendidos.
Entretanto no AltLab, quando fizémos o video, eu modifiquei mais um servo e o guibot modificou outro. Submetemos os 2 servos ao dispositivo de teste que mencionei acima. Como ele já aqui referiu, o 1º ficou com paragem perfeita e o 2º a precisar de um "toquezinho" para parar. Já não tenho a certeza mas penso que este 2º, ali no ponto de paragem, ficava naquele estado de "vibraçao" forte. Isto resolve-se facilmente desligando o servo quando ele já está nas proximidades do ponto zero.
Hoje estive a escrever um programa para o Arduino para ajudar na calibração destes servos, e levei ao teste o servo B. Este servo tem o tipo de problemas que o andnobre e outros referiram, no sentido em que, ao aproximar-se do ponto zero, começa a vibrar fortemente e há ali uma gama apreciável de valores (estou a usar o analogWrite()), uns 20 a 30, em que ele fica parado com essa vibração. Só depois de sair dessa zona é que perde a vibração e acelera para a velocidade que já devia ter nesse ponto. Quando vou da velocidade máxima para o ponto zero ele só começa a vibrar já quase parado, mas depois para o tirar do modo vibração é mais dificil, tendo que percorrer muito mais passos do PWM.
Comecei por medir a corrente que o servo consome, e verifiquei que na situação normal ele consome até 190mA (sem esforço). Em modo "vibração" ele consome entre 640 e 820mA, o que não admira dada a "potência" da vibração. Pensei que pudesse ser um problema de desacoplamento e adicionei um condensador à alimentação a ver se passava. Quando o ligava às vezes tinha algum efeito mas era apenas pelo distúrbio que ligá-lo causa na alimentação. A vibração sendo assim forte parece causada por uma ressonância, e então experimentei um condensador pequeno nos pinos do motor, sem qualquer sucesso.
Aí saquei do osciloscópio para ver a forma de onda nos pinos do motor. Quando está em modo normal os pinos vêm um PWM normal; se formos a reduzir a velocidade, então chega a um ponto em que entra no modo vibração e aí a onda muda para uma onda quadrada à potência máxima com 50% de ciclo activo. Esta onda fica quase inalterada enquanto se muda o ciclo activo do PWM no pino de controle até chegar ao ponto em que sai de repente desse modo.
Tinha estado a dar uma olhadela pela documentação do software Arduino e vi que a frequência que eles usam no PWM é cerca de 490Hz. Isto dá um periodo de cerca de 2ms, em que temos 256 valores possíveis de ciclo activo, podendo variar o tempo de HIGH da onda rectangular entre 0 e 2ms. Os tipos do Arduino escolheram estes valores de propósito para cobrirem os valores tipicos de tempo a HIGH usados pelos servos, que são de 1ms a 2ms se bem me lembro. Mas a literatura que já vi por aí na net indica que o servo espera ver um impulso HIGH de 1 a 2ms a cada cerca de 20ms. Pois uma onda rectangular tal como é gerada por uma periférico de PWM como o utilizado no Arduino, e com a configuração que o software do Arduino faz, gera um impulso HIGH a cada 2ms. Ou seja, não só bastante mais curto do que os tipicos 20ms mas também num valor que se aproxima muito na duração máxima possível do próprio impulso HIGH. Com esta história da ressonância na cabeça, coloquei a hipótese de que o modo vibração é causado por uma espécie de "ressonância" na electrónica de controle do servo por causa destes tempos tão aproximados.
Nesta datasheet (http://www.parallax.com/Portals/0/Downloads/docs/prod/motors/900-00008-CRServo-v2.0.pdf) dos servos de rotação contínua da Parallax, a própria Parallax recomenda 20ms de intervalo entre os impulsos, dizendo que tal é necessário para uma rotação suave.
Para colocar à prova a teoria, alterei a frequência do PWM no Arduino de 490 Hz para 122 Hz. Com esta alteração ele passa a gerar um impulso HIGH a cada ~8ms. Agora o servo B já se porta bem, nunca passando pelo tal modo de vibração. Mas esta alteração de frequência tem um senão, razão pela qual certamente os autores das libs do Arduino não a fizeram assim desde o inicio: é que temos agora menos resolução, menos passos para controlar a velocidade. Inclusivé tive um pequeno problema mas de fácil resolução: o servo não chega a ficar mesmo mesmo mesmo parado. Isto acontece porque agora a resolução de tempo não cobre o ponto em que o potenciómetro está regulado. Mas basta re-ajustar o potenciómetro para o servo parar e assim fica o problema resolvido.
Uma forma de respeitar a pausa recomendada e manter uma boa resolução é fazer uma biblioteca para controlar os servos e não usar os periféricos de PWM com o analogWrite() (não sei como foi implementada a ServoLib, mas usá-la pode ser uma solução, caso tenha sido implementada com um intervalo maior entre impulsos). Mas dada a aplicação pode não ser necessário ter um controle assim tão preciso da velocidade de rotação do servo.
Podemos perguntar porque é que quando em funcionamento 0..180graus o servo também não tem problemas. A resposta a isto pode ser simplesmente porque o servo não está muito tempo em velocidades baixas em que pode entrar em ressonância; ele só passa por lá muito depressa em direcção à posição final e pára logo. Algo a ver com o funcionamento em loop fechado.
Podemos ainda perguntar por que é que alguns servos modificados funcionam logo bem e outros não, e a resposta também é simples: tolerância de componentes. Todos os componentes têm ligeiras diferenças; por exemplo um tipico condensador de 100nF costuma ter +/-20% de tolerância.
Não vou especular mais sobre possíveis razões, também não tenho conhecimentos suficientes sobre isto. Talvez alguém da área de controlo tenha uma explicação.
Deixo abaixo o código do Arduino que fiz, para quem quiser experimentar. Se não tiverem por aí nenhum desses servos "vibradores" :), e não quiserem estar a modificar outro, podem simplesmente abrir um e retirar as engrenagens; assim o pot deixa de rodar e é como se tivessem um servo modificado. No sketch, carregar em '?' mostra o estado, em 'h' mostra os comandos disponíveis. Neste momento só suporta servos com a mudança do intervalo entre impulsos para 8ms nos pinos 3 e 11 ('f' para mudar entre impulso a cada 2ms ou a cada 8ms; ao mudarem também vai mudar (bastante) o ponto zero e têm que ajustar a posição do potenciómetro).
Divirtam-se :)
// Modified-servo manual calibrator
// By Njay in 2009 (embeddeddreams.com)
// Licensed under CC BY NC SA (http://creativecommons.org/licenses/by-nc-sa/2.5/pt/)
//
// Calibrate a modified servo means to find the PWM value at which it is stopped (or
// stopped as much as possible; sometimes the best you can get is stopped but vibrating,
// which is no problem since we can “really” stop it by disabling the PWM).
//
// To find this point you need to try values for the PWM (analogWrite) until you find
// the one that stops it.
//
// Start by choosing the PWM output to where your servo is connected, type the letter ‘s’
// (lower case) and then a number from 0 to 5, being 0 pin 3, 1 pin 5, and so on for all
// PWM pins.
//
// Then type ‘o’ to start the servo. Typing ‘o’ toggles the servo on/off.
//
// Then use the ‘+’ and ‘–‘ keys to change the PWM value. If the pot on the servo was set
// to 50%, then this value should be around XXX, so try values around this one first.
//
// When you find the spot, press ‘g’ to save it in the EEPROM for later use by other
// sketches.
//
// Future enhancement: do fully automatic calibration by inserting a resistor in the
// servo's negative power line and using the ADC to find the point of less current
// consumption (servo stopped).
#include <EEPROM.h>
typedef unsigned char byte; // I like to call things by their real name :)
const byte cEEServoBaseAddress = 8;
const byte cLoopDelay_ms = 20;
const byte cCalibTest_ms = 160;
const byte cMaxZeroPointDeviation = 18;
static byte gConvTab[] = {3, 5, 6, 9, 10, 11}; // conversion table from 0..5 to 3,5,6, ...
static byte gPin = 0; // current PWM output being controlled
static byte gVal = 115; // current analog output value
static byte gOn = 0; // controls servo on/off
static byte gCalibTest = 0; // controls calibrated servo test mode
static byte gCalibZeroPoint;
static byte gDir;
static byte gLongPause = 0;
void setup()
{
Serial.begin(19200);
Serial.println("Servo Calibrator v1");
pinMode(13, OUTPUT);
}
// waits until a byte is available at the serial port and then returns it
static byte ReadByte ()
{
while (!Serial.available());
byte ch = Serial.read();
Serial.print(ch); // echo the received character
return ch;
}
// waits for and reads a digit from 0 to 9; returns as a byte
static byte ReadDigit ()
{
return ReadByte() - '0';
}
static void PrintInfo ()
{
Serial.println("");
Serial.print("Pin: ");
Serial.print((int)gConvTab[gPin]);
Serial.print(" Value: ");
Serial.print((int)gVal);
Serial.print(" Servo: ");
Serial.print(gOn? "on" : "off");
Serial.print(" Pulse pause: ");
Serial.print(gLongPause? "8ms" : "2ms");
Serial.println("");
}
void loop()
{
static byte led_ctr = 0;
led_ctr++;
digitalWrite(13, (led_ctr & 0x10? HIGH : LOW));
if (Serial.available())
{
byte ch = Serial.read();
Serial.print(ch); // echo the received character
switch (ch)
{
case 's' :
{
byte tmp = ReadDigit();
Serial.println("");
if (tmp > 5)
{
Serial.println("Invalid pin (valid values: 0..5)");
break;
}
gPin = tmp;
PrintInfo();
break;
}
case '+' :
{
gVal = (gVal < 255? gVal + 1 : gVal);
PrintInfo();
break;
}
case '-' :
{
gVal = (gVal > 0? gVal - 1 : gVal);
PrintInfo();
break;
}
case 'g' : // save calibration value to EEPROM
{
EEPROM.write(gPin + cEEServoBaseAddress, gVal);
Serial.print("\nSaved to EEPROM address ");
Serial.print((int)(gPin + cEEServoBaseAddress));
PrintInfo();
break;
}
case 'o' : // on/off
{
gOn = !gOn;
break;
}
case 't' : // calibrated servo test mode
{
gCalibTest = !gCalibTest;
gCalibZeroPoint = gVal;
gVal = gCalibZeroPoint - cMaxZeroPointDeviation;
gDir = 1;
break;
}
case 'f' :
{
gLongPause = !gLongPause;
if (gLongPause)
{
TCCR2B = TCCR2B & 0b11111000 | 0x06;
}
else
{
TCCR2B = TCCR2B & 0b11111000 | 0x04;
}
}
case '?' :
{
PrintInfo();
break;
}
default :
{
Serial.println("Unkonwn command. Valid commands:");
Serial.println("\ts<n>\tset servo PWM pin <n>");
Serial.println("\t+\tincrease PWM value");
Serial.println("\t-\tdecrease PWM value");
Serial.println("\tg\tsave calibration to EEPROM");
Serial.println("\to\ttoggle servo on/off");
Serial.println("\tt\tcalibrated servo test mode");
Serial.println("\tf\ttoggle PWM frequency of channels 3 and 11");
}
}
}
if (gCalibTest)
{
static byte ctr = 0;
ctr++;
if (ctr >= cCalibTest_ms/cLoopDelay_ms)
{
ctr = 0;
if (gVal == gCalibZeroPoint)
{
analogWrite(gConvTab[gPin], 0);
delay(2000);
}
gVal += gDir;
// Invert rotation direction
if ( (gVal > gCalibZeroPoint + cMaxZeroPointDeviation)
|| (gVal < gCalibZeroPoint - cMaxZeroPointDeviation) )
{
gDir = -gDir;
delay(1000);
}
}
}
analogWrite(gConvTab[gPin], (gOn? gVal : 0));
delay(cLoopDelay_ms);
}
-
Muitoo bem e muitooo grande (mas bom e explicito)! ;) ;D ;D
Alguém ainda tem dúvidas? :D
-
Ainda falta o programa para usar os dados de calibração, talvez pegue no Smalluino do Tig e o altere para isso.
O código pode "assustar" alguns dos mais novatos mas ei, aproveitem para colocar questões ;)
-
HEEEELLLLPPPPP!!!!!! ??? ???
Boas
Estou a tentar construir o smalluino e pus-me a tentar passar um servo futaba para rotação continua.
Tal como indicado nos tutoriais anteriores desmontei o servo, fiz um pequeno golpe no potenciómetro e furei com todo o cuidado a peça que encaixa no potenciometro de forma a que rode livremente.
Até aqui tudo bem... Acho eu...
A partir daqui os muito iniciados como eu acho que ficarão a nadar ao largo ;D :P
Liguei o arduino experimentei carregar o codigo do TigPt e do Njay e o que acontece é que o servo parece dar um pequeno arranque e depois pára.
Tentei ajustar o potenciometro com uma chave de fendas e nada.
As ligações que efectuei ao servo foram Gnd -- preto Vin --- vermelho PWM 3 --- branco
Os meus parabens pelo tutorial, mas o que eu preciso mesmo é de um tutorial para totós ::) ::) ;D
Alguem me pode ajudar nos próximos passos a dar??? Já não sei que mais fazer...
-
explica melhor o que se passa com o teu servo...
-
Liga o pino de controle do servo ao pino 3 do arduino, e carrega o meu código. Aí tens que abrir o hyperterminal (ou o não-sei-quantos do IDE do arduino) para comunicar com o programa a correr no Arduino.
1º carregas em 'o' e aí, na maior parte dos casos, o servo começa logo a rodar sem parar; então podes usar as teclas + e - ou rodar o eixo do potenciómetro até encontrares um ponto em que ele pára. Depois de o parar, se carregares em 't' ele fica a fazer um teste que é acelerar até à velocidade máxima para um lado, estar assim uns segundos, depois desacelerar até parar, estar assim uns segundos, acelerar até à velocidade máxima no outro sentido, parar uns segundos, repetir ad eternum.
-
eu testava de outra maneira como no meu pdf
-
Problema solucionado. Obg andnobre e njay pela ajuda
-
Problema solucionado. Obg andnobre e njay pela ajuda
e resolveste como?
-
Como resolvi???
Bem... tenho até vergonha de dizer... :P
Por isso é que eu continua a dizer que se deveria fazer um manual para totós lol
Bem então aqui vai a minha "experiência" para que pelo menos elucide alguns que conseguem perceber ainda disto menos que eu.
Fiz tudo tal e qual o tutorial para modificar o servo: abri, serrei o potenciometro, furei o encaixe do potenciometro e parecia estar tudo a correr bem.
O que pensei... vou ligar o servo a 4 pilhas 1,5v para ver se isto anda... népia, dava um pequeno arranque e parava logo. Pilhas descarregadas???? Toca de usar transformador ... igual resultado. Só ontem me lembrei que o fio branco do servo devia servir para alguma coisa.
Assim resolvi ligar o servo ao arduino seguindo o codigo do smalluino para acertar o potenciometro com a chave de fendas até que ele andasse para trás e para a frente seguindo as instruções do codigo. Para finalizar cola cyanolit no potenciometro, secar e fechar.
Ou seja "Aventuras de um enfermeiro no Mundo da Robótica", e isto ainda é o começo.
Digam de vossa justiça e não se riam muito com esta aventura.
-
:)
o que importa é que funciona.. ;) boas robotiquices..