Excel para WS2812 RGB LED Array Animations

Componentes e suprimentos

Arduino UNO

ws2812 Matriz LED RGB 8x8 RGB

Cabos de jumper masculino / feminino

Meus três são Black-Gnd, Red-5v e Green-Data

Bateria de 9 V (genérica)

9V para conector Barrel Jack

Male-Header 5 Position- 1 Row- Long (0.1 " )

São necessários apenas três pinos

Ferramentas e máquinas necessárias

Ferro de soldar (genérico)

Arame de solda, sem chumbo

Sobre este projeto

Tendo verificado que havia suporte on-line, encomendei uma matriz de LEDs WS2812 8x8 RGB esperando que fosse tratada como uma estrutura de coordenadas XY, não uma cadeia (fita) de 64 LEDs embrulhados em 8 fileiras de 8!

Uma pesquisa “WS2812 Led Animation” rendeu pouco que eu pudesse entender rápida e imediatamente. Quando encontrei um vídeo do YouTube produzido por Kevin Darrah, ele estava endereçando uma matriz 16 x 16 (256LEDs em cadeia) como se fosse um sistema de coordenadas XY.

Seu utilitário Excel compilou código de texto para copiar / colar em seu esboço, dentro do qual estavam todas as funções necessárias; nenhuma biblioteca precisava ser importada.

Quando ele selecionou células dentro de seu utilitário e valores RGB foram adicionados, eles se aplicaram àquelas células selecionadas sem discriminação; não o que eu desejava, então eu o redesenhei e reconstruí. Isso também significou que eu tive que alterar seu esboço para compatibilidade com 8x8.

Conforme eu pedia mais do meu WS2812, tive que modificar continuamente meu aplicativo Excel, LED_Utility.xlsm.

A pasta de trabalho do Excel agora oferece:

Propriedades RGB do LED a serem tratadas individualmente.

Alterar dinamicamente essas propriedades por meio da programação.

Realocação XY dessas propriedades para simular movimento.

Valores RGB a serem endereçados, bem como alteração da localização XY.

Endereçamento de LEDs 8x8 e 16x16.

Uma pequena coleção de valores RGB para referência rápida.

Especificamente, meu objetivo é:

Desenvolva um quadrado vazio vermelho e ligue-o e desligue-o.

Sobreponha outro quadrado com uma camada de cores diferentes e alterne entre elas.

Aumente a Praça Vermelha e brinque com ela.

Considere pensamentos sobre o uso de funções para manter elementos de exibição; Vou construir uma espiral de desvanecimento.

Crie um design em que as cores apareçam e desapareçam.

Traga movimento para o design.

Endereços de matrizes 16x16.

Eu reconheço que o conhecimento de programação criará problemas. Ofereci algumas orientações, mas sugiro pesquisar ou perguntar a alguém que possa aconselhá-lo pessoalmente.

PARA BEGIN

Monte o hardware

Se sua matriz vier sem os pinos de cabeçalho, solde o banco de pinos de cabeçalho na parte traseira da Matriz no local inferior (DIN, + 5V, GND). Conecte o pino DIN ao pino 8 à direita do Arduino e os outros dois aos locais correspondentes no outro lado da placa.

Para esta placa e o utilitário, XY (0, 0) é o canto superior esquerdo.

O utilitário Excel

Abra o arquivo LED_Utility.xlsm. Você verá três planilhas, “Eight”, “Sixteen” e “ColMap”.

O último é uma pequena amostra de códigos RGB fornecidos para referência.

Eu configurei LED_Utility.xlsm para somente leitura para evitar a substituição, mas também para encorajar o uso de “SaveAs” para reter um arquivo para possível reutilização. Algumas outras “armadilhas de erro” também foram incluídas.

Selecione a planilha “Oito”.

Observe que a grade do lado direito está preenchida com zeros. Isso é importante porque o esboço não aceita valores "nulos".

Existem quatro botões como mostrado acima (em “Dezesseis” eles provavelmente estarão fora da tela à direita, um abaixo do outro, mas funcionarão conforme descrito abaixo).

Para produzir o código de texto:

“Mostrar” exibe o RGB dos valores na grade esquerda. Ele lida apenas com valores de 0 a 255. Ele alertará para valores acima de 255 ou quaisquer variáveis.

“Var Map” aceita numéricos e variáveis, mas não oferece exibição.

“Wrap Map” tem duas camadas. Ele aceita valores RGB normalmente inseridos para uma exibição “Mostrar”. Em seguida, ele adiciona uma função de módulo para codificação de esboço para permitir a saturação da matriz. Em segundo lugar, variáveis podem ser adicionadas, mas devem ser posteriormente programadas no esboço. Não estou tratando disso aqui.

Cada um gera texto 'vermelho' abaixo das grades (em ambas as planilhas) compatível com um esboço projetado para aceitá-lo.

“Limpar” obviamente anula ambas as grades.

Tudo isso será descrito mais tarde.

Quando você está trabalhando com o Utilitário Excel, recomendo que você use Arquivo / Salvar como ... depois de ter gerou seu código para que você não tenha que recriar seu design em algum outro ponto, e especialmente se o design for razoavelmente complexo. Além disso, seu LED_Utility.xlsm original foi definido como somente leitura para protegê-lo de ser substituído.

O esboço

O código é oferecido abaixo com uma nota de advertência para salvar com uma propriedade somente leitura.

Abra o IDE do Arduino e carregue o esboço ‘LED_Arduino.ino’.

Você verá que:

A linha 3 define o pino do Arduino em uso. Isso é definido como Pin 8.

A linha 4 define as unidades de LED na placa. São 64.

A linha 5, entretanto, multiplica esse número por 3 para levar em conta a contagem RBG, portanto, 192.

As linhas 8, 10 e 25 definem as funções em uso.

Entre as linhas 3 e 19, o texto original foi alterado, mas você pode editar para endereçar uma matriz 16x16. Dito isso, forneci LED_Ardino16.ino no software e LED_Utility.xlsm irá acomodá-lo.

Freqüentemente, aconselho que você abra o ‘LED_Arduino.ino’ e, em seguida, “Salvar como” com algum nome. Isso garantirá que ‘LED_Arduino.ino’ permaneça inalterado se você não tiver definido a propriedade apropriada como ‘Somente leitura’. [Descobri que meu arquivo recém-criado ainda tinha a propriedade Somente leitura definida; libere isso para garantir futuras edições e salvamentos].

Ao mesmo tempo, um esboço recém-criado provavelmente precisa ter uma ou ambas a porta e a placa redefinidas; uma mensagem de erro aparecerá, mas pode não ser imediatamente eliminada.

Projeto 1

Carregue o LED_Arduino.ino no IDE do Arduino e salve-o como Red_Square (o ino será adicionado automaticamente).

Inicialmente, estou propondo construir um quadrado vermelho 3x3 e coloque esse código na linha 40 do esboço. As células N8, O8, P8, N11, P11, N14, O14 e P14 manterão o valor de 255.

Quando o texto em vermelho de LED_Utility,

  mapLEDXY (2,2,255,0,0); mapLEDXY (2,3,255,0,0); mapLEDXY (2,4,255,0,0); mapLEDXY (3,2,255,0,0); mapLEDXY (3,4,255,0,0); mapLEDXY (4,2,255,0,0); mapLEDXY (4,3,255,0,0); mapLEDXY (4,4,255,0,0);

é copiado para a linha 40, o texto abaixo será naturalmente movido para baixo.

Quando você faz o upload do esboço para o seu Arduino, sua matriz liga e desliga esse quadrado.

Antes de prosseguir, considere:

Limpando as duas grades.

Altere algumas cores dentro desse quadrado.

Adicione um quadrado de cor diferente ao redor do original.

Projeto2

Eu sugiro que você abra o esboço Red_Square.ino e salve-o como Colour_Sq (‘.ino’ será adicionado automaticamente) para evitar sobrescrever Red_Square.ino.

Com Colour_Sq.ino carregado no IDE, vá para Red_Square no Utilitário e modifique os quadrados médios. MakeO8, O10, O14 e O16 ‘255’. N11 e P11 são '0', mas N12 e P12 são '255'. Pressione “Mostrar”.

Depois de adicionar o novo código em, eu anteciparia a linha 47 no IDE, você precisa segui-la com este bloco de código:

  RGB_update (-1, 0, 0, 0); delay (1000); clearLEDs (); RGB_update (-1, 0, 0, 0); atraso (1000);

Observe que você pode alterar o valor do atraso para se adequar a você; 1000 equivale a 1 segundo.

Projeto3

Recarregue Red_Square.ino e salve-o como Grow.

Recrie o quadrado vermelho no utilitário. Ao redor desse quadrado, adicione valores de sua escolha para criar uma borda, eles podem estar em qualquer lugar de 0 a 255, mas inferiores a 32 podem ser muito esmaecidos. Esta é minha criação em ‘LED_Utility.xlsm’:

Agora exclua os valores para aquele quadrado vermelho interno e pressione “Mostrar”. Copie o código gerado para a linha 47 noIDE e copie / cole as linhas 42 a 46 depois disso. Faça upload para o Arduino para alternar um quadrado vermelho interno e outro cercado por várias cores.

Tente expandir para outra fronteira, se desejar.

Projeto4

Você deve ter se dado conta de que, conforme adicionamos o código ao “Loop”, há uma tendência de ele se tornar longo e possivelmente apresentar dificuldade para edição posterior.

Aqui estou construindo uma espiral.

A imagem é da pasta de trabalho “spir5.xlsm”. É o resultado de 4 Pastas de Trabalho anteriores.

“Spir1.xlsm” era o centro com blocos brilhantes (255), “spir2.xlsm” usava os valores do quadrado interno 4x4, com “spir3.xlsm” sendo o bloco de 27 quadrados, etc. Em cada estágio eu copiei o código ao meu esboço, mas não para “fazer um loop”.

Em vez disso, criei 5 funções nulas abaixo de “loop” e as referenciei dentro de “loop”:

  Loid loop () {Sp1 (); Sp2 (); Sp3 (); Sp4 (); Sp5 (); clearLEDs (); atraso (1000);}

Minha primeira função, void Sp1 (), é:

  void Sp1 () {mapLEDXY (3,3,255,0,0); mapLEDXY (3,4,255,0,0); mapLEDXY (4,3,255,0,0); mapLEDXY (4,4,255, 0,0); RGB_update (-1, 0, 0, 0); delay (100); clearLEDs (); RGB_update (-1, 0, 0, 0); delay (10);}

Cada função sucessiva será a mesma, exceto para as duas linhas de “mapLEDXY…”.

Pode parecer trivial com este exemplo sugerir a abertura de “spir4.xlsm” para editar as cores das pontas externas para editar uma função dedicada em vez de editar dentro do “loop”.

Quase no ridículo, suponha que você queira exibir as letras da palavra “MISSISSIPPI” sucessivamente, uma de cada vez. Existem 11 caracteres, o que significa 77 linhas de código para ‘void loop ()’ manipular. Se você decidir alterar o “S”, deverá fazer 4 edições. Existem apenas 4 caracteres usados na palavra. Portanto, faz sentido criar uma função para cada um deles e chamá-los apropriadamente do “loop”.

Projeto5

Este projeto leva em consideração outra função do LED_Utility, “Var Map”. Aqui, as variáveis serão introduzidas e, portanto, alguns conhecimentos básicos de programação serão necessários.

A sintaxe “For Loop” será empregada, bem como a condição “If”.

O "para" será usado para aumentar ou diminuir um valor RGB, como:

  for (int r =0; r <=256; r ++) {} orfor (int r =255; r> =0; r--) {}

“Se” modificará os procedimentos conforme necessário.

Comecemos simplesmente, e quero dizer simplesmente.

Crie um quadrado vermelho 2x2 no meio de LED_utility e “Show”, e aqui está o código:

  mapLEDXY (3,3,255,0,0); mapLEDXY (3,4,255,0,0); mapLEDXY (4,3,255,0,0); mapLEDXY (4,4,255,0,0);

Agora mude todos os 255 valores para 'r'. Pressione “Mostrar”…. Oooow! Não é assim. Tudo bem, é uma proteção que adicionei. Pressione “Var Map” e verifique o código gerado:

  mapLEDXY (3,3, r, 0,0); mapLEDXY (3,4, r, 0,0); mapLEDXY (4,3, r, 0,0); mapLEDXY (4,4 , r, 0,0);

os 255 foram substituídos por 'r'.

No IDE, abra o arquivo LED_Arduino.ino e salve-o como “alterações”.

Na linha 40, digite:

  for (int r =0; r <256; r ++) {} /// seguido por:for (int r =255; r> =0; r -) {}

Observe que há uma linha em branco após cada instrução 'para'.

Na linha 41, cole seu código do Excel:

  mapLEDXY (3,3, r, 0,0); mapLEDXY (3,4, r, 0,0); mapLEDXY (4,3, r, 0,0); mapLEDXY (4,4 , r, 0,0); siga isso com:RGB_update (-1, 0, 0, 0); atraso (50);

Agora copie / cole o mesmo bloco de código de 4 linhas naquele segundo bloco “for”.

Depois desse bloco “para”, abaixo de “}” adicione ‘atraso (200);’. Achei necessário para meus olhos saberem que o segundo bloco havia fechado!

Após o upload, o bloco vermelho aumenta até o brilho total e depois diminui, desliga e se repete.

Projeto6

Vamos agora usar a condição “If”.

Recrie o quadrado vermelho anterior em LED_utility, mas rodeie-o com blocos de "azul celeste" usando 255 para os valores G e B. Use o “Show”.

Deixe os 255 vermelhos sozinhos, mas mude todos os G 255s para um ‘g’ e os B 255s para um ‘b’,

e então pressione “Var Map”.

Recarregue “LED_Arduino.ino” no IDE e salve como “FadeBorder”.

Agora vamos ter alguns problemas. Temos duas variáveis, 'g' e 'b', e cada uma deve receber um valor. Eles também devem ser declarados no programa. Pretendo declarar o ‘g’ em uma declaração ‘para’, mas preciso declarar o ‘b’ anteriormente no esboço. No esboço da linha 5 está a declaração BYTE RGB [192]. Abaixo disso, insira ‘int b =0;’.

Como ponto de explicação, não se pode usar dois loops “for”, como será necessário mais tarde. Aqui, cada valor ‘b’ deve ser igual ao valor ‘g’ gerado pelo loop “for”.

Meu “loop” está estruturado como abaixo, mas sem meu código do mapa:

  void loop () {delay (50); for (int g =0; g <256; g ++) {b =g; [Adicione o código do mapa aqui] RGB_update (-1, 0, 0, 0 ); atraso (50);} para (int g =255; g> =0; g -) {b =g; [Adicione o código do mapa aqui] RGB_update (-1, 0, 0, 0); atraso (50);}}

Observe que o valor B está vinculado ao valor G com a declaração ‘b =g;’. O valor R permanece estático em 255 enquanto a borda aumenta e diminui em brilho.

Projeto7

Agora é hora de usar a instrução “if”.

Crie e "mostre" o seguinte usando 255 onde as variáveis aparecem na grade certa. Observe que um minúsculo 'L' aparece nas células adjacentes às células vermelhas. Isso permitirá que o programa assuma o controle dessas células quando apropriado.

Desta vez, os LEDs ficarão verdes e vermelhos até que o valor 64 seja alcançado e, em seguida, as células da borda intermediária mudarão para amarelo e o brilho da placa continuará aumentando. Então o processo será revertido.

Mais uma vez, vou oferecer a estrutura básica do meu 'loop'. Chamei este esboço de ‘FadeColourChange.ino’.

  void loop () {delay (50); for (int r =0; r <256; r ++) {g =r; if (g> 64) {g =65; l =r;} [AddMap Code aqui] RGB_update (-1, 0, 0, 0); atraso (50);} para (int r =255; r> =0; r -) {se (r <65) {g =r; l =0;} [Adicione MapCode aqui] RGB_update (-1, 0, 0, 0); delay (50);}}

Projeto8

Para este último projeto, não mudarei as cores, mas introduzirei movimento; Tenho uma seta que se move através do tabuleiro, mas reaparece à esquerda.

Aqui, desejo apenas gerar código usando “Mostrar”.

Como quero que a seta se mova de sua posição atual para cada posição seguinte, preciso alterar o valor 'x'.

Este é o código gerado em G29:G33:

  mapLEDXY (0,3,0,255,255); mapLEDXY (1,1,255,128,128); mapLEDXY (1,3,0,255,255); mapLEDXY (1,5,255,128,128); mapLEDXY (2,2,255,128,128); mapLEDXY (2,3,0,255,255); , 0,255,255); mapLEDXY (2,4,255,128,128); mapLEDXY (3,3,255,128,128);

Uma vez que '1' é meu menor valor para as coordenadas X, estou me referindo a isso como 'x' e diminuindo todos os outros valores em 1.

  mapLEDXY (x + 0,3,0,255,255); mapLEDXY (x + 1,255,128,128); mapLEDXY (x + 1,3,0,255,255); mapLEDXY (x + 1,5,255,128,128); mapLEDXY (x + 2, 2.255.128.128); mapLEDXY (x + 2,3,0.255.255); mapLEDXY (x + 2.455.128.128); mapLEDXY (x + 3.355.128.128);

Meu "for (int x ... loop" faz bem, exceto que a ponta da seta transborda para a linha inferior por algumas passagens do loop!

Solução! Se um valor ultrapassar '8', preciso de seu valor de módulo. Isso me forçou a criar o botão “Wrap Map”. O código para um LED agora aparece como:

mapLEDXY ((x +1)% 8, (y +1)% 8, 255, 128, 128);

Para abordar um layout XY, acho que é melhor aninhar dois loops ‘for’, mesmo se um não for usado (sim, encontrei uma alternativa estranha).

  for (int x =0; x <8; x ++) {for (int y =0; y <8; y ++) {[mapcode]}}

Se eu fizer 'y <1' no segundo loop, 'y' é desconsiderado. Inversamente, mudar 'y' para 8 e 'x' para 0 tem um efeito diferente.

Como um último pensamento, “Wrap Map” aceitará variáveis RGB. Veja acima onde mencionei. Alguém com programação básica deve ser capaz de lidar com isso. Eu adicionei um esboço INO, ArrowVar.ino, onde a frente da seta muda de brilho como uma demonstração secundária.

Uso da matriz 16x16.

Tudo o que foi mencionado acima é aplicável para a matriz WS2812 de 16x16. O esboço ‘LED_Arduino16.ino’, entretanto, deve ser usado.

Os esboços fornecidos são projetados para a Matriz 8x8, exceto um, o ‘Spiral16.ino’. Ele oferece uma exibição maior do que o ‘Spiral.ino’.

Essa espiral, de matriz 16x16, tinha 2 folhas de papel para impressora como difusor de luz. A exibição foi pausada por cerca de 10 segundos para capturar uma imagem razoável.

Para desenvolver seu código, abra LED_Utility.xlsm e selecione a guia “Dezesseis” na parte inferior da página.

Se, como eu, sua tela for muito grande e você precisar rolar, use uma opção de diminuir o zoom. Mesmo assim, alguma rolagem será necessária para copiar seu código.

Extensões?

É possível abordar Matrizes de outros tamanhos?

Estou me perguntando por que meu ‘LED_Arduino.ino’ e ‘LED_Arduino16.ino’ são tão diferentes em suas linhas de abertura. Tenho certas linhas comentadas no meu primeiro; ambos os esboços funcionam como desejo.

Não estou prestes a escrever uma planilha para um ‘8x32’, embora tenha acabado de adquirir uma placa. Vou encaminhá-lo para “ O esboço " acima. Existem parâmetros que precisam ser tratados. Seja específico sobre as linhas 15 e 18 também.

NB:Também estou considerando opções menores do que uma placa do tipo UNO.

Código

LED_Arduino

LED_Arduino C / C ++

Este esboço forma a base do projeto. Ao salvar, deve ser definido como Somente leitura e uso posterior como 'Salvar como' para arquivamento para evitar sobrescrever e permitir fácil reedição.

 // VARIÁVEIS E DEFINIÇÕES AQUI - NECESSÁRIOS PELO CÓDIGO DO DRIVER WS2812 # define WS2812_pin 8 // apenas o pino digital 8 funciona agora # define numberOfLEDs 64 // número total de RGB LEDs [256] byte RGB [192]; // pegue seu número de LEDs e multiplique por 3 [768] // FUNÇÕES AQUI evite RGB_update (int LED, byte VERMELHO, byte VERDE, byte AZUL); // função para acionar LEDsvoid mapLEDXY (int x, int y, byte VERMELHO, byte VERDE, byte AZUL) {int RGBlocation =0; // if (y% 2 ==0) {// coluna par [Uncomment] RGBlocation =x + y * 8; // [16] //} else {// coluna ímpar [Uncomment] // RGBlocation =7 - x + y * 8; // [15] e [16] //} [Descomentar] RGB [RGBlocation * 3] =AZUL; RGB [RGBlocation * 3 + 1] =VERMELHO; RGB [RGBlocation * 3 + 2] =GREEN;} void clearLEDs () {memset (RGB, 0, sizeof (RGB));} void setup () {pinMode (WS2812_pin, OUTPUT); clearLEDs (); RGB_update (-1, 0, 0, 0);} // setup0void loop () {// Cole as linhas mapLEDXY diretamente acima de RGB_update abaixo.RGB_update (-1, 0, 0, 0); atraso (1000); clearLEDs (); RGB_update (-1, 0, 0, 0); delay (1000);} // loop // Função do driver WS2812void RGB_update (int LED, byte VERMELHO, byte VERDE, byte AZUL) {// LED é o número do LED começando com 0 // VERMELHO, VERDE, AZUL é o brilho 0 ..255 ponto de ajuste para aquele byte de LED ExistingPort, WS2812pinHIGH; // variáveis locais aqui para acelerar pinWrites if (LED> =0) {// mapeie os valores REG GREEN BLUE no array RGB [] RGB [LED * 3] =VERDE; RGB [LED * 3 + 1] =VERMELHO; RGB [LED * 3 + 2] =AZUL; } noInterrupts (); // elimina as interrupções enquanto enviamos o fluxo de bits ... ExistingPort =PORTB; // salve o status de toda a PORTA B - vamos gravar em toda a porta sem bagunçar os outros pinos dessa porta WS2812pinHIGH =PORTB | 1; // isso nos dá um byte que podemos usar para definir todo o PORTB com o pino WS2812 HIGH int bitStream =numberOfLEDs * 3; // total de bytes na string de LED // Este loop for percorre todos os bits (8 em um tempo) para definir os tempos de ON / OFF do pino WS2812 para (int i =bitStream - 1; i> =0; i--) {PORTB =WS2812pinHIGH; // bit 7 primeiro, defina o pino HIGH - ele sempre vai alto, independentemente de um 0/1 // aqui está a parte complicada, verifique se o bit no byte é alto / baixo e, em seguida, esse status para o pino // (RGB [i] e B10000000) removerá os outros bits em RGB [i ], então aqui ficaremos com B10000000 ou B00000000 // então é fácil verificar se o bit é alto ou baixo fazendo o AND com a máscara de bit "" &&B10000000) "" isso dá 1 ou 0 // se for 1, faremos OU isso com a porta Existing, mantendo assim o pino HIGH, se 0 o pino é escrito LOW PORTB =((RGB [i] &B10000000) &&B10000000) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); // são NOPS - permitem atrasar o relógio ciclos para um tempo mais preciso PORTB =ExistingPort; // ok, aqui sabemos que temos que estar BAIXOS independentemente do estado de 0/1 bit __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t "" nop \ n \ t "" nop \ n \ t "" nop \ n \ t "" nop \ n \ t "); // tempo mínimo BAIXO para pino independentemente do estado de 0/1 bit // então faça novamente para o próximo bit e assim por diante ... veja o último bit para uma ligeira mudança PORTB =WS2812pinHIGH; // bit 6 PORTB =((RGB [i] &B01000000) &&B01000000) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 5 PORTB =((RGB [i] &B00100000) &&B00100000) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 4 PORTB =((RGB [i] &B00010000) &&B00010000) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 3 PORTB =((RGB [i] &B00001000) &&B00001000) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 2 PORTB =((RGB [i] &B00000100) &&B00000100) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 1 PORTB =((RGB [i] &B00000010) &&B00000010) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =Porta Existente; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t "); PORTB =WS2812pinHIGH; // bit 0 __asm __ ("nop \ n \ t"); // neste último bit, a verificação é muito mais rápida, então tive que adicionar um NOP aqui PORTB =((RGB [i] &B00000001) &&B00000001) | ExistingPort; __asm __ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =ExistingPort; // observe que não há NOPs após escrever o pino LOW, isso ocorre porque o FOR Loop usa ciclos de clock que podemos usar em vez do NOPS} // for loop interrupts (); // habilita as interrupções // tudo pronto!} // void RGB_update

Led_Utility.xlsm

Este aplicativo gera os vários textos para copiar / colar no sketch.https://github.com/CobraCat/LED_Utility

Sketches.zip

Estes são alguns ou mais esboços usados durante o desenvolvimento. Eles estão disponíveis como 'support'.https://github.com/CobraCat/LED_Utility

Switch / Painel de LED com Arduino para FS2020 32 (Linier) / 11 (Pseudo Log) banda Audio Spectrum Analyzer

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial