Excel pour les animations de matrice de LED RVB WS2812

Outils et machines nécessaires

	Fer à souder (générique)
	Fil à souder, sans plomb

À propos de ce projet

Après avoir vérifié qu'il y avait un support en ligne, j'ai commandé une matrice de LED RVB WS2812 8x8 en espérant qu'elle soit adressée comme une structure de coordonnées XY, et non comme une guirlande (ruban) de 64 LED enveloppées dans 8 rangées de 8 !

Une recherche « WS2812 Led animation » n'a donné que peu de choses que je pouvais facilement et immédiatement comprendre. Lorsque j'ai trouvé une vidéo YouTube produite par Kevin Darrah, il s'adressait à une matrice 16 x 16 (256 LED en guirlande) comme s'il s'agissait d'un système de coordonnées XY.

Son utilitaire Excel a compilé du code texte à copier/coller dans son croquis, dans lequel se trouvaient toutes les fonctions nécessaires ; aucune bibliothèque n'a besoin d'être importée.

Lorsqu'il a sélectionné des cellules dans son utilité et que les valeurs RVB ont été ajoutées, elles s'appliquent à ces cellules sélectionnées sans discrimination ; pas ce que je voulais donc je l'ai repensé et reconstruit. Cela signifiait également que j'ai dû modifier son croquis pour une compatibilité 8x8.

Au fur et à mesure que je demandais plus à mon WS2812, je devais continuellement modifier mon application Excel, LED_Utility.xlsm.

Le classeur Excel propose désormais :

• Propriétés LED RGB à traiter individuellement.

• Modification dynamique de ces propriétés via la programmation.

• Déplacement XY de ces propriétés pour simuler le mouvement.

• Valeurs RVB à traiter ainsi que la modification de l'emplacement XY.

• Adressage LED 8x8 et 16x16.

• Une petite collection de valeurs RVB pour une référence rapide.

Plus précisément, mon objectif est de :

• Développez un carré creux rouge et activez et désactivez-le.

• Superposez un autre carré avec une couche de couleurs différentes et alternez entre eux.

• Développez le carré rouge et jouez avec.

• Réfléchissez à l'utilisation des fonctions pour contenir les éléments d'affichage ; Je vais construire une spirale de décoloration.

• Créez un design où les couleurs s'estompent.

• Amenez du mouvement dans la conception.

• Réseaux d'adresses 16 x 16.

Je reconnais que les connaissances en programmation créeront des problèmes. J'ai offert quelques conseils, mais je suggère des recherches ou je demande à quelqu'un qui pourrait vous conseiller personnellement.

À COMMENCER

Assembler le matériel

Si votre matrice est livrée sans broches d'en-tête, soudez la banque de broches d'en-tête à l'arrière de la matrice à l'emplacement inférieur (DIN, +5V, GND). Connectez la broche DIN à la broche 8 à droite de l'Arduino et les deux autres aux emplacements correspondants de l'autre côté de la carte.

Pour cette carte et l'utilitaire, XY (0, 0) est en haut à gauche.

L'utilitaire Excel

Ouvrez le fichier LED_Utility.xlsm. Vous verrez trois feuilles, « Eight », « Seize » et « ColMap ».

Le dernier est un petit échantillon de codes RVB fourni à titre de référence.

J'ai défini LED_Utility.xlsm en lecture seule pour éviter à la fois l'écrasement, mais aussi pour encourager l'utilisation de la fonction "Enregistrer sous" pour conserver un fichier en vue d'une éventuelle réutilisation. D'autres « trappings d'erreurs » ont également été intégrés.

Sélectionnez la feuille de travail « Huit ».

Notez que la grille de droite est remplie de zéros. C'est important car l'esquisse n'acceptera pas les valeurs « nulles ».

Il y a quatre boutons comme indiqué ci-dessus (sur « Seize », ils seront probablement hors écran à droite, l'un en dessous de l'autre, mais fonctionneront comme décrit ci-dessous).

Pour produire du code texte :

« Afficher » affiche le RVB des valeurs dans la grille de gauche. Il ne gère que les valeurs de 0 à 255. Il alertera sur les valeurs supérieures à 255 ou sur toute variable.

"Var Map" accepte les numériques et les variables mais n'offre aucun affichage.

« Wrap Map » est à deux niveaux. Il accepte les valeurs RVB généralement saisies pour un affichage « Afficher ». Il ajoute ensuite une fonction de module pour le codage d'esquisse afin de permettre le dépassement de la matrice. Deuxièmement, des variables peuvent être ajoutées mais doivent être programmées ultérieurement dans l'esquisse. Je n'en parle pas ici.

Chacun génère un texte « rouge » sous les grilles (dans les deux feuilles de travail) compatible avec un croquis conçu pour l'accepter.

« Effacer » annule évidemment les deux grilles.

Ceux-ci seront tous décrits plus tard.

Lorsque vous travaillez avec le Utilitaire Excel, je vous recommande d'utiliser File/SaveAs... après avoir généré votre code afin que vous n'ayez pas à recréer votre conception à certains moments autre point, et surtout si la conception est raisonnablement complexe. Aussi, votre D'origine LED_Utility.xlsm a été mis en lecture seule pour le protéger d'être écrasé.

Le croquis

Le code est offert ci-dessous avec une mise en garde pour enregistrer avec une propriété en lecture seule.

Ouvrez l'IDE Arduino et chargez le croquis « LED_Arduino.ino ».

Vous verrez que :

• La ligne 3 définit la broche Arduino utilisée. Cet ensemble comme Pin 8.

• La ligne 4 définit les unités LED sur la carte. Ce sont 64.

• La ligne 5 multiplie cependant ce chiffre par 3 pour tenir compte du nombre de RBG, soit 192.

• Les lignes 8, 10 et 25 définissent les fonctions utilisées.

Entre les lignes 3 et 19, le texte original a été modifié mais vous pouvez le modifier pour adresser une matrice 16x16. Cela dit, j'ai fourni LED_Ardino16.ino dans le logiciel et LED_Utility.xlsm s'en chargera.

Fréquemment, je vous conseillerai d'ouvrir le « LED_Arduino.ino », puis « Enregistrer sous » avec un nom. Cela garantira que « LED_Arduino.ino » est inchangé si vous n'avez pas défini la propriété appropriée sur « Lecture seule ». [J'ai trouvé que mon fichier nouvellement créé avait toujours la propriété en lecture seule définie ; libérer cela pour assurer les futures modifications et sauvegardes].

Dans le même temps, une esquisse nouvellement créée doit probablement avoir l'un ou les deux redéfinis du port et de la carte ; un message d'erreur apparaîtra mais peut ne pas être immédiatement clair.

Projet 1

Chargez le LED_Arduino.ino dans l'IDE Arduino et enregistrez-le sous Red_Square (ino sera ajouté automatiquement).

Initialement je propose de construire un carré rouge 3x3 et mettez ce code à la ligne 40 du croquis. Les cellules N8, O8, P8, N11, P11, N14, O14 et P14 conserveront la valeur 255.

Lorsque le texte rouge 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); 

est copié dans la ligne 40, le texte en dessous sera naturellement déplacé vers le bas.

Lorsque vous téléchargez le croquis sur votre Arduino, votre matrice active et désactive ce carré.

Avant de passer à autre chose, considérez :

• Effacement des deux grilles.

• Modifiez certaines couleurs dans ce carré.

• Ajoutez un carré de couleur différente autour de l'original.

Projet2

Je vous suggère d'ouvrir le croquis Red_Square.ino et de l'enregistrer sous Colour_Sq (".ino" sera ajouté automatiquement) pour éviter d'écraser Red_Square.ino.

Avec Colour_Sq.ino chargé dans l'IDE, accédez à Red_Square dans l'utilitaire et modifiez les carrés du milieu. Marque O8, O10, O14 et O16 « 255 ». N11 et P11 sont « 0 » mais N12 et P12 sont « 255 ». Appuyez sur « Afficher ».

Après avoir ajouté le nouveau code à, j'anticipe la ligne 47 dans l'IDE, vous devez le suivre avec ce bloc de code :

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

Notez que vous pouvez modifier la valeur du délai à votre convenance ; 1000 équivaut à 1 seconde.

Projet3

Rechargez Red_Square.ino et enregistrez-le sous Grow.

Recréez le carré rouge dans l'utilitaire. Autour de ce carré, ajoutez les valeurs de votre choix pour créer une bordure, elles peuvent être comprises entre 0 et 255 mais inférieures à 32 peuvent être très faibles. Ceci est ma création dans 'LED_Utility.xlsm' :

Supprimez maintenant les valeurs de ce carré rouge intérieur et appuyez sur « Afficher ». Copiez le code généré à la ligne 47 dans l'IDE et copiez/collez les lignes 42 à 46 après cela. Téléchargez sur l'Arduino pour une alternance d'un carré rouge intérieur, puis d'un autre entouré de différentes couleurs.

Essayez d'étendre à une autre bordure si vous le désirez.

Projet4

Vous vous êtes peut-être rendu compte qu'au fur et à mesure que nous ajoutons du code dans "Loop", il a tendance à devenir long et peut-être poser des difficultés à modifier plus tard.

Ici, je construis une spirale.

L'image provient du classeur « spir5.xlsm ». C'est le point culminant de 4 manuels précédents.

« spir1.xlsm » était le centre avec des blocs brillants (255), « spir2.xlsm » utilisait les valeurs du carré 4x4 intérieur, « spir3.xlsm » étant le bloc carré 27, etc. À chaque étape, j'ai copié le code à mon croquis mais pas à "boucler".

Au lieu de cela, j'ai créé 5 fonctions vides sous « boucle » et les ai référencées dans « boucle » :

Void loop(){Sp1();Sp2();Sp3();Sp4();Sp5();clearLEDs();delay(1000);} 

Ma première fonction, void Sp1(), est :

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

Chaque fonction successive sera la même à l'exception des deux lignes de « mapLEDXY… ».

Il peut sembler trivial à partir de cet exemple de suggérer d'ouvrir « spir4.xlsm » pour modifier les couleurs des pointes extérieures afin de modifier une fonction dédiée plutôt que de modifier dans la « boucle ».

À la limite du ridicule, supposons que vous vouliez afficher les lettres du mot « MISSISSIPPI » successivement une par une. Il y a 11 caractères, ce qui signifie 77 lignes de code à gérer pour « void loop() ». Si vous décidez de modifier le « S », vous devez effectuer 4 modifications. Il n'y a que 4 caractères utilisés dans le mot. Il est donc logique de créer une fonction pour chacun d'eux et de les appeler de manière appropriée à partir de « boucle ».

Projet5

Ce projet prend en compte une autre fonction du LED_Utility, « Var Map ». Ici, des variables seront introduites et donc des connaissances de base en programmation seront nécessaires.

La syntaxe "For Loop" sera utilisée ainsi que la condition "If".

Le « pour » sera utilisé pour augmenter ou diminuer une valeur RVB telle que :

pour (int r=0; r<=256; r++) {} oupour (int r=255; r>=0; r--) {}  

« Si » modifiera les procédures si nécessaire.

Commençons simplement, et je veux dire simplement.

Créez un carré rouge 2x2 au milieu de LED_utility et "Show", et voici le code :

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

Remplacez maintenant toutes les 255 valeurs par « r ». Appuyez sur « Afficher » …. Ouah ! Ça n'aime pas ça. C'est bon, c'est une protection que j'ai ajoutée. Appuyez sur "Var Map" et vérifiez le code généré :

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

les 255 ont été remplacés par 'r'.

Dans l'IDE, ouvrez le fichier LED_Arduino.ino archivé et enregistrez-le en tant que « modifications ».

À la ligne 40, entrez :

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

Notez qu'il y a une ligne vide après chaque déclaration « pour ».

A la ligne 41 collez votre code 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);suivre cela avec :RGB_update(-1, 0, 0, 0);delay(50); 

Copiez/collez maintenant ce même bloc de code de 4 lignes dans ce deuxième bloc « pour ».

Après ce bloc "for", sous le "}", ajoutez "delay(200);". J'ai trouvé cela nécessaire pour que mes yeux sachent que le deuxième bloc s'était fermé !

Lors du téléchargement, le bloc rouge augmente à pleine luminosité, puis diminue, s'éteint puis se répète.

Projet6

Utilisons maintenant la condition "Si".

Recréez ce carré rouge précédent dans le LED_utility mais entourez-le de blocs d'un "bleu ciel" en utilisant 255 pour les valeurs G et B. Utilisez le « Afficher ».

Laissez les Red 255 seuls, mais changez tous les G 255 en « g » et les B 255 en « b »,

puis appuyez sur « Var Map ».

Rechargez "LED_Arduino.ino" dans l'IDE et enregistrez sous "FadeBorder".

Maintenant, nous allons avoir des problèmes. Nous avons deux variables, 'g' et 'b', et chacune doit recevoir une valeur. Ils doivent également être déclarés dans le programme. J'ai l'intention de déclarer le « g » dans une déclaration « pour », mais je dois déclarer le « b » plus tôt dans le croquis. Dans le croquis à la ligne 5 se trouve la déclaration BYTE RGB[192]. En-dessous, saisissez « int b=0 ; ».

A titre d'explication on ne peut pas utiliser deux boucles « for » comme il sera nécessaire plus tard. Ici, chaque valeur "b" doit être la même que la valeur "g" générée par la boucle "for".

Ma "boucle" est structurée comme ci-dessous mais sans mon code Map :

void loop() {delay(50);for (int g=0; g<256;g++){b=g;[Add Map Code here]RGB_update(-1, 0, 0, 0 );delay(50);}for (int g=255;g>=0;g--){b=g; [Ajouter le code de la carte ici]RGB_update(-1, 0, 0, 0);delay(50);}} 

Notez que la valeur B est liée à la valeur G avec l'instruction « b=g ; ». La valeur R reste statique à 255 tandis que la bordure s'estompe de haut en bas en luminosité.

Projet7

Il est maintenant temps d'utiliser l'instruction "if".

Créez et « Montrez » ce qui suit en utilisant 255 où les variables apparaissent dans la grille de droite. Notez qu'un minuscule « L » apparaît dans les cellules adjacentes aux globules rouges. Cela permettra au programme de prendre le contrôle de ces cellules le cas échéant.

Cette fois, les LED passeront au vert et au rouge jusqu'à ce que la valeur 64 soit atteinte, puis ces cellules de la bordure médiane deviendront jaunes, la carte continuant à augmenter en luminosité. Ensuite, le processus sera inversé.

Encore une fois, je vais offrir la structure de base de ma « boucle ». J'ai appelé ce croquis « FadeColourChange.ino ».

void loop() { delay(50);for (int r=0; r<256;r++){g=r;if(g>64){ g=65; l=r;}[Ajouter le code de la carte ici]RGB_update(-1, 0, 0, 0); délai (50);}pour (int r=255;r>=0;r--){if(r<65){g=r; l=0;}[Ajouter MapCode ici]RGB_update(-1, 0, 0, 0);delay(50);}} 

Projet8

Pour ce dernier projet je ne vais pas changer les couleurs mais introduire du mouvement; J'ai une flèche qui se déplace sur le plateau mais réapparaîtra de la gauche.

Ici, je veux seulement générer du code en utilisant "Afficher".

Puisque je veux que la flèche se déplace de sa position actuelle à chaque position suivante, je dois changer la valeur « x ».

Ceci est le code généré à 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); 

Étant donné que « 1 » est ma plus petite valeur pour les coordonnées X, j'appelle cela « x » et je décrémente toutes les autres valeurs de 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) ; 

Mon 'for (int x…loop' fait bien, sauf que la pointe de flèche déborde vers la rangée inférieure pour quelques passages de la boucle !

Solution ! Si une valeur dépasse « 8 », j'ai besoin de sa valeur de module. Cela m'a obligé à créer le bouton « Wrap Map ». Le code pour une LED apparaît maintenant comme :

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

Pour aborder une disposition XY, je pense qu'il est préférable d'imbriquer deux boucles "for" même si une ne sera pas utilisée (oui, j'ai trouvé une alternative maladroite).

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

Si je fais « y<1 » dans la deuxième boucle, le « y » est ignoré. Inversement, changer « y » en 8 et « x » en 0 a un effet différent.

En dernier lieu, « Wrap Map » acceptera les variables RVB. Voir ci-dessus où j'ai référencé. Un avec une programmation de base devrait être capable de gérer cela. J'ai ajouté un croquis de l'INO, ArrowVar.ino, où le front de la pointe de flèche change de luminosité en tant que démo mineure.

Utilisation de la matrice 16x16.

Tout ce qui est indiqué ci-dessus s'applique à la matrice 16x16 WS2812. Le croquis 'LED_Arduino16.ino' doit cependant être utilisé.

Les croquis fournis sont conçus pour la matrice 8x8, à l'exception d'un, le « Spiral16.ino ». Il offre un affichage plus grand que le « Spiral.ino ».

Cette spirale, matrice 16x16, avait 2 feuilles de papier d'impression comme diffuseur de lumière. L'affichage a été mis en pause pendant environ 10 secondes pour capturer une image raisonnable.

Pour développer votre code, ouvrez LED_Utility.xlsm et sélectionnez l'onglet « Seize » en bas de la page.

Si, comme pour moi, votre écran est trop grand et que vous devez faire défiler, utilisez une option de zoom arrière. Même dans ce cas, un certain défilement sera nécessaire pour copier votre code.

Prolongations ?

Est-il possible d'adresser des matrices d'autres tailles ?

Je me demande pourquoi mes "LED_Arduino.ino" et "LED_Arduino16.ino" sont si différents dans leurs lignes d'ouverture. J'ai commenté certaines lignes dans mon premier; les deux croquis fonctionnent comme je le souhaite.

Je ne suis pas sur le point d'écrire une feuille de travail pour un « 8x32 » même si je viens d'acquérir une planche. Je vais vous diriger vers « Le croquis " au dessus. Il y a des paramètres à régler. Soyez également attentif aux lignes 15 et 18.

NB :J'envisage également des options plus petites qu'une carte de type UNO.

Code

• LED_Arduino

LED_ArduinoC/C++

//VARIABLES AND DEFINES HERE - NÉCESSAIRES PAR LE CODE DU PILOTE WS2812 // seule la broche numérique 8 fonctionne actuellement#define numberOfLEDs 64// nombre total de LED RGB [256]byte RGB[192] ;//prenez votre nombre de LED et multipliez par 3 [768]// FUNCTIONS HEREvoid RGB_update(int LED, octet ROUGE, octet VERT, octet BLEU );//fonction pour piloter LEDsvoid mapLEDXY(int x, int y, octet ROUGE, octet VERT, octet BLEU) { int RGBlocation =0 ; //if (y % 2 ==0) { //colonne paire [Décommenter] RGBlocation =x + y * 8; //[16] // } else { //colonne impaire [Uncomment] //RGBlocation =7 - x + y * 8; //[15] et [16] // } [Décommenter] RGB[RGBlocation * 3] =BLUE; RVB[emplacement RVB * 3 + 1] =ROUGE ; 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() {//Coller les lignes mapLEDXY directement au-dessus de RGB_update en dessous.RGB_update(-1, 0, 0, 0); retard(1000); clearLEDs(); RVB_update(-1, 0, 0, 0); delay(1000);}//loop//WS2812 Driver Functionvoid RGB_update(int LED, byte RED, byte GREEN, byte BLUE) { // LED est le numéro de LED commençant par 0 // RED, GREEN, BLUE est la luminosité 0 ..255 point de consigne pour cet octet LED ExistingPort, WS2812pinHIGH ; // variables locales ici pour accélérer les pinWrites if (LED>=0) { // mapper les valeurs REG GREEN BLUE dans le tableau RGB[] RGB[LED * 3] =VERT; RVB[LED * 3 + 1] =ROUGE ; RVB[LED * 3 + 2] =BLEU ; } noInterrupts(); // tue les interruptions pendant que nous envoyons le flux de bits... ExistingPort =PORTB; // enregistre l'état de l'ensemble du PORT B ​​- écrivons sur l'ensemble du port sans déranger les autres broches de ce port WS2812pinHIGH =PORTB | 1; // cela nous donne un octet que nous pouvons utiliser pour définir l'ensemble du PORTB avec la broche WS2812 HIGH int bitStream =numberOfLEDs * 3; // total d'octets dans la chaîne LED // Cette boucle for parcourt tous les bits (8 à un time) pour définir les temps d'activation/désactivation de la broche WS2812 pour (int i =bitStream - 1 ; i>=0 ; i--) { PORTB =WS2812pinHIGH ; // bit 7 d'abord, définissez la broche HIGH - elle passe toujours à l'état haut, peu importe d'un 0/1 //voici la partie délicate, vérifiez si le bit dans l'octet est haut/bas puis appliquez ce statut à la broche // (RGB[i] &B10000000) supprimera les autres bits en RGB[i ], il nous restera donc ici B10000000 ou B00000000 // alors il est facile de vérifier si le bit est haut ou bas en faisant un AND avec le masque de bits ""&&B10000000)"" cela donne 1 ou 0 // si c'est un 1, nous allons OU cela avec le port existant, gardant ainsi la broche HAUTE, si 0 la broche est écrite LOW PORTB =((RGB[i] &B10000000) &&B10000000) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");//ce sont des NOPS - cela nous permet de retarder l'horloge cycles pour un timing plus précis PORTB =ExistingPort;//d'accord, ici nous savons que nous devons être BAS quel que soit l'état 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"); // temps minimum pour la broche quel que soit l'état 0/1 bit // alors faites recommencez pour le bit suivant et ainsi de suite... voir le dernier bit cependant pour un léger changement PORTB =WS2812pinHIGH;//bit 6 PORTB =((RGB[i] &B01000000) &&B01000000) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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 =((RVB[i] &B00100000) &&B00100000) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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 =((RVB[i] &B00010000) &&B00010000) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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 =((RVB[i] &B00001000) &&B00001000) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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 =((RVB[i] &B00000010) &&B00000010) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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 =((RVB[i] &B00000010) &&B00000010) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =Port existant ; __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");//sur ce dernier bit, la vérification est beaucoup plus rapide, il a donc fallu ajouter un NOP ici PORTB =((RGB[i] &B00000001) &&B00000001) | Port existant ; __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); PORTB =ExistingPort;//notez qu'il n'y a pas de NOP après avoir écrit la broche LOW, c'est parce que la boucle FOR utilise des cycles d'horloge que nous pouvons utiliser à la place des NOPS }//for loop interrupts(); // activer les interruptions // tout est fait !}//void RGB_update

Led_Utility.xlsm

Esquisse.zip