FUNDAȚIA PENTRU CULTURĂ ȘI ÎNVĂȚĂMÂNT IOAN SLAVICI TIMIȘOARA [308841]

FUNDAȚIA PENTRU CULTURĂ ȘI ÎNVĂȚĂMÂNT “IOAN SLAVICI” TIMIȘOARA

UNIVERSITATEA “IOAN SLAVICI” [anonimizat]./conf./ș.l.. dr . ………

ABSOLVENT: [anonimizat]

2019

FUNDAȚIA PENTRU CULTURĂ ȘI ÎNVĂȚĂMÂNT “IOAN SLAVICI” TIMIȘOARA

UNIVERSITATEA “IOAN SLAVICI” [anonimizat]

P

Realizarea unei scene de lumini folosind Arduino

COORDONATOR ȘTIINȚIFIC

prof./conf./ș.l. dr . ………

ABSOLVENT: [anonimizat]

2019

Cuprins

UNIVERSITATEA DIN ORADEA

FACULTATEA de Inginerie Electrică și Tehnologia Informației

DEPARTAMENTUL Calculatoare și tehnologia informației

TEMA _________________

Proiectul de Finalizare a studiilor a student: [anonimizat]________________________

1). Tema proiectului de finalizare a studiilor: _______________________________________________________________________________________________________________________________________________________________________________________________________

2). Termenul pentru predarea proiectului de diplomă__________________________________

3). Elemente inițiale pentru elaborarea proiectului de finalizare a studiilor _______________________________________________________________________________________________________________________________________________________________________________

4). Conținutul proiectului de finalizare a studiilor : ______________________________ ___________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

5). Material grafic: ________________________________________________________________________________________________________________________________________________________________________________________________________________________________

6). Locul de documentare pentru elaborarea proiectului de diplomă:

______________________________________________________________________________________________________________________________________________________

7). Data emiterii temei: ___________________________________________________

Coordonatori științifici

(titlul științific și numele)

Introducere

Oglinda

1.1. Definiție. Legea reflexiei

Orice suprafață lustruită care reflectă o [anonimizat] o oglindă.

Oglinda tipică este defapt o foaie de sticlă care este acoperită pe spate cu aluminiu sau argint astfel producand imagini.

Când lumina cade pe un corp, o [anonimizat], iar cealaltă parte transmisă prin corp. Pentru ca o suprafață netedă să acționeze ca o oglindă, ea trebuie să reflecte cât mai multă lumină posibilă și trebuie să transmită și să absoarbă cât mai puțin posibil. Pentru a reflecta razele luminoase fără a le împrăștia sau a [anonimizat] a luminii reflectate.

Legea reflexiei descrie unghiul luminii reflectate: unghiul luminii incidente este același cu unghiul luminii reflectate.

Astfel ea decurge din difracția unei unde plane cu o lungime de undă mică pe o suprafață limită plată: astfel în momentul în care dimensiunea suprafeței limită este mult mai mare decât lungimea de undă, electronii pe suprafața limită îi vedem oscilând exact în fază numai dintr-o direcție – direcția speculară. Dacă o oglindă devine foarte mică în comparație cu lungimea de undă, legea reflexiei nu mai rămâne valabilă, iar comportamentul luminii este mai complicat.

1.2 Oglinda în istorie

În timp ce prima oglindă era, fără îndoială, un corp de apă, prima care a fost facută de mâna omului datează de aproximativ 6200 înaintea erei noastre, găsită la situl Çatal Hüyük din Turcia modernă. În alte trei mii de ani, Egipteni și Sumerienii au creat oglinzi metalice – primul a fost cuprul, apoi bronz, aur și argint.

Între timp, în emisfera vestică, Olmecs, Moche și alte culturi foloseau oglinzi realizate din antracit, slat, pirită și obsidian.

Vechii romani au pionierat în a face oglinzi de sticlă prin suflare în borcane de sticlă și acoperind interiorul lor cu plumb topit, apoi rupându-le în afară rezultând oglinzi convexe de calitate slabă. În Evul Mediu, această artă a fost aproape uitată, dar a devenit din nou populară, în special în nordul Europei.

De la înființarea sa, în Evul Mediu ca o brescă italiană secretă, urmată mai apoi de spionajul industrial francez din secolul al XVII-lea, care a deținut monopolul, industria oglinzii de sticla a crescut la proporții uriașe. Odată cu evoluția acestei industrii, au apărut atât procese tehnologice mai ieftine de prelucrare cât și metode moderne de aplicare a materialului reflectorizant astfel încât oglinda a devenit un obiect obișnuit ce se regăsește în orice gospodărie.

Astfel putem afirma ca oglinzile au apărut încă din cele mai vechi timpuri ale civilizației noastre și acum ne indrumă în continuare spre viitor. Istoria oglinzilor acoperă un teritoriu vast, de la creația universului (probabil alături de alte universe în oglindă alternativă) și până la primul telescopul spațial si anume Hubble care încă ne oferă informații prețioase.

1.3 Fizica oglinzii. Tipuri de oglinzi.

Pentru a înțelege oglinzile, mai întâi trebuie să înțelegem lumina.

Când lumina atinge o suprafață la un unghi mic, ca pe un lac la apusul soarelui, aceasta se rotește la același unghi mic și lovește ochii din plin, astfel observăm o mare diferență față de oblicitatea ce o are atunci când soarele stă deasupra capului. De aceea, strălucirea soarelui seara și dimineața este mult mai intensă decât în ​​restul zilei.

Lumina în sine este invizibilă până când ricoșează din ceva și ne lovește ochii. De exemplu, un fascicul de lumină care călătorește prin spațiu nu poate fi văzut din lateral până când nu intră în ceva care îl împrăștie, cum ar fi un nor de hidrogen sau un satelit. Această împrăștiere este cunoscută sub numele de reflexie difuză și astfel ochii noștri interpretează ceea ce se întâmplă atunci când lumina atinge o suprafață neuniformă.

Oglinzile nu împrăștie lumina în acest fel. Cu o suprafață netedă, lumina reflectă fără a deranja imaginea care intră. Aceasta se numește reflecție speculară. Acest concept ridică o întrebare interesantă: dacă oglinzile păstrează imaginile care le-au lovit, de ce se transformă din stânga în dreapta și invers? De ce nu în sus și în jos? Adevărul este că o oglindă nu se inversează într-adevăr la stânga și la dreapta, ci mai degrabă în față și în spate, ca o imprimantă sau o ștampilă. Imaginați-vă că scrieți ceva pe o foaie de hârtie în stilou închis și apoi îl țineți într-o oglindă. Se vede înapoi, dar seamănă la fel ca și cum a-ți fi ținut la o lampă hârtia și ați privit-o din spate. Imaginea dumneavoastră în oglindă este o imprimare ușoară a dumneavoastră, nu o reflectare, din perspectiva oglinzii.

Când o oglindă reflectă lumina, ea formează o imagine. O imagine este o copie a unui obiect care este format prin reflexie sau refracție. Oglinzile pot avea suprafețe plane sau curbate. Forma suprafeței unei oglinzi determină tipul imaginii pe care o formează. De exemplu, unele oglinzi formează imagini reale, iar alte oglinzi formează imagini virtuale.

O imagine reală se formează în fața unei oglinzi unde razele de lumină reflectate se întâlnesc de fapt aceasta fiind o imagine adevărată care poate fi proiectată pe ecran.

O imagine virtuală pare a fi pe cealaltă parte a oglinzii. Desigur, razele reflectate nu trec de fapt prin oglinda spre cealaltă parte, deci o imagine virtuală nu există cu adevărat.

Oglinda plană

Acesta este cel mai obișnuit tip de oglindă. Are o suprafață plană reflectorizantă și formează numai imagini virtuale. Imaginea formată dintr-o oglindă plană este, de asemenea, în partea dreaptă și păstrează dimensiunea originală. Dar ceva este diferit în ceea ce privește imaginea, comparativ cu obiectul real din fața oglinzii. Stânga și dreapta sunt inversate. Din punct de vedere matematic, o oglindă plană poate fi considerată a fi limita oricărei oglinzi curbe convexe sau concave, deoarece atât raza cât și lungimea focală devin infinite.

Figura 1.2 Diagrama oglindă plană

Oglindă concavă

Oglinzile curbate pot fi concave sau convexe. O oglindă concavă are formă asemănătoare cu interiorul unui bol. Acest tip de oglindă formează imagini reale sau virtuale, în funcție de locul în care obiectul este plasat în raport cu punctul focal.

Punctul focal este punctul din fața oglinzii unde se întâlnesc razele reflectate. Puteți vedea cum oglinzile concave formează imaginile în figura nr. 1.3 si figura nr. 1.4. Oglinzile conice sunt utilizate în spatele farurilor auto. Ele focalizează lumina și o fac mai luminoasă. Oglinzile conice sunt de asemenea folosite în construcția telescoapelor.

Dacă obiectul este mai departe de oglindă decât punctul focal, atunci imaginea este reală, cu capul în jos și redusă în dimensiune.

Figura 1.3 Obiect aflat dupa punctul focal

Dacă obiectul este mai departe de oglindă decât punctul focal, atunci imaginea este reală, cu capul în jos și redusă în dimensiune.

Figura 1.4 Obiect aflat intre punctul focal și oglindă

Dacă obiectul este mai aproape de oglindă decât punctul focal, atunci imaginea este virtuală, cu partea dreaptă în sus și cu dimensiunea mărită.

Oglinda convexă

Un alt tip de oglindă curbată, este oglinda convexă, care are forma asemeni exteriorului unui bol. Datorită formei sale, ea poate aduna și reflecta lumina dintr-o arie mai largă. După cum puteți vedea în figura nr. 1.5, o oglindă convexă formează numai imagini virtuale care sunt în partea dreaptă și mai mici decât obiectul real.

Figura 1.5 Diagramă oglindă convexă

1.4 Conceptul de oglindă infinită. Principiul de funcționare.

Până acuma am studiat despre oglindă, originile ei, legi ce stau la bază si diferitele tipuri de oglinzi.

În continuare am ales să prezint ce se întamplă în momentul în care luam aceste legi ale relfexiei luminii și le punem față în față folosind două tipuri diferite de oglinzi.

De la inventarea tehnologiilor moderne de reflexie(oglinzi), s-a depus un efort mare în inventarea nu doar a materialelor noi de construcție care să permită amplasarea unor suprafețe reglexive în noi tipuri de medii și produse, dar și noi modalități prin care oglinzile pot fi folosite pentru artă, și scopuri estetice. Unul dintre cele mai faimoase și mai ușor de găsit exemple de astfel de oglinzi sunt oglinzile infinit care sunt folosite ca decorațiuni, obiecte de artă în muzee sau expoziții de artă, obiecte de divertisment, părți de mobilier sau decorațiuni interioare sau uneori în cele mai luminoase locuri cum ar fi mall-uri, shopping center-e, frizeri, saloane de înfrumusețare, spații publice și lifturi.

Oglinda infinit lucrează pe principiul plasării a două suprafețe tip oglindă, astfel încât lumina să fie reflectată dintr-un plan în celălalt în permanență lăsând impresia că este prinsă între ele la infinit. Aceste oglinzi de infinit, de obicei, vin în formele de bază.

Primul tip (figura nr. 1.6) este setul mare de oglinzi clasice care sunt setate să se confrunte unul cu celălalt, permițând utilizatorilor să intre în acea parte a spațiului în care reflectarea lor va fi afișată în ambele oglinzi, iar reflexia lor de la o oglindă la alta va crea un aspect foarte interesant și anume, efectul reflexiilor infinite care se micsorează înapoi la punctul infinit îndepărtat din mijlocul oglinzilor. Cel mai frecvent, oglinzile infinite de tip "tavan spre perete" pot fi găsite în saloanele de îmbrăcăminte sau în centrele de distracții.

Figura 1.6 Oglindă infinită formată din două suprafețe cu reflexie 100%

Cel de-al doilea tip (figura nr. 1.7) este oglinda infinită autonomă, care funcționează pe principiul de a transmite lumina între două suprafețe paralele ținute îndeaproape – unul dintre planuri fiind o oglindă obișnuită, iar celălalt plan o oglindă parțială (reflectă lumina, dar permite si trecerea ei prin sticla). Cu toate acestea, deoarece oglinda unidirecțională permite doar "ieșirea" luminii din spațiul dintre oglinzi, trebuie să fie plasată o iluminare interioară în spațiul întunecat dintre ele.

Pentru a face acest tip de oglindă infinită atrăgătoare, marginile periferice dintre cele două suprafețe(sau uneori chiar matrice complexă plasată direct pe întreaga suprafață a oglinzii) sunt decorate cu anumite puncte de lumină statice sau dinamice(LED-uri, becuri sau alte surse de lumină).

Cu o lumină prezentă între cele două planuri, oglinda cu sens unidirecțional poate lăsa apoi o gamă de imagini înapoi în afara structurii oglinzii interne, oferind utilizatorilor iluzia foarte realistă a adâncimii, cu lumini care "intră" adânc în interiorul întunericului din oglinda secundară. Unele modele rare de oglinzi infinite pot avea o orientare non-paralelă a suprafeței oglinzilor, ceea ce creează efectul tunelului vizual înclinat care este curbat într-o direcție. Chiar mai rar, suprafața oglinzii infinite ar putea fi făcută automatizată, creând efectul tunelului învârtit.

Figura 1.7 Oglindă infinită formată din două suprafețe cu procente diferite de reflexie

Distanța dintre două suprafețe de oglindă paralele poate avea un efect semnificativ asupra aspectului profunzimii pe care utilizatorul o va percepe.

De exemplu, la o distanța de 2 cm între oglinzi și sursa de lumină, adică având distanța de 1 cm față de fiecare dintre cele doua suprafețe, creează iluzia următoarelor distanțe vizibile atunci când este privită din exterior – 1cm, 4cm, 7cm, 11cm, 15cm, iar fiecare reflecție urmărește o distanță de 4 centimetri față de suprafata oglinzii exterioare.

2. Arduino

2.1 Ce este Arduino?

Arduino este o platformă cu microcontroler care poate fi folosită pentru dezvoltarea de aplicații interactive. Practic, informația este preluată de la elementele de intrare (senzori și comutatoare), se procesează în interiorul microcontrolerului platformei și este transmisă către elementele de ieșire: leduri, motoare, actuatoare, etc.

Exista mai multe variante de placi de dezvoltare Arduino, cum ar fi: Mega, Diecimila, Duemilanove, Mini, Nano și chiar Bluetooth Arduino, cele mai noi produse fiind Arduino Uno și Arduino Mega 2560.

Figura 2.1 Placi de dezvoltare Arduino

Pentru a face o idee despre ceea ce se poate face cu Arduino, iată câteva exemple de proiecte care se pot realiza cu Arduino:

OpenEnergyMonitor, sistem bazat pe Arduino care monitorizează energia electrică consumată în casă;

Arduino + senzor temperatură + senzor umiditate + senzor presiune atmosferică + placă de rețea Ethernet care transmite datele de mediu pe Google Docs, la fiecare 10 secunde;

mână robotică, bazată pe o mânușă cu senzori de îndoire si servomotoare;

robot autonom care ocolește obstacole;

robot controlat prin Bluetooth folosind telefonul mobil sau laptop-ul;

dispozitiv pentru pictat ouă („the EggBot”);

acces bazat pe cartele RFID + notificari prin Twitter

O platformă Arduino este compusă dintr-un microcontroler Atmel AVR de 8, 16 sau 32 biți în special ATmega8, ATmega168, ATmega328, ATmega1280 și ATmega2560 precum și componente complementare care facilitează programarea și încorporarea în alte circuite. Pentru programare se utilizează software-ul Arduino IDE (Integrated Development Environment) care suportă limbajele de programare C și C++ folosind reguli speciale de organizare a codului.

Spre deosebire de majoritatea plăcilor de circuite programabile anterioare, Arduino nu are nevoie de o bucată separată de hardware (numită programator) pentru a încărca un nou cod pe placă – puteți pur și simplu utiliza un cablu USB. În plus, ID-ul Arduino utilizează o versiune simplificată a C++, facilitând învățarea programării.

2.2 Evoluția platformei

În 2005, bazându-se pe munca lui Hernando Barragán (creatorul platformei Wiring), Massimo Banzi și David Cuartielles au creat Arduino, un dispozitiv programabil ușor de utilizat pentru proiecte interactive de design de artă, la Institutul de Design Interacțiune Ivrea din Ivrea, Italia. David Mellis a dezvoltat software-ul Arduino, care se baza pe platforma Wiring. În scurt timp, Gianluca Martino și Tom Igoe s-au alăturat proiectului, iar cei cinci sunt în prezent cunoscuți ca fondatorii inițiali ai platformei Arduino. Ei doreau un dispozitiv simplu, ușor de conectat la diverse lucruri (cum ar fi relee, motoare și senzori) și ușor de programat.

De asemenea, a trebuit să fie ieftin, deoarece studenții și artiștii nu sunt cunoscuți pentru că au o mulțime de bani în numerar. Ei au selectat familia AVR de la Atmel de microcontroler pe 8 biți (MCU sau μC) și au proiectat o placă de circuit autonomă cu conexiuni ușor de folosit, au scris firmware-ul bootloader-ului pentru microcontroler și l-au ambalat într-o dezvoltare integrată simplă (IDE) care folosea programe denumite "schițe". Rezultatul a fost Arduino.

De atunci, Arduino a crescut în mai multe direcții diferite, unele versiuni fiind mai mici decât cele originale, iar unele devenind mai mari. Fiecare are o nișă specifică pe care să o umple. Elementul comun printre ele este biblioteca ARduino AVR-GCC runtime care este livrată cu mediul de dezvoltare Arduino și firmware-ul de bootloader de la bord care este preîncărcat pe microcontrolerul fiecărui board Arduino.

Familia Arduino utilizează procesoare dezvoltate de Atmel Corporation din San Jose, California. Majoritatea modelelor Arduino utilizează seria de microcontrolere AVR pe 8 biți, cu excepția primului procesorul ARM Cortex-M3 pe 32 de biți.

Deși un board Arduino este, după cum afirmă echipa Arduino, doar o bază de dezvoltare Atmel AVR de bază, mediul software Arduino îl diferențiază.

Având în vedere evoluția tehnologică în timp, putem spune că în ziua de azi platforma Arduino acoperă o gama foarte mare de aplicații.

Monitorizări în timp real:

Stație meteo automată

Detector de lumină

Urmărirea soarelui pentru panouri solare

Monitorizarea radiației de fundal

Detector automat de sălbăticie

Sistem de securitate casnic sau de afaceri

Controlul la scară mică

Roboți mici

Rachete model

Model de aeronavă

Quadrotor UAVs

CNC simplă pentru mașini-unelte mici

Automatizare la scară mică

Sera automată

Acvariu automat

Robot de transfer de probe de laborator

Cameră termică precisă

Sistem de testare electronic automatizat

Artă de performanță

Controlul iluminării dinamice

Controlul dinamic al sunetului

Structuri cinematice

Lucrări de artă receptive la public

2.3 Arduino UNO

Platforma Arduino Uno este o placa de dezvoltare bazată pe microcontrolerul ATmega328P, având 6 intrări analogice, 14 de intrări digitale/pini de ieșire (din care 6 pot fi utilizate ca ieșiri PWM), un oscilator cu quart de 20 MHz, o conexiune USB, o mufa de alimentare, și un buton de resetare.

Figura 2.2 Placă de dezvoltare Arduino UNO – schema explicativă

Uno diferă de toate plăcile precedente prin faptul că nu utilizează chip-ul FTDI USB-to-serial.

În schimb, acesta oferă Atmega16U2 (Atmega8U2 până la versiunea R2) programată ca USB-to-serial convertor.

Revizia 2 a plăcii Uno are un rezistor care trage linia HWB 8U2 la sol, făcând mai ușor să pună în modul DFU.

Revizia 3 a tabloului are următoarele caracteristici noi:

1.0 pinout: au fost adăugați pinii SDA și SCL care sunt aproape de pinul AREF și alte două ieșiri noi amplasate în apropierea pinului RESET, IOREF care permite ecranelor să se adapteze la tensiunea furnizată de la bord. În viitor, scuturile vor fi compatibile atât cu placa care utilizează AVR, care funcționează cu 5V și cu Arduino Due care funcționează cu 3.3V.

Circuit RESET mai puternic.

Atmega 16U2 înlocuiește 8U2.

Comunicarea – Arduino Uno are o serie de facilități pentru a comunica cu un computer, un alt Arduino sau alte microcontrolere. ATmega328 oferă comunicație serială UART TTL (5V), care este disponibilă pe pinii digitali 0 (RX) și 1 (TX).

Un ATmega16U2 de pe placa canalizează această comunicare prin USB și apare ca un port virtual pentru software-ul de pe computer. "16U2 firmware-ul folosește driverele standard USB COM și nu este nevoie de driver extern. Cu toate acestea, pe Windows, este necesar un fișier .inf. Software-ul Arduino include un monitor serial care permite transmiterea de date textuale simple înspre si dispre Arduino.

LED-urile RX și TX de pe placă vor clipi când există date transmise prin cip USB-to-serial și conexiune USB la computer (dar nu pentru comunicare serială pe pinii 0 și 1).

2.4. Mediul de dezvoltare

Mediul de dezvoltare integrat Arduino (IDE) este o aplicație cross-platform (pentru Windows, MacOS, Linux) care este scrisă în limbaj de programare Java. Acesta a provenit din IDE pentru procesarea și cablarea limbilor și include un editor de coduri cu funcții precum tăierea și lipirea textului, căutarea și înlocuirea textului, indentarea automată și evidențierea sintaxelor și oferă mecanisme simple cu un singur clic pentru a compila și a încărca programe într-o placă Arduino. De asemenea, conține o zonă de mesaje, o consolă de text, o bară de instrumente cu butoane pentru funcții comune și o ierarhie a meniurilor de operare. Codul sursă pentru IDE este lansat sub GNU General Public License, versiunea 2.

IDE-ul Arduino suportă limbajele C și C ++ folosind reguli speciale de structurare a codurilor. IDE-ul furnizează o bibliotecă software din proiectul Wiring, care oferă multe proceduri comune de intrare și ieșire. Codul scris de utilizator necesită doar două funcții de bază, pentru pornirea schiței și buclă principală de program, care sunt compilate și legate cu un secvență principal de programare () într-un program executiv ciclic executabil cu unelte GNU, de asemenea inclus în distribuția IDE. ID-ul Arduino utilizează programul avrdude pentru a converti codul executabil într-un fișier text în codificare hexazecimală care este încărcat în placa Arduino printr-un program de încărcare din firmware-ul plăcii.

Sketch este un program scris cu IDE Arduino.

Schițele sau sketch-urile sunt salvate pe computerul de dezvoltare ca fișiere text cu extensia .ino. Arduino Software (IDE) pre-1.0 salva shițele folosind extensia .pde.

Un program minimal Arduino C / C ++ constă doar din două funcții:

setup (): Această funcție se numește o dată când o schiță începe după pornire sau resetare. Se utilizează pentru a inițializa variabilele, modurile de intrare și ieșire cu pini și alte biblioteci necesare.

buclă (): După ce funcția de configurare () se termină, funcția buclă () este executată în mod repetat în programul principal. Controlează placa până când placa este oprită sau resetată.

Figura 2.3 Sketch software

Astfel putem spune că Arduino este mult mai mult decât un simplu microcontroler. Cu un IDE expansiv și o gamă largă de configurații hardware, Arduino este într-adevăr o platformă diversă. Varietatea bibliotecilor sale și design-ul intuitiv îl fac favorit atât pentru utilizatorii noi, cât și pentru cei cu experiență. Există mii de resurse comunitare care vă ajută să începeți atât cu hardware-ul, cât și cu software-ul.

3. Scena de lumini

3.1. Structura proiectului și materiale necesare

Pentru acest proiect am ales o structură clasică dreptunghiulară și am parcurs următoarele etape:

Realizarea corpului care urmează să găzduiască atât elementele optice cât și cele electrice;

Realizarea schemei electrice și a ansamblului;

Realizarea programului care urmează să fie încărcat pe placa de dezvoltare.

Pentru construcția acestei scene de lumini avem nevoie de următoarele materiale:

Structură realizată dintr-un cadru de lemn;

Oglindă cu reflexie 100%;

Sticlă reflexivă care să permită trecerea luminii într-un singur sens;

Bandă de leduri adresabile (Neopixel, model WS2812B);

Placă de dezvoltare Arduino (Arduino UNO);

Senzor de sunet;

Rezistor de 470Ω;

Jumper tată-mamă și tată-tată;

Breadboard;

Sursă externă de tensiune.

Figura 3.1 Materiale necesare

3.2 Structura de bază

Pentru structura de bază am folosit un ansamblu dreptunghiular din lemn, fiind mult mai maleabil și ușor de modificat dacă sunt modificări pe parcurs.

Am realizat un desen tehnic pentru a stabili dimensiuniile la care execut ansamblul (figura nr.3.2).

Figura 3.2 Desen cu cote pentru structura de bază

În următoarele etape am obținut materia primă și am prelucrat-o conform desenelor.

Cotele din interior au fost realizate la aceleași dimensiuni ca și oglinda și sticla reflexiva pentru a asigura fixarea.

Printr-un proces de șlefuire am îndepartat un strat subțire de lemn cât a fost necesar pentru a poziționa și fixa cele două oglinzi în interiorul structurii și de asemenea pentru a evita jocul acestora în timpul manipulării.

Cadrul de lemn a fost găurit în partea de jos pentru a permite ieșirea firelor de alimentare și de date a ledurilor (figura nr. 3.3).

Pentru fixarea oglinzii am folosit și o peliculă de adeziv pe partea din spate, astfel eliminând riscul de a se mișca sau desprinde de baza structurii (figura nr. 3.4).

Banda de leduri adresabilă a fost poziționată pe mijlocul cadrului de lemn. Pentru a maximiza efectul optic dorit și a obține o simetrie, este necesar ca sursa de lumină aflată în interiorul structurii să fie la distanțe egale de amblele suprafețe.

În cazul de față am ales o distanță de aproximativ 10mm în ambele sensuri (figura nr. 3.5).

Înainte de a pune sticla reflexivă, interiorul cadrului ce nu este acoperit de banda de leduri, se vopseste cu o culoare închisă, de preferabil negru pentru a sporii efectul de adâncime.

Montarea capacului de stică reflexivă se montează conform figurii 3.6.

Sticla folosită permite trecerea luminii în totalitate doar într-un singur sens, din exterior spre interior. Astfel se obține efectul de oglindă infinită.

Lumina produsă de banda de leduri lovește suprafața cu procent ridicat de reflexie a capacului, o mică parte din aceasta trece prin suprafața de sticlă, iar restul este întoarsă înapoi spre oglindă.

Luând în considerare miciile pierderi ce au loc de fiecare dată când lumina lovește sticla reflexivă, acest proces se repetă până ce lumina ledurilor își pierde în intregime intensitatea și nu mai poate fi percepută de ochiul uman.

3.3 Structură secundară

Această structură din lemn a fost realizată pentru a susține și a masca partea electrică a scenei de lumini. De asemenea are rol de susținere fiind poziționată la baza ansamblului.

…. to be continued…. + poze ….. 2 pag. Max.

3.4 Asamblarea electrică, schemă

În figura 3.7 se poate observa banda de leduri adresabile utilizată, mai exact modelul WS2812B.

Fiecare circuit este compus din patru bucăți de siliciu: trei leduri de culori diferite (RGB) și un circuit de control și limitare a curentului (figura nr. 3.8).

Pe o bandă, alimentările sunt legate în paralel, dar circuitele de control în serie.

Are o tensiune de alimentare de 5V și un consum individual de 0.3W, astfel pentru fiecare led e nevoie de un curent de 60mA (20mA pe fiecare din cele 3 culori).

Pentru a reduce zgomotul, legăm între pinul de date al benzii și pinul de date al placuței de dezvoltare o rezistență de 470Ω (figura nr. 3.9). De asemenea pentru a ne asigura că banda de leduri primește curentul de care are nevoie, vom folosi și o sursă externă de tensiune legată la circuit ca în figura nr. 3.9.

Asamblarea senzorului de sunet figura nr. 3.10.

Senzorul are două ieșiri astfel este posibilă citirea lui fie pe cale analogică, fie digitală. Acesta funcționează la o tensiune de 3.3V – 5V.

Conectarea sa la Arduino se face conform schemei din figura nr. 3.11.

Odată ce este pornit, se poate observa că ambele leduri sunt pornite, atât cel de pornire, cât și cel de detectie al sunetului.

Pentru a regla senzorul, se folosește potențiometrul de pe el și se întoarce în sens opus acelor de ceasornic până ce ledul de detecție al sunetului se stinge. În acest moment, acel led ar trebui sa se aprindă doar la detectarea unui sunet.

Relația dintre senzorul de sunet, banda de leduri și placuța de dezvoltare se va face folosind un breadboard și o serie de jumperi.

Realizarea fizică a circuitului:

Pasul 1 – Stabilirea legăturii între senzorul de sunet și Arduino (figura nr. 3.12)

În realizarea circuitului fizic, am folosit breadboard-ul pentru a asigura conexiunea dintre cele două scheme de montaj (a senzorului și a benzii de leduri), did moment ce am ambele se alimentează la 5V și au nevoie de legătură la masă.

În figura nr. 3.12 am folosit un singur pin de date între senzorul de sunet și Arduino, astfel încât citirea este una analogică, iar valorilor primite de la sezor vin pe pinul analogic A0 al placuței de dezvoltare.

Pasul 2 – Introducerea circuitului de leduri în ansamblul existent (figura nr. 3.13)

În această etapă, am adăugat și banda de leduri în circuit, comunicarea cu Arduino fiind posibilă prin pinul digial 6. Pentru o comunicare cu mai puțin zgomot, am adăugat un rezistor de 470Ω pe breadboard intre pinul 6 si pinul de control al benzii WS8212B.

Pasul 3 – adăugarea unei surse externe de tensiune circuitului (figura nr. 3.14)

În ultima etapă a ansamblului, am adăugat o sursă externă de tensiune pentru a echilibra consumul de putere datorat ledurilor.

Pentru a calcula necesarul de putere a benzii de leduri folosite este nevoie să știm numărul exact de leduri.

Astfel folosind cotele interne ale desenului, putem afla perimetrul cadrului din lemn.

2L + 2l = (2 × 270) + (2 × 390) = 1320 mm

Densitatea de leduri pe WS2812B folosită este de 60 leduri la 1000mm

1000 mm ÷ 60 Led = 16.66 mm/Led

1320 mm ÷ 16.66 mm/Led = 79.23 Led

Pentru cadrul nostru sunt necesare 79 de Leduri, prin urmare, puterea necesară este de:

79 × 60mA = 4740 mA (4,7 Amperi)

Sursa de tensiune externă trebuie să genereze suficienți amperi astfel încât să asigure acel echilibru de consum pentru leduri.

Astfel am decis să folosesc un sistem de acumulatori NiMH. Sistemul NiMH are o capacitate mare de stocare a energiei. Procesul de fabricație și folosirea au un impact mic asupra mediului, acumulatorii nu conțin plumb sau mercur.

4 acumulatori HiMH AA R6 – 1,2V si 2500mA = 4,8V si 10000mA (extra suficient).

3.4. Realizare cod Arduino

#include <FastLED.h>

/** Configurare de bază **/

//Numărul de Leduri pentru aceasta configurație

#define NUM_LEDS 78

//Pinul care controlează ledurile

#define LED_PIN 6

//Pinul care citește valorile primite de senzor

#define ANALOG_READ 0

// Valoarea mică confirmată a microfonului și valoarea maximă

#define MIC_LOW 0.0

#define MIC_HIGH 737.0

/** Alte macro-uri */

// Câte valori anterioare ale senzorului influențează media operațională?

#define AVGLEN 15

// Câte valori anterioare ale senzorului decid dacă suntem pe un vârf / HIGH (ex. Într-o melodie)

#define LONG_SECTOR 5

// Mnemonice

#define HIGH 3

#define NORMAL 2

// Cât timp păstrăm sunetul "mediu actual", înainte de a reporni măsurarea

#define MSECS 2000

#define CYCLES MSECS / DELAY

/* Uneori citirile sunt greșite sau ciudate. Cât de mult este permisă o citire

să se abată de la media pentru a nu fi aruncată? **/

#define DEV_THRESH 0.8

// Arduino întârziere buclă

#define DELAY 1

float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve);

void insert(int val, int *avgs, int len);

int compute_average(int *avgs, int len);

void visualize_music();

// Câte LED-uri trebuie să afișăm

int curshow = NUM_LEDS;

/* Nu este încă folosit încă. Gândit să fie capabil să treacă între modul de sunet reactiv

și pulsarea generală a gradientului / culoarea statică */

int mode = 0;

// Se afișează culori diferite pe baza modului.

int songmode = NORMAL;

// Măsurarea sonoră medie a ultimelor CICLURI

unsigned long song_avg;

// Suma iterațiilor de la resetarea melodiei song_avg

int iter = 0;

// Viteza LED-urilor se estompează negru dacă nu se reliefează

float fade_scale = 1.2;

// Tastatură led

CRGB leds[NUM_LEDS];

/* Media scurtă a sunetului folosit pentru a "normaliza" valorile de intrare.

Utilizăm media scurtă în loc să folosim direct intrarea senzorului */

int avgs[AVGLEN] = {-1};

//Media mai lungă a sunetului

int long_avg[LONG_SECTOR] = {-1};

// Ținem evidența cât de des și cât de mult timp am atins un anumit mod

struct time_keeping {

unsigned long times_start;

short times;

};

// Cât de mult să creștem sau să reducem fiecare culoare în fiecare ciclu

struct color {

int r;

int g;

int b;

};

struct time_keeping high;

struct color Color;

void setup() {

Serial.begin(9600);

// Setam toate luminile pentru a ne asigura că toate funcționează conform așteptărilor

FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);

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

leds[i] = CRGB(0, 0, 255);

FastLED.show();

delay(1000);

// bootstrap media cu unele valori scăzute

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

insert(250, avgs, AVGLEN);

}

//Valori inițiale

high.times = 0;

high.times_start = millis();

Color.r = 0;

Color.g = 0;

Color.b = 1;

}

/* Cu aceasta putem schimba modul dacă vrem să punem în aplicare un de ex. o

lampă, cu pulsații generale. Poate dacă sunetul este scăzut pentru un timp? */

void loop() {

switch(mode) {

case 0:

visualize_music();

break;

default:

break;

}

delay(DELAY); // întârzierea între citirile pentru stabilitate

}

/**Funcție pentru a verifica dacă lampa trebuie să intre într-un mod HIGH,

sau se revine la NORMAL dacă e deja în HIGH. Dacă senzorii raportează valori

care sunt mai mari decât 1,1 ori valorile medii, iar acest lucru sa întâmplat de

mai mult de 30 de ori în ultimele milisecunde, va intra în modul HIGH.

De facut!: Posibil nu este foarte bine scris, eliminam valorile hardcoded și îl facem mult mai

reutilizabil și configurabil. */

void check_high(int avg) {

if (avg > (song_avg/iter * 1.1)) {

if (high.times != 0) {

if (millis() – high.times_start > 200.0) {

high.times = 0;

songmode = NORMAL;

} else {

high.times_start = millis();

high.times++;

}

} else {

high.times++;

high.times_start = millis();

}

}

if (high.times > 30 && millis() – high.times_start < 50.0)

songmode = HIGH;

else if (millis() – high.times_start > 200) {

high.times = 0;

songmode = NORMAL;

}

}

// Funcția principală pentru vizualizarea sunetelor din lampă

void visualize_music() {

int sensor_value, mapped, avg, longavg;

// Valoarea reală a senzorului

sensor_value = analogRead(ANALOG_READ);

// Dacă este 0, eliminam imediat. Probabil nu este corect și salvam CPU.

if (sensor_value == 0)

return;

// Eliminam citirile care se abat prea mult de nivelul trecut.

mapped = (float)fscale(MIC_LOW, MIC_HIGH, MIC_LOW, (float)MIC_HIGH, (float)sensor_value, 2.0);

avg = compute_average(avgs, AVGLEN);

if (((avg – mapped) > avg*DEV_THRESH)) //|| ((avg – mapped) < -avg*DEV_THRESH))

return;

//Inseram noi valori medii

insert(mapped, avgs, AVGLEN);

insert(avg, long_avg, LONG_SECTOR);

// Calculam valoarea senzorului "media piesei"

song_avg += avg;

iter++;

if (iter > CYCLES) {

song_avg = song_avg / iter;

iter = 1;

}

longavg = compute_average(long_avg, LONG_SECTOR);

// Verificam dacă intrăm în modul HIGH

check_high(longavg);

if (songmode == HIGH) {

fade_scale = 3;

Color.r = 8;

Color.g = 1;

Color.b = -2;

}

else if (songmode == NORMAL) {

fade_scale = 3;

Color.r = -1;

Color.b = 6;

Color.g = -2;

}

// Decide câte dintre LED-uri vor fi aprinse

curshow = fscale(MIC_LOW, MIC_HIGH, 0.0, (float)NUM_LEDS, (float)avg, -1);

/* Setam led-urile diferit. Controlam pentru valori prea mari și prea scăzute.

Un lucru interesant de încercat: Nu luam în considerare depășirea într-o singură direcție,

astfel apar câteva efecte de lumină interesante! */

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

// Led-urile pe care vrem să le arătăm

if (i < curshow) {

if (leds[i].r + Color.r > 255)

leds[i].r = 255;

else if (leds[i].r + Color.r < 0)

leds[i].r = 0;

else

leds[i].r = leds[i].r + Color.r;

if (leds[i].g + Color.g > 255)

leds[i].g = 255;

else if (leds[i].g + Color.g < 0)

leds[i].g = 0;

else

leds[i].g = leds[i].g + Color.g;

if (leds[i].b + Color.b > 255)

leds[i].b = 255;

else if (leds[i].b + Color.b < 0)

leds[i].b = 0;

else

leds[i].b = leds[i].b + Color.b;

// Toate celelalte LED-uri încep să drumul spre scăderea intensității până iși pierd toată intensitatea

} else {

leds[i] = CRGB(leds[i].r/fade_scale, leds[i].g/fade_scale, leds[i].b/fade_scale);

}

FastLED.show();

}

// Calculam media unei matrice int, având în vedere indicatorul de pornire și lungimea

int compute_average(int *avgs, int len) {

int sum = 0;

for (int i = 0; i < len; i++)

sum += avgs[i];

return (int)(sum / len);

}

// Introducem o valoare într-o matrice și o deplasam în jos

// prima valoare dacă matricea este deja plină

void insert(int val, int *avgs, int len) {

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

if (avgs[i] == -1) {

avgs[i] = val;

return;

}

}

for (int i = 1; i < len; i++) {

avgs[i – 1] = avgs[i];

}

avgs[len – 1] = val;

}

// Funcție importată de pe site-ul web arduino.

// Practic harta, dar cu o curbă pe scară (poate fi neuniformă).

float fscale( float originalMin, float originalMax, float newBegin, float

newEnd, float inputValue, float curve){

float OriginalRange = 0;

float NewRange = 0;

float zeroRefCurVal = 0;

float normalizedCurVal = 0;

float rangedValue = 0;

boolean invFlag = 0;

// parametrul curbei de stare

// limită

if (curve > 10) curve = 10;

if (curve < -10) curve = -10;

curve = (curve * -.1) ; // – invert and scale – this seems more intuitive – postive numbers give more weight to high end on output

curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function

// Verificam valori de intrare în afara intervalului

if (inputValue < originalMin) {

inputValue = originalMin;

}

if (inputValue > originalMax) {

inputValue = originalMax;

}

// Zero Refference the values

OriginalRange = originalMax – originalMin;

if (newEnd > newBegin){

NewRange = newEnd – newBegin;

}

else

{

NewRange = newBegin – newEnd;

invFlag = 1;

}

zeroRefCurVal = inputValue – originalMin;

normalizedCurVal = zeroRefCurVal / OriginalRange; // normalize to 0 – 1 float

// Verificam pentru originalMin > originalMax – matematic pentru toate celelalte cazuri, adică numărul negativ să pară că funcționeză bine

if (originalMin > originalMax ) {

return 0;

}

if (invFlag == 0){

rangedValue = (pow(normalizedCurVal, curve) * NewRange) + newBegin;

}

else // invert the ranges

{

rangedValue = newBegin – (pow(normalizedCurVal, curve) * NewRange);

}

return rangedValue;

}