LusoRobótica - Robótica em Português
Sistemas específicos => Arduino / AVR => Tópico iniciado por: Junior Frota em 27 de Janeiro de 2011, 22:46
-
Olá amigos, primeiramente peço desculpas se já existe algum tópico com esse mesmo assunto, no entanto, procurei muito e não achei nada muito específico para o meu problema.
Então vamos lá!
Eu estou desenvolvendo um projeto de um braço robótico que usa cinemática inversa. Ele funcionará da seguinte forma:
1º - será digitado no terminal Serial Monitor do Arduino as coordenadas do ponto a que se quer atingir com o braço no formato (x, y, z, a), onde "x", "y" e "z" são as coordenadas do ponto e "a" é o ângulo do último seguimento do braço em relação ao eixo "x" da base do braço;
2º - o programa desenvolvido receberá essas coordenadas e salvará em quatro variáveis (x, y, z e a);
3º - o programa calculará os valores dos demais ângulos;
4º - a extremidade do braço será localizado no ponto determinado previamente.
Minha dúvida é:
Como faço para que o meu programa receba os dados via Serial Monitor e salve cada informação em uma variável diferente?
Eu pensei em algo do tipo:
"Digite a coordenada x"...
"Digite a coordenada y"...
"Digite a coordenada z"...
"Digite o ângulo"...
Mas eu queria que o programa recebesse os dados no formato (x, y, z, a) e separasse cada informação pra sua variável correspondente.
Se alguém puder me ajudar com esse algoritmo, ficarei muito agradecido.
Um abraço...
-
E vais usar um terminal qualquer ou fazer um pequeno programa para isso?
Se vais usar um terminal simples, pedes cada variavel, e antes de pedires a próxima, fazes um read da porta serial e guardas esse numero lido, convertes de ascii para inteiro usando a função atoi() e muito basicamente é isso, como é para ler assim sequencialmente se calhar até é mais simples guardar os dados num array.
-
E vais usar um terminal qualquer ou fazer um pequeno programa para isso?
Se vais usar um terminal simples, pedes cada variavel, e antes de pedires a próxima, fazes um read da porta serial e guardas esse numero lido, convertes de ascii para inteiro usando a função atoi() e muito basicamente é isso, como é para ler assim sequencialmente se calhar até é mais simples guardar os dados num array.
Metes isso num array... basta depois fazeres um ciclo que percorra o array (um ciclo for por exemplo) e separas os valores.
-
Obrigado Senso e obrigado Beirao!
Certo! A primeira sugestão é válida, mas a segunda é que me anima mais.
Vocês deram a sugestão de eu usar uma array, mas não tenho a mínima ideia de como alocar cada componente de coordenada nos campos da matriz.
Se alguém puder me ajudar com algum algoritmo, ficarei agradecido.
Um abraço...
-
Mostra ai o teu código actual, para sabermos como juntar o resto.
-
Na verdade ainda não comecei o código, mas tenho uma ligeira noção de programação em Arduino, que queria um norteamento para eu começar.
Minhas ideias são as que eu postei mais acima, então o que eu queria era uma sugestão de como conseguir essa proeza.
Um abraço...
-
Fazes uma função para ler caracteres da porta série para um array global (não é bom método de programação, mas é mais fácil se for global), até atingir um número máximo de caracteres ou ser lido o caracter 13 ('\n', ou seja, o ENTER). Qualquer coisa do género (pode não compilar, é um exemplo)
const int cTamanhoDoArray = 8;
char entrada[cTamanhoDoArray];
void lerDados (void)
{
int indice = 0;
while (indice < cTamanhoDoArray - 1)
{
byte caracter = Serial.read();
entrada[indice] = caracter;
indice++;
if (caracter == '\n')
break; // sair do ciclo while se o caracter lido for um ENTER
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
Depois basta usares a atoi() como disse o senso para converteres os caracteres (texto) no array entrada para uma variável de tipo inteiro (int).
Isto é muito simplificado (por exemplo não processa erros) e assume que as coordenadas são números inteiros.
-
Olá companheiros! Abaixo segue um pequeno código que eu julgo dar certo:
char x, y, z, a3; // variáveis que serão lidas pelo Serial Monitor
int a1, a2 = 0; // variáveis que serão calculadas por cinemática inversa
const int r1 = 20; // refere-se ao comprimento do primeiro segmento do braço
const int r2 = 20; // refere-se ao comprimento do segundo segmento do braço
const int r3 = 20; // refere-se ao comprimento do terceiro segmento do braço
void setup(){
Serial.begin(9600); // inicia a comunicação serial com o PC
}
void loop(){
Serial.print("Entre com a coordenada x: ");
x = Serial.read(); // lê a coordenada "x" e salva-a na variável de mesmo nome
Serial.println(" "); // passa para a próxima linha
Serial.print("Entre com a coordenada y: ");
y = Serial.read(); // lê a coordenada "y" e salva-a na variável de mesmo nome
Serial.println(" "); // passa para a próxima linha
Serial.print("Entre com a coordenada z: ");
z = Serial.read(); // lê a coordenada "z" e salva-a na variável de mesmo nome
Serial.println(" "); // passa para a próxima linha
Serial.print("Entre com o ângulo: ");
a3 = Serial.read(); // lê o angulo "a3" e salva-a na variável de mesmo nome
Serial.println(" "); // passa para a próxima linha
}
Daqui eu teria condição suficiente para desenvolver o restante do código, mas o que eu queria mesmo era não ter que entrar com as coordenadas de uma por uma. Sei que dá certo, mas eu gostaria que a entrada de dados seguisse o estilo "x, y, z, a", assim teria que ter uma função pra pegar essa entrada e dividir cada caracte para sua respectiva variável e depois transformar em inteiro. Só lembrando, não sei usar a função atoi(), é preciso incluir alguma biblioteca?
Como esse código poderia ser escrito usando array, pegando as coordenadas na forma "x, y, z, a" e colocando cada coordenada em sua variável correspondente?
Desculpe minha ignorância, é que ainda estou engatinhando nesse maravilhoso ramo da robótica.
Um abraço...
-
Isso assim não funciona, tens de usar a função que o Njay fez, pois não recebes numeros do computador, mas sim caracteres ASCII, depois para ler a porta serial tens de fazer primeiro Serial.available().
Aconselho-te a aprenderes primeiro a usar o Serial.read/available() e assim para ler coisas da porta serial antes de ter meteres num programa tão complexo, é da fundação que se começa uma casa e não do telhado ;)
Tens muitos blogs brasileiros sobre esse assunto e muitos bons exemplos.
-
senso, pk dizes que não funciona? a ideia dele, pelo que percebi, não seria algo deste género:
no código ter uma chamada à função:
getVars();
e dps ter a função:
void getVars(){
x = analogRead(pinX);
y = analogRead(pinY);
z = analogRead(pinZ);
a3 = analogRead(pinA3);
}
EDIT: ignorem, não tinha lido desd'o início.. :X
-
Serial.read() lê apenas 1 caracter. É preciso acumular numa cadeia de caracteres (cadeia = array = grupo, sequência) os vários caracteres que compõem um número. Por exemplo, o número -34 é composto por 3 caracteres, o sinal -, o 3 e o 4. O caracter de valor zero ('\0') é um sinalizador que indica o final da cadeia (senão não saberiamos onde termina nem quantos caracteres "úteis" lá estão guardados).
Se pegares na função lerDados() que deixei e mudares o caracter de terminação de input de dados, que actualmente é '\n' (ENTER), para ',' (virgula), já obténs o que queres. Melhor ainda, é passar como parametro para a função lerDados() qual é o caracter de terminação. Com esta alteração, a função pára de ler caracteres quando for introduzido pelo utilizador o caracter indicado, e o array entrada terá os caracteres lidos (supostamente um número).
A função atoi usa-se assim:
int x;
x = atoi(entrada);
Portanto ficarias com algo como
int x, y, z, a;
Serial.print("Entre com o primeiro ponto: ");
lerDados(',');
x = atoi(entrada);
lerDados(',');
y = atoi(entrada);
... etc...
lerDados('\n'); // na última coordenada, o que termina a entrada de dados do utilizador é a tecla ENTER e não uma virgula
a = atoi(entrada);
-
E aí pessoal, legal pelas ajudas, mas tenham paciência, isso tudo é um desafio para mim e espero que pensem o mesmo. A final, ensinar alguém que é quase leigo em um determinado assunto, não deixa de ser um desafio.
Vamos para o que interessa!
Tentei juntar os códigos que o Njay postou e resultou no seguinte:
const int cTamanhoDoArray = 8;
char entrada[cTamanhoDoArray];
int x, y, z, a;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Entre com o primeiro ponto: ");
lerDados(',');
x = atoi(entrada);
lerDados(',');
y = atoi(entrada);
lerDados(',');
z = atoi(entrada);
lerDados('\n'); // na última coordenada, o que termina a entrada de dados do utilizador é a tecla ENTER e não uma virgula
a = atoi(entrada);
}
void lerDados (void){
int indice = 0;
while (indice < cTamanhoDoArray - 1){
byte caracter = Serial.read();
entrada[indice] = caracter;
indice++;
if (caracter == '\n'){
break; // sair do ciclo while se o caracter lido for um ENTER
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
}
Só que quando compilo dá esse erro:
In function 'void loop()':
error: too many arguments to function 'void lerDados()'
Acho que é sobre o argumento da função lerDados() que não foi bem definido.
Njay, você poderia fazer um teste nesse código, já que ele é praticamente de autoria sua?
Mais uma vez, desculpem minha ignorância.
Um abraço...
-
const int cTamanhoDoArray = 8;
char entrada[cTamanhoDoArray];
int x, y, z, a;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Entre com o primeiro ponto: ");
lerDados(',');
x = atoi(entrada);
lerDados(',');
y = atoi(entrada);
lerDados(',');
z = atoi(entrada);
lerDados('\n'); // na última coordenada, o que termina a entrada de dados do utilizador é a tecla ENTER e não uma virgula
a = atoi(entrada);
}
void lerDados (uint8_t terminador){
int indice = 0;
while (indice < cTamanhoDoArray - 1){
byte caracter = Serial.read();
entrada[indice] = caracter;
indice++;
if (caracter == terminador){
break; // sair do ciclo while se o caracter lido for um ENTER
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
}
Experimenta assim.
-
Olá senso, experimentei o código que você postou e realmente não apresentou mais o erro. Muito obrigado pela ajuda e paciência!
O problema agora não é mais de compilação, mas sim na hora de entrar com os dados.
Quando executo o código no Arduino Duemilanove com a janela do Serial Monitor, na janela dos resultados, não para de imprimir a frase "Entre com o primeiro ponto: ", ou seja, não dá chance pra gente colocar as informações.
Acho que é preciso entrar com um código que pare o procedimento e só continue quando for pressionado o ENTER.
Outra coisa, nesse mesmo projeto eu irei movimentar servos com os dados que resultarão dessas entradas, e também será preciso reconhecer a cor de alguns objetos para poder selecioná-los.
Sobre a movimentação dos servos, já tenho todo o código fonte, mas para identificar a cor de um objeto seria melhor eu usar um sensor de infravermelho ou LDR?
Eu tenho um par de fotodiodos (emissor e receptor), mas até então, não consegui usá-los de forma eficiente. Eles trabalham com sinal digital ou analógico?
Mas uma vez agradeço pela paciência e ajuda que estão tendo comigo. Ainda bem que existem pessoas que se prestam a ajudar a quem lhes pedem ajuda.
Um abraço...
-
Quanto à identificação da cor, não estou bem a ver como se possa fazer com um sensor IV, mas com LDR existem bons exemplos, aqui fica um http://letsmakerobots.com/node/23768 (http://letsmakerobots.com/node/23768) (em inglês).
-
Erro meu Junior, pensava que a função Serial.read() era bloqueante (que esperava que houvesse um caracter disponível para ler), mas não é. Neste caso precisas de trocar a linha
byte caracter = Serial.read();
por
int caracter;
do { caracter = Serial.read(); } while (caracter == -1);
-
Erro meu Junior, pensava que a função Serial.read() era bloqueante (que esperava que houvesse um caracter disponível para ler), mas não é. Neste caso precisas de trocar a linha
byte caracter = Serial.read();
por
int caracter;
do { caracter = Serial.read(); } while (caracter == -1);
Não precisa de ser int para comparar com -1?
A minha sugestão é ler o Serial.available().
-
Se olhares bem vais ver que (já) é int ;)
Usar a Serial.available() é outra solução.
-
Se olhares bem vais ver que (já) é int ;)
Usar a Serial.available() é outra solução.
Opah, desculpa, vi à pressa... :P
Metam um jump de dois posts anteriores para o próximo a este! xD
-
Olá pessoal! Muito bom a ajuda que estão me dando, mais uma vez agradeço muito.
Eu fiz umas pequenas mudanças no código, ele ficou assim:
const int cTamanhoDoArray = 8;
char entrada[cTamanhoDoArray];
int x, y, z, a;
void setup(){
Serial.begin(9600);
Serial.println("Entre com um ponto (x, y, z, a): ");
}
void loop(){
if (Serial.available()){
lerDados(',');
x = atoi(entrada);
lerDados(',');
y = atoi(entrada);
lerDados(',');
z = atoi(entrada);
lerDados('\n'); // na última coordenada, o que termina a entrada de dados do utilizador é a tecla ENTER e não uma virgula
a = atoi(entrada);
Serial.print("Ponto: ");
Serial.print(x);
Serial.print(",");
Serial.print(y);
Serial.print(",");
Serial.print(z);
Serial.print(",");
Serial.println(a);
}
}
void lerDados (uint8_t terminador){
int indice = 0;
while (indice < cTamanhoDoArray - 1){
byte caracter = Serial.read();
entrada[indice] = caracter;
indice++;
if (caracter == terminador){
break; // sair do ciclo while se o caracter lido for um ENTER
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
}
eu acrescentei um teste para ver se as variáveis estavam realmente sendo lidas via teclado. O código funcionou bem, só com um pequeno problema, que eu acho que nem é preciso resolvê-lo: quando inicio o código pelo Arduino, na tela Serial Monitor é imprimida, inicialmente, a frase "Entre com um ponto (x, y, z, a): ", até aqui beleza, só que quando eu entro com as coordenadas do ponto, eu preciso acrescentar um zero antes da primeira coordenada para que seja lida corretamente. Se o problema puder ser solucionado, muito bom, se não, fico colocando o zero antes mesmo. hehehe
Uma amostra de como foi imprimido na janela:
Entre com um ponto (x, y, z, a):
Ponto: 0,0,0,0
Ponto: 10,10,20,30
Lembrando que foi preciso que eu digitasse 010,10,20,30 para que fosse reconhecido 10,10,20,30. Sendo assim, o código está funcionando beleza, mas se puder ser aprimorado, aceito ajuda.
Mais uma vez, muitíssimo obrigado.
Um abraço...
-
E se não meteres o dito 0 o que acontece?
-
Esqueceste-te de fazer esta alteração que indiquei anteriormente.
Erro meu Junior, pensava que a função Serial.read() era bloqueante (que esperava que houvesse um caracter disponível para ler), mas não é. Neste caso precisas de trocar a linha
byte caracter = Serial.read();
por
int caracter;
do { caracter = Serial.read(); } while (caracter == -1);
-
Beirao, se eu não colocar o zero, ele separa o primeiro algarismo da primeira coordenada.
Eu digito: 10,10,20,30 e quando teclo Enter, ele imprime assim:
Entre com um ponto (x, y, z, a):
Ponto: 1,0,0,0 // essa linha não era para existir
Ponto: 0,10,20,30 // está faltando o "1" do "10" que foi digitado
Ou seja, ele pega o primeiro algarismo da coordenada x e separa dos outros.
Honestamente não sei como ajeitar. Não vejo problema em ter que colocar um zero ou qualquer outro numero antes das coordenadas, mas se puderem me ajudar, estarei grato.
Njay, em que parte do código devo colocar o que você me mandou? Pois quando, simplesmente substituí uma coisa pela outra, o programa não apresentou resultado, ele passou a misturar algumas coordenadas.
Um abraço...
-
O que o Njay disse para fazeres foi:
const int cTamanhoDoArray = 8;
char entrada[cTamanhoDoArray];
int x, y, z, a;
void setup(){
Serial.begin(9600);
Serial.println("Entre com um ponto (x, y, z, a): ");
}
void loop(){
if (Serial.available()){
lerDados(',');
x = atoi(entrada);
lerDados(',');
y = atoi(entrada);
lerDados(',');
z = atoi(entrada);
lerDados('\n'); // na última coordenada, o que termina a entrada de dados do utilizador é a tecla ENTER e não uma virgula
a = atoi(entrada);
Serial.print("Ponto: ");
Serial.print(x);
Serial.print(",");
Serial.print(y);
Serial.print(",");
Serial.print(z);
Serial.print(",");
Serial.println(a);
}
}
void lerDados (uint8_t terminador){
int caracter, indice= 0;
while (indice < cTamanhoDoArray - 1){
do {
caracter = Serial.read();
} while (caracter == -1);
entrada[indice] = caracter;
indice++;
if (caracter == terminador){
break; // sair do ciclo while se o caracter lido for um ENTER
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
}
-
beirao, eu já fiz o que o Njay pediu, mas não funcionou. Você já testou esse código? Ele apresenta um comportamento estranho. Vou tentar descrever:
1º - Quando a gente coloca ele pra rodar e insere os dados, primeiramente ele não reage a nada;
2º - Tentando entrar com os dados novamente, ele imprime as coordenadas de forma misturada, assim:
Eu digitei uma vez "10,20,30,40" e não aconteceu nada, digitei novamente "10,20,30,40" e aparecei isso:
Entre com um ponto (x, y, z, a):
Ponto: 10,20,30,4010
Quando eu tinha apenas que digitar o zero antes da primeira coordenada, dava certo, ele reconhecia as 4 variáveis de forma independente e sem misturar.
Vejamos se é possível concertar isso.
Um abraço...
-
Mas o serial.available retorna o tamanho do array de chegada, não pode simplesmente meter isso e esperar que funcione certo.
Pois tanto pode ter recebido só o 1 como ter recebido 10,2.
-
Então senso, você tem alguma sugestão?
Pois já tentei de tudo quanto foi forma pra resolver esse problema, até o ponto de me contentar com o código que se precisa colocar o zero na frente do número, hehehe
Mas é isso mesmo, na vida, somos eternos aprendizes.
Sou professor de Física em uma escola pública aqui do Brasil e nesse ano eu gostaria de desenvolver um projeto voltado à Robótica educacional, sendo assim, vou tentar explicar o meu projeto:
Meu projeto constitui em criar um mecanismo de seleção de objeto por cores. Este mecanismo consiste em um braço mecânico e uma esteira rolante dotada de um sensor de cores.
Quando o objeto interceptar o sensor, ele identificará a cor e fará o braço leva-lo para um local determinado.
Sendo assim, o meu projeto em si, nem precisa tanto que eu entre com as coordenadas pelo Serial Monitor, mas preciso disso sim, para testar o alcance e poder determinar os locais de coleta dos objetos.
Eu estou trabalhando na construção do sensor de cores, já tenho os leds e os filtros RGBs, só preciso desenvolver o código, que julgo não ser tão difícil.
Então, é este o meu projeto. Preciso muito poder entrar com as coordenadas para poder testar o braço, só pra isso.
Então, se alguém puder me ajudar, muito obrigado.
Um abraço...
-
Às vezes há algum "lixo" lido da porta série no arranque, aconselho a colocar o seguinte código no final da função setup(), para esvaziar o "buffer de entrada":
while (Serial.read() == -1);
Para ajudar na depuração do programa, sugiro esta nova função lerDados() que faz echo dos caracteres lidos, ou seja, quando digitas um carater no terminal esse caracter é lido no Arduino e o Arduino envia-o de volta para o PC e assim vês o caracter que o Arduino leu:
void lerDados (uint8_t terminador)
{
int caracter, indice = 0;
while (indice < cTamanhoDoArray - 1)
{
do {
caracter = Serial.read();
} while (caracter == -1);
Serial.write(caracter); // ecoar o caracter lido de volta para o terminal
entrada[indice] = caracter;
indice++;
if (caracter == terminador)
{
break; // sair do ciclo while se o caracter lido for o 'terminador'
}
entrada[indice] = '\0'; // terminar a string, com o caracter nulo (0)
}
}
Também pode haver problemas se o terminal estiver a enviar \n\r como terminador de linha; experimenta '\r' em vez de '\n' na leitura da última coordenada no teu programa.