Excel para animaciones de matriz de LED RGB WS2812

Acerca de este proyecto

Después de comprobar que había soporte en línea, pedí una matriz de LED RGB WS2812 8x8 esperando que se tratara como una estructura de coordenadas XY, no como una cadena de margarita (cinta) de 64 LED envueltos en 8 filas de 8.

Una búsqueda de "WS2812 Led animation" arrojó poco que pudiera comprender de inmediato. Cuando encontré un video de YouTube producido por Kevin Darrah, se estaba dirigiendo a una matriz de 16 x 16 (256 LED conectados en cadena) como si fuera un sistema de coordenadas XY.

Su utilidad de Excel compiló código de texto para copiar / pegar en su boceto dentro del cual estaban todas las funciones necesarias; no es necesario importar bibliotecas.

Cuando seleccionó celdas dentro de su utilidad y se agregaron valores RGB, se aplicaron a esas celdas seleccionadas sin discriminación; no es lo que deseaba, así que lo rediseñé y lo reconstruí. Eso también significó que tuve que modificar su boceto para compatibilidad con 8x8.

A medida que pedí más de mi WS2812, tuve que modificar continuamente mi aplicación de Excel, LED_Utility.xlsm.

El libro de trabajo de Excel ahora ofrece:

• Las propiedades del LED RGB deben abordarse individualmente.

• Alterar dinámicamente esas propiedades a través de la programación.

• Reubicación XY de esas propiedades para simular movimiento.

• Los valores RGB que se deben abordar y la alteración de la ubicación XY.

• Direccionamiento de LED de 8x8 y 16x16.

• Una pequeña colección de valores RGB para referencia rápida.

Específicamente, mi objetivo es:

• Desarrolle un cuadrado hueco rojo y enciéndalo y apáguelo.

• Superponga otro cuadrado con una capa de diferentes colores y alterne entre ellos.

• Haga crecer el cuadrado rojo y juegue con él.

• Considere pensamientos sobre el uso de funciones para contener elementos de visualización; Construiré una espiral que se desvanece.

• Cree un diseño en el que los colores aparezcan y desaparezcan.

• Aporta movimiento al diseño.

• Abordar matrices de 16x16.

Reconozco que el conocimiento de programación creará problemas. Le he ofrecido alguna orientación, pero sugiero que investigue o pregunte a alguien que pueda asesorarlo personalmente.

PARA COMIENZO

Ensamble el hardware

Si su matriz viene sin pines de encabezado, suelde el banco de pines de encabezado a la parte posterior de la matriz en la ubicación inferior (DIN, + 5V, GND). Conecte el pin DIN al pin 8 a la derecha del Arduino y los otros dos a ubicaciones coincidentes en el otro lado de la placa.

Para esta placa y la utilidad, XY (0, 0) es la parte superior izquierda.

La utilidad de Excel

Abra el archivo LED_Utility.xlsm. Verá tres hojas, "Ocho", "Dieciséis" y "ColMap".

La última es una pequeña muestra de códigos RGB que se proporcionan como referencia.

He configurado LED_Utility.xlsm en solo lectura para evitar que se sobrescriban, pero también para alentar el uso de "SaveAs" para retener un archivo para una posible reutilización. También se han incorporado algunas otras "trampas de error".

Seleccione la hoja de trabajo "Ocho".

Observe que la cuadrícula de la derecha está llena de ceros. Eso es importante ya que el boceto no aceptará valores "nulos".

Hay cuatro botones como se muestra arriba (en "Dieciséis" probablemente estarán fuera de la pantalla a la derecha, uno debajo del otro, pero funcionarán como se describe a continuación).

Para producir código de texto:

"Mostrar" muestra el RGB de los valores en la cuadrícula de la izquierda. Solo maneja valores de 0 a 255. Avisará sobre valores superiores a 255 o cualquier variable.

"Var Map" acepta números y variables, pero no ofrece visualización.

"Wrap Map" tiene dos niveles. Acepta valores RGB que normalmente se ingresan para una pantalla "Mostrar". Luego agrega una función de módulo para la codificación de croquis para permitir el desbordamiento de la matriz. En segundo lugar, se pueden agregar variables, pero luego se deben programar en el esquema. No me refiero a eso aquí.

Cada uno genera texto "rojo" debajo de las cuadrículas (en ambas hojas de trabajo) compatible con un boceto diseñado para aceptarlo.

"Claro" obviamente anula ambas cuadrículas.

Todos estos se describirán más adelante.

Cuando trabaja con Utilidad de Excel, le recomiendo que utilice Archivo / Guardar como ... después de haber generó su código para que no tenga que volver a crear su diseño en algunos otro punto, y especialmente si el diseño es razonablemente complejo. Además, su LED_Utility.xlsm original se ha configurado como de solo lectura para protegerlo de sobrescrito.

El bosquejo

Se ofrece el código a continuación con una nota de advertencia para guardar con una propiedad de solo lectura.

Abra Arduino IDE y cargue el boceto "LED_Arduino.ino".

Verá que:

• La línea 3 define el pin Arduino en uso. Este conjunto como Pin 8.

• La línea 4 define las unidades LED en el tablero. Estos son 64.

• Sin embargo, la línea 5 multiplica esa cifra por 3 para tener en cuenta el recuento de RBG, por lo tanto, 192.

• Las líneas 8, 10 y 25 definen las funciones en uso.

Entre las líneas 3 y 19 se ha modificado el texto original, pero puede editarlo para abordar una matriz de 16x16. Dicho esto, he proporcionado LED_Ardino16.ino en el software y LED_Utility.xlsm lo admitirá.

Con frecuencia le aconsejaré que abra "LED_Arduino.ino" y luego "Guardar como" con algún nombre. Eso garantizará que "LED_Arduino.ino" no se modifique si no ha configurado la propiedad adecuada en "Solo lectura". [Descubrí que mi archivo recién creado todavía tenía la propiedad de Sólo lectura establecida; libérelo para asegurarse de que se puedan editar y guardar en el futuro].

Al mismo tiempo, es probable que un boceto recién creado necesite redefinir el puerto y la placa, o ambos; aparecerá un mensaje de error, pero es posible que no se aclare de inmediato.

Proyecto 1

Cargue LED_Arduino.ino en el IDE de Arduino y guárdelo como Red_Square (ino se agregará automáticamente).

Inicialmente propongo construir un cuadrado rojo de 3x3 y ponga ese código en la línea 40 del boceto. Las celdas N8, O8, P8, N11, P11, N14, O14 y P14 tendrán el valor de 255.

Cuando el texto rojo 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);  

se copia en la línea 40, el texto debajo de él naturalmente se moverá hacia abajo.

Cuando cargue el boceto en su Arduino, su matriz encenderá y apagará ese cuadrado.

Antes de continuar, considere:

• Borrar ambas cuadrículas.

• Cambie algunos colores dentro de ese cuadrado.

• Agrega un cuadrado de diferente color alrededor del original.

Proyecto2

Le sugiero que abra el boceto Red_Square.ino y lo guarde como Colour_Sq (".ino" se agregará automáticamente) para evitar sobrescribir Red_Square.ino.

Con Colour_Sq.ino cargado en el IDE, vaya a Red_Square en la Utilidad y modifique los cuadrados medios. Hacer O8, O10, O14 y O16 "255". N11 y P11 son "0" pero N12 y P12 son "255". Presione "Mostrar".

Una vez que haya agregado el nuevo código en, anticipo la línea 47 en el IDE, debe seguirlo con este bloque de código:

  RGB_update (-1, 0, 0, 0); retraso (1000); clearLEDs (); RGB_update (-1, 0, 0, 0); retraso (1000);  

Tenga en cuenta que puede cambiar el valor de retraso según sus necesidades; 1000 equivale a 1 segundo.

Proyecto3

Vuelva a cargar Red_Square.ino y guárdelo como Grow.

Recrea el cuadrado rojo en la utilidad. Alrededor de ese cuadrado, agregue los valores de su elección para crear un borde, pueden estar entre 0 y 255, pero menos de 32 pueden ser muy tenues. Esta es mi creación en "LED_Utility.xlsm":

Ahora elimine los valores para ese cuadrado rojo interior y presione "Mostrar". Copie el código generado en la línea 47 en el IDE y copie / pegue las líneas 42 a 46 después de eso. Sube al Arduino para alternar un cuadrado rojo interior y luego uno rodeado de varios colores.

Intente expandir a otro borde si lo desea.

Proyecto4

Es posible que se haya dado cuenta de que a medida que agregamos código en "Loop", existe una tendencia a que se vuelva más largo y posiblemente plantee dificultades para editarlo más adelante.

Aquí estoy construyendo una espiral.

La imagen es del Libro de trabajo “spir5.xlsm”. Es la culminación de 4 libros de trabajo anteriores.

"Spir1.xlsm" era el centro con bloques brillantes (255), "spir2.xlsm" usaba los valores del cuadrado interior de 4x4, siendo "spir3.xlsm" el bloque de 27 cuadrados, etc. En cada etapa copié el código a mi boceto pero no a "bucle".

En su lugar, creé 5 funciones vacías debajo de "bucle" y las hice referencia dentro de "bucle":

  Bucle vacío () {Sp1 (); Sp2 (); Sp3 (); Sp4 (); Sp5 (); clearLEDs (); delay (1000);}  

Mi primera función, void Sp1 (), es:

  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); retraso (100); clearLEDs (); RGB_update (-1, 0, 0, 0); retraso (10);}  

Cada función sucesiva será la misma excepto por las dos líneas de "mapLEDXY ...".

Puede parecer trivial en este ejemplo sugerir abrir "spir4.xlsm" para editar los colores de las puntas externas para editar una función dedicada en lugar de editar dentro del "bucle".

Rodeando lo ridículo, suponga que desea mostrar las letras de la palabra “MISSISSIPPI” sucesivamente una a la vez. Hay 11 caracteres, lo que significa 77 líneas de código para que las maneje "void loop ()". Si decide modificar la "S", debe realizar 4 ediciones. Solo se utilizan 4 caracteres en la palabra. Por lo tanto, tiene sentido crear una función para cada uno de ellos y llamarlos apropiadamente desde "loop".

Proyecto5

Este proyecto tiene en cuenta otra función de LED_Utility, “Var Map”. Aquí se introducirán variables y, por lo tanto, se requerirán algunos conocimientos básicos de programación.

Se empleará la sintaxis "For Loop", así como la condición "If".

El "para" se utilizará para aumentar o disminuir un valor RGB como:

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

"Si" modificará los procedimientos según sea necesario.

Comencemos simplemente, y quiero decir simplemente.

Cree un cuadrado rojo de 2x2 en el medio de LED_utility y "Show", y aquí está el 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);  

Ahora cambie todos los 255 valores a "r". Presione "Mostrar"…. ¡Oooow! Eso no le gusta. Está bien, es una protección que he agregado. Presione "Var Map" y verifique el código generado:

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

los 255 han sido reemplazados por "r".

En el IDE, abra el archivo LED_Arduino.ino y guárdelo como "cambios".

En la línea 40 ingrese:

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

Tenga en cuenta que hay una línea en blanco después de cada declaración "para".

En la línea 41 pegue su código de 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 eso con:RGB_update (-1, 0, 0, 0); delay (50);  

Ahora copie / pegue ese mismo bloque de código de 4 líneas en ese segundo bloque "para".

Después de ese bloque "para", debajo de "}", agregue "retraso (200);". ¡Encontré eso necesario para que mis ojos supieran que el segundo bloque se había cerrado!

Al cargar, el bloque rojo aumenta a su brillo total y luego disminuye, se apaga y luego se repite.

Proyecto6

Utilicemos ahora la condición "Si".

Recrea ese cuadrado rojo anterior en LED_utility pero rodéalo con bloques de un "azul celeste" usando 255 para los valores G y B. Utilice el "Show".

Deje los Red 255 en paz, pero cambie todos los G 255 a una "g" y los B 255 a una "b",

y luego presione "Var Map".

Vuelva a cargar "LED_Arduino.ino" en el IDE y guárdelo como "FadeBorder".

Ahora vamos a tener algunos problemas. Tenemos dos variables, 'g' y 'b', y cada una debe tener un valor. También deben declararse en el programa. Tengo la intención de declarar la "g" en una declaración "para", pero necesito declarar la "b" antes en el boceto. En el croquis de la línea 5 está la declaración BYTE RGB [192]. Debajo, ingrese "int b =0;".

Como punto de explicación, no se pueden utilizar dos bucles "for", ya que será necesario más adelante. Aquí, cada valor de "b" debe ser el mismo que el valor de "g" generado por el ciclo "for".

Mi "bucle" está estructurado como se muestra a continuación, pero sin mi código de mapa:

  void loop () {delay (50); for (int g =0; g <256; g ++) {b =g; [Agregar código de mapa aquí] RGB_update (-1, 0, 0, 0 ); demora (50);} for (int g =255; g> =0; g -) {b =g; [Agregar código de mapa aquí] RGB_update (-1, 0, 0, 0); delay (50);}}  

Tenga en cuenta que el valor B está vinculado al valor G con la declaración "b =g;". El valor R permanece estático en 255 mientras que el borde aumenta y disminuye el brillo.

Proyecto7

Ahora es el momento de hacer uso de la declaración "si".

Cree y "muestre" lo siguiente usando 255, donde las variables aparecen en la cuadrícula de la derecha. Observe que aparece una minúscula "L" en las celdas adyacentes a los glóbulos rojos. Eso permitirá que el programa tome el control de esas células cuando sea apropiado.

Esta vez, los LED se iluminarán en verde y rojo hasta que se alcance el valor 64 y luego esas celdas del borde medio cambiarán a amarillo y la placa continuará aumentando su brillo. Entonces el proceso se invertirá.

Nuevamente ofreceré la estructura base de mi "bucle". Llamé a este boceto "FadeColourChange.ino".

  void loop () {delay (50); for (int r =0; r <256; r ++) {g =r; if (g> 64) {g =65; l =r;} [Agregar código de mapa aquí] RGB_update (-1, 0, 0, 0); retardo (50);} for (int r =255; r> =0; r -) {if (r <65) {g =r; l =0;} [Agregar MapCode aquí] RGB_update (-1, 0, 0, 0); delay (50);}}  

Proyecto8

Para este último proyecto no cambiaré los colores sino que introduciré movimiento; Tengo una flecha que se mueve a través del tablero pero volverá a aparecer desde la izquierda.

Aquí solo quiero generar código usando "Mostrar".

Como quiero que la flecha se mueva de su posición actual a cada posición siguiente, necesito cambiar el valor de "x".

Este es el código generado en 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); mapLEDXY (2,4,255,128,128); mapLEDXY (3,3,255,128,128);  

Dado que "1" es mi valor mínimo para las coordenadas X, me refiero a eso como "x" y reduzco todos los demás valores en 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,4,255,128,128); mapLEDXY (x + 3,3,255,128,128);  

Mi "for (int x ... loop" funciona bien, excepto que la punta de la flecha se desborda hacia la fila inferior durante algunas pasadas del bucle.

¡Solución! Si un valor sobrepasa "8", necesito su valor de módulo. Eso me obligó a crear el botón "Ajustar mapa". El código para un LED ahora aparece como:

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

Para abordar un diseño XY, creo que es mejor anidar dos bucles "for" incluso si no se usará uno (sí, encontré una alternativa incómoda).

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

Si hago "y <1" en el segundo ciclo, la "y" no se tiene en cuenta. A la inversa, cambiar "y" a 8 y "x" a 0 tiene un efecto diferente.

Como último pensamiento, "Wrap Map" aceptará variables RGB. Vea arriba donde he hecho referencia. Uno con programación básica debería poder lidiar con eso. He agregado un boceto INO, ArrowVar.ino, donde el frente de la punta de flecha cambia de brillo como una demostración menor.

Uso de matriz 16x16.

Todo lo indicado anteriormente es aplicable para la matriz WS2812 de 16x16. Sin embargo, se debe utilizar el boceto "LED_Arduino16.ino".

Los bocetos que se proporcionan están diseñados para la matriz 8x8 excepto uno, el "Spiral16.ino". Ofrece una pantalla más grande que la de "Spiral.ino".

Esta espiral, matriz de 16x16, tenía 2 hojas de papel de impresora como difusor de luz. La pantalla se pausó durante unos 10 segundos para capturar una imagen razonable.

Para desarrollar su código, abra LED_Utility.xlsm y seleccione la pestaña "Dieciséis" en la parte inferior de la página.

Si, como en mi caso, su pantalla es demasiado grande y necesita desplazarse, utilice una opción de alejamiento. Incluso entonces será necesario desplazarse para copiar su código.

Extensiones?

¿Es posible abordar Matrices de otros tamaños?

Me pregunto por qué mi "LED_Arduino.ino" y "LED_Arduino16.ino" son tan diferentes en sus primeras líneas. Tengo ciertas líneas comentadas en mi primera; ambos bocetos funcionan como deseo.

No voy a escribir una hoja de trabajo para un "8x32" aunque acabo de adquirir una pizarra. Te dirigiré a " The Sketch " sobre. Hay parámetros que deben abordarse. Sea particular con las líneas 15 y 18 también.

NB:También estoy considerando opciones más pequeñas que una placa tipo UNO.

 // VARIABLES Y DEFINIDAS AQUÍ - NECESITADAS POR EL CÓDIGO DE CONTROLADOR WS2812 # define WS2812_pin 8 // solo el pin digital 8 funciona en este momento # defina numberOfLEDs 64 // número total de LED RGB [256] byte RGB [192]; // tome su número de LED y multiplíquelo por 3 [768] // FUNCIONES AQUÍvoid RGB_update (int LED, byte ROJO, byte VERDE, byte AZUL); // función para controlar LEDsvoid mapLEDXY (int x, int y, byte ROJO, byte VERDE, byte AZUL) {int RGBlocation =0; // if (y% 2 ==0) {// columna par [Descomentar] RGBlocation =x + y * 8; // [16] //} else {// columna impar [Descomentar] // RGBlocation =7 - x + y * 8; // [15] y [16] //} [Descomentar] RGB [Ubicación RGB * 3] =AZUL; RGB [Ubicación RGB * 3 + 1] =ROJO; RGB [RGBlocation * 3 + 2] =VERDE;} void clearLEDs () {memset (RGB, 0, tamaño de (RGB));} void setup () {pinMode (WS2812_pin, OUTPUT); clearLEDs (); RGB_update (-1, 0, 0, 0);} // setup0void loop () {// Pegar las líneas mapLEDXY directamente encima de RGB_update debajo. RGB_update (-1, 0, 0, 0); retraso (1000); clearLEDs (); Actualización_RGB (-1, 0, 0, 0); delay (1000);} // loop // WS2812 Driver Functionvoid RGB_update (int LED, byte RED, byte GREEN, byte BLUE) {// LED es el número de LED que comienza con 0 // ROJO, VERDE, AZUL es el brillo 0 ..255 punto de ajuste para ese byte LED ExistingPort, WS2812pinHIGH; // variables locales aquí para acelerar pinWrites if (LED> =0) {// mapea los valores REG VERDE AZUL en la matriz RGB [] RGB [LED * 3] =VERDE; RGB [LED * 3 + 1] =ROJO; RGB [LED * 3 + 2] =AZUL; } noInterrupts (); // elimina las interrupciones mientras enviamos el flujo de bits ... ExistingPort =PORTB; // guarde el estado de todo el PUERTO B - escribamos en todo el puerto sin estropear los otros pines de ese puerto WS2812pinHIGH =PORTB | 1; // esto nos da un byte que podemos usar para configurar el PORTB completo con el pin HIGH de WS2812 int bitStream =numberOfLEDs * 3; // bytes totales en la cadena de LED // Este bucle for recorre todos los bits (8 en un time) para configurar los tiempos de encendido / apagado del pin WS2812 para (int i =bitStream - 1; i> =0; i--) {PORTB =WS2812pinHIGH; // bit 7 primero, establezca el pin HIGH - siempre va alto independientemente de un 0/1 // aquí está la parte complicada, verifique si el bit en el byte es alto / bajo y luego correcto ese estado al pin // (RGB [i] y B10000000) eliminará los otros bits en RGB [i ], así que aquí nos quedaremos con B10000000 o B00000000 // entonces es fácil verificar si el bit es alto o bajo haciendo un AND con la máscara de bits "" &&B10000000) "" esto da 1 o 0 // si es un 1, lo haremos con el puerto existente, manteniendo así el pin ALTO, si 0 el pin se escribe LOW PORTB =((RGB [i] &B10000000) &&B10000000) | ExistingPort; __asm ​​__ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); // estos son NOPS - estos nos permiten retrasar el reloj ciclos para una sincronización más precisa PORTB =ExistingPort; // bien, aquí sabemos que tenemos que estar BAJO independientemente del 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 "); // tiempo mínimo BAJO para el pin independientemente del estado de 0/1 bit // entonces haz de nuevo para el siguiente bit y así sucesivamente ... aunque vea el último bit para un ligero cambio 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 =Puerto 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 =Puerto 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 =Puerto 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 =Puerto 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 =Puerto 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 =Puerto 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"); // en este último bit, la verificación es mucho más rápida, así que tuve que agregar un NOP aquí PORTB =((RGB [i] &B00000001) &&B00000001) | ExistingPort; __asm ​​__ ("nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t" "nop \ n \ t"); PORTB =ExistingPort; // tenga en cuenta que no hay NOP después de escribir el pin LOW, esto se debe a que el bucle FOR usa ciclos de reloj que podemos usar en lugar del NOPS} // para interrupciones del bucle (); // habilita las interrupciones // ¡Todo listo!} // void RGB_update