Postagem em destaque

Controle PID de Potência em Corrente Alternada - Arduino e TRIAC - Parte I

Este post é o primeiro de uma série de seis que escrevi tratando de controle de potência e PID (controle proporcional, integral e derivativo...

quarta-feira, 28 de janeiro de 2015

And so... Arduino Yún! - Parte II

Este é o segundo post de uma série sobre o Arduino Yún. A primeira parte vc acha aqui.

Chega de pago, som na caixa. Primeiro vamos usar o Yún exatamente como se fosse um "Arduino comum", ou seja, programando pela USB.

Nada mais fácil: primeiro é preciso atualizar a IDE do Arduino ("pograminha" que a gente usa prá programar os outros Arduinos) para que suportem a nova plaquinha. Para isso, é só clicar . Procure pela versão compatível com o Yún que seja mais adequada para o seu caso (Mac, PC ou Linux).

Para programar a plaquinha agora o procedimento é o mesmo de se programar qualquer Arduino via USB. O cabo é que é um pouco diferente, já que a ponta que vai no Yún é daquelas tipo mini-USB, dessa daí do lado.

Uma vez feito o download, ao executar o programa vemos que agora aparece o Yún entre as opções de placa da lista, como você pode ver na imagem abaixo:









Na hora de selecionar a porta, outra surpresa: agora o programa indica em qual porta o Yún está conectado, o que é uma ótima dica para quem tem um monte de portas. Espiem aí ao lado:








A partir daí, é só alegria! Selecione o programa Arduino que vc queira (que tal o bom e velho Blink?) e mande ver.

Você pode rodar quaaaase todo sketch que vc tenha rodado um dia num Arduino Uno. Porque o "quaaaaase"? Porque a maior compatibilidade dessa placa é com o Leonardo, um Arduino não muito popular principalmente cá no Brasil. Existem alguns shields que são muito específicos para o Uno e que podem não funcionar, mas eu não sei dizer (ainda) de nenhum específico.

Prá terminar, dois detalhes que me chamaram a atenção sobre o Yún, um legal, outro nem tanto mas que tem conserto:


O detalhe legal são as definições das portas escritas nas laterais dos conectores. Melhor de ver, na minha opinião.

O problema, que dá prá ver também nessa foto, é que os conectores ficaram mais baixos que o conector USB e o Ethernet (ao fundo, à esquerda), fazendo com que um shield com pernas curtas possa não se encaixar direito e, mais grave, pode dar um curto por entrar em contato com trilhas e soldas na parte inferior do shield.

Pensei então numa solução: peguei um conjunto de terminais de shield que vende por aí e eu tinha em casa e coloquei como um espaçador. Ficou grande (ou seja, podemos cortar os pinos para melhorar), mas vocês podem ter uma ideia na foto abaixo:


Deu prá ver que resolveu, ou seja, o shield ficará mais alto que os conectores USB e de rede.

E... por hoje é só. Na próxima veremos como usar recursos do "Yún como Yún", quer dizer, usar características específicas do brinquedim.

Abracadabraço!



domingo, 25 de janeiro de 2015

And so... Arduino Yún! - Parte I

No dia do meu aniversário de 50 anos, em 13/12 passado, meu amigo Tiago, um Arduino-aficcionado a quem eu tive o prazer de apresentar o mundo das plaquinhas, trouxe-me direto de NYC dois brinquedinhos novos: um Google Chromecast e um Arduino Yún. O Chormecast foi logo espetado na TV e passou imediatamente a prestar os seus serviços.

Já o Yún ficou na caixa algum tempo e, como vieram as férias, fim de ano etc, só agora tive um tempo para começar a explorá-lo. Boralá?

Esta é a plaquinha:


Como dá prá ver, ela tem mais ou menos a cara de um Arduino Uno, e o mesmo tamanho. Apesar disso, ela é muito mais que o Uno. Senão vejamos:

Um pouco de história

Quando foi lançado, já nos idos de 2005, o primeiro modelo de Arduino trouxe um conceito novo ao mundo: uma plaquinha única contendo microprocessador, clock, porta serial, regulador de tensão e portas de entrada e saída, bem como uma IDE (software editor de programas) integrada capaz de compilar e enviar os programas direto para o processador. Além disso, o produto foi lançado como "hardware livre", quer dizer, os caras não patentearam o produto e publicaram toda a documentação para reproduzi-lo livremente na internet, de maneira que imediatamente começaram a aparecer clones vendidos por todo o mundo, e a plataforma Arduino foi fazendo um sucesso cada vez maior. No início de 2013 tinham sido vendidas 700k placas "oficiais", e estima-se que exista uma n"ao-oficial para cada oficial. O preço, hoje em torno de $15 por um modelo típico também ajudou, claro.

Pode-se afirmar, sem medo de errar, que o Arduino revolucionou o ensino e a prática de automação, robótica e mesmo programação, já que tudo o que vc precisa para controlar dispositivos está contido numa única plaquinha. Uma ideia na cabeça e um Arduino na mão é o suficiente.

Vários modelos foram lançados pelo pessoal do Arduino, todos com a mesma filosofia: microcontroladores diferentes, mais ou menos memória e portas de E/S, tamanho menor ao maior, mas o mesmo conceito: microcontrolador único, sem sistema operacional, perfeito para uso em controle e automação.

Com o tempo, outras iniciativas apareceram com conceitos um pouco diferentes. Exemplo: o Raspberry Pi, plaquinha do tamanho de um cartão de crédito, capaz de rodar algumas distribuições Linux, usando cartões de memória tipo SD como "HD". Possui também uma porta HDMI para ser ligada a monitores e TVs, ao mesmo tempo em que possui também pinos para conexão de entrada e saída de dados. O preço também em conta, em torno de $35, mas não foi adotado o conceito do hardware livre.

Interessante que o assunto interessou também os gigantes do hardware e software, que também lançaram suas iniciativas, ex:

- Microsoft: NetDuino, capaz de rodar uma versão do .Net Framework.
- Intel: Galileo e Edson.

Algumas alternativas possuem alguma compatibilidade com o Arduino, por exemplo a posição dos pinos de E/S compatível, o que facilita a interconexão com hardwares (shields) desenvolvidos para o Arduino.

A questão é que, por terem um sistema operacional, as plaquinhas de outros fabricantes, apesar de terem clocks bem mais rápidos, acabam sendo mais lentas quando se trata de controle em tempo real. Isso porque o sistema operacional traz várias demandas a serem atendidas (segurança, vídeo, rede etc) que fazem com que um RPi com um clock de 700 MHz tenha problemas para controlar mais de um servo enquanto o Arduino, do alto dos seus 16 MHz possa controlar 5 servos com um pé nas costas.

Isso faz com que a gente às vezes tenha que colocar um Arduino junto para fazer o "trabalho sujo", ou seja, fazer o controle do hardware enquanto o RPi (ou Galileo etc) roda a parte nobre, ou seja, o software mais sofisticado.

Ao lado, um exemplo de um projeto combinado. O sistema publica um site que, hospedado numa instância Apache que roda no RPi (dentro da caixa plástica transparente), exibe em tempo real as imagens da câmera do RPi (quadradinho preto). O posicionamento da câmera pode ser ajustado pelos dois servo-motores (em azul, abaixo da câmera). Para que isso funcione foi necessário colocar um Arduino para comandar os motores e criar uma comunicação I2C entre Arduino e Pi para que o comando enviado pela internet ao Pi seja transmitido para o Arduino.

Em cena, o Yún

O Yún foi concebido para preencher essa lacuna. Ele é uma espécie de 2 em 1: tem um processador AR0331, que "roda" o Linux, e outro, o ATMega 32U4, que é um microcontrolador típico da plataforma Arduino. Isso proporciona o melhor dos dois mundos: um microprocessador rodando um sistema operacional e um microcontrolador para interagir com o hardware.

Para comunicar um "mundo" com o outro, protocolo serial com uma camada de software que os caras chamam de Bridge.

Como se não bastasse: o Yún tem ainda WiFi, duas portas USB em vez de uma (mais sobre isso à frente) e uma porta Ethernet (conexão de rede). Tudo isso mantendo a mesma pinagem do Arduino Uno, ou seja, compatível com tudo o que existe em termos de shields para a plataforma Arduino.

O foco do Yún, como se pode perceber, é a interação pela internet, mais especificamente IoT, Internet das Coisas.

Aliás, Yún quer dizer "Nuvem", em chinês. Em mandarim:

Cool, isn´t it?

Tudo isso por aproximadamente US$74,00 (nos EUA)

Nos próximos posts, mais sobre o brinquedinho.

Automação no Parque, 24/1/2015

Ontem no Parque a brincadeira, só para variar, "teve boa".

Um projeto que apareceu, de um aluno de graduação, foi de monitoramento pela web de incêndios. A ideia é monitorar o aumento da temperatura e a presença de gases e fumaça advindos da combustão ou potencialmente perigosos (combustíveis como o butano, nosso "gás de cozinha").

No primeiro momento nos dedicamos aos sensores que o camarada (prá variar, me esqueci do nome dele...) trouxe. O primeiro que exploramos foi o detetor de fumaça, o tal do MQ-2, cujo datasheet vc pode ver clicando .


 O sensor fica protegido por uma tela metálica, e é preso num break (plaquinha) onde estão os conectores e também um trimpot (potenciômetro) que pode ser usado para ajustar a sensibilidade do dito.

Ele é capaz  de detectar a presença de butano, GLP, metano, álcool, hidrogênio (todos estes gases inflamáveis) e fumaça. Aqui vc encontra uma discussão detalhada sobre o princípio de funcionamento desses sensores, chamados eletroquímicos.

Deve ser alimentado com 5Vcc, e tem duas saídas de dados (nesse modelo que a gente usou, de quatro pinos): uma saída analógica, de 0 a 5V, cujo sinal pode ser lido diretamente em uma entrada analógica do Arduino. A outra saída é digital, onde, de acordo com o ajuste de sensibilidade feito no pot, aparece um sinal de 5V quando a presença de gases é detetada. Tem também um LED verde que indica visualmente a presença de gases e um outro que indica que a bagaça tá ligada. Outros modelos podem ter somente um dos sinais, analógico ou digital, ou ainda não ter os LEDs.

Ligar o bicho, mamão com açúcar: Vcc no pino de 5V do Arduino, GND com GND e a saída digital ou analógica, dependendo do que vc resolver usar, numa porta correspondente do Arduno. No meu programa de testes usei a analógica.

Moleza, não? Bom, acontece que tentamos usar o sensor seguindo esses procedimentos acima quem disse que a coisa funcionou? Nada...

Testa dali, ajusta sensibilidade daqui e o sensor lá, e nada do bicho funcionar. Ainda bem que o dono do projeto, sujeito precavido como sói (!) nesses casos, tinha um segundo sensor. Testamos com o outro e... funcionou de prima!

Aqui vai a lição "novamente aprendida": Quando comprar sensores para o seu projeto, principalmente se forem baratos e/ou vierem de longe, compre no mínimo dois de cada.

Abaixo o programa que usamos para testar o bicho:

const int sensorPin= 0;
int smoke_level;

void setup() {
  Serial.begin(9600); //sets the baud rate for data transfer in bits/second
  pinMode(sensorPin, INPUT);//the smoke sensor will be an input to the arduino
}

void loop() {
  smoke_level= analogRead(sensorPin); //arduino reads the value from the smoke sensor
  Serial.println(smoke_level);//prints just for debugging purposes, to see what values the sensor is picking up
}

Simples a mais não poder, o "pograminha" simplesmente lê o valor exibido na porta 0 analógica e mostra no Serial Monitor.

E como testar o troço? Piece of cake: basta comprar um isqueiro na padoca da esquina e esguichar o gás em direção ao sensor, sem chama. O sinal vai variar em função disso. Use o pot para mexer na sensibilidade do bicho.

"Morto" o MQ-2, passamos à diversão com o sensor que ele trouxe para usar com temperatura

O sensor que foi trazido foi o DHT-11. Pertence a uma família que inclui outros similares (DHT-21, 22...) é muito utilizado em conjunto com o Arduino. Engraçado que no parque ainda não tinha aparecido nenhum até hoje. Aqui o datasheet, abaixo a "fotinho", como diz essa moçadinha de hoje, para desespero dos puristas:



Esse sensor lê tanto a temperatura quanto a umidade relativa do ar.

Assim como o MQ-2 acima, o sensor é o que vai dentro da caixinha azul. Ele por sua vez está preso a um break que tem os conectores etc. Tanto no caso do MQ-2 quanto no caso dos DHT é possível comprar somente o sensor, sem o break. Nesse caso, vai dar um pouco mais de trabalho para usá-los, mas é possível.

A conexão é diferente: ocorre que a saída desse camarada é digital, na forma de pulsos, então usa-se um resistor de push-up ou pull-down conforme o diagrama abaixo:



Na net a gente acha também a ligação "direta", quer dizer, sem o resistor, mas nós optamos por fazer como está acima.

Para usar o dito vc tem que baixar um biblioteca daqui. Para descobrir como instalar uma biblioteca no Arduino, veja esse link do Brasil Robotics, que também tem muitas outras arduinices legais.

Para testar usei o programa que vem de teste com a lib, um tal de DHTTester. Funcionou de prima, e a saída vc pode ver abaixo:


E aqui o circuitim montado:


That´s all, folks!

segunda-feira, 19 de janeiro de 2015

Automação no Parque, 17/01/15

Nesse sabadão apareceu por lá o Carlos, um frequentador jovem ainda a mais tempo que eu. Ele trouxe um kit que ganhou de presente em uma palestra de Arduino, muito legal por sinal. Nesse kit havia um shield com uma matriz de LEDs. Melhor mostrar o bicho funcionando do que descrevê-lo, nénão?


Essa "espiral de DNA" é um programa exemplo que vem com a plaquinha. Uma coisa interessante que dá para ver é dá inclusive para controlar a intensidade dos LEDs, repare em que uma das "pernas" da dupla hélice brilha menos que a outra.

O shield chama-se LOLShield, sabe-se lá porque... tem um site muito legal feito pelo povo que faz o bicho, que vc encontra aqui. Ele é baseado num esquema de multiplexação chamado Charlieplexing, que a Wikipedia explica direitinho. A biblioteca tem funções de texto, schroll, tudo muito bem feito e razoavelmente bem documentado (é só olhar os exemplos e a coisa anda bem).

O dono da bola (Carlos, claro) propôs o desafio de construirmos uma aplicação que mostrasse uma seta em movimento de maneira a indicar uma determinada direção, ou seja, uma espécie de "seta cuticuti" para veículos. Assim foi feito, abaixo o código, no fim a coisa funcionando.

#include "Charliplexing.h"
#include "Font.h"

// Dimensões da matriz
#define rows 10
#define cols 14

// Diagrama da seta
byte seta[rows][cols] =
{{0 ,0 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0, 0, 0, 0},
 {0 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,0, 0, 0, 0},
 {0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0, 0, 0, 0},
 {0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1, 1, 1, 1},
 {1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1, 1, 1, 1},
 {0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1, 1, 1, 1},
 {0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0, 0, 0, 0},
 {0 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,0, 0, 0, 0},
 {0 ,0 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0, 0, 0, 0}
};

void drawArray(byte inicio, byte array[rows][cols])
{
  for(int i=0;i<rows;i++)
    for(int j=0;j<cols;j++)
    {
      int c=j+inicio;
      if(c < cols)
        LedSign::Set(c,i,array[i][j]);
    }
}

void schrollArray(byte time,byte array[rows][cols])
{
  for(int i=0;i<cols;i++)
  {
     drawArray(cols-i-1,seta);
     delay(time);
  }
}

void setup()
{
  LedSign::Init();
  LedSign::Clear();
}

void loop()  
{
  schrollArray(25,seta);
}


As falhas que aparecem no painel, como vc provavelmente adivinhou, são LEDs queimados... :(

That´s it!

Arduino comunicando-se via rádio I

No último Automação no Parque o grande Euclas apareceu com dois radinhos de comunicação para que a gente testasse o seu uso com o Arduino.

O kit é o APC 220, que vem dessa forma aí do lado: duas unidades  mais um conversor USB serial que possibilita a conexão direta do radinho no PC.

O datasheet do bichinho vc acha aqui.

A primeira prática que fizemos foi tentar botar o bichinho para funcionar. Apanhamos um pouco, mas no fim funcionou. Não conseguimos usar o sw de configuração depe (vc pode baixá-lo daqui, bem como os drivers do conversor TTL).

Para os testes fiz dois "pograminhas": um que enviava comandos e outro que recebia do outro lado. O receptor fazia i LED do pino 13 piscar, de maneira que, ao ligá-lo numa bateria podia-se identificar se  o radinho estava recebendo os comandos, podendo-se assim afastá-lo e medir o alcance.

Abaixo os fontes dos programas:

// Este é o programa que roda no Arduino que fará o  
// papel de transmissor

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


void pisca(int c, int v) 
{
   for(int i=0;i<c;i++)
   {
     Serial.print('1');
     delay(v);
     Serial.print('1');
     delay(v);
   }
 } 

void loop()

// Pisca o LED 3 vezes com intervalo de 200ms, então dá um tempo de 1s.   
   pisca(3,200);
   delay(1000);
 }

// Este é o programa que roda no receptor.
char buf;
int porta_led = 13;

int estado_led = 0;

void setup()
{
  pinMode(porta_led, OUTPUT);
  Serial.begin(9600);
  Serial.println("Digite : ");
  Serial.println("1 - Para ligar/desligar o led do Arduino");
  Serial.println();
}
void loop()
{
  while(Serial.available() > 0)
  {
    buf = Serial.read();
    if (buf == '1')
    {
      estado_led = !estado_led;
      digitalWrite(porta_led, estado_led);
      mensagem_estado_led("led ", estado_led);
    }
  }
}
void mensagem_estado_led(String led, int estado)
{
  Serial.print("Led ");
  Serial.print(led);
  if (estado == 1)
  { 
    Serial.println(" ligado");
  }
  else
  {
    Serial.println(" desligado");
  }
}


Dá prá ver que a comunicação com o radinho é serial. Como eu usei a porta serial de hardware do Arduino (objeto Serial), para que estes programas funcionem é necessário que vc conecte os radios à porta serial dos pinos 0 e 1. Lembre-se que, fazendo isso, vc deve desconectar o pino TX toda vez que for atualizar o programa no Arduino. Se vc usar a biblioteca SoftwareSerial que agora vem com o programa do Arduino vc pode usar outras portas para se comunicar com os rádios, dispensando-se de ficar ligando e desligando o TX.

Abaixo fotos do circuito montado.



Testamos  o rádio até uma distância de uns 50 metros, sem visada direta, e o bichinho funcionou normalmente. Vamos testá-lo para o envio de textos, mas isso é assunto para outro post.

Cem mil pageviews!

E não é que esse blog bateu em 100k pageviews e eu nem reparei?

Pois é, três anos e meio  e 112 posts depois de criado, atingimos essa marca. Já são também quase 1000 comentários, todos devidamente respondidos, o que também expressa o movimento das pessoas por aqui.

Legal...