terça-feira, 11 de junho de 2013

Motor Servo

Olá, neste artigo iremos mostrar como utilizar um motor servo com o arduino. Esse motor tem uma série de engrenagens e uma placa controladora onde é possível controlar o ângulo do seu eixo. Por exemplo, pode-se indicar que o mesmo gire 45, 90, 180 graus, etc... Esse tipo de motor é muito utilizado em robótica, para fazer articulações em robores. Segue abaixo uma foto do mesmo. Você pode utilizá-lo para girar uma câmera ou um sensor ultrasônico, explicado no artigo anterior.



Para esse projeto, utilizaremos a biblioteca Servo disponibilizada na IDE do arduino. Para maiores detalhes sobre ela, clique aqui.

Esse motores vêm com 3 fios onde normalmente temos um vermelho(VCC) que deve ser ligado na alimentação do arduino em 5V, um preto ou marrom que deve ser ligado ao terra(GND) e um amarelo ou laranja (DADOS), que deve ser ligado para esse exemplo ao pino digital 9 do arduino.

A seguir um código-exemplo. Este código irá mover o eixo do motor a cada 2 segundos, alternando entre 45 e 135 graus.

#include <Servo.h>
#define SERVO 9
Servo servoMotor;

void setup()
{
  servoMotor.attach(SERVO);//pino de dados do motor
  servoMotor.write(90);//iniciando em 90 graus
}

void loop()
{
   delay(2000);
   servoMotor.write(45);//indo ate 45 graus
   delay(2000);
   servoMotor.write(135);//indo ate 135 graus
}


Segue uma imagem do motor ligado ao arduino.



Até a próxima.


Sensor Ultrasônico

Olá, neste artigo iremos explicar como utilizar um sensor ultrasônico HY-SRF05 com o arduino.

Este sensor (figura abaixo) funciona como um sonar, onde o mesmo calcula a distancia a partir do tempo que uma onda sonora emitida por ele leva para sair do sensor e voltar, refletida por algum objeto. Com isso, teremos a distância entre o sensor e o objeto que refletiu o som emitido.


Faremos uma aplicação que ficará medindo a distância a cada segundo. Para isso, utilizaremos a biblioteca NewPing. Para mais informações sobre ela clique aqui.

Ligue os pinos VCC(5V) e GND aos pinos do arduino. O pino TRIG ao pino digital 6 e o pino ECHO ao pino 5.

Segue abaixo um código-exemplo para esse projeto.

#include <NewPing.h>

#define TRIG_PIN 6
#define ECHO_PIN 5 
#define DISTANCIA_MAX 100
//API utilizada para acionar o sonar
NewPing sonar(TRIG_PIN, ECHO_PIN, DISTANCIA_MAX);//Distancia em cm

float distancia = 0.0;

void setup(void) 
{
  Serial.begin(9600);
}

void loop()
{
   distancia = sonar.ping()/US_ROUNDTRIP_CM;//Calculando em cm
   Serial.print("Distancia em cm:");
   Serial.println(distancia);
   delay(1000);//A distancia sera calculada a cada segundo
}

A seguir, a saída  serial. Aproxime e afaste a mão na frente do sensor e observe a saída do console serial.

 Abaixo uma foto do sensor ligado ao arduino. Você pode utilizar mais de um sensor, bastando ligar os pinos TRIG e ECHO a outros pinos do arduino.




Até a próxima.

domingo, 9 de junho de 2013

Transmissão RF

Olá, neste artigo iremos explicar como realizar uma transmissão com Rádio Frequência (RF), utilizando os módulos abaixo com dois arduinos.


O módulo menor é o transmissor (TX). O maior é o receptor (RX). Utilizaremos também a biblioteca VirtualWire para fazer a comunicação com os módulos. Esses módulos só permitem a comunicação em um sentido ou unidirecional, ou seja, sempre teremos o envio de dados do TX para o RX. Para que possamos fazer uma comunicação completa com envio e recebimento por ambos teríamos que utilizar dois pares de módulos com frequências diferentes. O download da biblioteca e maiores detalhes sobre ela, podem ser obtidos no link já informado.

Em ambos os módulos temos um local para colocar uma antena (ANT). Com a antena, a distância entre eles poderá ficar bem maior. 

Transmissão (TX)

Iniciaremos pela aplicação que envia os dados. Essa aplicação enviará a mensagem "TransRF" a cada segundo. Ligue os pinos de alimentação e terra do módulo ao arduino e o pino ATAD ao pino 9 também do arduino. 

Segue abaixo o código-exemplo.

#include <VirtualWire.h> // lib para RF

//Pinos para o transmissor RF
#define TX_PIN 9
#define RX_PIN 10
#define PTT_PIN 11

#define DOIS_MIL 2000

char mensagem[8];

void setup()
{
  //Pino de envio
  vw_set_tx_pin(TX_PIN);
  //Pino de recepcao. Embora nao seja utilizado no TX, faz-se necessario definir
  vw_set_rx_pin(RX_PIN);
  vw_set_ptt_pin(PTT_PIN);
  vw_set_ptt_inverted(true);
  vw_setup(DOIS_MIL);
  
  mensagem[0]= 'T';
  mensagem[1]= 'r'; 
  mensagem[2]= 'a';
  mensagem[3]= 'n';
  mensagem[4]= 's';
  mensagem[5]= 'R';
  mensagem[6]= 'F';
  mensagem[7]= '\0';
}

void loop()
{
     vw_send((uint8_t *)mensagem, 8);
     delay(1000);
}

Recepção

Essa aplicação receberá a mensagem enviada pelo TX e imprimirá a mesma no console serial.
Ligue os pinos de alimentação e terra do módulo no arduino e ligue o pino DATA ao pino 9 também do arduino. Note de nesse módulo temos 2 pinos de dados. Ambos são iguais. Utilize qualquer um deles.

Segue abaixo o código-exemplo.

#include <VirtualWire.h>

void setup() {                
  Serial.begin(9600); 
  vw_set_tx_pin(10);//Embora nao usado, mas precisa ser definido
  vw_set_ptt_pin(11);
  vw_set_rx_pin(9);//Pino de envio
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_rx_start(); 
}

void loop() {
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;
 
  Serial.println("Aguardando");
  if (vw_get_message(buf, &buflen))
  {
    Serial.print("Texto recebido:");
    Serial.write((char*)buf);
    Serial.println();
  }
  delay(1000);
}

Saída do console serial:


Segue abaixo uma foto dos módulos montados:


Até a próxima.

terça-feira, 4 de junho de 2013

Arduino Ethernet

Olá, neste artigo iremos mostrar como montar um mini servidor, que retorne uma página para um navegador utilizando um arduino e uma placa ethernet.



A placa ethernet que usaremos é compatível pino a pino com o arduino UNO. Sendo assim, ela encaixará perfeitamente na mesma. A figura abaixo mostra a placa e o arduino.



Utilizaremos as biblioteca Ethernet.h e SPI.h que já fazem parte da IDE 1.0.1, utilizada para fazer esse artigo.

Abaixo, segue montado.


A seguir, segue um código-exemplo.

 #include <SPI.h>  
 #include <Ethernet.h>  
 // Defina o IP de acordo com a sua rede:  
 byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };//Informe um mac-address  
 IPAddress ip(169,254,109, 208);//Informe um IP   
 EthernetServer server(80);//Informando a porta para receber requisicoes  
 void setup()   
 {  
  // Inicializando modulo com mac e ip  
  Ethernet.begin(mac, ip);  
  server.begin();//Inicializando o servidor  
 }  
 void loop() {  
  // Aguardando conexoes  
  EthernetClient client = server.available();  
  if (client)   
  {  
   boolean currentLineIsBlank = true;  
   while (client.connected())   
   {  
    if (client.available())   
    {  
     char c = client.read();//Lendo carcteres recebidos  
     Serial.write(c);  
     //Se receber \n e a linha for em branco (dois \n) - fim http request  
     if (c == '\n' && currentLineIsBlank)   
     {  
      client.println("HTTP/1.1 200 OK");  
      client.println("Content-Type: text/html");  
      client.println("Connnection: close");  
      client.println();  
      client.println("<!DOCTYPE HTML>");  
      client.println("<html>");  
      client.println("<head>");  
      client.println("<title>Ola</title>");  
      client.println("<html>");  
      client.println("</head>");  
      client.println("<center>");  
      client.println("<h1>");  
      client.println("<p>ArduinoCC</p>");  
      client.println("</h1>");  
      client.println("<h1>");  
      client.println("<p>Arduino Ethernet</p>");  
      client.println("</h1>");  
      client.println("TESTE HTTP");  
      client.println("</center>");  
      client.println("</html>");  
      break;  
     }  
     if (c == '\n') {  
      // Nova linha  
      currentLineIsBlank = true;  
     }  
     else if (c != '\r') {  
      // recebendo caractere apos nova linha  
      currentLineIsBlank = false;  
     }  
    }  
   }  
   //Aguardando o navegador receber a pagina  
   delay(1);  
   client.stop();//Fechando conexao  
  }  
 }  

Segue a saída no navegador


Até a próxima.

segunda-feira, 3 de junho de 2013

Utilização de cartões SD

Olá, Neste artigo iremos ver como ler e escrever em um cartão SD com o arduino. A IDE do arduino já possui uma API para trabalhar com SDs. Mostraremos como utilizá-la.
Material necessário:

  • Arduino
  • Módulo de leitura e escrita de cartão SD - aqui
  • Alguns fios
A implementação da biblioteca do arduino (SD.h) utiliza um padrão chamado de SPI - Serial Peripheral Interface Bus. Para maiores detalhes, clique aqui e aqui.
Essa biblioteca utiliza alguns pinos pré-definidos. A ligação dos mesmos deve seguir a tabela abaixo.


No módulo há indicações de cada um dos pino. Ver figura abaixo.


Lembre-se de ligar os pinos de 5V e 3.3V. O Módulo precisa de ambos para funcionar. O Cartão SD deverá está formatado com o sistema de arquivos FAT.

Segue abaixo um exemplo de ligação do módulo ao arduino.


Segue o fonte para o arduino UNO

 #include <SD.h>  
 //Pino CS do arduino UNO  
 #define CS 10  
 File myFile;  
 #define FILENAME "teste.txt"  
 void setup()  
 {  
  Serial.begin(9600);  
  Serial.print("Inicializando SD...");  
  pinMode(CS, OUTPUT);//Inicializando pino CS como output  
  if (!SD.begin(CS)) {//Inicializando SD card  
   Serial.println("Falha!");  
   return;  
  }  
  Serial.println("Ok!");  
  if(!SD.exists(FILENAME))//Se nao existe o arquivo  
  {  
   myFile = SD.open(FILENAME, FILE_WRITE);//Abrindo arquivo para gravacao  
   if (myFile)   
   {  
    Serial.print("Escrevendo no arquivo...");  
    myFile.println("teste 1, 2, 3.");  
    myFile.println("teste 4, 5, 6.");  
    myFile.close();  
    Serial.println("fim de escrita.");  
   }   
   else   
   {  
    Serial.println("erro na abertura");  
   }  
  }  
  myFile = SD.open(FILENAME, FILE_READ);//Abrindo o arquivo para leitura  
  char tmp;  
  while(myFile.available())//Enquanto nao chega no fim do arquivo  
  {  
   tmp = myFile.read();//Leitura de cada caractere   
   Serial.print(tmp);  
  }  
  myFile.close();//Fechando arquivo  
 }  
 void loop()  
 {  
  //Nao se faz necessario usar  
 }  

A saída serial deve apresentar algo parecido com:


Até a próxima

domingo, 2 de junho de 2013

ATTiny - Arduino Tiny

Olá, neste artigo iremos falar sobre uma opção barata de processador compatível com a plataforma arduino, o attiny85. Explicaremos como gravar uma aplicação que acende um LED pelo tiny.



O Tiny85 apresenta as seguintes vantagens:

  • É pequeno, tem apenas 8 pinos divididos em 2 blocos de 4;
  • Bem mais barato que um ATMega;
  • Relativamente fácil de programar;
  • Compatível com a IDE do arduino.
Para esse projeto precisaremos dos seguintes componentes:
  • 1 x ATTiny85 PU20
  • 1 x Arduino UNO
  • 1 x Capacitor eletrolítico de 10 uf
  • 1 x Resistor de 220 ohms
  • 1 x LED
Primeiramente devemos preparar a IDE do arduino para compilar código para o tiny.

Passos:
  1. Fazer o download da biblioteca do Tiny aqui.
  2. Descompacte o zip
  3. Abra a pasta Hardware dentro da instalação do arduino e crie uma pasta chamada de attiny
  4. Copie o conteúdo para lá. Deve ficar de acordo com a figura abaixo.
  5. Abra a IDE do arduino e vá em Tools->Board. Deverá aparecer algo como:

    Usaremos o arduino UNO para gravar o programa no tiny e para isso, precisamos carregar o software ArduinoISP. Vá em File->Examples->ArduinoISP. Procure pela função abaixo e troque de 40 para 20 o tempo de delay.

    uint8_t hbval=128;
    int8_t hbdelta=8;
    void heartbeat(){
      if (hbval > 192) hbdelta = -hbdelta;
      if (hbval < 32) hbdelta = -hbdelta;
      hbval += hbdelta;
      analogWrite(LED_HB, hbval);
      delay(20); // <-- alterar essa linha de 40 para 20
    }
    

    Grave o programa ArduinoISP no UNO. Após a gravação, abra o exemplo Blink altere o pino 13 do LED para pino 0. Segue figura.

    /*
      Blink
      Turns on an LED on for one second, then off for one second, repeatedly.
      This example code is in the public domain.
     */
    //Pin 13 has an LED connected on most Arduino boards.
    //give it a name:
    in led = 0;
    
    //this setup routine runs once when you press reset:
    void setup(){
      //initialize the digital pin as an putput.
      pinMode(led, OUTPUT);
    }
    //this loop routine runs over and over again forever:
    void loop(){
      //turn the LED on
      digitalWrite(led, HIGH);
      //wait fora second
      delay(1000);
      //turn the LED off
      digitalWrite(led, LOW);
      //wait for a second
      delay(1000);
    }
    

    Em Tools->Board, selecione ATtiny85(internal 1 MHz clock) e em seguida, em Tools->Programmer, selecione Arduino as ISP.



    Seu programa está pronto para ser carregado. Monte o circuito de acordo com a figura abaixo.


    O Capacitor deve ser usado para evitar que a IDE faça o reset do UNO - Ligando o GND ao pino de Reset. Abaixo a tabela com a ligação dos pinos.


    O programa (Blink alterado) já pode ser gravado. Grave normamente. Nesse momento o arduino UNO irá gravar o código no Tiny. Após a gravação, retire o Tiny e monte o circuito abaixo, Utilize preferencialmente uma alimentação de 5V.


    Eu montei na mesma protoboard os dois circuitos, trocando apenas o tiny de lugar e aproveitei a alimentação do arduino para alimentar o circuito acima.

    Tiny na posição do gravador.


    Tiny em execução, aproveitando a mesma protoboard e alimentacão


    Somente alterei o tiny de posição.

    Até a próxima.

LCD Nokia 5110 e Sensor de Temperatura LM35

Olá, neste artigo falaremos sobre a utilização do LCD Nokia 5110 e o sensor de temperatura LM35 com o arduino.
Também utilizaremos duas bibliotecas externas para acessar o LCD do nokia e uma outra feita por mim para criar menus.
O datasheet do sensor de temperatura LM35 pode ser obtido aqui.
O LCD do nokia, possui os seguintes pinos:

  • RST - Reset
  • CE - Chip Enable
  • DC - Data/Command
  • DIN - Data Input
  • CLK - Clock
  • VCC - Alimentação
  • BL - Backlight
  • GND - Ground

Devem ser ligados no Arduino de acordo com a tabela abaixo:


Segue abaixo o esquema completo do projeto.



A aplicação aqui exemplificada desenhará um menu inicial, um menu de demonstração e um exibindo a temperatura do ambiente.

Menu Inicial:
Menu Temperatura:

A troca entre as telas é feita através do Console Serial informando 1 - para o menu de exemplos, 2 - para o menu de temperatura e 3 ou outro caractere para voltar ao menu inicial. Pode-se colocar botões para substituir a interface serial.

Abaixo um exemplo de saída serial. 


A seguir o fonte desse projeto.

 #include <APIGrafica.h>  
 //Definindo o contraste do LCD  
 #define LCD_CONTRAST 49  
 //Pino analogico do A0 do arduino para o LM35  
 #define sensor 0  
 PCD8544 nokia = PCD8544(3, 4, 5,6,7); // 3 - clk, 4 - din, 5 - dc, 6 - ce, 7 - rst  
 APIGrafica apiGraf = APIGrafica(nokia); //Inicializacao da API Grafica  
 float temperaturaAmb; //Variavel que armazena a temperatura  
 int leituraSensor; //Valor lido pelo sensor  
 char buffer[20]; //Buffer temporario  
 void setup()  
 {  
  nokia.init(LCD_CONTRAST); //Inicializacao do LCD  
  Serial.begin(9600); //Inicializacao da serial  
  menuInicio(); //Carregando o menu inicial  
  Serial.println("Aguardando comando....");  
 }  
 //Menu de exemplo   
 void menu()  
 {  
   apiGraf.clearDisplay(); //Limpando a tela  
   apiGraf.createMenu("Titulo",3); //Setando o titulo do menu  
   apiGraf.setItem(0,"Item 01"); //Setando item 1  
   apiGraf.setItem(1,"Item 02"); //Setando item 2  
   apiGraf.setItem(2,"Item 03"); //Setando item 3  
   apiGraf.selItem(1); //Selecionando o item 1 da tela  
   apiGraf.setTextLeftBTN("Btn1"); //Setando o texto do botao esquerdo  
   apiGraf.setTextRightBTN("Btn2"); //Setando o texto do botao Direito  
   apiGraf.drawMenu(); //Desenhando o menu  
   apiGraf.updateDisplay(); //Atualizando o display  
 }  
 //Utilizando o menu e conjunto com a API do LCD nokia  
 void tempAmb()  
 {  
   apiGraf.clearDisplay();  
   apiGraf.createMenu("Temperatura",3);   
   apiGraf.setItem(0,"");  
   apiGraf.setItem(1,"");  
   apiGraf.setItem(2,"");  
   apiGraf.selItem(-1);  
   apiGraf.setTextLeftBTN("Voltar");  
   apiGraf.drawMenu();  
   //convertendo de float para string  
   dtostrf(temperaturaAmb, 4, 2, buffer);  
   //Desenhando a string na tela  
   nokia.setTextColor(BLACK);  
   nokia.drawstring(0,20,buffer);  
   apiGraf.updateDisplay();  
 }  
 //Menu inicial  
 void menuInicio()  
 {  
   apiGraf.clearDisplay();  
   apiGraf.createMenu("Aguard Serial",3);   
   apiGraf.setItem(0,"1 - Menu");  
   apiGraf.setItem(1,"2 - Temp");  
   apiGraf.setItem(2,"3 - Inicio");  
   apiGraf.setTextLeftBTN("btn1");  
   apiGraf.setTextRightBTN("btn2");  
   apiGraf.drawMenu();  
   apiGraf.updateDisplay();  
 }  
 void lerTemperatura()  
 {  
  leituraSensor = analogRead(sensor); //Lendo o valor do sensor  
  temperaturaAmb = (5.0*leituraSensor*100.0)/1024.0; //Convertendo para float  
 }  
 char comando = 0;//Variavel que armazenara o comando digitado na serial  
 void loop()  
 {  
   if(Serial.available()) //Aguardando dados na serial  
   {  
    comando = Serial.read(); //Lendo serial  
    Serial.print("comando recebido");  
    Serial.println(comando);  
    Serial.println("Aguardando comando....");  
   }  
   switch(comando)  
   {  
    case '1': //Se numero 1  
     menu(); //Desenha menu de exemplo  
    break;  
    case '2': //Se numero 2  
     lerTemperatura(); //Leitura da temperatura  
     tempAmb(); //Desenha menu de temperatura  
    break;  
    default: //Quanquer outro valor  
     menuInicio(); //Desenha menu inicial  
   }  
 }  


Até a próxima.

Tiny RTC I2C Real Time Clock

Olá, neste artigo iremos falar um pouco sobre a utilização de um RTC - Real Time Clock com o arduino. Utilizaremos o módulo Tiny RTC I2C Real Time Clock, figura abaixo:

Esse módulo contém os componentes abaixo:

  • DS1307 - clock
  • EEPROM 24C32AN - memória
  • Bateria de lithium CR2032


Como ele tem uma bateria,  as configurações de data e hora serão mantidas mesmo que o módulo seja desligado. Para maiores informações sobre o módulo clique aqui.

Para a este artigo, utilizaremos a biblioteca RTCLib para trabalhar com o módulo que pode ser baixada aqui.

Abaixo uma tabela com a pinagem que deve ser seguida para ligar o módulo ao arduino.


Segue uma foto, ilustrando a ligação.



Segue um código exemplo para testar o módulo.

#include <Wire.h>
#include <RTClib.h>
//RTC - Real Time Clock
RTC_DS1307 RTC;
//Inicializacao dos modulos 
void setup () {
    //Inicialozacao da serial
    Serial.begin(9600);//Inicializacao da serial
    Wire.begin();//Inicializacao do protocolo wire
    RTC.begin();//Inicializacao do modulo RTC
  //Verifica se o modulo esta funcionando ou nao
  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    //Ajusta a data/hora do Clock com a data/hora em que o codigo foi compilado, basta descomentar a linha
    //RTC.adjust(DateTime(__DATE__, __TIME__));
  }
}
void loop () {
    DateTime now = RTC.now();//Recuperando a data e hora atual
    Serial.print(now.day(), DEC);//Imprimindo o dia
    Serial.print('/');
    Serial.print(now.month(), DEC);//Recuperando o mes
    Serial.print('/');
    Serial.print(now.year(), DEC);//Recuperando o ano
    Serial.print(' ');
    Serial.print(now.hour(), DEC);//Recuperando a hora
    Serial.print(':');
    Serial.print(now.minute(), DEC);//Reci[erando os minutos
    Serial.print(':');
    Serial.print(now.second(), DEC);//Recuperando os segundos
    Serial.println();
    delay(3000);//A leitura sera repetida a cada 3 segundos
}

O código acima deve gerar uma saída similar no console serial conforme abaixo.


Até a próxima.

sábado, 1 de junho de 2013

Ponte H com transistores

Neste artigo exemplificaremos o uso da Ponte H (artigo anterior) com transistores em conjunto com o arduino.

Lista de componentes:
  • 1 x Arduino
  • 4 x Resistores de 470 ohms
  • 4 x Transistores TIP120
  • 2 x Diodos 
  • 1 x Protoboard
  • 1 x Bateria 9V
  • 1 x Chicote para ligar a bateria 
  • 1 x Motor CC
  • Alguns fios
Os mesmos devem ser ligados de acordo com o diagrama abaixo:


Os diodos devem ser colocados entre o arduino e a ponte, para evitar que algum tipo de corrente gerada pelos motores volte para o arduino e queime o mesmo. Segue abaixo o diagrama esquemático do circuito.


Abaixo uma imagem do circuito montado.


Com esse circuito é possível controlar a direção e velocidade do motor, através dos pinos 5 e 6 do arduino. É importante frisar que a tabela abaixo deve ser respeitada pois poderá haver curto-circuito.


Segue abaixo um código exemplo para o arduino. Ele inverterá o sentido do motor a cada 5 segundos.

//Pinos 5 e 6 do arduino utilizados como saida para controla o sentido do motor
int sentido1 = 5;
int sentido2 = 6;
//Funcao de inicializacao:
void setup(){
  //Pinos inicializados como saida.
  pinMode(sentido1, OUTPUT);
  pinMode(sentido2, OUTPUT);
}
//Contador de segundos do motor ligado
int segundos = 1;
//loop principal chamado eternamente
void loop(){
  if(segundos <= 5){
    //Ligando o motor em um sentido
    digitalWrite(sentido1, HIGH);
    digitalWrite(sentido2, LOW);
  } else {
    //Ligando o motor em outro sentido
    digitalWrite(sentido1, LOW);
    digitalWrite(sentido2, HIGH);
  }
  segundos++;
  //Se passou de 10 segundos, reinicia o contador
  if(segundos > 10)
    segundos = 1;
  //Aguarda 1 segundo
  delay(1000);
}
Softwares utilizados:
  • IDE arduino versão 1.0.1 - compilação e carga do programa
  • Fritzing - diagramas do circuito
Datasheets:

Até a próxima!

segunda-feira, 27 de maio de 2013

Ponte H

O que é?

A ponte H é um circuito com quatro chaves que são acionadas de forma alternada, fundamental para o desenvolvimento de dispositivos, capaz de controlar motores de corrente contínua, através de sinais elétricos permitindo assim o controle do sentido, potência e velocidade.

Como Funciona?

A ponte H é um circuito com quatro chaves que são acionadas de forma alternada (chave 1 e chave 4 ou chave 2 e chave 3). Na primeira configuração das chaves, o motor girará em um sentido e, utilizando a segunda configuração o motor girará no sentido contrário. Segue abaixo circuito que exemplifica o seu funcionamento:
Na figura mais da esquerda você verifica que a seta do motor está apontando para cima. Isso devido as chaves S1 e S4 estarem fechadas, fechando assim o circuito num sentido.
Na outra figura verifica-se que a seta do motor está apontando para baixo devido as chaves S2 e S3 estarem fechadas, fechando assim o circuito no outro sentido.

Inicialmente, o propósito é consolidarmos algumas teorias para quando chegarmos na implementação os conceitos já tenham sido entendidos evitando assim que se implemente algo sem ao menos entender como funciona.




sexta-feira, 24 de maio de 2013

Apresentação

Olá Arduinistas de plantão...

Eu, juntamente com meu amigo Fernando Rebouças, vamos aqui postar informações sobre nossas experiências com o Arduino.

Pretendemos postar dicas para os mais variados níveis, seja você um entusiasta e/ou um profissional da área.

Nossa idéia é estar trocando experiências com vocês para assim fazermos, desse espaço, um local de troca de experiências.