Horloge miroir Infinity avec potentiomètres : 3 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Je suis tombé sur un miroir infini et j'ai trouvé que c'était vraiment cool. Cela m'a inspiré pour faire un miroir à l'infini, mais j'en avais besoin pour avoir un but. J'ai donc décidé de fabriquer une horloge miroir à l'infini fonctionnelle. Il s'agit d'un miroir infini qui permet de changer les modes, la vitesse et les couleurs à l'aide de potentiomètres. (Remarque: c'est la première fois que je fais quelque chose comme ça)

Fournitures

Voyons ce dont vous avez besoin pour faire cette chose !

Tu auras besoin de…

1) 1 Arduino Uno

3) 1 planche à pain

4) 1 interrupteur à glissière

5) 3 potentiomètres

6) 1 pile 9V

7) Bande LED WS2811 de 5 mètres

8) Fils de câble de démarrage

9) Une horloge (l'horloge que j'ai utilisée 12 pouces grande horloge moderne)

10) Feuille de miroir flexible (celle que j'ai utilisée pour la feuille de miroir)

11) Film de confidentialité (celui que j'ai utilisé One Way Mirror)

12) La soudure peut être nécessaire, cela dépend de vos matériaux

Étape 1: Câblage

Le câblage est assez simple

- L'interrupteur SPST allume et éteint les LED (A0)

- Le potentiomètre gauche contrôle la lumière (A1)

- Le potentiomètre du milieu contrôle les modes (A2)

- Le potentiomètre droit contrôle la vitesse (A3)

Étape 2: le code

#comprendre

#définir le code PIN 6

#définir NUM_LEDS 54

#définir A0 A0

#définir A1 A1

#définir A2 A2

#définir A3 A3

// Paramètre 1 = nombre de pixels dans la bande

// Paramètre 2 = numéro de broche (la plupart sont valides)

// Paramètre 3 = indicateurs de type de pixel, additionnés au besoin:

// NEO_KHZ800 800 KHz Bitstream (la plupart des produits NeoPixel avec LED WS2812)

// NEO_KHZ400 400 KHz (pixels FLORA classiques 'v1' (pas v2), drivers WS2811)

// Les pixels NEO_GRB sont câblés pour le flux binaire GRB (la plupart des produits NeoPixel)

// Les pixels NEO_RGB sont câblés pour le flux binaire RVB (pixels FLORA v1, pas v2)

Bande Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {

strip.begin();

strip.show(); // Initialise tous les pixels sur 'off'

}

boucle vide() {

if(analogRead(A0)>=512){

if(analogRead(A2)>=768){

if(analogRead(A3)>=768){

rainbowCycle(80, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A3)>=512){

rainbowCycle(60, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A3)>=256){

rainbowCycle (40, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

autre{

rainbowCycle (20, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

} else if(analogRead(A2)>=512){

if(analogRead(A1)>=768){

CylonBounce(random(255), random(255), random(255), 4, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=512){

CylonBounce(random(255), 0, 0, 4, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=256){

CylonBounce(0, random(255), 0, 4, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

autre{

CylonBounce(0, 0, random(255), 4, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

}sinon if(analogRead(A2)>=256){

if(analogRead(A1)>=768){

octet r, g, b;

r = aléatoire (255);

g = aléatoire(255);

b = aléatoire (255);

météoreRain(r, g, b, 10, 20, vrai, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=512){

octet r, g, b;

r = aléatoire (255);

g = 0;

b = 0;

météoreRain(r, g, b, 10, 20, vrai, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=256){

octet r, g, b;

r = 0;

g = aléatoire(255);

b = 0;

météoreRain(r, g, b, 10, 20, vrai, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

autre{

octet r, g, b;

r = 0;

g = 0;

b = aléatoire (255);

météoreRain(r, g, b, 10, 20, vrai, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

}

else{ if(analogRead(A1)>=768){

RunningLights(random(255), random(255), random(255), analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=512){

RunningLights(random(255), 1, 1, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}sinon if(analogRead(A1)>=256){

RunningLights(1, random(255), 1, analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

autre{

RunningLights(1, 1, random(255), analogRead(A0), analogRead(A1), analogRead(A2), analogRead(A3));

}

}

}autre{

setAll(0, 0, 0);

}

}

void rainbowCycle(int SpeedDelay, int oldA0, int oldA1, int oldA2, int oldA3) {

octet *c;

uint16_t i, j;

for(j=0; j<256*5; j++) { // 5 cycles de toutes les couleurs sur la roue

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

for(i=0; i< NUM_LEDS; i++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

c=Roue(((i * 256 / NUM_LEDS) + j) & 255);

setPixel(i, *c, *(c+1), *(c+2));

}

showStrip();

retard(VitesseDelay);

}

}

octet * Wheel(byte WheelPos) {

octet statique c[3];

si (PosRoue < 85) {

c[0]=RouePos * 3;

c[1]=255 - WheelPos * 3;

c[2]=0;

} else if(RouePos < 170) {

RouePos -= 85;

c[0]=255 - WheelPos * 3;

c[1]=0;

c[2]=RouePos * 3;

} autre {

RouePos -= 170;

c[0]=0;

c[1]=RouePos * 3;

c[2]=255 - WheelPos * 3;

}

retour c;

}

void CylonBounce(octet rouge, octet vert, octet bleu, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3){

int SpeedDelay;

int ReturnDelay;

if(AnalogRead(A3)>=768){SpeedDelay=80;ReturnDelay=120;}

else if(analogRead(A3)>=512){SpeedDelay=60;ReturnDelay=100;}

else if(analogRead(A3)>=256){SpeedDelay=40;ReturnDelay=80;}

else{SpeedDelay=20;ReturnDelay=60;}

for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

setAll(0, 0, 0);

setPixel(i, rouge/10, vert/10, bleu/10);

for(int j = 1; j <= EyeSize; j++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

setPixel(i+j, rouge, vert, bleu);

}

setPixel(i+EyeSize+1, rouge/10, vert/10, bleu/10);

showStrip();

retard(VitesseDelay);

}

délai(RetourDélai);

for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {

setAll(0, 0, 0);

setPixel(i, rouge/10, vert/10, bleu/10);

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

for(int j = 1; j <= EyeSize; j++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

setPixel(i+j, rouge, vert, bleu);

}

setPixel(i+EyeSize+1, rouge/10, vert/10, bleu/10);

showStrip();

retard(VitesseDelay);

}

délai(RetourDélai);

}

void RunningLights (octet rouge, octet vert, octet bleu, int oldA0, int oldA1, int oldA2, int oldA3) {

int Position=0;

int WaveDelay;

if(AnalogRead(A3)>=768){WaveDelay=80;}

else if(analogRead(A3)>=512){WaveDelay=60;}

else if(analogRead(A3)>=256){WaveDelay=40;}

else{WaveDelay=20;}

for(int j=0; j

{

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

Poste++; // = 0; //Position + Taux;

for(int i=0; i

// onde sinusoïdale, 3 ondes décalées font un arc-en-ciel !

//niveau flottant = sin(i+Position) * 127 + 128;

//setPixel(i, niveau, 0, 0);

//niveau flottant = sin(i+Position) * 127 + 128;

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

setPixel(i, ((sin(i+Position) * 127 + 128)/255)*rouge, ((sin(i+Position) * 127 + 128)/255)*vert, ((sin(i+Position) * 127 + 128)/255)*bleu);

}

showStrip();

retard(WaveDelay);

}

}

void meteorRain (octet rouge, octet vert, octet bleu, octet météoreSize, octet météoreTrailDecay, booléen météoreRandomDecay, int oldA0, int oldA1, int oldA2, int oldA3) {

setAll(0, 0, 0);

int SpeedDelay;

if(AnalogRead(A3)>=768){SpeedDelay=80;}

else if(analogRead(A3)>=512){SpeedDelay=60;}

else if(analogRead(A3)>=256){SpeedDelay=40;}

else{SpeedDelay=20;}

for(int i = 0; i < NUM_LEDS+NUM_LEDS; i++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

// atténue la luminosité de toutes les LED d'un pas

for(int j=0; j

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

if((!meteorRandomDecay) || (random(10)>5)) {

fadeToBlack(j, meteorTrailDecay);

}

}

// dessine un météore

for(int j = 0; j <meteorSize; j++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ancienA3+256)

Pause;

}

si((i-j =0)) {

setPixel(i-j, rouge, vert, bleu);

}

}

showStrip();

retard(VitesseDelay);

}

}

void fadeToBlack(int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NéoPixel

uint32_t oldColor;

uint8_t r, g, b;

valeur entière;

oldColor = strip.getPixelColor(ledNo);

r = (oldColor & 0x00ff0000UL) >> 16;

g = (oldColor & 0x0000ff00UL) >> 8;

b = (oldColor & 0x000000ffUL);

r=(r<=10) ? 0: (int) r-(r*valeur de fondu/256);

g=(g<=10) ? 0: (int) g-(g*valeur de fondu/256);

b=(b<=10) ? 0: (int) b-(b*valeur de fondu/256);

strip.setPixelColor(ledNo, r, g, b);

#fin si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds[ledNo].fadeToBlackBy(fadeValue);

#fin si

}

// *** REMPLACER PAR ICI ***

void showStrip() {

#ifdef ADAFRUIT_NEOPIXEL_H

// NéoPixel

strip.show();

#fin si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show();

#fin si

}

void setPixel(int Pixel, octet rouge, octet vert, octet bleu) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NéoPixel

strip.setPixelColor(Pixel, strip. Color(rouge, vert, bleu));

#fin si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds[Pixel].r = rouge;

leds[Pixel].g = vert;

leds[Pixel].b = bleu;

#fin si

}

void setAll (octet rouge, octet vert, octet bleu) {

for(int i = 0; i < NUM_LEDS; i++) {

setPixel(i, rouge, vert, bleu);

}

showStrip();

}

Étape 3: Création de l'horloge

Je recommanderais d'acheter une horloge en verre plate à l'intérieur. Lorsque j'appliquais le miroir flexible à l'intérieur de l'horloge, il y avait un problème dû au fait que les chiffres à l'intérieur de l'horloge sortaient, le miroir se pliait, ce qui faisait que l'effet miroir infini ne se produisait pas. Vous devez avoir la feuille miroir flexible et le film de confidentialité pour être aussi plat que possible. Si vous obtenez une horloge, assurez-vous que vous pouvez placer la LED à l'intérieur sans problème.

Étape 1: Ouvrez l'horloge et retirez la vitre avant

Étape 2: placez le film de confidentialité sur la vitre avant (cette vidéo vous montre comment le faire)

Étape 3: Appliquez le miroir flexible à l'intérieur de l'horloge (retirez les aiguilles de l'horloge avant de le faire)

Étape 4: Faites un trou au milieu pour les aiguilles de l'horloge à remettre en place

Étape 5: Placez la bande LED autour des parois intérieures de l'horloge (j'ai utilisé un pistolet à colle chaude pour cette étape)

Étape 6: Allumez la bande LED et placez le verre sur l'horloge pour voir si l'effet miroir infini est là

Étape 7: Une fois que vous avez terminé avec tout, assemblez l'horloge et laissez les fils passer à l'arrière

Étape 8: Félicitations, vous avez terminé le projet et tout devrait bien fonctionner

Si vous avez des questions, veuillez les commenter ci-dessous (Sachez que je ne pourrai peut-être pas répondre, mais je ferai de mon mieux)