Lite Brite LED clock (12 / 13 étapes)

Etape 12 : Le Code

Temps de programmer l’Arduino.  N’hésitez pas à utiliser le code ci-dessous.  Vous devrez tout d’abord télécharger la bibliothèque de http://arduino.cc/playground/Code/Time .  Une fois téléchargé, vous mettrez la bibliothèque dans le dossier des bibliothèques de l’annuaire de l’Arduino.  Vous devrez alors aller à esquisse---bibliothèque d’importation---temps d’inclure la bibliothèque dans votre dessin.

Voici comment cela fonctionne :

1. les LED individuels sont activés en définissant la ligne de la LED à faible et la colonne de la LED à haute.  L’astuce est que qu’une seule LED peut être commandée à la fois.  Si vous regardez le code, vous verrez que dès qu’un voyant est allumé, il s’arrête tout de suite.  Cela fonctionne en raison de notre persistance rétinienne et parce que les LED sont soit remis en marche à une vitesse très élevée.  La totalité de l’écran est obtenir redessiné sur l’ordre de 500 fois par seconde.

2. vous remarquerez que j’ai les points du côlon accrochés à deux les broches de sortie.  Pourquoi je ferais cela quand ils sont toujours sur ?  Bonne question !  C’est parce que si nous ne passons les points du côlon marche au même taux que le reste des LEDs, les points du côlon serait environ dix fois plus brillantes que leurs voisins.  J’ai essayé d’utiliser la puissance constante pour les points, et il avait l’air terrible.

3. j’ai écrit une fonction qui dessine chaque chiffre dans la première position de 7 segments.  J’ai aussi fait la fonction afin qu’elle accepte un paramètre d’offset.  Pour écrire le chiffre en première position, le décalage est -1.  La troisième place est + 3 et la dernière position est + 6.  Mon code est probablement assez inefficace, mais cette partie fonctionne bien.

4. l’heure est facile à analyser par la fonction timeFormat12() de la bibliothèque de Time.h.  La partie délicate seulement est d’obtenir les deux parties du procès-verbal.  Le premier chiffre des minutes peut être obtenu de la division d’entiers simples par 10.  Cela tronque le deuxième chiffre et retourner uniquement la portion de dix minutes.  Par exemple, 59/10 = 5 dans la division d’entiers.  Pour le deuxième chiffre du procès-verbal, vous utilisez la fonction mod pour renvoyer le reste après division par 10.  Ainsi, 59 % 10 = 9.

5. je suis conscient que le code de l’horloge aurait pu être écrit beaucoup plus efficacement, et si quelqu'un qui dérange pour l’améliorer, je serais ravi de voir qu’il est bien fait.  J’ai fait du mieux que je pouvais pour un gars qui n’est pas un mécanicien ou un programmeur.  Tout ce que je peux vraiment dire sur mon code est qu’il semble fonctionner.

#include < Time.h >

int colonne [] = {0,1,2,3,4,5,6,7,8,9,10,11} ;
int rang [] = {14,15,16,17,18} ;

void setup()
{
setTime(9,27,0,27,7,2012) ;

pour (int i = 0; i < 13; i ++) {}
pinMode(column[i],OUTPUT) ;
digitalWrite(column[i],LOW) ;
}

pour (int j = 0; j < 5; j ++) {}
pinMode(row[j],OUTPUT) ;
digitalWrite(row[j],HIGH) ;
}
}
void loop () {}

digitalWrite(column[11],HIGH) ;
digitalWrite(column[12],HIGH) ;
digitalWrite(column[11],LOW) ;
digitalWrite(column[12],LOW) ;

commutateur (hourFormat12()) {}
cas 1 :
One(0) ;
rupture ;
cas 2 :
Two(0) ;
rupture ;
cas 3 :
Three(0) ;
rupture ;
cas 4 :
four(0) ;
rupture ;
cas no 5 :
Five(0) ;
rupture ;
cas 6 :
six(0) ;
rupture ;
cas 7 :
Seven(0) ;
rupture ;
cas 8 :
Eight(0) ;
rupture ;
cas 9 :
Nine(0) ;
rupture ;
cas no 10 :
One(-3) ;
Zero(0) ;
rupture ;
cas no 11 :
One(-3) ;
One(0) ;
rupture ;
cas 12 :
One(-3) ;
Two(0) ;
rupture ;

}

commutateur ((minute()/10)) {}
case 0 :
Zero(3) ;
rupture ;
cas 1 :
One(3) ;
rupture ;
cas 2 :
Two(3) ;
rupture ;
cas 3 :
trois (3) ;
rupture ;
cas 4 :
four(3) ;
rupture ;
cas no 5 :
Five(3) ;
rupture ;
}

commutateur (minute()%10) {}
case 0 :
Zero(6) ;
rupture ;
cas 1 :
One(6) ;
rupture ;
cas 2 :
Two(6) ;
rupture ;
cas 3 :
Three(6) ;
rupture ;
cas 4 :
four(6) ;
rupture ;
cas no 5 :
Five(6) ;
rupture ;
cas 6 :
six (6) ;
rupture ;
cas 7 :
Seven(6) ;
rupture ;
cas 8 :
Eight(6) ;
rupture ;
cas 9 :
Nine(6) ;
rupture ;
Si correspond à rien d’autre, faire la valeur par défaut
valeur par défaut est facultatif
}

}

void allOn() {}
pour (int x = 0; x < 5; x ++) {}
pour (int y = 0; y < 13; y ++) {}
digitalWrite(row[x],LOW) ;
digitalWrite(column[y],HIGH) ;
}
}
}

void allOff() {}
pour (int x = 0; x < 5; x ++) {}
pour (int y = 0; y < 13; y ++) {}
digitalWrite(row[x],HIGH) ;
digitalWrite(column[y],LOW) ;
}
}
}

void zero(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[1],HIGH) ;

}

void one(int x) {}
digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;
}

void two(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

}

void three(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

}

void four(int x) {}
digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;
}

void five(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

}

void six(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[1],HIGH) ;

}

void seven(int x) {}
digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;
}

void eight(int x) {}
digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

}

void nine(int x) {}
digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[0],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[0],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[1],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[1],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[1+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[1+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[2],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[2],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[3],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[3],HIGH) ;

digitalWrite(column[2+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[2+x],LOW) ;
digitalWrite(row[4],HIGH) ;

digitalWrite(column[3+x],HIGH) ;
digitalWrite(row[4],LOW) ;
digitalWrite(column[3+x],LOW) ;
digitalWrite(row[4],HIGH) ;


}

Articles Liés

Pauvre Mans Lite-Brite

Pauvre Mans Lite-Brite

il s'agit d'un petit (dans mon cas) Lite-Brite issu un peu facile de trouver des pièces. La qualité de la Lite-Brite repose sur les outils vous utiliser et votre source de lumière. Bonne chance et amusez-vous !Étape 1: pièces Bien. C'est probablement
Lite Brite Shirt !

Lite Brite Shirt !

Il s'agit d'une chemise qui utilise des LED pour éclairer un Bright Lite !Étape 1: Ce que vous aurez besoinCe projet doit :Chemise noireLEDSFil conducteurBatterie de celluleSupport de batterie celluleTissu blancGrille noire (montré est arraché réelle
Pirater une torche Mag-Lite torche led rechargeable

Pirater une torche Mag-Lite torche led rechargeable

remplacer les cellules sur une torche est une telle chose ennuyeuse à voir pour certains des gars paresseux comme moi...(obtenir de nouvelles cellules, ouvrant la torche, jeter les cellules en boxe spécial... bla bla bla)Nous allons donc pirater votr
Géant Lite Brite

Géant Lite Brite

j'ai fait un géant Lite Brite pour Instructables qui a plus 1 100 trous de guérison auto et des centaines de piquets multicolores qui vont à l'intérieur et de la lumière. C'est une amélioration sur la version du jouet original au format surhumain ! C
Camion lit feux Led innovant

Camion lit feux Led innovant

Intro :N'importe quiqui a déjà eu une camionnette avec une boîte à outils, toit campeur ou une couverture de lit aexpérience de la douleur jalonnement tâche de tenter de récupérer quelque chose sur leretour après l'obscurité. Alors que la plupart des
Lit de LED et de la nuit se tenir sous la lueur

Lit de LED et de la nuit se tenir sous la lueur

Il s'agit d'un excellent moyen pour rendre votre chambre plus lumineux et coloré, la section du lit se compose de 12 groupes de 3 LED changeant de couleur et la position de la nuit sous la lueur a 7 leds rouges. Espérons que vous l'aimez et laissez v
RGB-Led Clock avec puce Bluetooth

RGB-Led Clock avec puce Bluetooth

Cette instructable vous montre comment utiliser un cyprès-BLE-Devkit pour construire une RGB-LED-horloge.Vous devez seulement très peu choses :RGB-LED-Strip de 30 ou 60 WS2812b-LEDs.une carte de circuit imprimé style grillecertaines broches broche-en
LED Clock

LED Clock

une horloge de 24 heures avec l'heure, minute et seconde indicateurs. Voici la capture, en dépit d'être un média numérique (LED) il affiche toujours en utilisant une méthode analogue (cercles!). J'ai fini de faire cette horloge il y a mois, mais n'a
Super Brite LED Sneakers 1.0

Super Brite LED Sneakers 1.0

créer vos propres baskets doublé Super Bright LED qui clignotent avec plusieurs modèles.1.0 FONCTIONNALITÉS DE :-1 couleur LED-6 modèles-capteurs reed + aimants qui vous donnent le contrôle à l'étape par le biais de modèles-conception de velcro détac
Construction d’une Alternative LED Clock

Construction d’une Alternative LED Clock

la raison pourquoi les montres courir dans le sens horaire et horloge a à voir avec SUNDAILS. Sundails sont plus ancienne horloge du monde qui suit le mouvement du soleil à travers nos éventuels sur la terre. Puisque nous n'utilisons pas sundails plu
Moderne RGB LED Clock de Craig

Moderne RGB LED Clock de Craig

j'ai besoin une jolie horloge à la recherche pour ma nouvelle maison alors j'ai décidé de concevoir et de construire un. Cette horloge utilise un contrôleur micro compatible Arduino, un module d'horloge temps réel Chronodot et un segment LED 14 d'un
Installer camion Fender lit côté LED clignotants

Installer camion Fender lit côté LED clignotants

Ce guide d'installation est pour les feux de côté lit camion LED fender sur les camions lourds qui ont un corps plus large et nécessitent 2 feux de position latéraux à l'avant et l'arrière. Les feux de balisage côté stock sont juste ambre et rouge le
Plaque de forme libre connectable à LED (Power)

Plaque de forme libre connectable à LED (Power)

ce Instructable décrit un moyen de faire un flexible alimenté que vous pouvez coller des choses en un point quelconque de l'autre pour alimenter leur surface.  Montré ici sont de LED.  Il y a une entrée pour le défi du laser Epliog.J'ai ruiné mon cer
Comment construire un 8 x 8 x 8 cube LED et le contrôler avec un Arduino

Comment construire un 8 x 8 x 8 cube LED et le contrôler avec un Arduino

il y a beaucoup de cubes de LED sur Instructables, alors pourquoi faire un autre ? La plupart sont de petits cubes composé de 27 ou 64 LEDs, dépassent rarement car elles sont limitées au nombre de sorties disponibles sur le microcontrôleur. Ce cube s