Projet étudiant: LED Cube

Bonjour à tous

Les vacances d'été en Allemagne touchent à leur fin et certains jeunes talents ont profité de ce temps libre pour monter leurs propres projets.

Aujourd'hui, nous voulons Niklas Heinzel  donner l'occasion de présenter son projet sur notre blog. Niklas a repris le cube LED classique et l'a conçu et programmé complètement à partir de zéro:

Aujourd'hui, je voudrais vous présenter un nouveau projet passionnant que j'ai construit dans ma maison, un cube LED dans les dimensions 4x4x4.

Pour cela j'utilise:

• 1 x Nano V3
• 4 transistors NPN 2n2222
• 4 x résistances 1k Ω
• 16 x 220Résistances Ω
• 64 x LED bleues diffuses (5 mm)
• Port micro USB
• LED jaune (SMD)
  
  

Pour construire le cube LED:

Avec les 64 LED, l'anode (toujours au même endroit) est courbée de 90 °. Ceux-ci sont ensuite dirigés vers le pôle positif.
Comme on peut le voir dans l'image ci-dessus, le cube se compose d'un axe X-Y et de 4 couches empilées les unes sur les autres. La couche inférieure porte le numéro 0 et la couche supérieure porte le numéro 3. De même, les LED sont numérotées comme une matrice tridimensionnelle. La LED inférieure gauche est sur la couche 0 (1,1). La LED ci-dessus est également sur la couche 1 (1,1). La LED de droite sur la couche 0 (2,1) et ainsi de suite. Toutes les couches horizontales sont les broches négatives des LED soudées ensemble.
Toutes les broches positives des LED sont traitées comme des colonnes de ce cube matriciel. Nous avons donc 4 couches et 16 colonnes qui en font 20 fils connectés à l'Arduino. Les broches positives (couches) ont des résistances de 220 ohms.

Assemblage du cube:

Nous avons d'abord besoin d'un carton ou d'un bois moyennement épais. Maintenant, nous y percons des trous afin qu'un motif de cube 4 × 4 soit créé avec le même espacement entre tous les trous.
Des trous de 5 mm (chaque trou est à 2,4 cm du suivant (centre-centre)) ont été percés comme gabarit pour les LED.
Vous devez maintenant tester et préparer vos LED. Vous pouvez utiliser une pile bouton 3V à cet effet. Testez toutes les LED pour ne plus avoir de problèmes plus tard!
Si vous voulez que la lumière sorte de tous les côtés de la LED, vous pouvez disperser la lumière en frottant la coque en plastique avec du papier de verre.
Placez les LED dans la boîte, mais faites attention à leur orientation. Les broches positives des LED doivent être pliées et les broches négatives connectées comme une couche. En effet, nous allons créer quatre couches de ce type et il est facile de les souder ensemble.

Nous répétons ces couches 4x et les finissons les unes sur les autres, en connectant toutes les broches + et en les plaçant les unes sur les autres.

La carte, le brochage et les connexions:

dans mon cas, j'ai choisi le brochage suivant pour contrôler le cube comme dans une matrice:

Vous devez effectuer ces connexions et faire également attention au choix correct des broches, sinon l'animation ne fonctionnera pas correctement plus tard.

J'ai conçu le tableau comme suit et je ne devrais que vous donner une idée de ce à quoi pourrait ressembler la disposition:

Télécharger le circuit imprimé de liaison

Il ne manque que le code:

// LED Cube 1.0
// Niklas Heinzel
//2019   int couche[4]={A3,A2,A1,A0}; // initialisation et déclaration des couches led   int colonne[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4}; // initialisation et déclaration des lignes de led   int le temps = 250;



nul configuration()
{   pour(int je = 0; je<16; je++)   {     pinMode(colonne[je], SORTIE);  // définition des lignes à sortir   }   pour(int je = 0; je<4; je++)   {     pinMode(couche[je], SORTIE);  // définition des calques à afficher   }   randomSeed(analogRead(10));  // ensemencement aléatoire pour motif aléatoire
}

nul boucle()
{   turnEverythingOff();   flickerOn();   turnEverythingOn();   retard(le temps);   turnOnAndOffAllByLayerUpAndDownNotTimed();   layerstompUpAndDown();   spiralInAndOut();   turnOnAndOffAllByColumnSideways();   retard(le temps);   aroundEdgeDown();   turnEverythingOff();   scintillement aléatoire();   randomRain();   diagonalRectangle();   goThroughAllLedsOneAtATime();   hélice();   spiralInAndOut();   flickerOff();   turnEverythingOff();   retard(2000);
}


// tout désactiver
néant turnEverythingOff()
 {    pour(int je = 0; je<16; je++)    {      digitalWrite(colonne[je], 1);    }    pour(int je = 0; je<4; je++)    {      digitalWrite(couche[je], 0);    }
 }

// allume tout
néant turnEverythingOn()
{   pour(int je = 0; je<16; je++)   {     digitalWrite(colonne[je], 0);   }   // activer les calques   pour(int je = 0; je<4; je++)   {     digitalWrite(couche[je], 1);   }
}
// désactiver les colonnes
néant turnColumnsOff()
{   pour(int je = 0; je<16; je++)   {     digitalWrite(colonne[je], 1);   }
}
// clignote
néant flickerOn()
{   int je = 150;   tandis que(je != 0)   {     turnEverythingOn();     retard(je);     turnEverythingOff();     retard(je);     je-= 5;   }
}
// allume et éteint tout par calque de haut en bas NON TIMED
néant turnOnAndOffAllByLayerUpAndDownNotTimed()
{   int X = 75;   pour(int je = 5; je != 0; je--)   {     turnEverythingOn();     pour(int je = 4; je!=0; je--)     {       digitalWrite(couche[je-1], 0);       retard(X);     }     pour(int je = 0; je<4; je++)     {       digitalWrite(couche[je], 1);       retard(X);     }       pour(int je = 0; je<4; je++)     {       digitalWrite(couche[je], 0);       retard(X);     }     pour(int je = 4; je!=0; je--)     {       digitalWrite(couche[je-1], 1);       retard(X);     }   }
}
// allume et éteint tout par colonne latéralement
néant turnOnAndOffAllByColumnSideways()
{   int X = 75;   turnEverythingOff();   // activer les calques   pour(int je = 0; je<4; je++)   {     digitalWrite(couche[je], 1);   }   pour(int y = 0; y<3; y++)   {     // allume 0-3     pour(int je = 0; je<4; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 4-7     pour(int je = 4; je<8; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 8-11     pour(int je = 8; je<12; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 12-15     pour(int je = 12; je<16; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // désactiver 0-3     pour(int je = 0; je<4; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 4-7     pour(int je = 4; je<8; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 8-11     pour(int je = 8; je<12; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 12-15     pour(int je = 12; je<16; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // allume 12-15     pour(int je = 12; je<16; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 8-11     pour(int je = 8; je<12; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 4-7     pour(int je = 4; je<8; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // allume 0-3     pour(int je = 0; je<4; je++)     {       digitalWrite(colonne[je], 0);       retard(X);     }     // désactiver 12-15     pour(int je = 12; je<16; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 8-11     pour(int je = 8; je<12; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 4-7     pour(int je = 4; je<8; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }     // désactiver 0-3     pour(int je = 0; je<4; je++)     {       digitalWrite(colonne[je], 1);       retard(X);     }   }
}
// montée et descente simple couche
néant layerstompUpAndDown()
{   int X = 75;   pour(int je = 0; je<4; je++)   {     digitalWrite(couche[je], 0);   }   pour(int y = 0; y<5; y++)   {     pour(int compter = 0; compter<1; compter++)     {       pour(int je = 0; je<4; je++)       {         digitalWrite(couche[je], 1);         retard(X);         digitalWrite(couche[je], 0);       }       pour(int je = 4; je !=0; je--)       {         digitalWrite(couche[je-1], 1);         retard(X);         digitalWrite(couche[je-1], 0);       }     }     pour(int je = 0; je<4; je++)     {       digitalWrite(couche[je], 1);       retard(X);     }     pour(int je = 4; je!=0; je--)     {       digitalWrite(couche[je-1], 0);       retard(X);     }   }
}
// scintillement
néant flickerOff()
{   turnEverythingOn();   pour(int je = 0; je!= 150; je+=5)   {     turnEverythingOff();     retard(je+50);     turnEverythingOn();     retard(je);   }
}
// autour du bord du cube vers le bas
néant aroundEdgeDown()
{   pour(int X = 200; X != 0; X -=50)   {     turnEverythingOff();     pour(int je = 4; je != 0; je--)     {       digitalWrite(couche[je-1], 1);       digitalWrite(colonne[5], 0);       digitalWrite(colonne[6], 0);       digitalWrite(colonne[9], 0);       digitalWrite(colonne[10], 0);       digitalWrite(colonne[0], 0);       retard(X);       digitalWrite(colonne[0], 1);       digitalWrite(colonne[4], 0);       retard(X);       digitalWrite(colonne[4], 1);       digitalWrite(colonne[8], 0);       retard(X);       digitalWrite(colonne[8], 1);       digitalWrite(colonne[12], 0);       retard(X);       digitalWrite(colonne[12], 1);       digitalWrite(colonne[13], 0);       retard(X);       digitalWrite(colonne[13], 1);       digitalWrite(colonne[15], 0);       retard(X);       digitalWrite(colonne[15], 1);       digitalWrite(colonne[14], 0);       retard(X);       digitalWrite(colonne[14], 1);       digitalWrite(colonne[11], 0);       retard(X);       digitalWrite(colonne[11], 1);       digitalWrite(colonne[7], 0);       retard(X);       digitalWrite(colonne[7], 1);       digitalWrite(colonne[3], 0);       retard(X);       digitalWrite(colonne[3], 1);       digitalWrite(colonne[2], 0);       retard(X);       digitalWrite(colonne[2], 1);       digitalWrite(colonne[1], 0);       retard(X);       digitalWrite(colonne[1], 1);     }   }
}
// scintillement aléatoire
néant scintillement aléatoire()
{   turnEverythingOff();   int X = 10;   pour(int je = 0; je !=750; je+=2)   {   int randomLayer = Aléatoire(0,4);   int randomColumn = Aléatoire(0,16);   digitalWrite(couche[randomLayer], 1);   digitalWrite(colonne[randomColumn], 0);   retard(X);   digitalWrite(couche[randomLayer], 0);   digitalWrite(colonne[randomColumn], 1);   retard(X);   }
}
// pluie aléatoire
néant randomRain()
{   turnEverythingOff();   int X = 100;   pour(int je = 0; je!=60; je+=2)   {     int randomColumn = Aléatoire(0,16);     digitalWrite(colonne[randomColumn], 0);     digitalWrite(couche[0], 1);     retard(X+50);     digitalWrite(couche[0], 0);     digitalWrite(couche[1], 1);     retard(X);     digitalWrite(couche[1], 0);     digitalWrite(couche[2], 1);     retard(X);     digitalWrite(couche[2], 0);     digitalWrite(couche[3], 1);     retard(X+50);     digitalWrite(couche[3], 0);     digitalWrite(colonne[randomColumn], 1);   }
}
// rectangle diagonal
néant diagonalRectangle()
{   int X = 350;   turnEverythingOff();   pour(int compter = 0; compter<5; compter++)   {     //en haut à gauche     pour(int je = 0; je<8; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[3], 1);     digitalWrite(couche[2], 1);     retard(X);     turnEverythingOff();     // milieu milieu     pour(int je = 4; je<12; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[1], 1);     digitalWrite(couche[2], 1);     retard(X);     turnEverythingOff();     //en bas à droite     pour(int je = 8; je<16; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[0], 1);     digitalWrite(couche[1], 1);     retard(X);     turnEverythingOff();     // en bas au milieu     pour(int je = 4; je<12; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[0], 1);     digitalWrite(couche[1], 1);     retard(X);     turnEverythingOff();     //en bas à gauche     pour(int je = 0; je<8; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[0], 1);     digitalWrite(couche[1], 1);     retard(X);     turnEverythingOff();     // milieu milieu     pour(int je = 4; je<12; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[1], 1);     digitalWrite(couche[2], 1);     retard(X);     turnEverythingOff();     //en haut à droite     pour(int je = 8; je<16; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[2], 1);     digitalWrite(couche[3], 1);     retard(X);     turnEverythingOff();     // milieu supérieur     pour(int je = 4; je<12; je++)     {       digitalWrite(colonne[je], 0);     }     digitalWrite(couche[2], 1);     digitalWrite(couche[3], 1);     retard(X);     turnEverythingOff();   }   //en haut à gauche   pour(int je = 0; je<8; je++)   {     digitalWrite(colonne[je], 0);   }   digitalWrite(couche[3], 1);   digitalWrite(couche[2], 1);   retard(X);   turnEverythingOff();
}
//hélice
néant hélice()
{   turnEverythingOff();   int X = 90;   pour(int y = 4; y>0; y--)   {     pour(int je = 0; je<6; je++)     {       // activer le calque       digitalWrite(couche[y-1], 1);       // a1       turnColumnsOff();       digitalWrite(colonne[0], 0);       digitalWrite(colonne[5], 0);       digitalWrite(colonne[10], 0);       digitalWrite(colonne[15], 0);       retard(X);       // b1       turnColumnsOff();       digitalWrite(colonne[4], 0);       digitalWrite(colonne[5], 0);       digitalWrite(colonne[10], 0);       digitalWrite(colonne[11], 0);       retard(X);       // c1       turnColumnsOff();       digitalWrite(colonne[6], 0);       digitalWrite(colonne[7], 0);       digitalWrite(colonne[8], 0);       digitalWrite(colonne[9], 0);       retard(X);       // d1       turnColumnsOff();       digitalWrite(colonne[3], 0);       digitalWrite(colonne[6], 0);       digitalWrite(colonne[9], 0);       digitalWrite(colonne[12], 0);       retard(X);       // d2       turnColumnsOff();       digitalWrite(colonne[2], 0);       digitalWrite(colonne[6], 0);       digitalWrite(colonne[9], 0);       digitalWrite(colonne[13], 0);       retard(X);       // d3       turnColumnsOff();       digitalWrite(colonne[1], 0);       digitalWrite(colonne[5], 0);       digitalWrite(colonne[10], 0);       digitalWrite(colonne[14], 0);       retard(X);     }   }   // d4   turnColumnsOff();   digitalWrite(colonne[0], 0);   digitalWrite(colonne[5], 0);   digitalWrite(colonne[10], 0);   digitalWrite(colonne[15], 0);   retard(X);
}
// spirale dedans et dehors
néant spiralInAndOut()
{   turnEverythingOn();   int X = 60;   pour(int je = 0; je<6; je++)   {     // spirale dans le sens horaire     digitalWrite(colonne[0], 1);     retard(X);     digitalWrite(colonne[1], 1);     retard(X);     digitalWrite(colonne[2], 1);     retard(X);     digitalWrite(colonne[3], 1);     retard(X);     digitalWrite(colonne[7], 1);     retard(X);     digitalWrite(colonne[11], 1);     retard(X);     digitalWrite(colonne[15], 1);     retard(X);     digitalWrite(colonne[14], 1);     retard(X);     digitalWrite(colonne[13], 1);     retard(X);     digitalWrite(colonne[12], 1);     retard(X);     digitalWrite(colonne[8], 1);     retard(X);     digitalWrite(colonne[4], 1);     retard(X);     digitalWrite(colonne[5], 1);     retard(X);     digitalWrite(colonne[6], 1);     retard(X);     digitalWrite(colonne[10], 1);     retard(X);     digitalWrite(colonne[9], 1);     retard(X);
// spirale vers la gauche     digitalWrite(colonne[9], 0);     retard(X);     digitalWrite(colonne[10], 0);     retard(X);     digitalWrite(colonne[6], 0);     retard(X);     digitalWrite(colonne[5], 0);     retard(X);     digitalWrite(colonne[4], 0);     retard(X);     digitalWrite(colonne[8], 0);     retard(X);     digitalWrite(colonne[12], 0);     retard(X);     digitalWrite(colonne[13], 0);     retard(X);     digitalWrite(colonne[14], 0);     retard(X);     digitalWrite(colonne[15], 0);     retard(X);     digitalWrite(colonne[11], 0);     retard(X);     digitalWrite(colonne[7], 0);     retard(X);     digitalWrite(colonne[3], 0);     retard(X);     digitalWrite(colonne[2], 0);     retard(X);     digitalWrite(colonne[1], 0);     retard(X);     digitalWrite(colonne[0], 0);     retard(X);
// spirale dans le sens inverse des aiguilles d'une montre     digitalWrite(colonne[0], 1);     retard(X);     digitalWrite(colonne[4], 1);     retard(X);     digitalWrite(colonne[8], 1);     retard(X);     digitalWrite(colonne[12], 1);     retard(X);     digitalWrite(colonne[13], 1);     retard(X);     digitalWrite(colonne[14], 1);     retard(X);     digitalWrite(colonne[15], 1);     retard(X);     digitalWrite(colonne[11], 1);     retard(X);     digitalWrite(colonne[7], 1);     retard(X);     digitalWrite(colonne[3], 1);     retard(X);     digitalWrite(colonne[2], 1);     retard(X);     digitalWrite(colonne[1], 1);     retard(X);     digitalWrite(colonne[5], 1);     retard(X);     digitalWrite(colonne[9], 1);     retard(X);     digitalWrite(colonne[10], 1);     retard(X);     digitalWrite(colonne[6], 1);     retard(X);
// en spirale dans le sens des aiguilles d'une montre     digitalWrite(colonne[6], 0);     retard(X);     digitalWrite(colonne[10], 0);     retard(X);     digitalWrite(colonne[9], 0);     retard(X);     digitalWrite(colonne[5], 0);     retard(X);     digitalWrite(colonne[1], 0);     retard(X);     digitalWrite(colonne[2], 0);     retard(X);     digitalWrite(colonne[3], 0);     retard(X);     digitalWrite(colonne[7], 0);     retard(X);     digitalWrite(colonne[11], 0);     retard(X);     digitalWrite(colonne[15], 0);     retard(X);     digitalWrite(colonne[14], 0);     retard(X);     digitalWrite(colonne[13], 0);     retard(X);     digitalWrite(colonne[12], 0);     retard(X);     digitalWrite(colonne[8], 0);     retard(X);     digitalWrite(colonne[4], 0);     retard(X);     digitalWrite(colonne[0], 0);     retard(X);   }
}
// parcourir toutes les leds une à la fois
néant goThroughAllLedsOneAtATime()
{   int X = 15;   turnEverythingOff();   pour(int y = 0; y<5; y++)   {     //0-3     pour(int compter = 4; compter != 0; compter--)     {       digitalWrite(couche[compter-1], 1);       pour(int je = 0; je<4; je++)       {         digitalWrite(colonne[je], 0);         retard(X);         digitalWrite(colonne[je], 1);         retard(X);       }     digitalWrite(couche[compter-1], 0);     }     //4-7     pour(int compter = 0; compter < 4; compter++)     {       digitalWrite(couche[compter], 1);       pour(int je = 4; je<8; je++)       {         digitalWrite(colonne[je], 0);         retard(X);         digitalWrite(colonne[je], 1);         retard(X);       }     digitalWrite(couche[compter], 0);     }     //8-11     pour(int compter = 4; compter != 0; compter--)     {       digitalWrite(couche[compter-1], 1);       pour(int je = 8; je<12; je++)       {         digitalWrite(colonne[je], 0);         retard(X);         digitalWrite(colonne[je], 1);         retard(X);       }     digitalWrite(couche[compter-1], 0);     }     //12-15     pour(int compter = 0; compter < 4; compter++)     {       digitalWrite(couche[compter], 1);       pour(int je = 12; je<16; je++)       {         digitalWrite(colonne[je], 0);         retard(x);         digitalWrite(colonne[je], 1);         retard(x);       }     digitalWrite(couche[compter], 0);     }   }
}

Une fois le code téléchargé, vous pouvez admirer et ajouter des animations.