Luminária de LED impressa em ABS

A luminária foi impressa em uma Prusa i3 utilizando filamento ABS branco.

O preenchimento foi deixado em 0% para que ao iluminar o seu interior a luz dos LEDs chegassem em todas as suas partes.

Posteriormente utilizei um Arduino Uno para controlar os LEDs de cores Amarelo, Verde, Vermelho e Branco para que estes fossem ligados ou desligados dependendo do valor lido por um sensor de distância ultrassom. Para controlar o "fading" dos LEDs independemente foi utilizado um TLC5940 e o exemplo incluído em sua biblioteca como base para o sketch no arduino.

TLC5940 + Arduino: Controlando16 LEDs separadamente (independentes)

Utilizando um TLC5940 você pode controlar 16 leds utilizando apenas 5 saídas digitais do Arduino. Ainda é possivel ligar mais TLCs em série, multiplicando o número de saídas para cada IC adicionado.

O exemplo executado no vídeo e descrito com o código fonte abaixo é o "BasicUse" incluído com a library (disponível em https://code.google.com/p/tlc5940arduino/).

Material utilizado:

• Arduino UNO R3
• Protoboard (placa de prototipagem eletrônica - Solderless Breadboard)
• 16 LEDs
• 1 Resistor de 2k Ohms
• cabos coloridos para ligações

Faça o download da library do TLC5490 (em: https://code.google.com/p/tlc5940arduino/) e instale utilizando a IDE do Arduino.
Reinicie o programa e verá que já estarão disponíveis outros exemplos clicando em File / Examples / Tlc5490.
A ligação do TLC ao arduino deve ser feita de acordo com as instruções incluídas, mas para facilitar eu fiz esta imagem (utilizando o programa Frizing: http://fritzing.org/download/)

clique na imagem abaixo para ter uma visão das ligações:

O código fonte do exemplo BasicUse tem bastante comentários (em inglês), mas eu criei mais alguns em português para facilitar o entendimento das ações executadas em cada passo. As linhas acabaram ficando um pouco longas para serem mostradas na pequena janela de texto abaixo, mas se você colar na janela do IDE do Arduino e maximizar, poderá ler confortavelmente todos os comentários.
O comando principal desta biblioteca é o "Tlc.set(channel (0-15), value (0-4095))" onde channel é o número do pino para qual você está enviando o comando (de 0 a 15 se for apenas um TLC), e value é o valor enviado à aquele pino. No cado dos LEDs, um valor de 0 seria totalmente apagado e 4095 é aceso com o brilho máximo.
Note que valores intermediários entre 0 e 4095 fazem a dimerização (fade) do led, portanto não é necessário (nem permitido) a utilização de analogWrite() para fazer PWM destes pinos.

Creio que o código está bem comentado, qualquer dúvida utilize os comentários do blog!

 código fonte: copie e cole no IDE do Arduino!
/* /* This library uses the PWM output ability of digital pins 3, 9, 10, and 11. Do not use analogWrite(...) on these pins. This sketch does the Knight Rider strobe across a line of LEDs. Alex Leone <acleone ~AT~ gmail.com>, 2009-02-03 */ // notes in portuguese by Waldo Costa, Researcher at SimmLab/UFRGS, 2012-07-07 #include "Tlc5940.h" void setup() { /* Call Tlc.init() to setup the tlc. You can optionally pass an initial PWM value (0 - 4095) for all channels.*/ Tlc.init(); } /* This loop will create a Knight Rider-like effect if you have LEDs plugged into all the TLC outputs. NUM_TLCS is defined in "tlc_config.h" in the library folder. After editing tlc_config.h for your setup, delete the Tlc5940.o file to save the changes. */ void loop() { int direction = 1; /* quando a direção é igual à 1, os leds vão acendendo no sentido crescente */ for (int channel = 0; channel < NUM_TLCS * 16; channel += direction) { /* Loop que inicia em channel=0 e a cada volta do loop é adicionado o valor de direction(1 ou -1). O loop acontece até que o valor de channel NÃO seja MENOR do que o "número de TLCs utilizados multiplicado por 16 (isso é o número total de canais disponíveis: 16 para cada TLC) */ /* Tlc.clear() sets all the grayscale values to zero, but does not send them to the TLCs. To actually send the data, call Tlc.update() */ Tlc.clear(); /* Tlc.set(channel (0-15), value (0-4095)) sets the grayscale value for one channel (15 is OUT15 on the first TLC, if multiple TLCs are daisy- chained, then channel = 16 would be OUT0 of the second TLC, etc.). value goes from off (0) to always on (4095). Like Tlc.clear(), this function only sets up the data, Tlc.update() will send the data. */ if (channel == 0) { direction = 1; //se o canal for = 0, o valor da direção será definido como 1 } else { //se canal for diferente de zero, faz o seguinte: Tlc.set(channel - 1, 2000); // led mais da direita ( nº do canal -1) } // valor de iluminação do led: 2000 Tlc.set(channel, 4095); // led do meio (nº do canal) // valor de iluminação do led: 4095 if (channel != NUM_TLCS * 16 - 1) { // confere se o canal atual é diferente do // numero total de canais menos 1 Tlc.set(channel + 1, 2000); // led mais da esquerda (nº do canal +1) // valor de iluminação do led: 2000 } else { // se o valor de channel for igual ao número de canais menos 1 direction = -1; // troca a o valor da variável direction para -1 } /* Tlc.update() sends the data to the TLCs. This is when the LEDs will actually change. */ Tlc.update(); delay(500); // Valor em milisegundos (ou seja, 500ms é igual à 0,5 segundos) } }

Primeiro teste seguindo em parte o tutorial do Firefly. As ações experimentadas foram:

• Modificar o raio dos círculos (geometria gerada no Grasshopper e visualizada no Rhino) utilizando um potenciômetro ligado ao Arduino.
• Através de parâmetros no Grasshopper/Firefly, fazer com que um LED gradualmente acenda e apague.
• Fazer com que outro led acenda quando a letra "L" do teclado é pressionada.
• Controlar a inclinação do modelo físico (torre) utilizando 2 servos controlados através de parâmetros na tela do Grasshopper.

Primeiro teste com LDR - Resistor dependente de luz

Após fazer compras de mais alguns componentes eletrônicos, resolvi experimentar com um LDR (Light Dependent Resistor).

O que é LDR: É um resistor que varia a sua resistência de acordo com a quantidade de luz que recebe. Esta resistência pode variar de 1M ohms na escuridão, até 100 ohms quando sob a luz.forte.

Como funciona o circuito: O circuito e código fonte foram baseados no texto disponível no site [ http://www.hobbytronics.co.uk/arduino-tutorial8-nightlight ] em que é utilizado o fenômeno de divisão de tensão ( ver mais neste texto sobre divisor de tensão ).

Ao diminuir a luz no ambiente a resistência no LDR aumenta, diminuindo a tensão no pino A0 (analógico) do Arduino. O valor de tensão é transformado em um valor numérico que vai de 0 a 1024. No algorítmo ainda está incluído instruções para que quando o valor numérico recebido por esse pino baixe de um determinado valor (no caso 400), o led ligado ao pino 13 deve ser aceso.

Esse circuíto é bem simples, acho que apenas de ver o vídeo qualquer um é capaz de reproduzir. Ainda mais se acessar os links indicados neste post como referência. Os resistores utilizados foram de 4k7 ohms para o divisor de tensão e 1k ohms para o LED.

Abaixo estão o vídeo do modelo em ação e em seguida o código fonte utilizado.




código fonte:

/* ** Nightlight LDR test program ** Created 06 Feb 2010 ** ** This example code is in the public domain. ** www.hobbytronics.co.uk */ int sensorPin = A0; // select the input pin for the ldr unsigned int sensorValue = 0; // variable to store the value coming from the ldr void setup() { pinMode(13, OUTPUT); //Start Serial port Serial.begin(9600); // start serial for output - for testing } void loop() { // read the value from the ldr: sensorValue = analogRead(sensorPin); if(sensorValue<400) digitalWrite(13, HIGH); // set the LED on else digitalWrite(13, LOW); // set the LED on // For DEBUGGING - Print out our data, uncomment the lines below //Serial.print(sensorValue, DEC); // print the value (0 to 1024) //Serial.println(""); // print carriage return //delay(500); }

Matriz de LED 3x3 e sensor ultrasom de distância

Utilizando a técnica chamada multiplexing é possivel controlar cada LED de uma matriz individualmente. Existem vários textos e vídeos na internet que podem explicar bem melhor do que eu, mas indico um que achei que foi bem didático:

• Multiplex LEDs to Save I/O Pins (Jonathan Titus)

A princípio montei a matriz 3x3 de Leds na protoboard e conectei ao Arduino fazendo com que piscassem em sequencia. Em seguida adicionei um sensor ultra-som de distância e programei para que a coluna iluminada fosse correspondente à distância do sensor à um objeto.
Como pode ser observado posteriormente nas linhas de código, quando a distância é < 30cm a "linha1" fica ativa (a linha mais proxima do sensor no vídeo), quando a distância < 60cm a "linha2" (meio) é a que se acende, e em outras condições (quando a distância for maior ou igual a 60cm) a linha que fica acesa é a mais afastada do sensor ultra-som.

• Para não causar confusão: A matriz 3x3 deve ser visualizada como se as linhas de força da protoboard ( + e - ) fossem linhas verticais, e portanto, as colunas da matriz são paralelas a essas. As linhas não são perpendiculares às colunas apenas por uma questão construtiva, para facilitar a montagem sem o uso de soldas, e é pelo mesmo motivo que o afastamento entre as linhas é maior do que o entre as colunas.

Abaixo está o vídeo do experimento e em seguida o codigo fonte utilizado para programar o Arduino.


Um passo seguinte seria utilizar um segundo sensor de outra natureza, como temperatura ou iluminação, para controlar a coluna.
Dois potenciômetros poderiam ser utilizados também para controlar Linha x Coluna, mas não seria tão interessante por depender totalmente da ação do usuário...

código fonte:


#include <NewPing.h> #define TRIGGER_PIN 2 // Arduino pin tied to trigger pin on the ultrasonic sensor. #define ECHO_PIN 3 // Arduino pin tied to echo pin on the ultrasonic sensor. #define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm. NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance. // Here are the constants that we define prior to the program running int coluna1=5; // defines "coluna1" as the number 5 int coluna2=6; // coluna é esperado um valor positivo int coluna3=7; // para ligar o led (HIGH) int linha1=10; // linha é esperado um valor negativo int linha2=11; // para ligar o led (LOW) int linha3=12; // // End of constant definitions void setup() //run one time when the Arduino first powers up { Serial.begin(9600); //starts serial communication, only used for debgugging pinMode(coluna1, OUTPUT); // definindo as linhas e colunas como SAIDAS pinMode(coluna2, OUTPUT); // pinMode(coluna3, OUTPUT); // pinMode(linha1, OUTPUT); // pinMode(linha2, OUTPUT); // pinMode(linha3, OUTPUT); // } int delay_time = 50; void all_off() { digitalWrite(coluna1, LOW); digitalWrite(coluna2, LOW); digitalWrite(coluna3, LOW); digitalWrite(linha1, HIGH); digitalWrite(linha2, HIGH); digitalWrite(linha3, HIGH); } void FuncaoPasso() { delay(0); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings. unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS). Serial.print("Ping: "); Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance and print result (0 = outside set distance range, no ping echo) Serial.println("cm"); int dist = (uS / US_ROUNDTRIP_CM); if (dist < 30) { digitalWrite(linha1, LOW); } else if (dist < 60) { digitalWrite(linha2, LOW); } else { digitalWrite(linha3, LOW); } delay(delay_time); } void loop() { all_off(); // turn on LEDs based on the force value digitalWrite(coluna1, HIGH); FuncaoPasso(); all_off(); digitalWrite(coluna2, HIGH); FuncaoPasso(); all_off(); digitalWrite(coluna3, HIGH); FuncaoPasso(); }