Carritos

### **Resumo**

Projeto para construir carrinhos micro controlados com arduino e usando controle remoto via rádio frequência (RF).

### **Software/materiais utilizados**

Foram feitos dois conjuntos de carrinho/controle remoto, a lista abaixo é para um conjunto.

**Controle remoto:**

* Arduino UNO
* Joystick shield
* Transceiver NRF24L01
* Caixinha de mdf
* Bateria de 9 volts
* Conector para bateria
* Interruptor liga/desliga

.
**Carrinho:**

* Arduino Nano
* Placa padrão
* Módulo drive para motores baseado no chip L298
* 2 rodas
* 2 motores DC com redução
* Transceiver NRF24L01
* Adaptador para NRF20L01
* 2 baterias Li-ion 18650
* Case para as baterias
* Interruptor liga/desliga
* Placas de madeira de balsa
* Rodízio para roda boba dianteira
* Fios e jumpers para as conexões
* Garrafa pet de 2 litros para a carenagem

.
**Variados:**

* Parafusos com porca
* Ferro de solda
* Solda
* Régua e estilete
* Braçadeiras de plástico
* Cola de madeira

.
**Software**

* IDE do arduino
* Bibliotecas disponíveis em Bibliotecas para arduino
* Classes desenvolvidas para este projeto

### **Metodologia**

O carrinho usa dois motores DC em configuração diferencial, desse modo não é preciso uma roda de direção. O transceiver instalado no carrinho recebe os comandos do controle remoto e repassa para o arduino nano. No arduino roda o programa de controle do carro. O controle remoto conta com um arduino UNO com um shield que contém um joystick, quatro botões e o alojamento para o transceiver NRF24L01. Sendo um transceiver, este módulo pode tanto transmitir quanto receber transmissões, mas neste projeto o módulo do controle remoto só transmite e o módulo do carro só recebe.

### **Desenvolvimento**

O primeiro desafio foi construir a estrutura básica do carro, o chassi. Para isso foram usadas as placas de madeira de balsa. Também foram instalados os motores, os cases para as baterias e o rodízio. Para fixar os motores foram utilizadas braçadeiras de plástico (figuras 1 e 2).

A princípio a ideia era deixar o chassi como aparece na figura 2, mas como havia madeira sobrando, resolvi fazer uma cobertura para o chassi. Essa cobertura permitiu melhorar o acabamento escondendo os parafusos de fixação e ao mesmo tempo proporcionou mais espaço para a fixação de módulos no carro (figuras 3 e 4). Essa cobertura é destacável, não foi colada, são as braçadeiras que fixam os módulos que a mantém presa ao chassi.

A seguir foi feita a placa principal, que contém o arduino nano. A fim de economizar espaço (e verba), foi usada uma placa com furação padrão. Para o arduino foram usados conectores verticais (figura 5). A placa recebe a alimentação das baterias e dela saem os fios para o drive dos motores e o adaptador do transceiver (figura 6).

O passo seguinte foi montar todas as placas no chassi e finalizar as conexões. Foi instalado também o interruptor geral para o carro (figura 7). Nesse ponto o carro ainda não funciona, mas o fato de todos os leds terem acendido indica que as conexões estão corretas.

**Controle remoto**

Com o carrinho pronto, foram feitos testes de transmissão de comandos do controle remoto para o carrinho. Como os primeiros testes foram bem sucedidos, iniciei a montagem final do controle. O controle utiliza um shield para arduino UNO que já vem praticamente pronto, basta encaixa-lo no arduino (figura 8). No entanto, para que funcione sem cabos conectados ao computador é preciso providenciar uma fonte de alimentação. Para alimentar o conjunto, foi usada uma bateria de 9 volts (figura 10). Para conter todo o conjunto, foi usada uma caixinha de mdf adquirida em uma loja de artesanatos (figura 9).

Para ajustar melhor o controle à caixinha, foram usados retalhos de madeira de balsa. Também foi instalado um interruptor liga/desliga na caixinha (figura 11).

**Carenagem**
Para dar um toque mais aerodinâmico ao carrinho e também para proteger os dispositivos instalados nele, foi feita uma carenagem usando uma garrafa pet de 2 litros (figura 12 e 13).

**Programação**
Para controlar o carrinho foi declarada a estrutura abaixo, essa estrutura é enviada ao carro sempre que algum botão é pressionado ou os eixos do joystick são movidos:

```
// Estrutura para comandos
typedef struct
{
  byte cmd;
  int param1, param2;
}
CarCommand;

```

O campo **cmd** é usado para especificar o tipo de ação e os campos **param1** e **param2** para enviar parâmetros relacionados à ação. Na prática, apenas o movimento no joystick é que usa esses parâmetros. Abaixo a lista de ações que foram usadas no código:

```
// Comandos
#define cmdTest       1  // Apenas para testes
#define cmdSpeedUp    2  // Botão UP, marcha acima, aumenta a velocidade de referência
#define cmdSpeedDown  3  // Botão DOWN, marcha abaixo, diminui a velocidade de referência
#define cmdCurveLeft  4  // Botão LEFT pressionado, curva à esquerda
#define cmdCurveRight 5  // Botão RIGHT pressionado, curva à direita
#define cmdCurveOff   6  // Botão LEFT ou RIGHT liberado, retorna ao movimento retilíneo
#define cmdStopNow    7  // Botão do joystick, parada de emergência
#define cmdXYaxis     8  // Eixos do joystick, move (se estiver parado) ou aumenta/diminui a intensidade do movimento

```

**Teste de desempenho**
Depois de feita a programação básica foi feito um teste de movimento. Abaixo o vídeo com um dos primeiros testes:

## Resultados

Depois de efetuados os testes foram detectados alguns problemas. Abaixo os problemas encontrados e as soluções implementadas.

**1. Preservação das baterias de Li-ion**
As baterias de Li-ion não podem ser completamente descarregadas. Se a carga delas cair abaixo de um limite, elas perdem a capacidade de recarga, o que representa prejuízo e desperdício. Uma solução seria instalar um voltímetro no carro, mas essa solução não seria tão eficiente, já que o projeto tem a intenção de ser utilizado por crianças (no caso, meu filho de 6 anos).

A solução implementada foi instalar um divisor de voltagem na entrada da alimentação que reduz a voltagem pela metade (figura 14). As baterias completamente carregadas fornecem 8 volts, na saída do divisor é obtida uma voltagem máxima de 4 volts, o que é apropriado como entrada para os pinos analógicos do arduino. Conforme a carga das baterias vai caindo, a saída no divisor de voltagem cai na mesma proporção. Isso permite que a carga seja monitorada pelo arduino. Também foi instalado um led que mostra o nível de carga das baterias. O programa no carro fica monitorando o pino conectado ao divisor de voltagem. Se a carga estiver acima de 6.8 volts, o led fica aceso direto. Abaixo desse limite passa a piscar devagar. Se cair abaixo de 6 volts, o led pisca bem rapidamente e o carro deixa de funcionar, obrigando o usuário a trocar as baterias.

**2. Derrapagem das rodas**
A borracha usada nos pneus das rodas é excessivamente rígida, o que acaba provocando derrapagem em várias situações, principalmente em solos muito lisos. Isso compromete a qualidade do movimento. A fim de aumentar a aderência dos pneus, foram colocados pequenos elásticos na rodas (figura 15). A melhora nos movimentos foi bem expressiva.

**3. Economia da bateria de 9 volts**
A parte que mais gasta energia no controle remoto é o rádio NRF24L01. Como em todo transmissor de rádio, o alcance depende da potência de transmissão. Quanto maior a potência, maior será o gasto de energia. A primeira bateria usada nos testes não durou muito, o que sugere que o consumo estava alto, embora não fosse uma bateria nova. De qualquer maneira, economizar energia é sempre uma boa ideia. Uma solução intuitiva seria diminuir a potência do transmissor, já que esse módulo oferece três níveis de potência, mas isso também diminuiria o alcance do rádio. Pesquisando um pouco mais, descobri que o rádio pode ser colocado em modo ***stand by***, e nesse modo o consumo de energia despenca para menos de um décimo do consumo normal. O problema é que em modo ***stand by*** o rádio não consegue receber ou transmitir mensagens. Mas como o controle remoto apenas transmite e não recebe nada, isso não é realmente um problema. Então a solução encontrada foi deixar o rádio sempre em modo ***stand by*** e apenas quando é feita uma transmissão o rádio é colocado de volta no modo de operação. Abaixo o método que envia mensagens pelo rádio.

```
void sendCommand(byte cmd, int param1, int param2=0){
    CarCommand cc;
    cc.cmd= cmd;
    cc.param1= param1;
    cc.param2= param2;
    powerUp();                // "Acorda" o rádio
    delay(5);                 // Espera ele acordar completamente
    sendPayBuff((byte*)&cc);  // Envia a mensagem
    powerDown();              // Coloca o rádio para dormir novamente (modo stand by)
  }

```

## Conclusão

O projeto foi executado com sucesso, com os objetivos propostos atingidos. Os problemas detectados durante a execução e testes foram solucionados a contento. Também foi possível identificar aperfeiçoamentos e upgrades que podem vir a ser implementados no futuro, por exemplo, pode ser instalado um sensor de proximidade por infravermelho na dianteira e assim fazer com que o carrinho pare antes de colidir com algum obstáculo. Com certeza seria um melhoramento que aumentaria sua vida útil.

Também vale destacar a importância do projeto como aprendizado, graças a ele, pude aprofundar meu conhecimentos sobre arduino e sobre os dispositivos envolvidos. Com certeza esse conhecimento será útil na execução de outros projetos mais complexos.

Mas este projeto ainda não passou pelo seu teste final que determinará sem nenhuma dúvida se foi um sucesso ou não. O teste definitivo é saber se os usuários finais, meu filho de 6 anos e seu amigo, irão aprovar e se divertir com estes carrinhos. Se gostarem, aí considerarei que o projeto foi um sucesso completo.