-
Notifications
You must be signed in to change notification settings - Fork 0
Projeto Christina
Nesta Wiki irá conter a documentação de como está sendo desenvolvido o projeto e a progreção do robô.
Os componentes elétricos Parallax utilizados são os seguintes.
- HB-25 Motor Controller
- Motor Mount and Wheel Kit
- Position Controller Kit
Fora estes, também será utilizado: (Obs.: Esses são os componentes usados até o momento, é possivel que haja mudança)
- Bateria 12V
- Raspberry Pi 3
- Arduino UNO
O HB-25 é o contolador dos motores, também conhecido como ponte H. Ele será responsável por enviar a tenção para os motores, fazendo o acionamento deles, assim como sua velocidade.
O HB-25 possui 4 entradas de pinos, O B se refere ao GND, O R ao VCC (5V) e o W o pino de sinal. As conecções M1 E M2 são as ligações do motor, já o + e o - , são referentes a alimentação para o motor. É importante frisar que essa alimentação devera'ser entre +6VDC até +16VDC.
Esta ponte H apresenta dois modos de funcionamento. No seu primeiro modo, o que será o controle de apenas um motor, o pino J deverar está Jampiado. Para realizar o controle neste modo você precisará enviar um pulso PWM, o comprimento de onda desse pulso deverá está contido entre 0.8 a 2.2ms , se o comprimento de onda desse pulso estiver fora deste intervalo, a ponte H irá ignorar esse pulso. Para o envio de um novo pulso, deverá aguardar um período mínimo de 5.25ms caso contrário a ponte H não conseguirá receber o sinal adequadamente.
A segunda forma de controle, seria controlar mais de um motor utilizando um único controlador(Arduino pro exemplo). A ligação deverá ser feita como mostrado abaixo.
Lembrando sempre de remover o jumper da ultima ponte H.
Utilizando um Arduino como micro-controlador, podemos realizar testes de funcionamento do HB-25 ligado ao motor. Foi feita a seguinte ligação
Utilizei a fonte para gerar uma tenção de 12V para poder alimentar o os motores, e para enviar o sinal para controla-lô foi utilizado um arduino uno. O código que foi utilizado pode ser visto aqui. Os cabos do motor foram ligados respectivamente em seus locais demarcados, M1 e M2 , cuidado ao ligar a alimentação 12V, para não trocar a polaridade. E por ultimo, o arduino foi ligado no HB-25 nas portas B,R e W.
Após já ter conseguido fazer a ligação certa com o HB-25 é preciso entender um pouco como o motor funciona. ESte motor irá receber o pulso e dependendo de como for este pulso, ele se conforma de maneiras distintas. Como mencionei anteriormente, é preciso enviar um PWM que esteja contido entre 0.8 a 2.2 ms que irá interferir diretamente na velocidade e direção do motor. Fazendo uns testes rápidos, encontramos um esboço aproximado de gráfico de Velocidade por PWM.
Onde os picos do gráfico representa que, naquele valor de PWM(em milisegundos) a velocidade do motor será aproximadamente a máxima, em determinado sentido(horário ou anti-horário), que irá depender da posição em que você realizar a ligação dos motores. Ainda não foi feitos demais testes para que se possa concluir com exatidão estes valores, por esse motivo consideramos que são apenas valores aproximados.
Caso você queria apenas fazer o controle dos motores com os componentes apresentados até aqui e utilizando um sistema de encoder a parte já é possível, mas como iremos usar o sistema completo da Paralax, iremos utilizar o encoder dele para realizar a movimentação de Christina, abaixo descreverei como é feito sua utilização e envio de protocolos :)
Nosso ultimo componente a ser utilizado e o Position Controller, ou simplesmente encoder. Este controlador é utilizado para realizar a medição da quantidade de passos/giros que a roda do motor irá desempenhar, com essa informação temos como estimar a velocidade do carro, a posição em que ele se encontra no mapa e algumas outras informações.
Bem, primeiramente apresentando o encoder na imagem abaixo, note que ele tem duas fileiras de pinos "To controller", que no nosso caso será um arduino, a ligação será feito nessa duas fileiras de pinos. Os pinos DATA serão ligados nas portas RX e TX do arduino, para poder realizar a comunicação via serial entre eles.
A pinagem demarcada como "To HB-25" é destinada para a ligação a ponte-H, que foi vista no inicio desse documento. Ele será responsável por enviar o sinal a ponte-H, que por sua vez irá se comunicar com os motores e aciona-los, então utilizando esse encoder, não precisamos nos preocupar em nos comunicarmos diretamente com a ponte-H, já que o encoder já realiza essa comunicação por nós.
Sobre a comunicação com o encoder,temos que nos atentar a algumas configurações iniciais, a comunicação é feita por meio do protocolo UART(Caso queira saber mais sobre isso, basta clicar aqui), a frequência de comunicação entre a placa(no meu caso arduino) e o encoder deverá ser de 19.2Kbits/sec, além de garantir que os bits sejam sem paridade e tenha stop byts. Como estou utilizando o Arduino, só precisei configurar a frequência de comunicação, já que as demais configurações já vinheram configuradas por padrão.
Nessa seção vou explicar sobre a comunicação entre o encoder e o arduino, partindo primeiramente de envio de informação do arduino para o encoder.
No datasheat do encoder, podemos observar vários protocolos, vamos utilizar o protocolo de movimentação TRVL. Para um intendimento melhor sobre esse protocolo recomendo checar no datasheat. Mas em resumo, será enviado um numero 16bit de posições entre -32767<N<32767. Será enviado primeiro os 8 bits mais significativos e após isso, os 8 menos significativos.
Para evitar repetição de envio do código para o encoder, adicionei um botão, para que só seja enviado o código quando esse botão estiver em um, e um led para ver quando a informação for enviada. O código de teste se encontra aqui.
Com os testes com o botão funcionando, agora chegou o momento de montarmos o nosso código de controle geral. Eu decidi nesse código trabalhar com um protocolo interno meu, em que o controlador mandará esse protocolo para o arduino, que irá processar e passar as informações para o protocolo geral da Paralax. Para testes estou utilizando o display serial da IDE do arduino para enviar estes protocolos e testar se os parâmetros estão sendo bem interpretados.
Meu protocolo interno foi definido da seguinte maneira: Composto por 8 byts, o meu controlador mandará de uma vez só toda a informação. O primeiro byte será para definir qual protocolo interno(Paralax) será utilizado. O próximo byte será para definir qual é o motor que será utilizado. (0 para todos os motores, 1 para o motor de numero 1 e 2 para o motor de numero 2). O próximo será responsável por ditar o sinal da minha informação. Se ela é positiva e negativa, já que na função de travel um dos parâmetros poderá ser negativo. E por ultimo, os ultimos 5 byts são de informação. Como por exemplo no Travel, será a distância percorrida.
Como por exemplo, se meu controlador enviar para o arduino o seguinte protocolo : 41032768.
- O 4 será referente a qual protocolo interno estou requisitândo, que nesse caso é o quarto protocolo, o Travel.
- O 1 se refere a qual motor estou passando a informação, que nesse caso será o motor 1.
- O 0 Será para definir se o próximo valor será positivo ou negativo. Se for 0 será positivo, se for 1 será negativo.
- E por ultimo 32768 será a quantidade de giros que deverá ser dado pela roda.
O código para o controle está disponível aqui
Após varios testes, aqui é o mais longe que irei utilizando apenas o arduino. A próxima etapa é utilizar um raspberry para a comunicação I2C entre o rasp e o arduino. Desta forma terei alguams liberdades a mais, que não tinha antes só com o arduino (Como ter que deixar meu computador em Christina).
Fazendo um levantamento geral dos componentes e de seus sistemas fechados, eles funcionam bem em conjunto e o sistema de protocolo é bem consistente. Entretanto tive 2 problemas cruciais com esse kit, onde apenas um eu consegui resolver.
O primeiro é que, diferente de um motor convencional, não é possível controlar de forma direta a velocidade das rodas. Aqui, eu controlo a quantidade de pulsos que cada roda vai dar. E para uma aplicação de controle de percuso por exemplo, em que eu estou a todo momento controlando a velocidade das rodas e do robô, isso se torna problemático. Tendo que controlar a velocidade de forma indireta. Mesmo eu tendo uma função que altera a velocidade máxima de cada roda, ela não gera movimento nas rodas, então também necessito utilizar a função de movimento (travel) e passar uma quantidade de pulsos, o que dificulta bastante, por conta da leitura dos pulsos. Esta foi a solução que encontrei, pode não ser a melhor.
O que me leva para meu segundo problema, o qual não consegui corrigir e que é bastante serio. A função de leitura do encoder, teoricamente, me enviar a quantidade de pulsos que foram armazenados no buffer do encoder e com isso eu posso fazer minha odometria e também saber o quanto estou andando de fato. Mas como o barramento de leitura do encoder é o mesmo que o de escrita, eu não consegui fazer a sincronia entre eles, uma vez que eu tenho que enviar uma requisição de leitura e após isso, ler o retorno dela. Por não conseguir sincronizar isto, eu não consegui realizar a leitura do encoder. Então eu não sabia de fato quantos pulsos minha roda estava dando. Para contornar isto, tive que implementar um tipo de encoder virtual, queestá longe do ideal e faz com que meu erro suba muito mais rápido, mas foi a forma que encontrei para contornar este problema, já que não conseguia realizar de fato a leitura.
Irei continuar a trabalhar com Christina, só que utilizando uma estrutura mestre-escravo com o rasp. Então caso tenha interesse, basta acessar a próxima Wiki de Christina
https://www.parallax.com/downloads