BUGBot - Robot Seguidor de Luz - Parte-2

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Nesta segunda parte do Robot Seguidor de Luz, o BUGBot, veremos a parte de configuração lógica do cérebro (Arduino); mas também faremos uma simulação didática usando um pequeno, mas poderoso micro-controlador o PICAXE08M2 e usando o software didático de simulação de circuitos eletrônicos e para PICAXE, o Yenka Crocodile (esse software tem uma versão com licença gratuita para uso de propósito pessoal/residencial).

Baixe o Yenka Crocodile no site: http://www.yenka.com/en/Free_Yenka_home_licences/

Vamos então ao nosso projeto!

HARDWARE & MATERIAIS:

2 x Transistores TIP120
2 x Diodos 1N4001
2 x LEDs verde 3mm
2 x LDR
2 x Resistores de 1KΩ
2 x Resistores de 470Ω
2 x Capacitores de 100 nF
2 x Trim-pot 5KΩ
1 x Conectores AK300 de 2 pinos
2 x PinHead com 2 pinos
1 x PinHead com 6 pinos
1 x pack de bateria (9V ou 12V)



ESQUEMAS & LAYOUTs:

Abaixo vemos a placa de circuito impresso e o diagrama esquemático do nosso Hardware.

Layout da placa de circuito impresso do BUGBot

Note que:
Os diodos 1N4001 e os capacitores de 100nF, são para proteção do circuito e eliminação de ruídos; conforme já explicado no post sobre Ponte-H.
Temos LEDs verdes para indicar quando um motor está acionado ou não (cuidado com o valor do resistor, se você for usar uma tensão de trabalho maior que 6V. Aconselho usar 6V/270Ω, 9V/ 470Ω, 12/680Ω.

JP2 é a saída para o motor direito e JP3 é a saída para o motor esquerdo.
JP1 é a conexão com o arduino, sendo (da esquerda para a direita):
pino 1 = > LDR sensor esquerdo;
pino 2 => LDR sensor direito;
pino 3 => alimentação positiva logica dos sensores (+5V do Arduino);
pino 4 => negativo comum (Arduino)
pino 5 => comando para acionamento do motor esquerdo (vem do arduino)
pino 6 => comando para acionamento do motor direito (vem do arduino)

Mais adiante faremos uma paralelo entre a pinagem do JP1 com a pinagem usada no arduino

Vimos que os sensores usam a alimentação lógica do Arduino como referência, isso porque não podemos ter uma tensão maior que 5V nas portas do Arduino.
Quando tivermos luz incidente no LDR, teremos 0V na porta do Arduino, e quando não tivermos luz incidente no LDR, teremos 5V na porta do Arduino (logica reversa, já abordada na primeira parte do BUGBot).

Diagrama esquemático do BUGBot

Esse  é todo o hardware eletrônico que necessitaremos, mais o Arduino e pack de baterias para os motores.


Ajuste de sensibilidade:
Feito através dos Trim-Pots de 5KΩ, desta forma podemos ajustar com qual nível de luz queremos que o BUGBot tenha uma resposta e acione os motores para movimentação.

Abaixo os arquivos originais em Eagle:

Estes são os originais do equema e da placa de circuito impresso em Eagle.
http://www.4shared.com/file/K-dFSSPS/BugBot.html
http://www.4shared.com/file/XBHJe0QI/BugBot.html

Conexão com o Arduino:
pino do LDR Esquerdo => A0
pino do LDR Direito => A1
pino do Motor Esquerdo => 8
pino do Motor Direito => 9


Paralelo entre as conexões Arduino e conector JP1:
ARDUINO - JP1-x
A0 - JP1-1
A1 - JP1-2
+5V - JP1-3
GND - JP1-4
D8 - JP1-5
D9 - JP1-6



SOFTWARE & PROGRAMAÇÃO:


Fluxograma de operação no software Yenka Crocodile:
Notar que as entradas/saídas são apenas ilustrativas, foram as usadas no software didático Yenka Crocodile com o PICAXE.
Este já foi explicado na primeira parte do projeto.

Fluxo de operação logica do BUGBot

Fluxograma de operação usando o programa Logicator PIC.

LOGICATOR, usado para programar  PICAXE

Programa para Arduino:
Baixe diretamente neste link o  sketch para arduino IDE 0023: http://www.4shared.com/file/3FtFRaAS/Bug_Bot_R1.html

Agora vamos às simulações:
Assista no Youtube: http://youtu.be/8hBfOb6b1HU
Assista no screencast.com: http://www.screencast.com/t/2v6Lr9vQ7

Assista no Youtube: http://youtu.be/CnhTETe-OBk
Assista no screencast.com: http://www.screencast.com/t/a7d2yhcQsli

O próximo passo é a construção do chassi, que conterá a parte motriz, eletrônica de sensores, etapa de acionamento, alimentação (baterias) e a parte de processamento lógico (arduino),... mas isso só na Parte-3 do BUGBot - Robot Seguidor de Luz. Aguardem a execução final do projeto.
Então,... até lá!

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

BUGBot - Robot Seguidor de LUZ - Parte-1

-->

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);





O BUGBot, é um robot seguidor de luz (como se fosse realmente um inseto), ele sempre se desloca em direção a um foco de luz.  Na ausência de luz ele permanece parado.

Esse robot, será o primeiro de uma séria a ser mostrado aqui.
Nosso projeto é mostrar alem do BUGBot, mostrar também o:
LINUSBot que será um robot seguidor de linha e o ECOBot, um robot que será guiado por um sensor ultra-sônico, medindo distancia de obstáculos e desviando deles.


A primeira parte desta série, será a apresentação dos meios de construção do chassis e a parte mecânica em geral, bem como a parte eletrônica do robot.  Apresentaremos também uma simulação do BUGBot em um software didático.

Então mãos a obra....

Para construir o BUGBot, precisaremos de um chassis, que será construído em acrílico.
Precisaremos também, de um sistema de um sistema de transmissão (motor/engrenagem), para poder fazer o nosso robot se deslocar.
Além é claro da parte eletrônica de potência para controle dos motores; parte eletrônica para os sensores (serão utilizados LDRs como sensor) e a parte eletrônica de controle dos dispositivos (entrada = sensores LDR e saída = Motores), usaremos o Arduino ou Teensy para esta finalidade.

FUNCIONAMENTO:

A figura abaixo mostra a ideia básica de qualquer robot, onde temos os dispositivos de entrada e saída ligados ao cérebro, em particular para o BUGBot.

Processamento Básico dos sinais

Os dispositivos de entrada serão os LDR (Light Dependent Resistor) os resistores dependentes de luz, que tem a sua resistência alterada conforme a incidência de luz no dispositivo. Basicamente, se não houver incidência de luz, teremos uma alta resistência (na ordem de 200KΩ a 1MΩ ) no dispositivo, e quando houver a incidência de luz, termos uma diminuição da resistência do dispositivo, conforme a sua curva característica.

Curva, Resistência x Iluminação

Um LDR também é sensível ao comprimento de onda da luz incidente, desta forma podemos dizer que ele depende da cor da luz (o que caracteriza a cor da luz é o seu comprimento de onda).

Curva, Sensibilidade x Comprimento de onda

Espectro de cores (comprimento de Onda)

Detalhes dos LDRs

Estrutura e Simbologia do LDR

Encapsulamento do LDR

Circuito Básico

Circuito Básico com LDR para acionamento de um LED

Na figura acima, podemos ver o circuito básico para acionamento de um LED com o LDR como sensor de Luz.
No circuito da esquerda, notamos que inicialmente o LED estará apagado, pois a lata resistência do LDR sem luz incidente, deixará o transistor no estado de corte; ao incidir luz no LDR, ele terá uma diminuição de sua resistência e desta forma, teremos uma polarização na  base, fazendo com que o transistor entre no estado de condução, acendendo o LED.
No circuito da direita, notamos que o LED estará inicialmente aceso, pois o LDR sem luz incidente terá uma resistência muito maior do que a soma de resistências do resistor de 10KΩ + potenciômetro de 10KΩ, ficando a base do transistor polarizada e o transistor no estado de condução acendendo o LED; quando a luz incidir no LDR, este terá uma diminuição de sus resistência e levará o transistor ao estado de corte, desligando o LED.

Um ajuste de sensibilidade no sistema é permitido através do potenciômetro de 10KΩ.

Logicamente, podemos usar o LDR de outras maneira, mas esta é a forma mais usual.



BUGBot

O robot terá 2 sensores LDR para poder determinar se ele deve se movimentar para a direita, para a esquerda, para frente, ou permanecer parado.
sendo:

1 x LDR sensor DIREITO
1 x LDR sensor ESQUERDO

No nosso BUGBot, usaremos motores DC para comandar um sistema de transmissão (engrenagens mais Rodas) para que o robot possa se movimentar e assim seguir a luz incidente nos sensores.
Foi usado o Kit:  Tamiya Gear Box na proporção 58:1

Se o LDR esquerdo tiver luz incidente, deverá ser acionado o motor direito para que o robot possa girar ou mover-se para a esquerda.
Se o LDR direito tiver luz incidente, deverá ser acionado o motor esquerdo para que o robot possa girar ou mover-se para a direita.
Se ambos os LDRs tiverem luz incidente, deverão ser acionados ambos os motores para que o robot possa seguir em frente.
Se ambos os LDRs não tiverem luz incidente, não deverão ser acionados ambos os motores para que o robot possa permanecer parado.

Observação importante:
Não basta somente detectar a presença de luz nos sensores e ligar os motores, precisamos também manter os motores acionados por uma quantidade de tempo mínimo para o funcionamento.


O controle dos dispositivos sensores LDR e motores, será feito pelo Arduino com um software para executar exatamente os passos acima.

Para o acionamento dos motores (como eles deverão girar somente em uma direção), não será necessário usar uma ponte-H, poderemos efetuar o acionamento usando apenas um transistor Darlington de potência.

Abaixo temos um diagrama completo dos dispositivos eletrônicos, e que utilizaremos para simular o funcionamento (primeiramente usando um software didático).

Circuito, Sensores / acionamento / processamento

Note que na figura acima o cérebro do sistema é um PICAXE8M2 (não importando agora qual é o processador e sim a parte didática).
Aqui é possível verificar a interconexão dos sensores com o processador e com os motores/rodas.
Neste circuito é importante notar que o sistema sensor funciona com logica reversa, ou seja:
Quando não temos luz no sensor, temos nível alto na entrada do processador (5V ou binário 1).
Quando temos luz no sensor, teremos nível baixo na entrada do processador (0V ou binário 0).




É isso...
Finalizamos aqui a primeira parte do BUGBot; esperem o próximo post, onde veremos a parte de programação do cérebro eletrônico, e uma simulação completa usando o programa Yenka Crocodile.



Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Reaction Time - com Teensy / Arduino

-->

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Reaction Time - JOGO, Tempo de Reação

Um joguinho para medir o tempo de reação de uma pessoa entre o surgimento de um aviso luminoso e o apertar de um botão.
O tempo é medido em milisegundos, que seria o tempo normal de reação da maioria das pessoas...

O funcionamento é o seguinte:

Ao iniciar o Teensy, é mostrado no display de LCD 16x2, uma mensagem de inicialização.
Após isto é mostrado no display a mensagem "Teste de Reação!", "Aperte Botão"
Ao ser pressionado o botão, primeiramente toca uma música de inicio e acende os LEDs no ritmo da música; começa então, uma temporização aleatória (0-10s) para ser gerado o aviso luminoso inicial (em relação ao qual a pessoa deve ver e apertat novamente o botão para ver o seu tempo de reação ao aviso).
Antes de aparecer o aviso luminoso (LED azul) e durante o tempo aleatório, é mostrado as mensagens no LCD: "Preparado?", "... Aperte:..."; quando finalizar o tempo aleatório, será acionado o LED azul e mostrado a mensagem "<<<< AGORA! >>>>" no LCD.
Se a pessoa apertar o botão antes de 5000ms, será tocado uma música de parabenização, piscando os LEDs no ritmo da música e será mostrado uma mensagem com o tempo da pessoa em (ms), por exemplo "Seu tempo: 253ms", essa mensagem permanecerá por 2s na tela.
E o sistema voltará ao inicio esperando que seja apertado o botão, para começar novamente.

Condições extras:
1. Se a pessoa ficar apertando o botão (durante os 10s aleatórios) para burlar e quando vier o aviso o botão ja estar apertado???
Se você tiver um tempo de reação 0ms (não é impossível eu já consegui), ou você é um "SUPERMAN", ou você está trapasseando "Travessura", essas são as mensagem exibidas neste caso.
2. Caso a pessoa não aperte antes dos 5000 ms... ou o tempo de reação da pessoa é muito ruím, foi esquecido de apertar.... de qualquer forma "Falhou Feio!", "RIDICULO" são as mensagens exibidas e uma música de erro para finalizar.

HARDWARE & MATERIAL:
1 x Teensy ou Arduino UNO/MEGA/Duemilanove
1 x BreadBoard
1 x Buzzer
1 x Display LCD 16x2 I2C
1 x LED RGB
3 x Resistores de  330Ω
1 x Resistor de 10KΩ
1 x Botão Tactil
1 x Capacitor Eletrolítico 10uFx16V
Fios e cabos para as ligações



ESQUEMA & LAYOUT:

Abaixo as interligações necessárias, com Arduino e Teensy.

Notar que o Botão tem um Capacitor Eletrolítico em paralelo com os seus terminais, para o Debounce do chavemaento.


                        pino
                           |
                           |
+5V <-----/\/\/\/\/\---|---o/ o--|-----|GND
                           |           |
                           |---| (-----|

Cada terminal do LED RGB, tem um resistor de 330Ω em série com a ligação ao processador. E o Catodo Comum ligado ao GND.

O Buzzer, tem seu terminal - (negativo), ligado ao GND e o terminal + (positivo), em série com um resistor de 150Ω, ligado ao processador.



Ligação com o Arduino:

LED vermelho, pino 13;
LED verde, pino 11;
LED azul, pino 10;
Botão, pino 9;
Buzzer, pino 12;
LCD_SDA, pino A4;
LCD_SCL, pino A5.

Conexões com o Arduino

Para o Teensy foram usados os seguintes pinos:
LED vermelho, pino 12;
LED verde, pino 14;
LED azul, pino 15;
Botão, pino 7;
Buzzer, pino 13;
LCD_SDA, pino 1;
LCD_SCL, pino 0.

Conexões com o Teensy

PROGRAMAÇÃO & SOFTWARE:

Obtenha o arquivo (.pde) diretamente do 4shared:

  http://www.4shared.com/file/1c7mBavR/Arduino_Reaction_Timer_2.html

http://www.4shared.com/file/haSv9q3Z/Teensy_Reaction_Timer_2.html



VIDEO:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Youtube:  http://www.youtube.com/watch?v=-1nVPamC-5o

Ponte H, Experimentos Parte-1

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);


EXPERIMENTO 1


O primeiro experimento com a Ponte-H, será com as chaves liga/desliga/liga (alavanca 3T).

HARDWARE & MATERIAIS:
2 x Chaves alavanca de 3 posições, tipo LIGA/DESLIGA/LIGA
1 x motor DC de uso geral
Pack de bateria ou fonte de alimentação
Fios e cabos

Lembrando o conceito: 

em a) vemos as chaves sem acionamento e o motor está parado
em b) temos a chave superior da primeira "perna" do H acionada e a chave inferior da segunda "perna" do H acionada, o que resulta no motor girando em um sentido (por exemplo: horário).
em c) temos a chave inferior da primeira "perna" do H acionada e a chave superior da segunda "perna" do H acionada, o que resulta no motor girando no outro sentido (por exemplo: anti-horário).
NUNCA, deve ser acionado duas chaves na mesma "perna" do H, pois isso causaria um curto-circuito no sistema.
O acionamento de chaves em ambas as "pernas" do H, duas chaves superiores ou as dua chaves inferiores; isso não causaria efeito algum.

Esquema real de montagem:

Em X1-1 e X1-2, deve ser conectado o motor DC com tensão conveniente à alimentação do sistema.

Este esquema nos protege do caso que nunca devemos executar; pois, com o tipo de chave utilizado, nunca poderemos acionar somente uma "perna" do H (não podemos causar o curto-circuito).

O teste consiste em acionar as chaves de forma opostas; uma para cima e a outra para baixo e vice-versa.

VÍDEO:

Melhor visualizado pelo youtube: http://youtu.be/9Kz4qM8wOFY


EXPERIMENTO 2:

Agora vamos melhorar um pouco nossa ponte H, utilizando componentes eletrônicos discretos, tais como resistores e transistores bipolares de uso geral.

Isso permitirá utilizar o Arduino, para controlar o sentido da rotação de um motor DC.
De posse desse tipo de controle, podemos pensar em diversas utilizações para a ponte H.

HARDWARE & MATERIAIS:
2 x Transistores BC548C
2 x Transistores BC558C
4 x Resistores de 1KΩ
4 x resistores de 10KΩ
4 x Diodos 1N4148
1 x Motor DC
1 x BreadBoard
Fios e cabos para as conexões
Conectores parafusáveis (opcional)
Placa de circuito (opcional)

DataSheet dos Transistores
http://www.datasheetcatalog.org/datasheet/fairchild/BC548.pdf
http://www.datasheetcatalog.org/datasheet/fairchild/BC558.pdf



ESQUEMA & LAYOUT:

Abaixo o esquema e o layout da placa em eagle.

Não esqueça de conectar o GND do arduino com o GND do circuito (pino 2 - central do conector JP1)
Os outros dois pinos do conector JP1 são de sinal proveniente do Arduino (conforme programa).

No arduino os pinos usados foram o 10 e 11 .
Ligar M1-A ao pino 10 e M1-B ao pino 11

X1 é a conexão do Motor DC.

X2 é a coneção da alimentação externa para o motor. Sendo: X2-1=+VCC e X2-2=GND

Esquema Eletrônico

Os resistores podem ser testados com outros valores para melhores resultados.
Por exemplo: 330 Ω ou 470 Ω.

Ao colocar  M1-A em nível Alto, T1 ficará no estado de corte (Aberto) e T3 em saturação (conduzindo), ao mesmo tempo, colocando M1-B em nível Baixo, T4 ficará no estado de corte (aberto) e T2 em saturação (conduzindo). O motor irá ter uma rotação em um sentido.
Invertendo as condições em M1-A e M1-B, teremos rotação no outro sentido.

Layout Circuito Impresso

OBS.: Por questão de simetria, foi feito a opção por um jumper na placa de circuito impresso, conectando o GND externo (conector X2-2) com o GND da placa. Apenas por questão de simetria. Modificações podem ser feitas a vontade!

Pegue os arquivos originais aqui:
http://www.4shared.com/file/xaqSKSfU/Ponte_H_BC548-558.html

http://www.4shared.com/file/GhnC1RrI/Ponte_H_BC548-558.html

Como os transistores admitem no máximo 500 mA de pico máximo e trabalahm com 100 mA continuo, devemos escolher um motor DC que puxe no máximo 100 mA.

Circuitos mais avançados podem também ser testados.


SOFTWARE & PROGRAMAÇÃO:

O programa para teste é muito simples; consiste em um programa que comanda o motor em uma direção durante 1 segundo, inverte a direção por mais um segundo e assim por diante em loop.
Neste caso o suso é muito limitado, porém temos grandes possibilidades, tais como: controle de motor de passo para maior precisão no giro, uso do PWM para variação de velocidade, controle de servo-motores em aplicações de Robótica, Domótica ou Modelismo.
Enfim....
Basta programar e usar sua Ponte H com transistores.


// programa exemplo, somente

void setup(){
  pinMode(10, OUTPUT); // definição dos pinos
  pinMode(11, OUTPUT);
  digitalWrite(10, HIGH); // para o motor
  digitalWrite(11, HIGH);
}

void loop(){
  digitalWrite(10, HIGH); // primeira direção
  digitalWrite(11, LOW);
  delay(1000); // espera 1 segundo
  digitalWrite(10, LOW); // segunda direção
  digitalWrite(11, HIGH);
  delay(1000); // espera 1 segundo
}
// FIM DA COMPILAÇÃO


EXPERIMENTO 3:

Para obtermos uma maior corrente no acionamento de dispositivos que puxam uma maior corrente, devemos usar transistores que forneças esta corrente, assim, neste experimento, foi usado o transistor Darlington TIP-120 para a montagem da Ponte H.
Com isto garantimos uma maior corrente, um maior ganho de corrente, ou seja: necessitaremos menos corrente do Arduino para acionar uma carga que exige uma maior corrente.

Detalhe do circuito na BreadBoard

Mais detalhe, conector de alimentação externa

Circuito com o controle por PWM, via potenciômetro

HARDWARE & MATERIAIS:
4 x Transistores TIP120 ou TIP122
4 x Resistores de 1KΩ
1 x Motor DC
1 x BreadBoard
Fios e cabos para as conexões
Conectores parafusáveis (opcional)
Placa de circuito (opcional)


http://www.fairchildsemi.com/ds/TI/TIP120.pdf


ESQUEMA & LAYOUT:



Abaixo o esquema e o layout da placa em eagle.

No circuito,foi utilizado resistor de 1KΩ

A1 e A2 são as ligações com o Arduino nos pinos 10 e 11 respectivamente. No Conector JP1 são os pinos 1 e 3. Enquanto que o pino 2 é o GND comum.
X1-1 e X1-2, é a conexão do Motor DC.
X2-1 é a Conexão do GND e X2-2 é a conexão do +V Externo.

Originais Eagle:

http://www.4shared.com/file/sTNEBxsB/Ponte_H_TIP120.html

http://www.4shared.com/file/KZw6mtPx/Ponte_H_TIP120.html

SOFTWARE & PROGRAMAÇÃO:

Para o teste podemos usar o mesmo código da seção anterior.

Porém;

É possível colocar um potenciômetro conectado ao arduino (pino A0 por exemplo) e assim efetuar um controle PWM de velocidade e direção do Motor DC.

+5V----------/\/\/\/\/\-------------GND

                    |

                    |

                  A0

O 5V é o a alimentação proveniente do arduino (alimentação lógica, separada da alimentação do Motor DC).

O Código abaixo é um simples exemplo de como efetuar esse controle.

Na posição central do potenciômetro, teríamos o motor parado, girando para a esquerda o motor teria sentido anti-horário, e girando para a direita o motor teria sentido horário.

/* código de domínio público

modificações são permitidas sem necessidade de aviso prévio*/

// definição de pinos e constantes

int pinH1 = 9;

int pinH2 = 10;

int pinPOT = 0;  

int valor; 

int valorH1; 

int valorH2;

void setup() 

{ 

  Serial.begin(9600); // inicialização da comunicação serial

} 

// loop prinicpal do programa

void loop() 

{ 

  valor = analogRead(pinPOT); // faz a leitura analógica do potenciômetro            

  

  // mapeia os valores lidos

  valorH1 = map(valor, 0, 511, 255, 0); // entre 0 e metade do cursor do POT

                                                             // determina rotação em um sentido     

  valorH2 = map(valor, 512, 1023, 0, 255); // entre metade do cursor do POT e o fim de curso

                                                                  // determina rotação no outro sentido

  

  if (valor > 511){

     valorH1 = 0; // ao ultrapassar a metade do cursor do POT, zera este valor

  }

  else{

    valorH2 = 0; // se ainda não está na metade, deixa este valor zerado

  }

  

  // imprime no monitor serial as informações recebidas do POT e valores H1 e H2

  Serial.print("Valor: ");

  Serial.print(valor, DEC);

  Serial.print(" Valor H1: ");

  Serial.print(valorH1, DEC);

  Serial.print(" Valor H2: ");

  Serial.println(valorH2, DEC);

  

  // aciona os pinos do arduino convnientemente com o valor para o PWM.

  analogWrite(portaH1, val1);

  analogWrite(portaH2, val2);  

}

// FIM DA COMPILAÇÃO

VÍDEOS:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

No youtube: http://www.youtube.com/watch?v=hk4APp1_Jd0