Grade de Aulas Curso Arduino Automation

Semestre 1 – 2013

• Aula 1 – Ethernet Shield
  • Dilema do Ethernet Shield e a dificuldade de aprendizado
  • Diferenças entre os modelos de Ethernet Shield (W5100, ENC28J60, Shield e Módulo)
  • Discussão sobre as bibliotecas existentes e a dificuldade de utilização delas
  • Apresentação da biblioteca EthernetSup.h
    • Especialmente desenvolvida para simplificar o uso do Ethernet Shield com Arduino
  • Conexão com o Arduino, através do conector ICSP
  • Opções de conexão do Ethernet Shield com a rede local
  • Configurações de roteadores e disponibilidade da automação através da Internet
• Aula 2 – Acionamento de Cargas por Relês
  • Apresentação do Módulo de Relês de 4 Canais
  • Esquemas de ligação de cargas
    • Lâmpada
    • Ventilador
  • Acionamento de cargas
  • Abertura de Fechadura Elétrica
  • Detalhes da instalação da Fechadura
• Aula 3 – Controle de Cargas por TRIAC's
  • Controle de velocidade do ventilador
  • Apresentação do Módulo Dimmer
  • Programação do Ethernet Shield para contemplar controle Dimmer
• Aula 4 – Plataforma Supervisório
  • Apresentação do Arduino Supervisório
  • Modos de operação e gravação do programa no Arduino
  • Kit de acessórios do Supervisório
    • Shield Supervisório
    • Módulo Conversor Supervisório (converte pinos em bornes)
    • Módulo Distribuidor de Alimentação Supervisório
    • Módulo Conversor de Alimentação Supervisório
    • Módulo LCD Supervisório
    • Módulo Nobreak Supervisório
  • Detalhes da instalação e fixação em painéis e caixas
• Aula 5 – Integração com Infra-Vermelho
  • Acionamento de Ar-condicionado via Infra-Vermelho
  • Mapeamento das teclas do controle remoto do Ar-condicionado
  • Instalação do Emissor Infra-Vermelho com Plataforma Supervisório
  • Programação do Ethernet Shield para contemplar integração Infra-Vermelho
• Aula 6 – Integração Wireless
  • Utilização de módulos Wireless 433Mhz
  • Integrando com motores EMTECO de persiana
  • Mapeamento e clonagem de controles Wireless com função pulseIn() do Arduino
  • Acionamento de portões de garagem utilizando o HT12 com módulo Wireless
  • Shield Ethernet Wifi

Semestre 2 – 2013

• Aula 7 – Android (ADK)
  • Integrando Arduino com Android via Kit de Desenvolvimento do Android (ADK)
  • Utilização do USB Host Shield
  • Programando aplicativo Android com Java para integração com Arduino
• Aula 8 – Controle de Consumo & Queda de Energia
  • Sensor de corrente
  • Controle do consumo da energia elétrica
  • Chaveamento de energia elétrica por baterias para sistema continuar funcionando mesmo em caso de queda de energia
• Aula 9 – Módulo GSM
  • Utilização de sensor de movimento PIR
  • Envio de SMS's com eventos de sensores de movimento
• Aula 10 – Motores
  • Acionamento de motores de vidro-elétrico para abertura de janelas
  • Apresentação do Módulo de Ponte H de 5 amperes
  • Motores de precisão (Motor de passo) para posicionamento de aletas de persiana
  • Apresentação da placa Chopper
• Aula 11 – Sensores de Luminosidade e Temperatura
  • Sensor LM35 para determinar temperatura ambiente e regular o Ar-condicionado automaticamente
  • Ligação de LDR (sensor de luminosidade) para determinar a abertura de persiana
• Aula 12 – Comando de Voz
  • Módulo EasyVr para reconhecimento de voz
  • Abertura da fechadura através de comandos de voz
  • Acionamento de cargas através de comandos de voz

Material Necessário

• Aula 1 – Ethernet Shield
  • Essencial
    • Ethernet Shield W5100
    • Arduino UNO
    • Roteador
    • Cabo de Internet
    • Computador
  • Opcional
    • Nano Roteador TL-WR702N
    • Ethernet Shield ENC28J60
• Aula 2 – Acionamento de Cargas por Relês
  • Essencial
    • Material da Aula 1
    • Módulo de Relê de 4 Canais
    • Fechadura Elétrica 12V
    • Lâmpada
    • Ventilador
  • Opcional
    • Fio de cobre para ligação elétrica
    • Terminais de tomada
    • Conectores Sindal
    • Soquete para lâmpada
    • Capacitor de Poliester de 3300uF (se ventilador for de teto)
• Aula 3 – Controle de Cargas por TRIAC's
  • Essencial
    • Material da Aula 1
    • Módulo Dimmer
• Aula 4 – Plataforma Supervisório
  • Essencial
    • Material da Aula 1
    • Arduino Supervisório
  • Opcional
    • Módulo USB/Serial FTDi
    • Acessórios da plataforma Supervisório
    • Painel ou caixa para fixação
    • Suportes plásticos para fixação
• Aula 5 – Integração com Infra-Vermelho
  • Essencial
    • Material da Aula 1
    • Aparelho controlado por Infra-Vermelho (Ar-condicionado, TV etc)
    • Kit Infra-Vermelho (Emissor/Receptor)
  • Opcional
    • Material da Aula 4
• Aula 6 – Integração Wireless
  • Essencial
    • Material Aula 1
    • Kit Wireless 433Mhz
    • Motor EMTECO para persianas
  • Opcional
    • Kit Motor para Portão Eletrônico Deslizante PPA ¼ HP
    • Fechadura Elétrica Wireless 433Mhz
    • Shield WiFi 802.11b
• Aula 7 – Android (ADK)
  • Essencial
    • Arduino UNO
    • USB Host Shield
    • Celular/Tablet Android
    • Cabo USB
    • Computador PC
  • Opcional
    • Arduino MEGA ADK
• Aula 8 – Controle de Consumo & Queda de Energia
  • Essenciais
    • Material da Aula 1
    • Módulo Sensor de Corrente
    • Módulo Nobreak Supervisório
• Aula 9 – Módulo GSM
  • Essencial
    • Material da Aula 1
    • Sensor de Movimento PIR
    • Módulo GSM/GPRS SIM900
• Aula 10 – Motores
  • Essencial
    • Material da Aula 1
    • Motor Mabuschi 8 Dentes (Máquina de vidro-elétrico)
    • Módulo Ponte H 5A
    • Motor de Passo NEMA 23
    • Módulo Driver Chopper 5A
  • Opcionais
    • Correias e Polias Sincronizadoras
• Aula 11 – Sensores de Luminosidade e Temperatura
  • Essenciais
    • Material da Aula 1
    • Sensor LM35
    • Sensor LDR
  • Opcionais
    • Sensor de Temperatura e Umidade DHT11
• Aula 12 – Comando de Voz
  • Essencial
    • Material da Aula 1
    • Módulo EasyVr
  • Opcional
    • Auto-falantes

Previsão de lançamento: Março 2013

Grade de Aulas do Curso Arduino Pró

• Aula 1 – Bootloader
  • Entendendo como funciona o bootloader
  • Diferenças entre as versões das boards do Arduino
  • Conhecendo melhor o microcontrolador (ATMega), o cérebro do Arduino
  • Vamos aprender o que faz o Arduino ser um Arduino
• Aula 2 – Arrays e Ponteiros
  • Entendendo como funcionam ponteiros de memória
  • Conhecendo as diferenças entre arrays e ponteiros
  • Limitações e usos dos arrays e de ponteiros
• Aula 3 – Classes
  • Aprendendo a criar classes e consumir objetos
  • Utilizando Programação Voltada ao Objeto (OOP) no Arduino
  • Passando parâmetros e ponteiros para funções dentro de classes
• Aula 4 – Memórias
  • Entendendo as diferentes memórias que fazem parte do microcontrolador
  • Conhecendo a biblioteca FreeMem.h – ajuda a controlar o uso da memória RAM
  • PROGMEM – Variáveis armazenadas na memória de programação ao invés da RAM
• Aula 5 – Operadores Binários
  • Conhecendo os operadores binários Bitwise
  • Diferenças entre os operadores Boolean e Bitwise
  • Aplicando transformações com operadores Bitshift
  • Conversão de tipos, desmembrando e reagrupando bytes
• Aula 6 – AVRDude
  • Conhecendo a ferramenta de upload de código para o Arduino
  • Aprendendo como os programas são compilados e publicados no ATMega328
  • Diferenças entre upload através de bootloader e via programador
• Aula 7 – Fuse Bits
  • Aprendendo como configurar os Fuse bits e para que servem
  • Bloqueando o código no ATMega328 para evitar cópia por outras pessoas
  • Configurando o ATMega328 para funcionar sem cristal externo
• Aula 8 – Acesso Direto a Portas
  • Acessando diretamente as portas do Arduino sem utilização de funções
  • Configurando as portas diretamente pelos registradores internos
  • Conhecendo os registradores de configuração DDR
  • Escrevendo nas portas através dos registradores PORT
  • Lendo das portas através dos registradores PIN
• Aula 9 – Timers & Contadores
  • Explorando os timers internos do microcontrolador do Arduino
  • Detectando estouro de contagem através de interrupções dos contadores
  • Fazendo cálculos de tempos independentes da execução principal do código
  • Aprendendo mais sobre interrupções e seus vetores
• Aula 10 – DAC
  • Conversão analógica digital com Arduino
  • Entendendo o pino ARef e o valor de referência para conversão
  • Utilizando buffers de saída PWM
    
    

Previsão de lançamento: Segunda quinzena de Fevereiro de 2013

Criando Bibliotecas no Arduino

Este documento explica como criar bibliotecas para o Arduino. Começaremos com um programa exemplo de Código Morse, explicando como converter suas funcionalidades em uma biblioteca. Isto permite que outras pessoas possam facilmente utilizar seu código receber atualizações, conforme você melhorar a biblioteca.

Começamos com este Sketch (programa) que lida com Código Morse:

int pin = 13;

void setup()
{
  pinMode(pin, OUTPUT);
}

void loop()
{
  dot(); dot(); dot();
  dash(); dash(); dash();
  dot(); dot(); dot();
  delay(3000);
}

void dot()
{
  digitalWrite(pin, HIGH);
  delay(250);
  digitalWrite(pin, LOW);
  delay(250);
}

void dash()
{
  digitalWrite(pin, HIGH);
  delay(1000);
  digitalWrite(pin, LOW);
  delay(250);
}

[Get Code]

Se você executar o sketch acima, ele piscará o código S.O.S. na porta 13.

Este sketch possui partes diferentes que serão implementadas na nossa biblioteca. Primeiro, é claro, temos as funções dot() and dash() que executam a funcionalidade de piscar. Segundo, temos a variável ledPin que é utilizada pelas funções para determinar qual porta utilizar. Finalmente, temos a chamada da função pinMode() que inicia a porta como saída.

Vamos começar a transformar esse sketch em uma biblioteca!

Você precisa de pelo menos dois arquivos para criar uma biblioteca: um arquivo de cabeçalho (header file), com a extensão .h, e o arquivo de código-fonte (source file), com a extensão .cpp. O arquivo de cabeçalho possui as definições da biblioteca: basicamente uma listagem de tudo que a biblioteca possui; enquanto o arquivo de código-fonte, é o código real, que executa as funções. Vamos chamar nossa biblioteca de "Morse", então nosso arquivo de cabeçalho será Morse.h. Vamos ver o que vai dentro dele. Pode parecer um pouco estranho a primeira vista, mas fará mais sentido quando você vir o código-fonte, que acompanha este arquivo.

O truque desse arquivo de cabeçalho é criar em uma linha para cada função da biblioteca, contida em uma classe, acompanhada das variáveis que você utilizará:

class Morse
{
  public:
    Morse(int pin);
    void dot();
    void dash();
  private:
    int _pin;
};

[Get Code]

Uma classe é simplesmente uma coleção de funções e variáveis que estão organizadas em um pacote. Estas funções e variáveis, podem ser public (públicas), significando que podem ser acessadas pelos programadores que a implementarão, ou private (privada), significando que elas só podem ser utilizadas internamente na classe em si. Cada classe tem uma função especial conhecida por constructor (construtor), que é utilizada para criar uma instância da classe, em tempo de execução. O construtor possui o mesmo nome da classe, e sem tipo de retorno.

Você precisa de algumas outras coisas no seu arquivo de cabeçalho. Uma delas é uma declaração #include que lhe dá acesso aos tipos e constantes da linguagem do Arduino (isto é automaticamente feito quando você cria um sketch, mas não em uma biblioteca, devendo ser adicionado manualmente).

#include "Arduino.h"

[Get Code]

Finalmente, é comum empacotar o arquivo de cabeçalho, em uma construção de declarações, com a seguir:

#ifndef Morse_h
#define Morse_h

// the #include statment and code go here...

#endif

[Get Code]

Basicamente, isto previne que alguém acidentalmente adicione mais de uma vez o cabeçalho da sua biblioteca.

Para encerrar, normalmente colocamos um comentário no início do arquivo, com o nome da biblioteca, uma breve descrição, nome do autor, data e termos de uso.

Vamos dar uma olhada no arquivo de cabeçalho completo:

/*
  Morse.h - Library for flashing Morse code.
  Created by David A. Mellis, November 2, 2007.
  Released into the public domain.
*/
#ifndef Morse_h
#define Morse_h

#include "Arduino.h"

class Morse
{
  public:
    Morse(int pin);
    void dot();
    void dash();
  private:
    int _pin;
};

#endif

[Get Code]

Agora veremos as várias partes do arquivo de código-fonte, Morse.cpp.

Primeiro vem umas declarações #include. Elas trazem o código necessário para as funções básicas do Arduino, e as definições implementadas no seu arquivo de cabeçalho:

#include "Arduino.h"
#include "Morse.h"

[Get Code]

Então vem o construtor. Novamente, ele é iniciado cada vez que alguém cria uma instância da sua classe. Neste caso, o usuário especifica qual porta ele deseja utilizar. Configuramos então a porta como saída, gravando o parâmetro em uma variável privada, utilizada posteriormente em outras funções:

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

[Get Code]

Este código possui algumas coisas estranhas nele. Primeiro é o Morse:: antes do nome da função. Ele mostra que a função é parte da classe Morse  Você verá isto novamente na criação das outras funções da classe também. A segunda coisa é o underline (traço-baixo) no nome da nossa variável privada, _pin  Esta variável pode ter qualquer nome que você desejar, desde que coincida com a definição no arquivo de cabeçalho. Adicionar um underline no começo do nome é uma convenção para clarificar a ideia de que a variável é privada e também distinguir do nome de argumento da função.

Em seguida, temos o código realmente originado do sketch que estamos transformando em biblioteca. Não mudou, muito, exceto pelo Morse:: na frente dos nomes das funções, e _pin ao invés de pin:

void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250); 
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

[Get Code]

Finalmente, é comum incluir o comentário no início, como fizemos no arquivo do cabeçalho. Vamos ver como ficou o código-fonte completo:

/*
  Morse.cpp - Library for flashing Morse code.
  Created by David A. Mellis, November 2, 2007.
  Released into the public domain.
*/

#include "Arduino.h"
#include "Morse.h"

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250); 
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

[Get Code]

E isto é tudo que você precisa (existem algumas coisas adicionais interessantes, mas falaremos disso a seguir). Vamos ver como utilizar nossa biblioteca.

Primeiro, crie um diretório chamado Morse dentro do sub-diretório libraries do seu sketchbook (lugar padrão onde salva os sketches que você cria). Copie ou mova os arquivos Morse.h e Morse.cpp para esse diretório. Agora inicie o programa do Arduino (IDE). Se você abrir o menu Sketch > Import Library, verá que a biblioteca Morse está lá. A biblioteca será compilada com os sketches que a utilizarem.

Vamos ver como vai ficar nosso sketch SOS agora, usando a biblioteca:

#include

Morse morse(13);

void setup()
{
}

void loop()
{
  morse.dot(); morse.dot(); morse.dot();
  morse.dash(); morse.dash(); morse.dash();
  morse.dot(); morse.dot(); morse.dot();
  delay(3000);
}

[Get Code]

Existem algumas diferenças entre a versão original e este novo sketch (além do código que foi movido para dentro da biblioteca).

Primeiro, adicionamos uma declaração #include, no início do sketch. Isto faz a biblioteca Morse se tornar disponível durante o código. Isso significa que ao encontrar essa linha o compilador vai linkar o código da biblioteca e publicar na placa. Ou seja, caso não vá utilizar mais a biblioteca, lembre-se de retirar essa linha para o seu sketch gerar um arquivo final menor.

Segundo, declaramos uma instância da classe Morse, chamada morse :

Morse morse(13);

[Get Code]

Quando esta linha é executada (o que acontece até mesmo antes da função setup()), o construtor da classe Morse será chamado, passando o argumento da porta (no nosso caso, 13).

Finalmente, para chamar as funções dot() e dash(), você precisa utilizar um prefixo morse. - o nome da instância (objeto) que queremos utilizar. Podemos ter várias instâncias da classe Morse, cada qual configurando uma porta diferente, independentemente umas das outras com suas próprias variáveis privadas. Fazemos isso alterando o parâmetro inicial que será passado, conforme exemplo:

Morse morse(13);
Morse morse2(12);

[Get Code]

então dentro da chamada na função morse2.dot(), _pin seria 12.

Se você testou o novo sketch, provavelmente notou que alguns termos de nossa biblioteca não ficaram ressaltados pelo esquema de cores do Arduino. Infelizmente o programa do Arduino não pode reconhecer automaticamente o que você define dentro da biblioteca (embora essa seria uma funcionalidade interessante para as próximas versões), então você precisa dar uma mãozinha, criando um arquivo chamado keywords.txt dentro do diretório Morse. Deve se parecer com este:

Morse   KEYWORD1
dash    KEYWORD2
dot     KEYWORD2

[Get Code]

Cada linha tem o nome da palavra-chave, seguida por uma tabulação (não espaços), seguidos pelo tipo da palavra. As classes devem ser do tipo KEYWORD1, e coloridas de laranja; funções devem ser do tipo KEYWORD2, e serão marrons. Você deve reiniciar o ambiente do Arduino para que as modificações sejam aplicadas.

Seria bacana enviar um exemplo do uso da biblioteca junto com o pacote. Para fazer isso crie um diretório examples dentro do diretório Morse  Então copie ou mova o diretório contendo o sketch do SOS  que criamos, acima. Se você reiniciar o Arduino mais uma vez, a última, prometo - você verá sua Library-Morse dentro do menu File > Sketchbook > Examples.

Adicionalmente você pode adicionar comentários no seu código de exemplo para ensinar as pessoas como utilizar sua biblioteca.

Se você quiser o código completo da biblioteca (com exemplos de palavras-chave), você pode baixar aqui: Morse.zip.

Fonte: http://arduino.cc/en/Hacking/LibraryTutorial

Curso Arduino Advanced - Aula 17 (Bluetooth)

Pessoal,

Segue o link para acessar o código fonte desta aula sobre bluetooth e o Arduino:

http://seriallink.com.br/forum/viewtopic.php?f=71&t=1554

Abraços,
Renato

Fórum do Curso do Arduino

Pessoal,

Estou publicando este post para divulgar o fórum do Curso do Arduino no endereço do meu site:

http://www.seriallink.com.br/forum

Por favor utilizem o fórum para dúvidas técnicas e discussões sobre os posts feitos no blog.

Abraços,
Renato Aloi

Código Fonte - Aula 15 do Curso Arduino Advanced (PHP)

Pessoal,

Segue o código utilizado no Arduino:


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

void loop()
{
  if (Serial.available())
  {
    char recebido = Serial.read();
    if (recebido = 't')
    {
      int valorLido = analogRead(0);
      float temperatura = (valorLido * 0.00488) * 100;
      Serial.print("Temperatura: ");
      Serial.println(temperatura);
    }
  }
}

Código utilizado no PHP:




<?php

//MAC/Linux
//$portAddress = '/dev/tty.XYZ';

//Windows
$portAddress = 'COM3';
exec("mode com3: BAUD=9600 PARITY=N data=8 stop=1 xon=off");

echo(" <h1> Temperatura Via Arduino </h1> ");

echo(" <p> Conectando, aguarde...");
$port = fopen($portAddress, 'w+');
if(!$port)
{
echo " <br /> Nao foi possivel abrir a porta $portAddress";
}
else
{
echo " <br /> Conectado com sucesso na porta $portAddress";
}
echo(" </p> ");


sleep(3);
fwrite($port, 't');

sleep(1);
echo fgets($port);

fclose($port);

?>

Código Dimmer Digital AC - Aula 14

Pessoal,

Conforme prometido na Aula 14 do Curso Arduino Advanced, segue o código do Dimmer Digital AC com TRIAC:


int UP = 7;
int DOWN = 8;
int LAMP = 3;  
int dimming = 128;
int counts = 7;
int dimmer[7] = { 1, 105, 100, 75, 50, 25, 10 };
int i = 0;

void setup()
{
  //Serial.begin(9600);
  //delay(1000);
  pinMode(UP, INPUT);
  pinMode(DOWN, INPUT);
  pinMode(LAMP, OUTPUT);
  digitalWrite(UP, HIGH);
  digitalWrite(DOWN, HIGH);
  attachInterrupt(0, zero_crosss_int, RISING);
}

void loop()
{
  if (!digitalRead(UP) || !digitalRead(DOWN))
  {
    if (verifica_botao(UP))
    {
      if (i < (counts - 1)) i++;
      //Serial.print("UP: ");
      //Serial.println(i, DEC);
    }
    else if (verifica_botao(DOWN))
    {
      if (i > 0) i--;
      //Serial.print("DOWN: ");
      //Serial.println(i, DEC);
    }
  }
  //Serial.print("VALOR: ");
  //  Serial.println(i, DEC);
  dimming = dimmer[i];
  delay(100);
}

void zero_crosss_int()
{
  int dimtime = (65 * dimming);    
  delayMicroseconds(dimtime);  
  digitalWrite(LAMP, HIGH);  
  delayMicroseconds(8.33);        
  digitalWrite(LAMP, LOW);  
}

byte verifica_botao(byte botao)
{
  if (!digitalRead(botao))
  {
    unsigned long tempo = millis() + (150 - dimming);
    while(tempo > millis())
    {
     if (digitalRead(botao)) return LOW;
    }
    return HIGH;
  }
  else
    return LOW;
}