Lămpi cu fibră optică în pânză: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Acest proiect adaugă o rotire unică pe o imprimare tip pânză. Am programat în 4 moduri diferite de iluminare, dar ați putea adăuga cu ușurință mai multe. Modul este schimbat de fiecare dată când îl opriți și îl reporniți în loc să aveți un buton separat pentru a minimiza deteriorarea cadrului. Bateriile ar trebui să dureze peste 50 de ore de utilizare - nu sunt foarte sigur, dar am făcut un proiect similar pentru un prieten și a folosit de 5 ori mai multe lumini și a durat peste 20 de ore pe un singur set de baterii.

Materiale

• Imprimare pe pânză cu spațiu practicabil - am comandat-o pe a mea de la https://www.easycanvasprints.com deoarece aveau prețuri bune și un spate deschis. Cadrul mai gros de 1,5 "a fost perfect și mi-a oferit mult spațiu pentru a îndoi firele de fibră optică. În plus, doriți o imagine care să vă ofere 3" pe 8 "de spațiu funcțional pentru baterie și microcontroler și benzi LED
• Luminile cu benzi LED - am folosit benzi LED adresabile WS2812. Nu vă lăsați intimidați, sunt foarte ușor de utilizat cu bibliotecile FastLED sau Neopixel! Puteți utiliza, de asemenea, orice bandă LED standard, pur și simplu nu veți putea controla fiecare secțiune de lumină individual, fără mai multe cabluri.
• Microcontroler - Am folosit un Arduino Uno, dar puteți folosi aproape orice pentru acest proiect.
• Acumulator - l-am comandat de la eBay (din China) și s-a intitulat „6 x 1.5V AA 2A CELL Battery Batteries Holder”
• Toroane cu fibră optică - încă o dată, comandate de la China pe eBay - „PMMA Plastic Fiber Optic Cable End Grow Led Light DIY Decor” sau „PMMA End Glow Fiber Optic Cable for Star Plafon Light Kit”. Am folosit dimensiuni de 1 mm și 1,5 mm, de fapt recomand să folosesc mai mici decât atât.
• Comutator pornire / oprire - "SPDT Pornire / Pornire 2 comutatoare miniaturale de comutare"
• Cleme de organizare a firelor - Acestea ajută la menținerea firelor de fibră optică frumoase și ordonate.
• Placă de spumă, sârmă solidă a conectorului, tuburi termocontractabile

Instrumente

• Dremel - folosit pentru a cupla comutatorul de pornire / oprire în rama imaginii. Acest lucru ar putea fi realizat cu un exercițiu și un pic foarte mare, dar nu recomand asta.
• Fier de lipit - atașarea firelor la banda LED
• Pistol de lipit fierbinte - literalmente la fiecare pas al acestui proiect
• Acul de cusut mare - pentru introducerea găurilor prin pânză și panoul de spumă pentru lumini

Pasul 1: placa de spumă, pachetul de baterii și comutatorul de pornire / oprire

Înainte de orice altceva, trebuie să atașați o bucată de placă de spumă pe spatele imprimării pânzei. Acest lucru ne oferă o suprafață solidă plăcută pentru a atașa orice altceva și ajută la menținerea firelor de fibră optică în loc. Folosiți doar un cuțit exact sau un tăietor de cutie pentru a tăia o bucată de placă de spumă la dimensiunea potrivită și lipiți-o la cald în multe locuri. Recomand utilizarea plăcii de spumă neagră, astfel încât să nu permită să curgă la fel de multă lumină.

Am folosit burghiul dremel care arată ca un burghie normal, dar este de fapt excelent pentru îndepărtarea materialului. Este unul dintre biții care ar trebui să vină cu orice dremel. Folosiți o cutie de aer comprimat pentru a scăpa de orice rumeguș din dremel.

Lipiți totul la loc. Asigurați-vă că bateria este atașată foarte bine, deoarece necesită o forță bună pentru a introduce / scoate o baterie și nu doriți ca suportul bateriei să meargă nicăieri.

Pasul 2: Microcontroler și circuit

Am pus comutatorul de alimentare înainte de Arduino UNO, astfel încât atunci când comutați comutatorul, atunci nimic nu folosește energie din pachetele de baterii. Acest lucru ar trebui să ajute bateriile să reziste cât mai mult posibil atunci când proiectul nu este pornit. Plăcile Arduino sunt notoriu rele în ceea ce privește gestionarea energiei - folosesc mult curent dacă sunt pornite chiar dacă nu fac nimic în mod activ.

Conectați capătul pozitiv al bateriei la VIN (intrare de tensiune) a microcontrolerului, astfel încât să utilizeze regulatorul de tensiune încorporat al controlerului pentru a reduce tensiunea la 5V de care are nevoie. Dacă am alimenta mai multe lumini, ar trebui să folosim propriul regulator de tensiune pentru acestea, dar UNO ar trebui să poată manipula 5 LED-uri.

Am folosit un rezistor între ieșirea de date și banda LED pentru a netezi semnalul - fără rezistor s-ar putea să obțineți o clipire aleatorie a pixelilor. Dimensiunea rezistorului nu contează cu adevărat, orice între 50Ω și 400Ω ar trebui să funcționeze.

Pasul 3: Lumini cu fibră optică

După câteva încercări și erori, am găsit în cele din urmă o modalitate bună de a trece firele de fibră optică prin pânză.

1. Folosiți cel mai mare ac de cusut pe care îl aveți pentru a introduce o gaură prin partea din față a pânzei și a plăcii de spumă. Îți recomand să introduci fiecare gaură pe care o dorești chiar de la început, astfel încât să o poți răsturna și să vezi unde poți / nu poți pune clipurile de organizare prin cablu
2. Luați o pereche de clești cu nasul acului și apucați firul de fibră optică la mai puțin de un centimetru de capăt
3. Introduceți firul de fibră optică prin orificiul pe care l-ați făcut cu un ac
4. Treceți șuvița prin diferite cleme de plastic până acolo unde este puțin mai lung decât este necesar - o vom tăia mai târziu
5. Cu pistolul dvs. de adeziv fierbinte la setarea temperaturii LOW (dacă are această opțiune) puneți o picătură de adeziv fierbinte pe firul de fibră optică în care trece prin placa de spumă. Alternativ, ai putea folosi acele lucruri albastre. Adezivul fierbinte deformează puțin firul, dar nu pare să se încurce prea mult cu calitățile optice
6. Tăiați firul puțin departe de pânză folosind tăietori de sârmă.

Pentru a accelera procesul, puteți trece prin multe fibre la rând înainte de a face lipici fierbinte. În general, acestea ar trebui să rămână pe cont propriu.

Aveți grijă să nu rupeți sau să strângeți firele de fibră optică de pe masă - se vor rupe și dacă face firul prea scurt, atunci veți fi trist și va trebui să-l refaceți. Utilizați acumulatorul ca contrapondere, astfel încât să puteți avea rama de imagine mai puțin de jumătate pe birou.

Deoarece am folosit o placă de spumă albă în loc de neagră, lumina strălucește când LED-urile erau aprinse. Ca soluție, am înregistrat o folie de aluminiu între lumini și pânză.

Folosiți tuburi termocontractabile pentru a menține împreună fiecare fascicul de fire de fibră optică.

1. Tăiați firele pentru pachet la aproximativ aceeași lungime
2. Introduceți secțiunea prin tuburi termocontractabile
3. Folosiți un pistol cu căldură sau un fier de lipit pentru a-l micșora. Dacă folosiți un fier de lipit, lăsați partea laterală a fierului să atingă ușor tubulatura și se va micșora. Nu ar trebui să topească tubulatura, deoarece este concepută pentru puțină căldură.

În cele din urmă am folosit lipici fierbinte pentru a atașa capătul pachetului la fiecare lumină LED. Am folosit o mulțime de adeziv fierbinte, astfel încât fibrele să primească de fapt lumină de la fiecare diodă roșie / verde / albastră din lumină - când fibrele sunt foarte aproape de lumină o culoare „albă” (care este de fapt roșu și verde și albastru) atunci unele fibre vor fi doar roșii și altele vor fi verzi, în loc să fie toate albe. Acest lucru ar putea fi îmbunătățit folosind o bucată de hârtie sau altceva pentru ao difuza, dar lipiciul fierbinte a funcționat suficient de bine pentru mine.

Pasul 4: Programare

În programarea asta am folosit trei biblioteci

FastLED - o bibliotecă excelentă pentru controlul benzilor LED WS2812 (și a multor alte benzi LED adresabile) -

Arduino Low Power - Nu știu câtă energie economisește de fapt, dar a fost foarte ușor de implementat și ar trebui să ajute la economisirea unui pic de energie pe funcția care este doar luminile albe și apoi să întârzie pentru totdeauna.

EEPROM - Folosit pentru a citi / stoca modul curent al proiectului. Acest lucru permite proiectului să incrementeze modul de culoare de fiecare dată când îl opriți și îl reporniți, ceea ce elimină necesitatea unui buton separat pentru a schimba modul. Biblioteca EEPROM este instalată ori de câte ori instalați Arduino IDE.

De asemenea, am folosit o schiță pentru a scânteia luminile pe care altcineva le-a instalat. Se aprinde aleatoriu un pixel de la o culoare de bază la o culoare de vârf și apoi înapoi în jos. https://gist.github.com/kriegsman/88954aae22b03a66… (folosește și biblioteca FastLED)

Am folosit și pluginul vMicro pentru Visual Studio - aceasta este o versiune amplificată a ID-ului Arduino. Are o mulțime de funcții utile de completare automată și evidențiază problemele din codul dvs. fără a fi nevoie să îl compilați. Costă 15 USD, dar merită atât de mult dacă veți face mai mult de un proiect Arduino și vă va forța să aflați despre Visual Studio, care este un program super puternic.

(Atașez și fișierul.ino de cod deoarece găzduirea instructabilă a unui Github Gist distruge o mulțime de spații goale din fișier)

Codul Arduino care rulează 4 moduri de culoare pe un Arduino UNO pentru unele lumini LED cu bandă WS2812B utilizând biblioteca FastLED

#include

#include

#include

// Configurare FastLED

# defineNUM_LEDS4

# definePIN3 // Pinul de date pentru banda LED

LED-uri CRGB [NUM_LEDS];

// Configurare Twinkle

#defineBASE_COLORCRGB (2, 2, 2) // Culoarea fundalului de bază

#definePEAK_COLORCRGB (255, 255, 255) // Culoare de vârf pentru a sclipi până la

// Suma pentru a crește culoarea cu fiecare buclă pe măsură ce devine mai strălucitoare:

#defineDELTA_COLOR_UPCRGB (4, 4, 4)

// Suma pentru a scădea culoarea de fiecare buclă pe măsură ce devine mai slabă:

#defineDELTA_COLOR_DOWNCRGB (4, 4, 4)

// Șansa ca fiecare pixel să înceapă să se lumineze.

// 1 sau 2 = câțiva pixeli strălucitori la un moment dat.

// 10 = o mulțime de pixeli care se luminează odată.

# defineCHANCE_OF_TWINKLE2

enum {SteadyDim, GettingBrighter, GettingDimmerAgain};

uint8_t PixelState [NUM_LEDS];

octet runMode;

octet globalBright = 150;

octet globalDelay = 20; // Viteza de întârziere pentru sclipire

adresa octet = 35; // Adresa pentru a stoca modul de rulare

voidsetup ()

{

FastLED.addLeds (leduri, NUM_LEDS);

FastLED.setCorrection (TypicalLEDStrip);

//FastLED.setMaxPowerInVoltsAndMilliamps(5, maxMilliamps);

FastLED.setBrightness (globalBright);

// Obțineți modul de rulare

runMode = EEPROM.read (adresa);

// Măriți modul de rulare cu 1

EEPROM.write (adresa, runMode + 1);

}

voidloop ()

{

comuta (runMode)

{

// Alb solid

case1: fill_solid (led-uri, NUM_LEDS, CRGB:: Alb);

FastLED.show ();

DelayForever ();

pauză;

// Twinkle cam încet

case2: FastLED.setBrightness (255);

globalDelay = 10;

TwinkleMapPixels ();

pauză;

// Clipește repede

case3: FastLED.setBrightness (150);

globalDelay = 2;

TwinkleMapPixels ();

pauză;

//Curcubeu

caz 4:

RunRainbow ();

pauză;

// Indexați în afara intervalului, resetați-l la 2 și apoi rulați modul 1.

// Când repornirea arduino va rula modul 2, dar pentru moment rula modul 1

Mod implicit:

EEPROM.write (adresa, 2);

runMode = 1;

pauză;

}

}

voidRunRainbow ()

{

octet * c;

uint16_t i, j;

în timp ce (adevărat)

{

pentru (j = 0; j <256; j ++) {// 1 ciclu al tuturor culorilor pe roată

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

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

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

}

FastLED.show ();

întârziere (globalDelay);

}

}

}

octet * Roată (octet WheelPos) {

octet static c [3];

if (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

}

elseif (WheelPos <170) {

WheelPos - = 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

}

altceva {

WheelPos - = 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

retur c;

}

voidTwinkleMapPixels ()

{

InitPixelStates ();

în timp ce (adevărat)

{

pentru (uint16_t i = 0; i <NUM_LEDS; i ++) {

if (PixelState == SteadyDim) {

// acest pixel este în prezent: SteadyDim

// deci ne gândim la întâmplare să-l facem să devină mai luminos

if (random8 () <CHANCE_OF_TWINKLE) {

PixelState = GettingBrighter;

}

}

elseif (PixelState == GettingBrighter) {

// acest pixel este în prezent: GettingBrighter

// deci, dacă are culoarea maximă, comutați-l din nou la obținerea mai slabă

if (leduri > = PEAK_COLOR) {

PixelState = GettingDimmerAgain;

}

altceva {

// în caz contrar, continuați să-l luminați:

leduri + = DELTA_COLOR_UP;

}

}

altfel {// devine din nou mai estompat

// acest pixel este în prezent: GettingDimmerAgain

// deci, dacă a revenit la culoarea de bază, comutați-l la o intensitate redusă

if (leduri <= BASE_COLOR) {

leduri = BASE_COLOR; // resetați la culoarea de bază exactă, în cazul în care depășim

PixelState = SteadyDim;

}

altceva {

// în caz contrar, continuați să o diminuați:

leduri - = DELTA_COLOR_DOWN;

}

}

}

FastLED.show ();

FastLED.delay (globalDelay);

}

}

voidInitPixelStates ()

{

memset (PixelState, sizeof (PixelState), SteadyDim); // inițializează toți pixelii în SteadyDim.

fill_solid (leduri, NUM_LEDS, BASE_COLOR);

}

voidDelayForever ()

{

în timp ce (adevărat)

{

întârziere (100);

LowPower.powerDown (SLEEP_FOREVER, ADC_OFF, BOD_OFF);

}

}

voidshowStrip () {

FastLED.show ();

}

voidsetPixel (int Pixel, octet roșu, octet verde, octet albastru) {

// FastLED

leduri [Pixel].r = roșu;

leduri [Pixel].g = verde;

leduri [Pixel].b = albastru;

}

vizualizați rawFiberOptic_ClemsonPic.ino găzduit cu ❤ de GitHub

Pasul 5: Produsul final

Ta-da! Sper că acest Instructable inspiră pe altcineva să-și facă propriul proiect similar. Chiar nu a fost greu de făcut și am fost surprins că nimeni nu a făcut-o și a scris încă un instructiv amănunțit despre asta.