Arduino 72 LEDs - Christmas Tree

Arduino 72 LEDs - Christmas Tree

Árvore de Natal baseda em Arduino com 72 LEDs

Este projeto foi baseado no projeto do Blog "Alicate de ponta fina" traduzido do Japonês

que se enconta no endereço http://radiopench.blog96.fc2.com/blog-entry-1135.html a quem dedico todos os créditos do projeto.

Para maiores detalhes consultem também o site do projeto original.

Consiste em utilizar o método Charlieplexing para multiplexar 72 LEDs com apenas 8 pinos de dados de um Arduino NANO para assim poder fazer efeitos parecidos com uma árvore natalina.

DIAGRAMA DE INTERLIGAÇÃO DOS LEDs:

Note que o pino comum (pino de interconexão de todos os ânodos e cátodos dos LEDs) de uma camada é ligado sempre no final da cadeia da camanda inferior.

Imagem do site origem do projeto, ver texto.

Como podemos observar consiste em 8 níveis (camadas) de LEDs interligados aos pinos de acionamento do arduino NANO (D2 a D10) Cada pino aciona un nível ou um conjunto de LEDs, fazendo assim o efeito de multiplexação dos LEDs

D6 e D5 - acionam o nível 0

D7 - aciona o nível 1

D4 - aciona o nível 2

D8 - aciona o nível 3

D3 - aciona o nível 4

D9 - aciona o nível 5

D2 - aciona o nível 6

D10 - aciona o nível 7

DIAGRAMA DO ARDUINO:

Imagem do site origem do projeto, ver texto.

O botão de Restart é para resetar o modo de Brilho, não importando seu estado caso o junper Manual Bright estiver fechado; nesse caso o brilho será proporcionado pela programação e/ou de acordo com o nível ajustado no potênciometro Brightness. Caso o jumper Manual Bright não estiver fechado o modo de brilho será setado pelo botão.

FOTOS:

Aspectos construtivos.

Usei o acrílico de CDs para poder colar os LEDs com super cola, depois os terminais dos LEDs foram dobrados (ânodo + cátodo) para formar os pares de LEDs (na parte de baixo) e os ânodos e cátodos dos LEDs foram interligados todos juntos (na parte de cima)

Veja os diagramas de conexão das camadas.

Na parte de cima fica o ponto comum dos LEDs (ânodos e cátodos conectados juntos e conectados ao pino de acionamento do nível correspondente).

Na parte de baixo ficam os conjuntos de LEDs (ânodo + cátodo) a ser acionado por cada pino do arduino para efetuar a multiplexação.

Durante a construção aprendi a retirar a camada brilhante do CD ai ficou muito melhor em aspecto, a primeira camada ficou com brilho.

Mais adiante colocarei um diagrama para cada camada.

NÍVEL 0 E NÍVEL 1

Note que o nível 1 foi contruído sem acrílico, no método aranha mesmo e o nível 0 é o mais fácil.

NÍVEL 2

NÍVEL 3

NÍVEL 4

NÍVEL 5

NÍVEL 6

NÍVEL 7

DIGRAMAS DAS CAMADAS:

Lembre-se o comum vem da união de todos os cátodos e ânodos dos LEDs na parte de cima da ligação.

A parte de baixo é a ligação entre ânodo e cátodo de cada conjunto de LED a ser multiplexado pelos pinos do Arduino.

Na hora de empilhar as camadas note que o comum de uma camada é ligado em lado oposto da camada inferior (se o comum da camada inferior esta a direira o da camada seguinte estará á esquerda e asim por diante....) conforme diagrama esquemático.

Camada 0: 2 LEDs, 180º

Camada 1: 4 LEDs, 90º

Camada 2: 6 LEDs, 60º

Camada 3: 8 LEDs, 45º

Camada 4: 10 LEDs, 36º

Camada 5: 12 LEDs, 30º

Camada 6: 14 LEDs, 26º

Camada 7: 16 LEDs, 22,5º

SOFTWARE:

Você pode baixar o código comentado em português do meu GitHub: 

https://github.com/Arduinobymyself/72-LEDs-Christmas-Tree/tree/main/Charlieplexed_Christmas_Tree_Portuguese

VÍDEOS:

1 - Vista frontal, mostrando todos os modos de operação.

2 - Vista superior.

Até a próxima!

Arduino - Relógio Binário HMS

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);

ARDUINO - RELÓGIO BINÁRIO HMS - USANDO MÉTODO CHARLIEPLEX

Este post mostra como construir um Relógio Binário com Arduino.
O nosso relógio mostra as Horas, Minutos e Segundos de forma binária e representada pelo acendimento de LEDs numa matriz com 20 LEDs usando somente 5 pinos do Arduino.

O relógio, como funciona:
Devemos fazer a soma binária de cada LED para deteminar a quantidade de Hora, Minuto e Segundo.

Para executar o projeto, usamos o método CharliePlex:
O Charlieplex é uma técnica usada para multiplexação de grande número de LEDs usando uma pequena quantidade de pinos do microcontrolador (arduino). Os LEDs são configurados na forma de pares complementares. O mais simples seria a multiplexação de 2 LEDs como abaixo.

Onde, quando o pino 1 está em nível ALTO e o pino 2 está em nível Baixo, o LED 1 acenderá e quando o pino 2 está em nível ALTO e o pino 1 está em nível Baixo, o LED 2 acenderá.

De uma forma geral o Charlieplex obedece a seguinte fórmula:

                                         n(n-1) = LEDs

onde n, é o número de pinos;

Assim:
para 3 pinos, podemos acionar até 3*(3-1) = 6 LEDs;
para 4 pinos. podemos acionar até 4*(4-1) = 12 LEDs;
para 5 pinos, podemos acionar até 5*(5-1) = 20 LEDs...... e assim por diante... como na tabela abaixo.

Number of Pins	Number of LED's
2	2
3	6
4	12
5	20
6	30
7	42
8	56
9	72
10	90
n	n * (n - 1)

3 pinos de controle:

4 pinos de controle:

5 pinos de controle:

O método Charlieplex usa a lógica Tri-State para acionar as linhas de controle, o que equivale dizer:
Para acender um determinado LED, temos que colocar uma linha em nível ALTO e a outra em nível BAIXO, e as restantes devem permanecer configuradas como ENTRADAS (para que não acionem um LED indevidamente).


Para nosso relógio, usaremos a configuração de LEDs abaixo:

Onde:
h10 representa as dezenas de hora;
h1 representa as unidades de hora;
m10 representa as dezenas de minuto;
m1 representa as unidades de minuto;
s10 representa as dezenas de segundo;
s1 representa as unidades de segundo;

Cada número indica um LED da configuração para 5 pinos de controle.

Esta configuração de LEDs é de acordo com o diagrama esquemático abaixo:

A interligação dos LEDs foi realizada seguindo a placa de circuito impresso abaixo e montada em placa padrão perfurada.

Um RTC DS-1307 nos dá a temporização necessária para o relógio funcionar com precisão.

MATERIAL NECESSÁRIO:
20 x LEDs 5mm
5 x resistores 100 R
1 x barra 5 pinos macho
1 x RTC DS-1307
1 x Arduino UNO ou equivalente
1 x placa perfurada
fios, cabos, solda e ferramentas




FOTOS REAIS:

Interligação RTC + Arduino + Placa de LEDs

RTC DS-1307

Arduino

Placa de LEDs CharliePlex (5 pinos de controle)

Vista Geral

Esboço do esquema da placa de LEDs

Esboço da disposição de LEDs

Relógio funcionando 14 : 50 : 08

Placa perfurada com as trilhas feita de solda - os jumpers são as trilhas em vermelho no diagrama de placa.

Trilhas em azul devem soldadas na placa perfurada, trilhas em vermelhos são jumpers com fios

Em funcionamento

CÓDIGO:

Envie um email para:

arduinobymyself@gmail.com

Obtenha o código completo deste projeto e os arquivos originais para Eagle-CAD da placa e esquema eletrônico.

Você pode também tirar suas dúvidas a respeito deste e de outros projetos.

VÍDEO:

Assista diretamente no youtube:

Arduino - Binary Clock - Charliplexing

UPDATE:

Como conectar o RTC ao Arduino e como sincronizar a hora e data com o PC?

Siga os Passos:

1 - Retire a pilha do seu RTC (ele vai zerar as configurações previas);

2 - Coloque a pilha;

3 - Rode o código de ajuste do RTC no seu Arduino com o relógio RTC devidamente conectado;

RTC pinout -> Arduino pinout

SDA          -> pino A4

SCL          -> pino A5

VCC          -> pino 5V

GND         -> pino GND

Ao terminar de enviar o código, o seu relógio RTC DS1307 já estará sincronizado com o PC. Você poderá monitorar isso via interface serial da IDE do arduino.

Código de sincronização:

#include <Wire.h>

#include "RTClib.h"

RTC_DS1307 rtc;

char hora[30];

void setup () {

Serial.begin(9600);

#ifdef AVR

Wire.begin();

#else

Wire1.begin(); // I2C 

#endif

rtc.begin();// aciona a função RTC

if (! rtc.isrunning()) {// se a função RTC não foi acionada

Serial.println("RTC não esta funcionando"); //

rtc.adjust(DateTime(__DATE__, __TIME__)); //caso rtc não esta funcionando ajusta a hora sincronizando com o PC

}

}

void loop () {

DateTime now = rtc.now();

sprintf( hora, "%02d:%02d:%02d", now.hour(), now.minute(), now.second() );

Serial.println(hora);

delay(1000);

}

Após terminar seu RTC estará com a hora configurada.... você poderá gravar um outro código que ele não perderá a configuração (logicamente fazendo somente leitura das informação previamente ajustadas).

Se você (em outro código) manter a linha:   rtc.adjust(DateTime(__DATE__,__TIME__)) ele vai sincronizar a todo momento... então, comente essa linha de qualquer outro código que inserir..., ela deve rodar somente quando for necessário sincronizar o relógio.

Sistema de Irrigação

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);

ARDUINO SISTEMA DE IRRIGAÇÃO

INTRODUÇÃO & OBJETIVOS:

Um sistema simples, usando Arduino para automatizar a irrigação de pequenos vasos de planta ou plantações.

Ele faz o controle da umidade do solo, fazendo indicações através de LEDs e em caso de solo seco emitindo um aviso sonoro. Em caso de solo seco ativa o sistema de irrigação, bombeando água para regar as plantas.

O uso de um display LCD possibilita notificar todas as ações que estão ocorrendo além de um relógio em tempo real.

Teoria:

"A umidade do solo  ou teor em água  é definida como o peso da água  contida em uma amostra de solo dividido pelo peso seco das partículas sólidas  do solo, sendo expressa empercentagem.

Para determinação do peso seco, o método tradicional é a secagem em estufa, na qual a amostra é mantida com temperatura entre 105 °C e 110 °C, até que apresente peso constante, o que significa que ela perdeu a sua água por evaporação.

O peso da água é determinado pela diferença entre o peso da amostra  e o peso seco ."

Desta forma temos: 

DESCRIÇÃO:

O sistema faz uso de um sensor de umidade (higrometro), através do qual, é possível monitorar a quantidade de água (umidade) presente no solo. 

Este sensor higrômetro entrega ao Arduino um sinal que varia entre 0 a 5V (0 a 1023 no arduino), deste modo, é possível especificar alcances de umidade relativa do sólo e assim caracterizar se o solo está: mais, ou menos úmido. 

Por exemplo:
- entre 0 a 500, umidade excessiva (solo encharcado); 
- entre 500 a 800, umidade normal (solo úmido);
- entre 800 a 1023, umidade escassa (solo seco).  
Todas estas etapas acima, serão indicadas em display LCD e LEDs.

Quando o solo estiver seco, o sistema efetuará essa indicação através de um LED vermelho, um aviso sonoro e mostrará uma mensagem no display LCD
Quando o solo estiver seco, será acionado uma bomba d'água para efetuar a irrigação do local. Um LED verde efetuará a indicação enquanto a bomba d'água estiver acionada.

A bomba d'água será desligada automáticamente após decorrido um tempo pré determinado de operação mínimo (por exemplo 30 segundos); se a irrigação não foi suficiente e o solo continua seco, a bomba será acionada novamente, e assim por diante... até quando a umidade do sólo atingir a condição de umidade normal ( a bomba será desligada e só acionará no próximo periodo de irrigação).
Se na hora estima o solo não estiver seco, o sistema irá esperar até o próximo horário de verificação.

O acionamento da bomba d'água é feito por um relé, isolado da parte eletrônica através de um acoplador óptico na entrada.

A irrigação será feita somente se:
1-  o solo estiver seco;
2 - uma hora pré determinada for alcançada (por exemplo: 06:00 da manhã)
Para isto usamos um relógio de tempo real (RTC) para gerar a hora do sistema.

O sistema é composto também de um sensor de nível para o reservatório de água. Sempre que o nível cair abaixo do mínimo estabelecido pelo posicionamento do sensor, será indicado através de um aviso sonoro e mensagem no display LCD.



HARDWARE & MATERIAL:

Para realizar este projeto, você necessitará de:
1 x Arduino UNO, MEGA, Duemilanove, ou Teensy 2.0+
1 x Display LCD com comunicação I2C
1 x Módulo RTC com comunicação I2C
1 x Módulo Relé opto-acoplado para 250V/10A
2 x Módulos "Driver" LM-393 de uso geral
1 x Sensor de umidade do Solo (Hygrometer) KDQ11
1 x Sensor de Nível de água (Feito em casa)
1 x Buzzer piezo-elétrico
2 x LEDs Verdes 10mm
1 x LED Vermelho 10mm
1 x LED Amarelo 10mm
4 x Resistores 150 Ohm 1/4 W
1 x Bomba dágua para Aquários com sistema de filtro (127 ou 220V)
1 x Cabo de Energia Elétrica, com plug CA 127/220V @10A
1 x Tomada para cabo de energia AC 127/220V @10A
Fios e cabos para as conexões

Você pode adquirir o sensor de umidade do solo e o "Driver" no ebay.
http://www.ebay.com/itm/KDQ11-MOISTURE-SENSOR-KIT-URBAN-GARDEN-TOOL-SOIL-MOISTURE-SENSOR-SCA-1703-/221227848188?pt=LH_DefaultDomain_0&hash=item33823511fc


Você pode adquirir o módulo relé no ebay.

http://www.ebay.com/itm/1-Channel-5V-Relay-Module-Shield-for-Arduino-uno-1280-2560-ARM-PIC-AVR-DSP-/271117672120?pt=LH_DefaultDomain_0&hash=item3f1fdf5eb8

COMPONENTES:

Abaixo uma visão geral dos componentes utilizados.

LCD I2C:

LM-393 DIVER:


Este é umdiagrama ilustrativo do uso do LM-393

Driver LM-393; Notar que N1 é o sensor a ser utilizado no Driver

Sensor de umidade do Solo:

Dados deste conjunto sensor/driver:
Quando o solo estiver seco, impedância será alta e o driver mostrará um valor alto na saída.
Quando o solo estiver encharcado, será mostrado um valor baixo na saída.
O range de 3 LEDs pode ser definido como:
- encharcado, umidade entre 0 a 500;
- Normal, umidade entre 500 a 800;
- seco, umidade entre 800 a 1023;
O módulo tem 1 saída digital e uma saída analógica. (no projeto, deve ser utilizado a saída analógica)



RTC:

Sensor de Nível:

Este sensor deve ser confeccionado em placa de fenolite.
Espaçamentos de 1mm e trilhas de 1 mm

RELÉ:

Módulo duplo, será utilizado somente uma via

 BOMBA D'ÁGUA:

DIAGRAMA & INTERLIGAÇÃO:

Abaixo temos um diagrama de blocos descrevendo as principais interligações do sistema.
Você pode obter o original deste arquivo, acessando o driver abaixo:
https://docs.google.com/file/d/0B_YlEklLDDS7SllRMzUyQlhHVDg/edit?usp=sharing

Diagrama de blocos

Abaixo o diagrama de interligação (em manuscrito).
Você pode obter o original deste arquivo, acessando o driver abaixo:
https://docs.google.com/file/d/0B_YlEklLDDS7RkNMZko2ckhLcUU/edit?usp=sharing

Diagrama de interligação e fiação original, em manuscrito

****************************************************************
****************************************************************
Corrija em seu diagrama: o sensor de nível deve ser conectado ao pino A0 do Arduino e o sensor de umidade do solo deve ser conectado ao pino A1 do arduino.
****************************************************************
****************************************************************

Descrição das pincipais conexões:

RTC <-> Arduino:
GND <-> GND
+5V <-> +5V
SDA <-> A4
SCL <-> A5

Relé <-> Arduino:
GND <-> GND
+5V <-> +5V
IN <-> D7

LCD <-> Arduino:
GND <-> GND
+5V <-> +5V
SDA <-> A4
SCL <-> A5

BUZZER <-> Arduino:
+ <-> D2
-  <-> GND

LM-393 DRIVER (sensor de umidade) <-> Arduino
GND <-> GND
+5V <-> +5V
OUT <-> A1

LM-393 DRIVER (sensor de Nível) <-> Arduino
GND <-> GND
+5V <-> +5V
OUT <-> A0

Outros Componentes <-> Função <-> Arduino
LED Vermelho <-> Solo seco           <-> D5
LED Amarelo   <-> Solo encharcado  <-> D3
LED Verde      <-> Solo úmido         <-> D4
LED Verde      <-> Bomba d'água     <-> D6 

Link para o original da figura acima:

https://docs.google.com/file/d/0B_YlEklLDDS7Ym52UE1qcGlqQVE/edit?usp=sharing

Link para o original da figura acima:

https://docs.google.com/file/d/0B_YlEklLDDS7Z3hZY3pNZ0NWZG8/edit?usp=sharing
SOFTWARE & PROGRAMAÇÃO:

Você pode baixar, gratuitamente o código para este projeto no driver do google docs abaixo:

https://docs.google.com/file/d/0B_YlEklLDDS7T3JFX05rR21xbEE/edit?usp=sharing

Ou no GitHub:

https://github.com/Arduinobymyself/ArduinoWateringSystem.git


Qualquer problema, dúvidas e sugestões; entre em contato via email:

arduinobymyself@gmail.com



TESTES:

Este é um exemplo de como trabalhará o sistema e como devem ser realizados os testes.
Logicamente, como o sistema tem um horário pré definido para operar, você pode mudar o horário via software para o horário em que fará os testes, e depois ajustar para o horário de trabalho.

Como montar o aparato para os testes

VÍDEOS & FOTOS:



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


Parte 1: http://youtu.be/_jcDxYK33ew

Parte 2: http://youtu.be/-JOfP1J0OHY

Parte 3: http://youtu.be/Czvxi1r21Zc


Parte 1




Parte 2




Parte 3

Fotos do projeto:

Sistema Montado com Garagino Versão 1

Detalhe das interligações do Garagino V1

Detalhe do sistema de potência - Relé e entrada e saída 127/220 VCA

Detalhe dos sensore de umidade do solo e sensor de nível do reservatório de água

Visão geral do sistema

Primeiro rascunho e ideias

Conceito definido

Algumas diretivas de operações

Vista Geral 1

Vista Geral 2

Componentes 1

Componentes 2

Sensores de Umidade do solo e Nível

Driver LM-393 - Detalhe 1

Driver LM-393 - Detalhe 2