Calendário DIY
Protótipo Cadeira de Rodas Inteligente
Aldeir
Pontos:  22
Desde:  29/09/2014
Finalizado
Nível avançado
x 0
Favoritado
Em:  30/09/2014   ( 30/09/2014 )
Domínio Público
Estrela vazia
0
1
2
3
4
5
Protótipo de uma cadeira de rodas elétrica de baixo custo, automatizada com Arduino e programada para detectar, alertar e impedir uma possível colisão da cadeira com obstáculos em seu caminho. Todos os componentes utilizados neste projeto, com exceção do Arduino e dos sensores ultrassônicos foram reaproveitados de sucata de eletrônicos. Além do lado acadêmico este trabalho também teve um lado humanista voltando o uso de tecnologias de diversas áreas para o desenvolvimento de técnicas para facilitar a vida de pessoas que por algum motivo tiveram sua capacidade de locomoção parcialmente reduzida ou completamente comprometida e, além disso, ainda tem alguma deficiência visual, motora ou cognitiva que os impossibilitem de controlar uma cadeira de rodas motorizada. O protótipo produzido e apresentado neste trabalho é apenas uma amostra que se pode conseguir grande sucesso nesta área, através do uso de micro controladores com maior poder computacional e sensores com maior precisão.
Este projeto está participando do concurso: Arduino 10 Anos.
1
DESENVOLVIMENTO DO HARDWARE
        O termo hardware aqui mencionado diz respeito a todo componente físico utilizado no desenvolvimento do protótipo da cadeira de rodas motorizada, os principais são os componentes eletrônicos como o Arduino, sensores, Ponte H, motores, LEDs, buzzer e baterias que terão seu funcionamento diretamente influenciado pelo software. Também faz parte do hardware a estrutura em que estes componentes foram montados como o chassi e as rodas do protótipo. Na figura A é possível ver o protótipo pronto com todos os componentes conectados.

        Para facilitar o entendimento de como os componentes eletrônicos estão conectados entre se, foi feito um diagrama que pode ser visto na Figura B. Explicações sobre cada um dos itens presentes no diagrama, assim como a justificativa de sua escolha e sua importância dentro do trabalho podem ser vistas nos tópicos seguintes.
 
2
Arduino
        O primeiro item a se definir para o início do trabalho foi o micro controlador, peça de primordial importância, pois é ele quem hospeda o software que foi implementado e é de acordo com suas características que os demais componentes de hardware foram escolhidos, assim como a linguagem de programação utilizada.
Tendo isso em mente e depois de analisar algumas características dos micro controladores disponíveis no mercado conclui-se que o Arduino Uno (versão mais recente da plataforma Arduino) seria ideal para o projeto, pois seu hardware e software são abertos, ou seja, livre para que qualquer pessoa que tenha interesse, possa utilizar e modificar sua estrutura sem se preocupar com direitos ou patentes. Outros pontos que favoreceram a escolha do Arduino foi sua facilidade de uso, preço baixo e por ser facilmente encontrado no mercado. Além disso, o Arduino, devido a sua grande popularidade, dispõe de uma imensa gama de dispositivos, sensores e atuadores, compatíveis com seus padrões que também são facilmente encontrados no mercado.
        A função do Arduino neste projeto é captar os sinais gerados pelos sensores, analisa-los e de acordo com o que foi programado em seu microprocessador, ativar, desativar ou regular o funcionamento dos atuadores nele conectados. Detalhes de como cada sensor e atuador é controlado pelo Arduino são especificados nos próximos tópicos, quando se discorrer especificamente sobre cada um deles.
Na Figura A é possível observar a placa Arduino usada neste trabalho.
 
3
Sensor Ultrassônico e Infravermelho
        Os sensores utilizados foram três, sendo dois deles ultrassônicos representados no diagrama de blocos da Figura B do Passo 1 como Sensor Ultra1 e Sensor Ultra2, e o terceiro sendo um sensor infravermelho, representado como Sensor IR no mesmo diagrama.
Os sensores ultrassônicos tem um papel de fundamental importância na percepção do ambiente, pois são eles que verificam a existência de algum obstáculo no percurso da cadeira. Existem outros tipos de sensores que poderiam desempenhar este papel, como o sensor de distância infravermelho, mas neste trabalho, em particular, foi mais apropriado o uso do sensor ultrassônico por sua maior abrangência em relação a objetos detectados. O sensor ultrassônico consegue perceber objetos de várias formas, cores e texturas diferentes que estejam em seu campo de atuação, diferente do sensor infravermelho, que apresenta dificuldade de perceber objetos translúcidos ou em ambientes onde exista a incidência de luz solar.

        De uma forma geral todos os objetos que apresentarem as características que permitam refletir a radiação ultrassônica serão percebidos pelo sensor, englobando assim grande parte dos obstáculos que possam se interpor no caminho percorrido por uma cadeira de rodas. O modelo de sensor ultrassônico utilizado foi o HC-SR04 2 que pode ser visto na Figura A.
        Já na Figura B é possível observar como os sensores foram ligados ao Arduino para receber corrente elétrica e transmitir informações. Nesta mesma Figura também é possível observar quais portas digitais foram utilizadas para comunicação entre Arduino e sensores.
        O pino VCC do sensor foi ligado ao pino 5 volt do Arduino e o pino GND do sensor foi ligado ao pino terra do Arduino, ligações estas que permitem a alimentação do sensor pelo próprio Arduino. Para transferência de informações, o pino Trig dos sensores foram ligados as portas 4 e 8 do Arduino e o pino Echo às portas 2 e 7.

O uso dos dois sensores ultrassônicos tem a finalidade de se monitorar o que estiver a frente e abaixo do protótipo. O sensor1 foi fixado na horizontal de modo que monitora tudo que estiver a frente da cadeira e a uma distância de até sete metros. O sensor2 foi fixado na posição vertical e a frente das rodas dianteiras do protótipo ficando a 10 centímetros do solo e tem a função de detectar buracos ou protuberâncias no piso.
O sensor infravermelho, ou sensor IR (Infra Red) como está representado no diagrama de blocos na Figura B do Passo 1, foi utilizado para desempenhar função diferente dos sensores ultrassônicos, sendo usado para receber instruções que permitam controlar o protótipo a distância, através de um controle remoto convencional. Na Figura C é possível ver em diversos ângulos o sensor infravermelho utilizado para captar os sinais enviados pelo controle remoto.

        Nas cadeiras de rodas motorizadas comuns estes comandos são realizados através de um Joystick fixado em um dos braços da cadeira e o usuário tem o controle da direção e velocidade do veículo através dele. Como o protótipo desenvolvido tem suas dimensões reduzidas, ele não tem capacidade para transportar o indivíduo que irá controla-lo, então, optou-se por utilizar um controle remoto para realizar tal tarefa.
        Os controles remotos mais utilizados no dia a dia para controlar equipamentos eletrônicos como TVS, DVDs, aparelhos de som entre outros, são controles que usam a tecnologia Infravermelha para transmissão de dados e é justamente por este motivo, aliado ao baixo custo e relativa simplicidade de uso que esta tecnologia foi utilizada no protótipo. A Figura D mostra o Controle remoto modelo PCR-96 produzido pela Philco utilizado no trabalho. 
       Este controle remoto originalmente é utilizado em aparelhos de som da Philco sendo que neste trabalho apenas alguns botões serão utilizados, para determinadas tarefas, desta forma, os demais botões não possuem função no controle do protótipo. Os botões utilizados assim como a função que ele desempenha no controle do protótipo são:
  •  Seta para cima: Protótipo movimenta se para frente.
  •  Seta para baixo: Protótipo movimenta se para trás.
  •  Seta para direita: Protótipo movimenta se para direita.
  •  Seta para esquerda: Protótipo movimenta se para esquerda.
  •  CD: Calibra o sensor vertical.
  •  TAPE: Calibra o sensor horizontal.
  •  POWER: Ativa/desativa os sensores.
  •  MUTE: Controla a velocidade.
        Neste controle remoto para cada botão existem dois códigos que são emitidos alternadamente quando se pressiona o botão. Desta forma ao se pressionar um botão pela primeira vez o controle envia um código ao receptor ou se pressionar este mesmo botão uma segunda vez o controle envia um segundo código alternando entre estes dois códigos toda vez que botão for pressionado. Os códigos emitidos por cada botão pressionado no controle serão vistos quando se tratar do desenvolvimento do software no próximo capítulo.
A Figura E mostra como o sensor IR foi ligado à porta 13 do Arduino e também ao pino GND e ao pino 5v, que fornecem alimentação ao sensor.

        Um resistor de 220 ohms foi ligado em série com a entrada positiva de energia do sensor, para restringir o fluxo de corrente, evitando sobrecargas. Já um capacitor de 0,1 μF foi ligado em paralelo à entrada de alimentação para filtrar possíveis interferências, que prejudicariam o correto funcionamento do sensor.

 
4
Ponte H
        A Ponte H é o circuito eletrônico utilizado em automação para controlar o sentido de rotação e/ou a velocidade de giro dos motores de corrente continua. Como o protótipo da cadeira de rodas deve conseguir se deslocar tanto para trás como para frente e ter sua velocidade de deslocamento controlada, o uso da Ponte H se fez necessário.
        Basicamente, a Ponte H controla o sentido e a quantidade de corrente elétrica da bateria a ser repassada aos motores do protótipo, de acordo com os sinais enviados pelo Arduino. Ou seja, a Ponte H é um item intermediário entre o Arduino e os motores, funcionando também como um circuito de proteção para o Arduino uma vez que os motores não podem ser ligados diretamente ao Micro controlador, sobre o risco de danificá-lo, pois os motores consomem uma correte elétrica muito acima daquela que as portas do Arduino podem oferecer.
No protótipo foram utilizadas duas Pontes H, uma para cada motor e optou-se por montá-las a partir de componentes discretos: transistores, diodos e resistores já que estes componentes são facilmente encontrados em placas de equipamentos eletrônicos que estão em desuso, podendo assim ser reaproveitados para a montagem da mesma. Na Figura A é apresentado o diagrama do circuito elétrico usado na montagem da Ponte H.

        Os transistores Q1 e Q3, modelo BC558 e Q2 e Q4 modelo BC548 funcionam como chaves e são ativados ou desativados de acordo com os sinais enviados pelo Arduino, através de suas portas digitais, que chegam à Ponte H pelas entradas 1 e 2. Os diodos modelo IN4004 ligados em paralelo aos transistores, tem a função de protegê-los de uma possível corrente reversa gerada pelas bobinas do motor. Já os quatro resistores de 220 ohms foram utilizados para se reduzir a corrente na base dos transistores, para limitar a quantidade de corrente demandada das portas digitais do Arduino, que só podem fornecer no máximo 40 miliamperes, sendo que valores acima deste, podem danificar o micro controlador. Na Figura B é possível ver a Ponte H em vários ângulos depois de pronta.
        Já na Figura B é visto como os diversos componentes da ponte H foram interligados entre si e entre os demais componentes do hardware.
Figura 32.

        As portas utilizadas foram 5, 6, 9 e 10 do Arduino, escolhidas por forneceram sinal PWM, importante para o controle da velocidade do protótipo. É possível observar que existe uma fonte exclusiva de energia para ponte H e consequentemente para os motores, pois eles estão conectados a ponte H e consomem bem mais corrente do que o micro controlador, tornando inviável o fornecimento de corrente elétrica através do Arduino sobe o risco de danifica-lo.
        A ponte H que controla o motor direito teve suas conexão ligadas às portas 5 e 6 do Arduino, já A ponte H que controla o motor esquerdo teve suas conexões ligadas às portas 9 e 10.

 
5
Motores
        Para a locomoção do protótipo, a intenção inicial era utilizar dois motores de corrente contínua, um para cada roda traseira. Entretanto, uma das características dos motores de corrente continua é apresentar uma alta velocidade de giro e um pequeno torque, o que o tornaria inviável para o uso no protótipo, que deve se deslocar em baixa velocidade, uma vez que simula o funcionamento de uma cadeira de rodas motorizada normal, que se desloca devagar e possui um alto torque.
        Para resolver este problema nas diferenças de giro e torque, o motor deve estar acoplado a uma caixa de redução de giro, que faz a inversão destes valores, reduzindo a velocidade de giro e aumentando o seu torque através de engrenagens. No mercado podem ser encontrados alguns motores que já vem com esta caixa de redução acoplada, mas para se obter o efeito pretendido, neste trabalho foram usados dois servos motores utilizados em antenas receptoras de TV via satélite.
        Os servos motores possuem uma limitação de giro do seu eixo, sendo que na maioria das vezes só pode girar 180º. Para serem usados no protótipo, eles passaram por uma adaptação, onde foi retirada uma trava presente em uma das engrenagens de redução de giro (vista na Figura A-A), o interior de um potenciômetro (visto na Figura A - B), assim como sua placa de controle (visto na Figura A - C).

        Após estas adaptações, o servo motor se transformou em um motor de corrente contínua, com uma caixa de redução acoplada, exatamente o que era necessário para o protótipo. A Figura B mostra como os motores foram adaptados na estrutura do protótipo e como as rodas foram encaixadas diretamente no eixo de saída da caixa de redução do motor.

        Os motores foram ligados à ponte H e esta por sua vez, foi ligada ao Arduino e as baterias. O esquema desta ligação pode ser conferido na Figura 32 do tópico anterior.

 
6
Buzzer piezoelétrico
        No protótipo, o buzzer foi usado com a finalidade de emitir sinais sonoros de alerta (bips). A opção de utilizar o buzzer piezoelétrico e não um alto-falante comum por exemplo, foi devido a seu tamanho mais compacto, maior robustez e uma maior eficiência na reprodução de sons na faixa de frequência que estão os sinais de alerta. Sendo que o buzzer em relação a um altofalante consegue produzir um efeito sonoro mais elevado desses sinais de alerta a partir de uma entrada de mesma intensidade. O sinal variante que fará o buzzer produzir som será gerado pelo Arduino, sendo que o tom e a duração destes sinais dependerá da programação feita no micro controlador.

        Na Figura A é visto a ligação do buzzer a porta 13 do Arduino, em série com uma junção de dois resistores de 100 ohms cada, ligados em paralelo, gerando assim uma resistência de 50 ohms. Esta junção dos resistores foi usada porque não foi encontrado um único resistor com resistência próxima a este valor. Esta resistência é importante para limitar a corrente consumida pelo buzzer e não danificar a porta do Arduino.
 
7
LEDs
        No protótipo, foram utilizados dois LEDs de cores diferentes, um que emite luz na cor vermelha e outro na cor verde. O vermelho é acionado como forma de alerta quando algum obstáculo é detectado pelos sensores do protótipo. Já o que emite luz na cor verde foi utilizado para sinalizar a recepção de sinal pelo sensor infravermelho, isto é importante para que se possa constatar o correto funcionamento do controle remoto.
Os LEDs utilizados medem 5mm e tem formato cilíndrico, foram ligados ao Arduino em paralelo a um resistor de 330 ohms para limitar a corrente que circula entre seus polos evitando possíveis danos aos mesmos por sobrecarga. O LED de cor vermelha foi ligado a porta 2 do Arduino e o de cor verde a porta 11 conforme visto na Figura A.
 
8
Baterias
        Para a alimentação do protótipo, optou-se pelo uso de baterias, uma vez que o mesmo deveria se movimentar livremente, e o uso de uma fonte de energia proveniente da rede elétrica o deixaria limitado a conexões com o cabo de energia. Para alimentar o Arduino foi utilizada uma bateria de 9 volts comum e para alimentação da ponte H e motores foram utilizadas três pilhas pequenas em série totalizando 4,5 volts.

        A Figura A mostra como as baterias foram adaptadas ao interior do protótipo e ligadas a uma chave, que tem a função de ligar e desligar a alimentação do protótipo.
 
9
Montagem da estrutura do protótipo
        O chassi do protótipo foi feito a partir de uma estrutura plástica onde foram adaptados os motores com as rodas traseiras, as rodas dianteiras e uma armação feita com fios de cobre de 6 mm, moldados e soldados em formato de uma cadeira, como pode ser visto na Figura A.

        Em seguida, foi acoplada a esta estrutura uma haste para a sustentação dos sensores ultrassônicos. Nesta haste foram presos conectores, permitindo que os sensores possam ser facilmente encaixados e desencaixados.

        A armação de fios de cobre em forma de cadeira e a estrutura plástica foram revestidas com um material emborrachado (E.V.A), e o Arduino, ponte H, LEDs, buzzer, sensor IR assim como os fios foram devidamente alocados e conectados como pode ser visto na Figura B.

O Arduino foi adaptado na parte de trás do encosto da cadeira. Já as pontes H, uma para cada motor, foram adaptadas na sobre os próprios motores. O LED vermelho que sinaliza a detecção de obstáculos pelos sensores foi adaptado no braço direito da cadeira, e o LED verde que sinaliza a recepção de dados pelo sensor IR foi adaptado na parte superior esquerda da cadeira. O buzzer e o sensor IR ficaram juntos as portas 13 e 12 do Arduino onde foram conectados.

         Durante a montagem do hardware, algumas dificuldades foram encontradas como o superaquecimento nos transistores das pontes H, este problema foi resolvido com o uso de resistores que limitaram o fluxo de corrente nestes componentes reduzindo seu aquecimento. Outro problema encontrado foi a sobrecarga que o buzzer provocava na parta do Arduino em que se encontrava ligado e mais uma vez este problema foi resolvido com o uso de resistores para o controle da corrente.

        O Sensor IR também apresentou problemas, pois captava muita interferência junto ao sinal fornecido pelo controle remoto, a solução foi o uso de um capacitor cerâmico em paralelo com seus terminais de alimentação. Este capacitor ajudou a filtrar estas interferências, resolvendo o problema.

De uma forma geral o processo de montagem do hardware foi tranquilo com todos os componentes funcionando dentro do esperando.
 
10
DESENVOLVIMENTO DO SOFTWARE
         O software foi desenvolvido na IDE versão 1.0 do Arduino, utilizando a linguagem de programação C/C++. Trata-se de um software embarcado, ou seja, feito especificamente para funcionar em dispositivos com recursos de processamento e memória escassos, se comparados aos computadores convencionais. O uso do computador se fez necessário para o desenvolvimento e a compilação do código pois uma vez tendo sido gerado o executável binário proveniente da compilação, ele é transferido e instalado via conexão USB no Arduino, não sendo mais necessário o uso do computador. O objetivo básico e principal do software é controlar e integrar o funcionamento dos diversos componentes de hardware interferindo nos comandos do usuário a fim de alertar e proporcionar segurança no controle de uma cadeira de rodas motorizada.

        A interação do usuário com o software ocorre através do controle remoto. A Tabela na Figura A mostra as ações realizadas pelo software quando é pressionado cada botão no controle remoto e o código corresponde a este botão.

Além das interações básicas de movimentação do protótipo, foi implementado no software outras quatro. Ao pressionar o botão Power o usuário pode habilitar ou desabilitar os sensores que detectam obstáculos. Esta função é importante se o usuário desejar utilizar apenas as funcionalidades de movimentação. Já ao pressionar o botão MUTE o software comanda um aumento ou redução da velocidade de deslocamento do protótipo. Existem duas velocidades pré-programadas o usuário pode apenas escolher qual ele quer usar.

Os botões CD E TAPE tem funcionalidade parecida e importante. Ao ser pressionado o botão CD, o software captura a distância em que o sensor instalado na posição vertical está do solo naquele momento. Com referencia nesta distância o software calcula se existe algum buraco ou elevação no trajeto do protótipo. O botão TAPE ao ser pressionado faz com que o software capture a distância entre o sensor instalado na posição horizontal e o obstáculo mais próximo naquele momento. É exatamente a esta distância que o software irá parar o protótipo e ligar os sinais de alerta quando o sensor detectar algum obstáculo e ao dobro desta distância, o protótipo reduz sua velocidade e também emite sinais de alerta.

Para controlar os dois sensores Ultrassónicos e o sensor IR foram utilizadas bibliotecas que simplificaram em muito a programação, no Código 1 a seguir, pode ser visto o uso das bibliotecas e a declaração de variáveis globais que tem papel fundamental no controle do protótipo.

Código 1: Bibliotecas
1  #include "Ultrasonic.h"
2  #include <IRremote.h>
3
4  Ultrasonic ultraHorizontal(4,2);
5  Ultrasonic ultraVertical(8,7);
6  IRrecv receptor(12);
7  decode_results resultado;
8
9  int distHorizontal=20, calibraHorizontal=20;
10 int distVertical=7, calibraVertical=7;
11 int velocidadeM1=255;
12 int velocidadeM2=255;
13 int cont=0;
14 boolean ATIVA = true;
15 boolean VELOC = true;

        Na primeira linha do código esta o include da biblioteca Ultrasonic.h[1] responsável por facilitar a programação dos sensores ultrassônicos. Esta biblioteca não vem nativamente na IDE do Arduino, mas é livre para o uso e modificação podendo ser facilmente encontrada na Internet e adicionada as bibliotecas já existentes no Arduino. Já nas linhas 4 e 5 cria-se objetos do tipo Ultrasonic, um corresponde ao sensor ultrassônico que foi usado no protótipo na posição horizontal ultraHorizontal e o outro ao sensor que foi instalado no protótipo na posição vertical, ultraVertical. Os parâmetros se referem as portas do Arduino em que os terminais dos sensores foram conectados. Na linha 2 está o include da biblioteca IRremote.h[2] responsável por decodificar os sinais que o sensor IR recebe do controle remoto.

         Esta biblioteca também não é nativa da IDE do Arduino, mas também é facilmente encontrada na internet e adicionada às bibliotecas do Arduino. Mas a diante na linha 6, cria-se o objeto receptor do tipoIRrecv, para recepção dos sinais infravermelhos. O parâmetro exigido corresponde ao número da porta em que o pino de saída de dados do sensor IR foi conectado ao Arduino. Já na linha 7 é criado o objeto resultado do tipo decode_results para armazenar o resultado da decodificação do sinal recebido. Da linha 9 até a linha 15 são declaradas variáveis globais fundamentais para que haja uma interação entre os comandos do controle remoto, as informações dos sensores e o controle de direção e velocidade do protótipo, assim como o acionamento ou não dos dispositivos de alerta.

No Codigo 2 mostrado em seguida, pode-se ver  a função setup().

Código 2: Função Setup()
17   void setup()
18   {
19       pinMode(3, OUTPUT);  // LED vermelho
20       pinMode(11, OUTPUT); // LED verde
21       pinMode(13, OUTPUT); // Buzzer
22
23       pinMode(5, OUTPUT); // Saida PWM pra Ponte H
24       pinMode(6, OUTPUT); // Saida PWM pra Ponte H
25       pinMode(9, OUTPUT); // Saida PWM pra Ponte H
26       pinMode(10, OUTPUT); // Saida PWM pra Ponte H
27
28       receptor.enableIRIn();
29   }

 [1] http://tetrasys-design.net/download/HCSR04Ultrasonic/HCSR04Ultrasonic-1.1.2.tar.gz

        Como visto no capítulo 3 deste trabalho, a função setup()  é a primeira a ser chamada quando se inicia o dispositivo e é uma função de preparação para os pinos do Arduino. Neste caso o comando pinMode() dita o comportamento dos pinos, se eles serão entradas de dados ou saídas. Na linha 19 o pino 3 do Arduino esta sendo configurado como saída, este pino esta conectado a um LED vermelho que no protótipo tem a função de emitir sinais de alerta. Detalhes relacionados ao que está conectado a cada pino do Arduino foi descrito no capítulo 6.

        Neste software, todos os pinos foram configurados como saída. Vale ressaltar que os pinos utilizados pelos sensores ultrassónicos e IR não estão especificados na função setup() pois devido ao uso das bibliotecas para controlar estes dispositivos esta configuração não foi necessária, mas caso não se faça o uso das bibliotecas estes pinos devem ser configurados na função setup(). Também nesta função, na linha 28 temos a inicialição do receptor de sinais infravermelhos.

A segunda função a ser chamada pelo Arduino é a função loop() vista no Código 3 a seguir.

Código 3: Função Loop()
31 void loop()
32 {
33     while(receptor.decode(&resultado)) {
34         digitalWrite(11, HIGH);
35         digitalWrite(3, LOW);
36         if(VELOC == true){
37             VelocMaxima();
38         }
39         if((resultado.value == 3344)||(resultado.value ==1296)){
40             Detecta();
41         }
42         else if((resultado.value == 3345)||(resultado.value==1297)){
43             Re();
44         }
45         else if((resultado.value == 1312)||(resultado.value==3360)){
46             Direita();
47         }
48         else if((resultado.value == 3361)||(resultado.value==1313)){
49             Esquerda();
50         }
51         else if((resultado.value == 1337)||(resultado.value==3385)){
52             CalibraDistVer();
53         }
54         else if((resultado.value == 1335)||(resultado.value== 3383)){
55             CalibraDistHor();
56         }
57         else if((resultado.value == 1292)||(resultado.value== 3340)) {
58             LigaDesligaSensores();
59         }
60         else if((resultado.value == 3341)||(resultado.value== 1293)){
61             ControlVeloc();
62         }
63         receptor.resume();
64         cont = 0;
65     }
66     cont ++;
67     delay(10);
68     if(cont == 15){
69         Parar();
70         digitalWrite(3, LOW);
71         digitalWrite(11, LOW);
72     }
73 }

 A função Loop é a principal do código fonte e é executada repetidamente bem como todas as demais funções nela embarcadas. As condicionais que tornam possível o controle do protótipo através do controle remoto estão na função loop().

Na linha 33 temos um comando while cuja condição de permanência no loop é o sensor IR está recebendo algum sinal, caso positivo a porta 11 do Arduino é configurada para fornecer sinal lógico em nível alto, ascendendo o LED verde indicando a recepção de sinal pelo sensor IR, este código de acionamento da porta 11 pode ser visto na linha 34, já na linha 35 a porta 3 é configurada para fornecer sinal de nível lógico baixo, isso faz com que o LED vermelho fique apagado pois a função que verifica se existe algum obstáculo detectado pelos sensores ainda não foi chamada e somente neste caso que ele deve permanecer aceso.

Na linha 36 temos uma condicional que verifica se o usuário configurou o protótipo para se locomover em uma velocidade lenta ou rápida. Caso tenha sido em velocidade rápida, a função VelocMaxima(), que impõem aos motores a maior velocidade possível é acionada. Caso contrário, a velocidade continua sem alteração, isto é importante, pois dependendo da distância que o sensor estiver de um determinado obstáculo, a velocidade de deslocamento do protótipo será reduzida automaticamente independente das configurações do usuário. O teste da linha 36 permite que a velocidade volte para a configuração do usuário, caso o obstáculo esteja mais no campo de visão do sensor.

As condicionais que permitem executar determinadas ações no protótipo de acordo com o botão pressionado no controle remoto começam na linha 39 onde o atributo value do objeto resultado, que contem o código correspondente ao botão pressionado no controle remoto é comparado aos códigos previamente conferidos, que correspondem a um determinado botão no controle remoto, no primeiro if na linha 39 pode ser visto o código 3344 e 1296 que correspondem ao botão seta para cima.

São dois códigos porque especificamente neste modelo de controle remoto da Philco utilizado no trabalho é emitido um código quando se pressiona o botão uma vez e outro ao pressionar o botão novamente. No caso do código presente na decodificação do sinal recebido pelo sensor IR coincidir com 3344 ou 1296 quer dizer que o botão seta para cima no controle remoto foi pressionado, então é chamada a função Detecta() que será vista mais a diante. Nas linhas seguintes o mesmo processo se repete para que de acordo com o botão pressionado as funções Re(), Direita(), Esquerda(), CalibraDistVer(), CalibraDistHor(), LigaDesligaSensores() e ControlVeloc() sejam executadas, as principais destas funções também serão detalhadas a seguir e o código completo pode ser visto no Apêndice I deste trabalho.

Na linha 63 já no final da função loop(), mas ainda dentro do while o receptor é preparado para receber um novo valor de decodificação do sinal recebido pelo sensor IR e logo abaixo na linha 64 uma variável inteira, usada como contador, é iniciada com o valor 0, toda vez que a execução do programa sair do while o contador incrementa mais um e aguarda por dez milissegundos usando a função delay() da linha 67, apenas quando for atingindo um total de quinze ciclos do loop fora do while é que as atividades que estavam sendo realizadas no protótipo serão desativas com o acionamento da função Parar() e a configuração das portas 3 e 11 do Arduino com sinal de nível lógico baixo. Esta estratégia de esperar quinze vezes antes de se desabilitar as atividades no protótipo é importante para que não haja intermitência no funcionamento do protótipo devido a interferências na recepção do sinal do controle remoto.

            O próximo trecho de código fonte a ser analisado e a função Detecta(), Código 4, criada para detectar a presença de obstáculos através dos sensores ultrassônicos, disparar ou não os sinais de alerta, diminuir a velocidade e parar o protótipo no caso de haver risco de colisão ou queda em algum buraco ou desnível no piso.

Código 4: Função Detecta()
75 void Detecta()
76 {
77     if(ATIVA == true){
78         distVertical = (ultraVertical.Ranging(CM));
79         distHorizontal = (ultraHorizontal.Ranging(CM));
80     }
81     else{
82         distHorizontal = calibraHorizontal*2;
83         distVertical = calibraVertical;
84     }
85     if((distVertical < calibraVertical -1)||(distVertical >
       calibraVertical+1)||(distHorizontal < calibraHorizontal)){
86         Parar();
87         digitalWrite(3, HIGH);
88         Bip(80, 300);
89         Bip(100, 300);
90         Bip(120, 300);
91     }
92     else if((distHorizontal<calibraHorizontal*2)&
       (distHorizontal>=calibraHorizontal)){
93         VelocMedia();
94         Frente();
95         digitalWrite(3, HIGH);
96         Bip(100, 80);
97         digitalWrite(3, LOW);
98      }
99      else{
100         if(VELOC == true){
101             VelocMaxima();
102         }
103         Frente();
104         digitalWrite(3, LOW);
105     }
106 }

Esta função é acionada sempre que for pressionado o botão Seta para cima no controle remoto. O primeiro teste executado na função é a verificação se o usuário ativou ou não os sensores através de uma condicional na linha 77, caso verdadeiro as variáveis distVertical e distHorizontal recebem os valores de distância em centímetros fornecidos pelos sensores Ultrassônicos através de cálculos do tempo de emissão de ondas sonoras e o retorno do eco realizados pela biblioteca Ultrasonic.h. Estes valores serão testados mais adiante com distancias configuradas pelo usuário como limite mínimo em que o protótipo pode se aproximar de um objeto. Caso o usuário tenha optado por não ativar os sensores, as variáveis simplesmente recebem os mesmos valores sempre, não havendo assim a detecção de obstáculos.

Na linha 75 é onde os valores de distância fornecidos pelos sensores ultrassônicos são comparados às distancias limite, nas variáveis calibraVertical para o sensor que detecta buracos ou protuberâncias e calibraHorizontal para o sensor que detecta obstáculos à frente do protótipo. A distância vertical é testada a fim de comparar se ela é menor que a distância que o sensor esta do solo menos um centímetro, caso seja, isso quer dizer que existe algum obstáculo a frente do protótipo e este obstáculo é maior que dois centímetros. Da mesma forma também é testado se a distância vertical é maior que a distância que o sensor esta do solo mais um centímetro, neste caso se positivo, quer dizer que existe um buraco ou desnível a frente do protótipo.

O último teste desta condicional é referente a distância horizontal, neste caso é testado se ela é menor que a distância mínima possível configurada pelo usuário para que o protótipo se aproxime de algum obstáculo. Se algum destes casos se confirmarem como positivo o algoritmo faz uma chamada a função Parar() na linha 86 imobilizando o protótipo logo em seguida na linha 87 ascende o LED vermelho conectado ao pino 3 do Arduino  e chama por três vezes nas linhas 88, 89 e 90 a função Bip() e para cada chamada é fornecido parâmetros diferentes que também fazem produzir  variações de sinais diferentes na porta 13 do Arduino onde esta ligado o Buzzer fazendo-o emitir bips de alerta de diferentes tons, mas detalhes da função Bip() serão vistos adiante. Caso nenhum dos testes acima for positivo ainda existe outro teste que esta na linha 92 e tem a finalidade de detectar a proximidade de um obstáculo que esteja ao dobro da distância configurada pelo usuário com a mínima possível para o protótipo se aproximar.

Caso o protótipo entre nesta região que fica compreendida entre a distância mínima de segurança onde o protótipo é parado automaticamente e o dobro desta distância o algoritmo faz uma chamada a função VelocMedia() na linha 93. Esta função faz com que o protótipo diminua sua velocidade caso ele esteja em sua velocidade máxima. Em seguida é feita uma chamada a função Frente() para que o protótipo continue em frente, na linha 95 o LED vermelho é aceso, já na 96 é chamada a função Bip(), com parâmetros para se produzir um bip curto em seguida o LED vermelho é apagado. Isto faz com que toda vez que o protótipo se aproxime de um obstáculo detectado pelo sensor que está na posição horizontal a uma distância suficiente para satisfizer o teste condicional da linha 92 o protótipo diminuirá a velocidade e piscara o LED vermelho emitindo bips curtos de alerta pelo Buzzer para que o usuário possa ver que esta se aproximando de um obstáculo e corrigir seu percurso antes que o protótipo pare.

Caso não haja nenhum obstáculo detectado pelos sensores, o algoritmo apenas verifica na linha 100 se a velocidade esta compatível com a escolha do usuário, mas adiante é chama a função Frente() para que o protótipo se locomova para frente pois não a nada o obstruindo e mantem o LED vermelho apagado.

No Código 5 a seguir é analisado as funções CalibraDistVer() e CalibraDistHor().

Código 5: Função CalibraDistVer()
108 void CalibraDistVer()
109 {
110     calibraVertical = (ultraVertical.Ranging(CM));
111     digitalWrite(3, HIGH);
112     Bip(100, 300);
113     digitalWrite(3, LOW);
114 }
115
116 void CalibraDistHor()
117 {
118     calibraHorizontal = (ultraHorizontal.Ranging(CM));
119     digitalWrite(3, HIGH);
120     Bip(100, 300);
121     digitalWrite(3, LOW);
122 }

Estas funções foram criadas para que o usuário possa escolher a menor distância que o protótipo da cadeira de rodas pode se aproximar de um objeto antes de parar automaticamente. Isto para os objetos detectados pelo sensor que esta na posição horizontal. Já para o sensor que esta na posição vertical a distância que ele fica do solo é fixa e deve se mantida, mas devido a atritos o valor desta distância pode variar interferindo na correta eficiência do software, por isso é importante calibrar esta distância antes de usar o protótipo.

O algoritmo funciona da seguinte maneira: para calibrar o sensor vertical é necessário pressionar o botão CD no controle remoto isto faz com que a função CalibraDistVer() seja chamada e nela, a variável global calibraVertical recebe e armazena o valor da distância lida pelo sensor naquele momento e é esta distancia que sera usada como parâmetro pelo software, isto ocorre na linha 110 do trecho de código fonte analisado.

Para confirmar que a calibração foi realizada o LED vermelho é aceso (linha 111) em seguida é emitido um bip pelo Buzzer (linha 112) e o LED vermelho é apagado (linha 113). O processo é exatamente o mesmo para calibração horizontal, porém, neste caso deve ser pressionado no controle remoto o botão TAPE. Toda vez que for feito um teste de comparação entre distancias será usado este valor ate que o usuário calibre novamente.

            Para que o protótipo possa se locomover para frente, para os lados, para trás e também parar, foram implementadas diversas funções que podem ser vistas no Código 5 a seguir:

Código 6: Funções para movimentação e parada do protótipo
134 void Parar()
135 { 
136     analogWrite(9, LOW);
137     analogWrite(10, LOW);
138     analogWrite(5, LOW);
139     analogWrite(6, LOW); 
140 } 
141
142 void Frente()
143 { 
144     analogWrite(9, velocidadeM1); 
145     analogWrite(10, LOW);
146     analogWrite(5, velocidadeM2); 
147     analogWrite(6, LOW);
148 } 
149
150 void Re()
151 { 
152     analogWrite(9, LOW); 
153     analogWrite(10, velocidadeM1);
154     analogWrite(5, LOW); 
155     analogWrite(6, velocidadeM2);
156     delay(100);
157 } 
158
159 void Direita()
160 { 
161     analogWrite(9, velocidadeM1); 
162     analogWrite(10, LOW);
163     analogWrite(5, 80); 
164     analogWrite(6, LOW); 
165     delay(100);  
166 } 
167
168 void Esquerda()
169 {
170     analogWrite(9, 80); 
171     analogWrite(10, LOW);
172     analogWrite(5, velocidadeM2); 
173     analogWrite(6, LOW);
174     delay(100);  
175 }

Para que o protótipo se movimente é preciso acionar os motores. E quem faz o acionamento dos motores é a ponte H, então na verdade o que o software esta controlando neste trecho são as tensões enviadas a pontes H, no protótipo foram utilizadas duas, uma para cada motor e cada ponte H necessita de duas portas do Arduino.

Na função Parar() temos o comando analogWrite(9, LOW), na linha 36, este comando faz com que o pino 9 do Arduino forneça 0 volts (nível lógico baixo) a entrada da ponte H. É possível notar que este mesmo valor é fornecido a todas as entradas da ponte H e como visto no capítulo 2 deste trabalho, esta configuração proporciona a parada do motor.

Sempre que é necessário que o protótipo se locomova pra frente é feito uma chamada a função Frente() na linha 142. Esta função aciona os dois motores no mesmo sentido e ao mesmo tempo. O uso das variáveis velocidadeM1 e velocidadeM2 é para que se possa controlar a velocidade em que o protótipo se desloca. Isto é possível porque a principal característica do comando analogWrite(pino, valor) como visto no capítulo 3 deste trabalho é gerar uma tensão analógica em um pino digital utilizando o sinal PWM (pulse width modulation), para isso são requeridos dois parâmetros, o número do pino em que essa tensão deve ser gerada e a amplitude desta tensão que pode variar de 0 correspondendo a 0 volts até 255 que corresponde a 5 volts no Arduino.

Se nas variáveis velocidadeM1 e velocidadeM2 estiver o valor 0 (zero) o protótipo permanecerá parado, a proporção em que este valor for aumentando também aumentara a velocidade de deslocamento do protótipo até o máximo de 255 que correspondera a máxima velocidade do protótipo.

A função Re() na linha 150 funciona exatamente como a função frente, porém os valores nas portas do Arduino foram invertidos, isso faz com que o protótipo se locomova para trás. Já na linha 159 temos a função Direita() que como o próprio nome sugere faz com que o protótipo vire a direita. Ela tem o mesmo princípio de funcionamento da função Frente() porém para que o protótipo se locomova para frente é preciso que as duas variáveis velocidadeM1 e velocidadeM2 tenham o mesmo valor. já para que ele vire a direita o motor da esquerda deve girar mais rápido do que o da direita isto é conseguido fixando um valor baixo no comando da linha 163, analogWrite(5, 80), com isto quando esta função for chamada o motor da esquerda sempre girara mais rápido virando o protótipo para a direita.

Para girar protótipo para a esquerda a função Esquerda() da linha 168 usa exatamente o mesmo princípio porém agora o motor da direita e que gira mais devagar. O comando delay(100) no final de cada função tem o objetivo de fazer com que a execução do programa espere por 100 milissegundos antes de encerar, isto evita o surgimento de intermitência devido a alguma dificuldade de recepção dos sinais do controle remoto.

            O último trecho de código fonte analisado será o da função Bip() vista no

Código 6, é esta função que permite ao Buzzer emitir sinais de alerta.

Código 7: Função Bip()
124 void Bip(int tom, int duracao)
125 {
126     for (long i = 0; i < duracao * 1000L; i += tom* 2) {
127         digitalWrite(13, HIGH);
128         delayMicroseconds(tom);
129         digitalWrite(13, LOW);
130         delayMicroseconds(tom);
131     }
132 }

O Arduino possui uma função exclusiva para produzir notas musicais, porém com o uso da biblioteca IRremote.h ouve um conflito que não possibilitou o uso da função tone() já presente no Arduino e então a função Bip() foi implementada para resolver o problema. Para fazer o Buzzer vibrar, escrevemos no pino do Arduino em que ele está ligado uma sequência de valores HIGH (valor lógico alto) e LOW (valor lógico baixo), tantas vezes por segundo quanto for a frequência da nota. Para isto foi usado o comando for da linha 126. O parâmetro tom diz respeito a frequência do som, quanto mais baixo for o valor da variável tom, mais agudo será o som emitido. Já o parâmetro duração esta relacionado à duração do som e quanto maior o seu valor maior será o tempo de duração do som emitido.som, quanto mais baixo for o valor da variável tom, mais agudo será o som emitido. Já o parâmetro duração esta relacionado à duração do som e quanto maior o seu valor maior será o tempo de duração do som emitido.


 
11
CONSIDERAÇÕES FINAIS

De uma forma geral, conseguiu-se chegar ao objetivo principal do Projeoto, produzindo um software estável, embarcado num micro processador e controlando um protótipo semelhante a uma cadeira de rodas motorizada, que possibilitou uma boa interação entre software e hardware. A principal função do software também correspondeu às expectativas cumprindo seu papel de auxiliar o usuário no controle do protótipo. Os conhecimentos adquiridos nas pesquisas bibliográficas foram de fundamental importância para a conclusão bem sucedida do trabalho e acrescentaram de maneira significativa aos conhecimentos já adquiridos.

Este trabalho buscou unir a crescente utilização de sistemas embarcados em uma grande parcela de dispositivos eletrônicos encontrados em nosso dia-a-dia a uma crescente necessidade de se desenvolver produtos que atendam os anseios de pessoas com algum tipo de deficiência física, tanto para proporcionar maior conforto e segurança, quanto para propiciar uma melhor integração à sociedade, promovendo assim, uma melhora significativa em sua qualidade de vida. O uso da tecnologia tem um papel fundamental nesse processo, desta forma, é bem vinda toda e qualquer atenção voltada a pessoas com necessidades especiais por parte daqueles que detém conhecimentos para desenvolver novas técnicas ou aprimorar as já existentes nesta área que muitas vezes é negligenciada por parte dos pesquisadores.

Além do lado acadêmico este trabalho também teve um lado humanista voltando o uso de tecnologias de diversas áreas para o desenvolvimento de técnicas para facilitar a vida de pessoas que por algum motivo tiveram sua capacidade de locomoção parcialmente reduzida ou completamente comprometida e, além disso, ainda tem alguma deficiência visual, motora ou cognitiva que os impossibilitem de controlar uma cadeira de rodas motorizada. O protótipo produzido e apresentado neste trabalho é apenas uma amostra que se pode conseguir grande sucesso nesta área, através do uso de micro controladores com maior poder computacional assim como o uso de um maior número de sensores e atuadores de diversos tipos.



A
Anexos
Você precisa estar logado para ver os anexos.
Comentários: