Arduinoflake!

Componentes e suprimentos

Arduino Nano R3

Sobre este projeto

O floco de neve consiste em 30 LEDs agrupados em 17 segmentos independentes que podem ser controlados separadamente pelo microcontrolador Arduino Nano. Cada grupo de LEDs pode ser escurecido com PWM para criar animações adoráveis.

Ferramentas

Tudo que você vai precisar é ferro de solda, solda e alicate.

Construção

Em primeiro lugar, selecione algum padrão. Eu escolho um cristal floco de neve simples e bonito e imprimo-o no tamanho que cabe no Arduino Nano dentro do hexágono - núcleo do cristal.

A estrutura de suporte que também atua como uma fiação é criada a partir de hastes de latão de 0,8 mm soldadas com estanho. Usei 2m de haste no total. Por que forma livre? Porque eu sempre quis experimentar e é um teste de sua paciência e habilidade.

Primeiro criei um hexágono central dobrando uma única haste e soldando as pontas. Ao adicionar outras 6 hastes ao topo do hexágono, a fiação de aterramento está completa, todos os terminais do cátodo dos LEDs agora precisam ser soldados a ele para criar um padrão de floco de neve. A parte complicada foi adicionar os LEDs SMD, mas me ajudei com um gabarito criado a partir de um papelão e uma fita dupla-face.

Em seguida, foi a vez de adicionar o microcontrolador Arduino Nano sob a estrutura central, deixando espaço suficiente entre eles para caber 3 camadas de fios de haste de latão que irão conectar os pinos do microcontrolador a todos os condutores do ânodo do LED. Isso exigia muita paciência. Você não só precisa evitar um curto-circuito entre os fios, mas também adicionar um resistor limitador de corrente e torná-lo bonito.

Os LEDs de folha são conectados separadamente cada um ao pino de saída do Arduino mais próximo. Os LEDs de ramificação são agrupados por dois e conectados aos pinos PWM. Os LEDs principais também são agrupados por dois e conectados ao resto dos pinos. Arduino NANO tem apenas 18 pinos de saída (A6 e A7 são apenas entrada) e eu preciso de um pino para o sensor de toque, que me deixou com apenas 17 pinos, então os dois pares de LEDs principais são conectados para criar um grupo de 4. I Estou usando resistores de 220Ω para limitar a corrente que flui através de cada pino em cerca de 8mA. Isso significa 240mA no total, o que é um pouco alto para o chip ATmega328, mas funciona - o máximo seguro é 200mA.

Sensor de toque

Para poder interagir com um floco de neve, adicionei outra haste de latão para criar um sensor de toque capacitivo. Encontrei uma ótima biblioteca e tutorial de Paul Stoffregen. O sensor de toque é usado para interagir com o arduinoflake - mudar a animação, ligar / desligar, brilhar quando tocado, você escolhe ...

Nota final

Não se esqueça de verificar todos os diodos antes de soldar, será muito difícil trocá-los se estiverem quebrados ou conectados em polaridade reversa.

Código

Originalmente, pensei que seria capaz de diminuir apenas os LEDs de ramificação que estão conectados aos pinos PWM de hardware. Mas felizmente existe uma biblioteca de software PWM incrível que me permitiu usar todos os pinos como se fossem PWM de hardware. Esta configuração criou possibilidades infinitas para animações! Confira o código anexado abaixo com algumas das primeiras animações.

Código

snowflake.ino

snowflake.ino Arduino

Código-fonte

 #include "SoftPWM.h" #include  byte edgeLedPins [] ={13, A4, A5, 2, 8, 12}; byte middleLedPins [] ={10, 6, 3, 5, 9, 11}; byte innerLedPins [] ={A2, A3, A1, 4, 7, A1}; ADCTouchSensor touchSensor =ADCTouchSensor (A0, 1); void setup () {Serial.begin (115200); SoftPWMBegin ();} byte animation =0; long touchAt =0; void loop () {switch (animação) {case 0:_fill (100); pausa; caso 1:Animação brilhante (); // fadingAnimation (); pausa; caso 2:circleAnimation (); pausa; caso 3:loopAnimation (); pausa; Caso 4:FireworkAnimation (); fogo de artifícioAnimação (); fogo de artifícioAnimação (); fogo de artifícioAnimação (); fogo de artifícioAnimação (); fogo de artifícioAnimação (); animação ++; pausa; caso 5:smileAnimação (); pausa; padrão:animação =0; pausa; } int touchValue =touchSensor.read (); if (touchAt + 2000  1000) {touchAt =millis (); // toque, o tempo limite de inatividade a frio é 2s animação ++; _fill (0); }} void fireworkAnimation () {for (int i =0; i <4; i ++) {SoftPWMSet (innerLedPins [i], 100); atraso (100); } SoftPWMSet (innerLedPins [4], 100); para (int i =0; i <6; i ++) {SoftPWMSet (middleLedPins [i], 255); } atraso (50); para (int i =0; i <6; i ++) {SoftPWMSet (innerLedPins [i], 0); SoftPWMSet (edgeLedPins [i], 255); } atraso (50); para (int i =0; i <6; i ++) {SoftPWMSet (middleLedPins [i], 0); } atraso (50); _fill (0);} void smileAnimation () {SoftPWMSet (innerLedPins [1], 100); SoftPWMSet (innerLedPins [3], 100); SoftPWMSet (middleLedPins [0], 255); SoftPWMSet (middleLedPins [5], 255); SoftPWMSet (edgeLedPins [2], 255); SoftPWMSet (edgeLedPins [3], 255); atraso (2000); SoftPWMSet (innerLedPins [1], 0); SoftPWMSet (innerLedPins [3], 0); atraso (100); SoftPWMSet (innerLedPins [1], 100); SoftPWMSet (innerLedPins [3], 100); atraso (100); SoftPWMSet (innerLedPins [1], 0); SoftPWMSet (innerLedPins [3], 0); atraso (100);} byte circleState [] ={100, 55, 10}; byte circleStateAnimation [] ={1, 1, 1}; vazio circleAnimation () {for (int i =0; i <3; i ++) {if (circleState [i]> =100) {circleStateAnimation [i] =-1; // escurecer} else if (circleState [i] <=10) {circleStateAnimation [i] =1; // brilhante} circleState [i] + =circleStateAnimation [i]; } para (int i =0; i <6; i ++) {SoftPWMSet (innerLedPins [i], circleState [0]); SoftPWMSet (middleLedPins [i], circleState [1]); SoftPWMSet (edgeLedPins [i], circleState [2]); } atraso (5);} byte waveState [] ={100, 55, 10, 10, 55, 100}; byte waveStateAnimation [] ={1, 1, 1, -1, -1, -1}; onda vaziaAnimação () {para (int i =0; i <6; i ++) {if (waveState [i]> =100) {waveStateAnimation [i] =-1; // escurece} else if (waveState [i] <=10) {waveStateAnimation [i] =1; // brilhante} waveState [i] + =waveStateAnimation [i]; } para (int i =0; i <6; i + =2) {SoftPWMSet (innerLedPins [i], waveState [0]); SoftPWMSet (middleLedPins [i], waveState [1]); SoftPWMSet (edgeLedPins [i], waveState [2]); SoftPWMSet (innerLedPins [i + 1], waveState [3]); SoftPWMSet (middleLedPins [i + 1], waveState [4]); SoftPWMSet (edgeLedPins [i + 1], waveState [5]); } delay (10);} byte loopCounter =0; byte loopState =150; void loopAnimation () {SoftPWMSet (innerLedPins [loopCounter], loopState); SoftPWMSet (middleLedPins [loopCounter], loopState); SoftPWMSet (edgeLedPins [loopCounter], loopState); loopCounter =_nextIndex (loopCounter, 1); if (loopCounter ==0) {loopState =(loopState ==150? 0:150); } atraso (100);} byte slowOnCounter =0; byte slowOnState =150; void slowOnAnimation () {byte randomLed =random (0, 18); if (randomLed <6) {SoftPWMSet (innerLedPins [randomLed], slowOnState); } else if (randomLed <12) {SoftPWMSet (middleLedPins [randomLed - 6], slowOnState); } else {SoftPWMSet (edgeLedPins [randomLed - 12], slowOnState); } slowOnCounter ++; if (slowOnCounter> =50) {slowOnCounter =0; slowOnState =(slowOnState ==150? 0:150); } atraso (50);} byte brilhanteState [] ={0, 100, 0, 100, 0, 100}; byte brilhanteStateAnimation [] ={1, 1, 1, 1, 1, 1}; byte brilhanteContador =0; void BrightAnimation () {for (int i =0; i <6; i ++) {if (brilhanteState [i]> =100) {thirtyStateAnimation [i] =-1; // dim} else if (brilhanteState [i] <=0) {thirtyStateAnimation [i] =1; // brilhante} brilhanteState [i] + =brilhanteStateAnimation [i]; SoftPWMSet (edgeLedPins [i], brilhanteState [i]); } BrightCounter ++; if (BrilhanteContador> 10) {BrilhanteContador =0; para (byte r =aleatório (1, 3); r> 0; r--) {byte randomLed =aleatório (0, 12); if (randomLed <6) {SoftPWMSet (innerLedPins [random (0, 6)], 255); } else {SoftPWMSet (middleLedPins [random (0, 6)], 255); }}} else {for (int i =0; i <6; i ++) {SoftPWMSet (innerLedPins [i], 20); SoftPWMSet (middleLedPins [i], 20); }} delay (30);} byte fadingState [] ={0, 100, 0, 100, 0, 100}; byte fadingStateAnimation [] ={1, 1, 1, 1, 1, 1}; void fadingAnimation () {para (int i =0; i <6; i ++) {if (fadingState [i]> =100) {fadingStateAnimation [i] =-1; // escurecer} else if (fadingState [i] <=0) {fadingStateAnimation [i] =1; // brilhante} fadingState [i] + =fadingStateAnimation [i]; SoftPWMSet (edgeLedPins [i], fadingState [i]); SoftPWMSet (middleLedPins [_nextIndex (i, 1)], fadingState [i]); SoftPWMSet (innerLedPins [i], 50); } atraso (20);} void _fill (valor do byte) {para (int i =0; i <6; i ++) {SoftPWMSet (edgeLedPins [i], valor); SoftPWMSet (middleLedPins [i], valor); SoftPWMSet (innerLedPins [i], valor); }} byte _prevIndex (índice curto, etapa de byte) {índice - =etapa; enquanto (índice <0) {índice + =6; } índice de retorno;} byte _nextIndex (índice curto, passo de byte) {índice + =passo; enquanto (índice> 5) {índice - =6; } índice de retorno;}

Esquemas

Robô de desenho do engenheiro louco Arduino GRBL CoreXY Drawbot Programador de computador breadboard

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial