Tempo de atualização do site
segunda-feira, setembro 29th, 2008 | Uncategorized | Nenhum Comentário
Bem pessoal, sei que o tempo de atualização do site esta meio lento, porem, este é um problema que todos os que trabalham entendem.
Neste fim de semana, eu tive tempo de testar a primeira idéia e durante a semana eu escrevo explicando melhor, mostro o código fonte e vou ver se faço um video para mostra melhor o robô.
Primeiros complicadores
segunda-feira, setembro 15th, 2008 | Uncategorized | Nenhum Comentário
Neste fim de semana, encontrei os meus primeiros complicadores, e o principal deles é um comportamento estranho da placa de controle SSC-32, que deveria ficar enviando um pulso de controle para o servo e manter o motor no lugar. O estranho é que depois de algum tempo, ela simplesmente para de fazer isto e o corpo do robô deita com o peso.
Uma alternativa é tentar resolver isto via software, fazendo com que a placa fique recebendo um “refresh” de todas as posições dos servos ligados. Outra alternativa e remover o microcontrolador ATmega 168 e fazer o meu próprio firmware. Que, embora esteja nos meus planos, não estou muito animado de fazer neste momento.
Acredito que nesta segunda-feira, eu tenha tempo de tentar resolver o problema, então, aproveitarei para deixar o código fonte explicado e partilhar, com o resto do mundo, possíveis soluções para o problema.
Alguém aqui conhece um bom caminho para se comprar FPGA barata em pequena quantidade, para que eu possa fazer uma pequena placa de controle para o Jonhy?
Primeiro teste on-line (passo a passo)
segunda-feira, setembro 8th, 2008 | Projeto Jonhy 5 | Nenhum Comentário
Mão do robô
Conforme prometido, segue abaixo uma descrição detalhada de como foi realizado o primeiro teste on-line de controle do robô.
Porém, antes de começar, tenha em mente que este foi um teste extremamente simples, apenas visando provar a possibilidade de interação entre um navegador web comum e o robô via internet.
Objetivo:
Fazer uma das mãos do robô alternar entre dois estados, aberto e fechado, através de uma conexão remota entre o navegador web e o robô com intermédio do Flash Media Server.
Os software usados na experiência são:
MDM Zinc 3.0 Builder;
Adobe Flash CS3;
Servidor Web;
Flash Media Server 1.0;
SSC-32 Sequencer;
Monitor de comunicação serial.
Primeiro teste - local
Antes de começar a programar, ligue o monitor de porta serial e em seguida o SSC-32 Sequencer que vem com o robô e descubra quais os dois valores usados para ‘mão aberta’ e ‘mão fechada’.
Acredito que não necessite falar que o servo da mão deva está ligado a placa de controle e a mesma ligada ao computador via porta serial com todos os valores de tensão corretos.
Uma boa dica é ter um amperímetro ligado a alimentação da placa de controle do robô, pois a subida da corrente indica quando os motores estão na posição errada e podem queimar.
No meu caso, os valores levantados são:
Mão aberta: 1981
Mão fechada: 1087
De posse desses valores, feche o programa SSC-32 Sequencer, abra o Adobe Flash CS3 e crie dois botões. Um botão abrir e outro botão fechar.
Abaixo segue o código ActinoScript 2.0 da aplicação:
mdm.COMPort.open(1, 115200, 8, "N", 1, "OFF");
abrir.onRelease = function ()
{
mdm.COMPort.send("#0P1981S1000\r");
}
fechar.onRelease = function ()
{
mdm.COMPort.send("#0P1087S1000\r");
}
Publique a aplicação e em seguida abra o MDM Zinc 3.0 Builder para gerar a sua aplicação. (Não esqueça de habilitar o componente mdm_comport)
Com está aplicação extremamente simples, você vai fazer o teste de comunicação serial entre a sua aplicação e o robô, apenas para garantir que este passo do processo está sem problemas.
Caso haja algum problema, veja se os jumpers da placa estão configurados corretamente e verifique os dados da porta serial, eles devem bater com os gerados previamente com o programa SSC-32 Sequencer.
Segundo teste - remoto
Antes de continuar, eu estou partindo do princípio que você sabe o básico sobre o Flash Media Server. Porém, não se preocupe, a aplicação que deve ser colocada no servido é um arquivo em branco. Nenhum componente ou configuração foi usado para esta aplicação.
Como o teste é extremamente simples, a mesma aplicação gerada pelo Flash será usada no servidor web (arquivo html e swf) e no robô (programa executável gerado pelo MDM Zinc).
Aproveite a mesma aplicação gerada no teste anterior e use o seguinte código ActionScript 2.0:
mdm.COMPort.open(1, 115200, 8, "N", 1, "OFF");
var vgsoUser :SharedObject = new SharedObject ();
var vgnconConnection :NetConnection = new NetConnection ();
vgnconConnection.connect ("rtmp://sevidor.mediaservices.ws/aplicacao", "web", "web");
vgnconConnection.onStatus = rmtpOnStatus;
function rmtpOnStatus (vraStatus :Array)
{
for (var i in vraStatus)
{
if (vraStatus[i] == "NetConnection.Connect.Success")
{
vgsoUser = SharedObject.getRemote ("userConect", vgnconConnection.uri, null);
vgsoUser.connect (vgnconConnection);
vgsoUser.maoAbrir = maoAbrir;
vgsoUser.maoFechar = maoFechar;
}
}
}
function maoAbrir ()
{
mdm.COMPort.send("#0P1981S1000\r");
}
function maoFechar ()
{
mdm.COMPort.send("#0P1087S1000\r");
}
abrir.onRelease = function ()
{
vgsoUser.send ("maoAbrir");
}
fechar.onRelease = function ()
{
vgsoUser.send ("maoFechar");
}
Aplicação final
Em seguida, publique a sua aplicação no Flash e no MDM Zinc para gerar os dois aplicativos, o on-line e o executável.
Como os dois aplicativos são iguais, mas, apenas o gerado pelo MDM Zinc pode se comunicar com o robô, os comandos do MDM serão ignorados pelo aplicativo rodando on-line.
Em seguida, feche todo e qualquer aplicativo que possa está acessando a sua porta serial e deixe apenas o monitor serial ligado. Envia a sua aplicação Flash para o seu servidor web e execute a aplicação de controle no computador do robô.
Faça o teste no aplicativo do robô primeiro e veja se ele está funcionando, em seguida, entre no seu servidor web e faça o mesmo teste.
Dicas para debugar a sua aplicação:
Vá no Stage de sua aplicação e crie uma caixa de texto, html, com borda, tipo dinâmico e de o nome de instância igual a ‘teste’. Esta será a sua área de Trace ();
Dentro das funções onRelease coloque a seguinte linha:
_root.teste.htmlText += "function onRelease entrou<br>";
Dentro do bloco if (vraStatus[i] == “NetConnection.Connect.Success”), coloque:
_root.teste.htmlText += vraStatus[i] + "<br>";
Esta última linha vai mostrar todas as mensagens de conexão do Flash Media Server.
Tenha certeza de ter colocado o endereço certo do servidor de mídia e o nome correto da aplicação.
Conclusão:
Embora a aplicação seja extremamente simples, ela cumpre com o objetivo de provar que comandos passados pelo navegador podem controlar hardware a distância.
Levantamento do protocolo (V1)
domingo, setembro 7th, 2008 | Projeto Jonhy 5 | Nenhum Comentário
Placa de controle SSC32
Como nesta primeira fase do projeto, vou usar a placa que veio junto no kit, primeiramente eu tenho que levantar o protocolo e fazer os primeiros testes de comunicação.
Como a placa ainda usa a boa e velha porta serial, que eu tenho muita prática no uso, instalei um monitor de comunicação serial. Mas, antes de instalar o programa que tem no site, procure nos sites de downloads que você irá encontrar uma versão freeware.
Antes de continuar, todos os códigos apresentados abaixo são escritos em ActionScript 2.0 (Leia “Primeira fase (V1)“), ou proprietários da MDM para serem usados com MDM Zinc Builder 3.0.
Pegar a versão da placa de controle:
Primeiro crie no stage da sua aplicação Flash, uma área de texto dinâmica, html, com quebra de linha, borda e instâncie com o nome “teste”. Está será nossa área de “trace ()” para os testes.
//Inicie e limpe a área de trace:
_root.teste.htmlText = “”;
//Inicie a porta serial conforme os jumpers de controle da sua placa. No nosso caso, COM1, baud rate de 115200 bps, oito bytes de dados, sem paridade, um stop bit e sem controle de fluxo.
mdm.COMPort.open(1, 115200, 8, “N”, 1, “OFF”);
//Crie uma função para receber a resposta da placa
mdm.COMPort.onCOMPortData = function(myObject:Object)
{
_root.teste.htmlText += myObject.data + “<br>”;
}
//Transmita o comando
mdm.COMPort.send(”VER\r”);
A resposta encontrada no área de trace para a minha placa foi:
SSC32-V2.01XE\r
Movendo os servos:
Programa de controle individual por servo
Embora a tela seja muito carregada de informações, lembre-se que a placa pode controlar até 32 servos por vez, mas, as informações que você vai necessitar são apenas três:
Porta: 0 - 31;
Posição: 500 - 2500 (para controlar os valores máximos e impedir que o motor queime por besteira, primeiro levante os valores mínimos e máximos por servo usando o programa de controle original e só depois de levantar estes valores, passe-os para seu programa)
Velocidade: O programa original aceita uma gama muito grande de valores e você vai ter que testar na prática. Este é o valor que define a velocidade com que o movimento vai ser executado e é calculado em uS.
O exemplo de comando seria:
mdm.COMPort.send(”#0P1500S0\r”);
ou
mdm.COMPort.send(”#0P1500#1P1000#2P500S500\r”);
Perceba que o segundo exemplo move mais de um servo ao mesmo tempo, porém, tenha em mente que o movimento sempre vai começar e terminar ao mesmo tempo para todos os servos.
Uma grande dica que não lembro de ter visto no manual é que passando a posição zero para o motor, o mesmo é desligado. Ex.:
mdm.COMPort.send(”#0P0\r”);
Requisição de status:
Deve retornar + (mais) caso a placa ainda esteja executando um movimento ou . (ponto) caso a placa esteja livre.
O exemplo de comando seria:
mdm.COMPort.send(”Q\r”);
Conclusão:
Caso você necessite, existe um manual do protocolo no site da Lynxmotion, porém, nem todos os valores que encontrei na prática, batem com os valores escritos no manual e como no meu tipo de aplicação, memória não é muito crítica, vou deixar o controle de posicionamento da placa por conta do meu programa e ignorar comandos como o “QP<argumento>” que fazem a placa de controle retornar uma posição aproximada do motor.
Na prática, a posição é aproximada, pois o retorno é um binário de 8 bits, ou seja, o dígito menos significativo da posição é perdido. Exemplo: um comando de posição 1500 vai retornar 150, uma vez que 8 bits em binário só vai de 0 a 255.
O bom, é que acabei de colocar a placa no ociloscópio e uma vez que você passa uma posição para o servo, a placa mantem os pulsos de controle do servo.
A escolha de um cérebro
domingo, setembro 7th, 2008 | Projeto Jonhy 5 | Nenhum Comentário
Primeiramente, pensei em fazer uma placa de circuitos do zero, usando um ARM7 da Philips, porém, me deparei logo de cara com a dificuldade de conectar uma webcam usb a placa e ao fato de ter que montar um driver novo a cada modelo de câmera usada, então deixei está idéia de lado e aposentei o meu kit de desenvolvimento ARM7.
A solução que encontrei, foi o uso de uma mini placa-mãe Pico-ITX que tem o tamanho aproximado de um DH 2.5”, normalmente usado em note books, e ainda traz a vantagem de ser um PC, padrão x86, completo.
As principais características são:
Quatro portas USB;
Uma porta serial;
Uma saída VGA e outra DVI (no windows, está rodando muito bem com dois monitores);
Uma porta SATA e uma IDE (poderiam ser duas SATA);
Aceita 1GB de RAM, mas, no meu caso só reconheceu 512MB e o pente tem que ser 533MHz, o que está ficando meio complicado de encontrar;
Primeiramente, fiquei impressionado com o tamanho ao abrir a caixa. Ela é muito menor de perto do que o que eu tinha imaginado, pena que os conectores sejam muito grandes, em relação a placa, e terminem atrapalhando a montagem.
De cara, imaginei que teria problemas de sobreaquecimento, já que a maior parte da placa é um cooler, porém, ela não esquenta e a temperatura do cooler não muda.
A fonte de alimentação escolhida é uma M3-ATX que é extremamente pequena e tem uma potência de 125W, agüentando até 150W de pico.
Quanto a escolha da fonte, eu não sabia exatamente o consumo total do conjunto e quais as minhas necessidades, então escolhi a melhor que encontrei. As principais características são:
Alimentação simples de 6V a 24V (Mas, não adianta usar em caminhões ou ônibus, 26V é a tenção máxima absoluta);
Configurável via jumper ou cabo serial;
Saída para o controle de liga / desliga da placa-mãe;
Monitora a chave de ignição do carro para ligar / desligar a placa de forma automática, garantindo que a placa permaneça ligada enquanto for alimentada. Na prática, ela aperta o botão de power da placa sempre que a corrente baixa, ou seja, sempre que o OS é desligado.
No momento, ela está montada com um HD IDE 2.5” de 80GB, agradecimento especial a Hiltom e um gravador de DVD SATA, além de dois monitores e um monte de periférico na porta USB. A fonte está sendo alimentada com 14V DC e o consumo varia entre 0.85A e 1.25A para uso normal, e chega a 2.10A na gravação de um DVD.
Como a potência total é muito elevada para as baterias que tenho acesso no momento, ainda não sei como vai ser feito para que Jonhy funcione sem cordão umbilical.
Quanto ao desempenho, ao contrário dos PCs de grande porte, ela se comporta melhor no WinXP do que no Ubuntu.
Arquivo
Links
Enquete
Loading ...