Conf . Dr. Ing. Ionuț Cristian Resceanu Iunie 2020 CRAIOVA 1 UNIVERSITATEA DIN CRAIOVA FACULTATEA DE AUTOMATICĂ, CALCULATOARE ȘI ELECTRONICĂ… [608360]

0
UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE AUTOMATICĂ, CALCULATOARE ȘI
ELECTRONICĂ

DEPARTAMENTUL DE AUTOMATICĂ ȘI ELECTRONICĂ

PROIECT DE DIPLOMĂ
Bolea Alexandru -Ionuț

COORDONATOR ȘTIINȚIFIC
Conf . Dr. Ing. Ionuț Cristian Resceanu

Iunie 2020
CRAIOVA

1
UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE AUTOMATICĂ, CALCULATOARE ȘI
ELECTRONICĂ

DEPARTAMENTUL DE AUTOMATICĂ ȘI ELECTRONICĂ

Sistem integrat pentru reprezentarea nivelului de
semnal in echipamentele audio
Bolea Alexandru -Ionuț

COORDONATOR ȘTIINȚIFIC
Conf . Dr. Ing. Ionuț Cristian Resceanu

Iunie 2020
CRAIOVA

2

3
„Învățătura este o comoară care își urmează stăpânul pretutindeni .”
Proverb popular

4
DECLARAȚIE DE ORIGINALITATE

Subsemnatul Bolea Alexandru -Ionuț student: [anonimizat], Calculatoare și Electronică a Universit ății din Craiova, certific prin prezenta
că am luat la cunoșt ință de cele prezentate mai jos și că î mi asum, în acest context, originalita tea
proiectului meu de licență :
• cu titlul Sistem integrat pentru reprezentarea nivelului de semnal in echip amentele audio
• coordonată de Conf. Dr. Ing. Ionuț Cristian Resceanu ,
• prezentată în sesiunea Iulie 2020.
La elaborarea proiectului de licență, se consideră plagiat una dintre următoarele acțiuni:
• reproducerea exactă a cuvintelor unui alt autor, dintr -o altă lucrare, în limba română sau prin
traducere dintr -o altă limbă, dacă se omit ghilimele și referința precisă,
• redarea cu alte c uvinte, reformularea prin cuvinte proprii sau rezumarea ideilor din alte lucrări ,
dacă nu se indică sursa bibliografică,
• prezentarea unor date experimentale obținute sau a unor aplicații realizate de alți autori fără
menționarea corectă a acestor surse,
• însușirea totală sau parțială a unei lucrări în care regulile de mai sus sunt respectate, dar care
are alt autor.
Pentru evitarea acest or situații neplăcute se recomandă:
• plasarea într e ghilimele a citatelor directe și indicarea referinței într -o listă corespunzătoare la
sfărșitul lucrării,
• indicarea în text a reformulării unei idei, opinii sau teorii și corespunzător în lista de referințe a
sursei originale de la care s -a făcut preluarea,
• precizarea sursei de la care s -au preluat date experimentale, d escrieri tehnice, figuri, imagini,
statistici, tabele et caetera ,
• precizarea referințelor poate fi omisă dacă se folosesc informații sau teorii arhicunoscute, a
căror paternitate este unanim cunoscută și acceptată.
Data , Semnătura candidat: [anonimizat],

5

UNIVERSITATEA DIN CRAIOVA
Facultatea de Automatică, Calculatoare și Electronică
Departamentul de Automatică și Electronică
Aprobat la data de
…………………
Director de
departament,
Prof. dr. ing.
Cosmin IONETE

PROIECTUL DE DIPLOMĂ

Numele și prenumele student: [anonimizat]/ –
ei:
Bolea Alexandru -Ionuț

Enunțul temei:

Sistem integrat pentru reprezentarea nivelului de semnal în
echipamentele audio

Datele de pornire:

[Descrierea datelor inițiale de la care s -a început
activitatea de cercetare/dezvoltare a tezei ]

Conținutul proiectului :

[Descrierea succintă a conținutului fiecărui capitol al
lucrării ]

Material grafic obligatoriu:

Consultații:
Saptămanale
Conducătorul științific
(titlul, nume și prenume,
semnătura): Șef lucrări dr. ing. Marius MARIAN

Data eliberării temei :
01.12.2019

Termenul estimat de predare a
proiectului :
01.06.2020

Data predării proiectului de către
student și semnătura acestuia:

6

7
UNIVERSITATEA DIN CRAIOVA
Facultatea de Automatică, Calculatoare și Electronică
Departamentul de Automatică și Electronică

REFERATUL CONDUCĂTORULUI ȘTIINȚIFIC

Numele și prenumele candidatului: Bolea Alexandru -Ionuț
Specializarea: Ingineria sistemelor multimedia
Titlul proiectului : Sistem integrat pentru reprezentarea nivelului de semnal in
echipamentele audio
Locația în care s -a realizat practica de
documentare (se bifează una sau mai
multe din opțiunile din dreapta): În facultate □
În producție □
În cercetare □
Altă locație: [ se detaliază ]

În urma analizei lucrării candidatului au fost constatate următoarele:
Nivelul documentării Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
Tipul proiectului Cercetare
□ Proiectare
□ Realizare
practică □ Altul
[se detaliază ]
Aparatul matematic utilizat Simplu
□ Mediu
□ Complex
□ Absent
□
Utilitate Contract de
cercetare □ Cercetare
internă □ Utilare
□ Altul
[se detaliază ]
Redactarea lucrării Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
Partea grafică, desene Insuficient ă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Realizarea
practică Contribuția autorului Insuficientă
□ Satisfăcătoare
□ Mare
□ Foarte mare
□
Complexitatea
temei Simplă
□ Medie
□ Mare
□ Complexă
□
Analiza cerințelor Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
Arhitectura Simplă
□ Medie
□ Mare
□ Complexă
□
Întocmirea
specificațiilor
funcționale Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□

8
Implementarea Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Testarea Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Funcționarea Da
□ Parțială
□ Nu
□
Rezultate experimentale Experiment propriu
□ Preluare din bibliografie
□
Bibliografie Cărți
Reviste
Articole
Referințe
web

Comentarii
și
observații

În concluzie, se propune:

ADMITEREA PROIECTULUI
□ RESPINGEREA PROIECTULUI
□

Data, Semnătura conducătorului științific,

9
REZUMATUL PROIECTULUI
În această secțiune sunt sumarizate elementele principale ale proiectului . Rezumatul proiectului are
menirea de a da potențialilor cititori o imagine succintă a temei abordate și a motivației alegerii acesteia,
a metodo logiilor de cercetare și dezvoltare alese , precum și a tehnologiilor utilizate, a problemelor
întâlnite pe parcursul realizării acesteia și modul de soluționare al acestora. Autorul trebuie să puncteze
în mod clar rezultatel e obținute prin contribuția personală , dar și lecțiile învățate pe parcursul realizării
proiectului .

Termenii cheie : [autorul va enumera aici cuvin tele cheie ale lucrării ].

10
CUPRINSUL
1 INTRODUCERE ARDUINO ………………………….. ………………………….. ………………………….. …………………. 1
1.1 ISTORIC ………………………….. ………………………….. …………………….. ERROR ! BOOKMARK NOT DEFINED .
1.2 CE ESTE ARDUINO ………………………….. ………………………….. ………………………….. ………………………….. … 2
2 CONVENȚII DE REDACTARE ………………………….. …………… ERROR! BOOKMARK NOT DEFINED.
2.1 CERINȚE GENERALE ………………………….. ………………………….. ……. ERROR ! BOOKMARK NOT DEFINED .
2.2 STRUCTURA DOCUMENTULUI ………………………….. ………………………….. ………………………….. …………….. 3
2.3 DIMENSIUNILE LUCRĂRII ………………………….. ………………………….. ………………………….. ………………….. 5
2.4 ELEMENTE DE TEHNOREDACTARE ………………………….. ………………………….. ………………………….. ………. 5
2.5 FORMULELE MATEMATICE ………………………….. ………………………….. ………………………….. ………………… 6
2.6 ILUSTRAȚIILE ………………………….. ………………………….. ………………………….. ………………………….. ……… 6
2.6.1 Figurile ………………………….. ………………………….. ………………………….. ………………………….. …………. 6
2.6.2 Tabelele ………………………….. ………………………….. ………………………….. ………………………….. ………… 6
2.6.3 Legenda (unei figuri/tabele) ………………………….. ………………………….. ………………………….. …………. 7
3 TERMENI DE UTILIZARE ………………………….. ………………………….. ………………………….. ………………….. 8
3.1 AUTORII ………………………….. ………………………….. ………………………….. ………………………….. …………….. 8
3.2 LICENȚA DE UTILIZARE ………………………….. ………………………….. ………………………….. …………………….. 8
4 CONCLUZII ………………………….. ………………………….. ………………………….. ………………………….. ……………. 9
5 BIBLIOGRAFIE ………………………….. ………………………….. ………………………….. ………………………….. …….. 10
6 REFERINȚE WEB ………………………….. ………………………….. ………………………….. ………………………….. …. 11
A. CODUL SURSĂ ………………………….. ………………………….. ………………………….. ………………………….. ……… 12
B. SITE -UL WEB AL PROIECTULUI ………………………….. ………………………….. ………………………….. …….. 37
C. CD / DVD ………………………….. ………………………….. ………………………….. ………………………….. ……………….. 38
INDEX ………………………….. ………………………….. ………………………….. ………………………….. ………………………….. . 39

11
LISTA FIGURILOR
FIGURA 1. SELECTAREA PRIN CLICK DREAPTA A OPȚIUNII „UPDATE FIELD ” ………………………….. ………………………. 6
FIGURA 2. ACTUALIZAREA ÎNTREGULUI TABEL ………………………….. ………………………….. ………………………….. ……. 7

12
LISTA TABELELOR
TABELUL 1. NUME DE UTILIZATORI ȘI VALORILE REZUMAT ALE PAROLELOR ACESTORA ………………………….. …….. 7

1
1 INTRODUCERE ARDUINO
1.1 Istoric
Arduino a început în 2005 ca un proiect al unui student al Institutului de Interacțiune a
Designului din Ivrea, Italia. La acea vreme studenții foloseau o plăcuță de dezvoltare BASIC
Stamp care costau 100 de dolari, ceea ce era considerat foarte scump pentru studenți. Massimo
Banzi, unul dintre fon datori, era stud ent la Ivrea. Numele "Arduino" provine de la un bar din
Ivrea, locul unde o parte din fondat ori obișnuiau să se întâlnească.
Studentul columbian Hernando Barragán a creat platforma de dezvoltare Wiring care a
servit ca bază pentru Arduino. După finalizarea platformei Wiring, mai multe versiu ni, mai
light și mai ieftine , au fost create și puse la dispoziția comunităților open -source. Din echipa
inițială Arduino au făcut parte Massimo Banzi, David Cuartielles, Tom Igoe, Gian luca Martino
și Da vid Mellis.
După finalizarea platformei de cablare, versiunile mai ușoare și mai puțin costisitoare au
fost distribuite în comunitatea open -source.
La mijlocul anului 2011, a fost estimat că peste 300.000 de Arduinos oficiali au fost produși în
comerț , iar în 2013, 700.000 de comisii oficiale erau în mâinile utilizatorilor.
În octombrie 2016, Federico Musto, fostul director general al lui Arduino, a asigurat o
proprietate de 50% a companiei. În aprilie 2017, Wired a raporta t că Musto și -a „fabricat
palmaresul academic … Pe site -ul companiei sale, pe conturile personale de LinkedIn și chiar
pe documentele de afaceri italiene, Musto a fost listat până de curând ca dețin un doctorat de la
Massachusetts Institute of Technology . În unele cazuri, biografia sa a revendicat și un MBA de
la New York University ". Wired a raportat că niciun fel de universitate nu a înregistrat vreo
înregistrare a prezenței lui Musto și, mai târziu, Musto a recunoscut într -un interviu cu Wired
că nu a câștigat niciodată aceste diplome.
Cam în aceeași perioadă, Massimo Banzi a anunțat că Fundația Arduino va fi „un nou
început pentru Arduino.” Dar un an mai târziu, Fundația încă nu a fost înființată, iar starea
proiectului rămâne neclară. Controversele din jurul Musto au continuat atunci când, în iulie
2017, a scos multe licențe, scheme și coduri open source de pe site -ul Arduino, ceea ce a
determinat scrutinul și criza. În octombrie 2017, Arduino și -a anunțat parteneriatul cu ARM
Holdings ( ARM). Anunțul spunea, în parte, „ARM a recunoscut independența ca valoare

2
esențială a Arduino … fără nicio blocare cu arhitectura ARM.” Arduino intenționează să
continue să lucreze cu toți furnizorii de tehnologie și arhitecturi.
1.2 Ce este Arduino
Arduino este o companie open -source care produce atât plăcuțe de dezvoltare bazate pe
microcontrolere, cât și partea de software destinată funcționării și programării acestora. Pe
lângă acestea include și o comunitate uriașă care se ocupă cu creația și di stribuirea de proiecte
care au ca scop crearea de dispozitive care pot sesiza și controla diverse activităț i sau procese în
lumea reală.
Proiectul este bazat pe designul plăcilor cu microcontroler produse de câțiva furnizori,
folosind diverse tipuri de microcontrolere. Aceste plăci pun la dispoziția utilizatorului pini I/O,
digitali și analogici, care pot fi interfațați cu o gamă largă de plăcuțe numite scuturi (shield -uri)
și/sau cu alte circuite. Plăcile au interfețe de comun icații seriale, inclusiv USB pe unele modele,
pentru a încărca programe din calculatorele personale. Pentru programarea microcontrolerelor,
Arduino vine cu un mediu de dezvoltare integrat (IDE) bazat pe proiectul Processing, care
include suport pentru limb aje de programare ca C și C++.

Primul Arduino a fost lansat în 2005, având ca țintă asigurarea unei soluții ieftine și simple
pentru începători și profesioniști spre a crea dispozitive capabile să interacționeze cu mediul,
folosind senzori și sistem e de acționare. Cele mai comune exemple sunt dispozitivele pentru
utilizatorii începători precum: roboții simpli, termostatele și/sau detectoarele de mișcare.

Plăcuțele Arduino sunt disponibile comercial sub formă preasamblată sau sub forma unor
kit-uri de asamblat acasă (do -it-yourself). Specificațiile schemelor sunt disponibile pentru orice
utilizator, permițând oricui să fabrice plăcuțe Arduino. Adafruit Industries estimase la mijlocul
anului 2011 că peste 300.000 de plăcuțe oficiale Arduino au fo st produse, iar în 2013 700.000
de plăcuțe oficiale erau în posesia utilizatorilor .

3
2 REPREZENTAREA NIVELULUI DE SEMNAL(VU)
2.1 Ce este nivelul de semnal
Un contor de unitate de volum (VU) sau indicator de volum standard (SVI) este un dispozitiv
care afișează o reprezentare a nivelului semnalului în echipamentele audio. Designul original a
fost propus în lucrarea IRE din 1940, Un nou indicator de volum și un nivel de referință,
redactate de experți de la CBS, NBC și Bell Telephone Laboratories. Societatea Acusti că din
America a standardizat -o în 1942 (ANSI C16.5 -1942) pentru utilizare în instalații de telefonie
și stații de radiodifuziune. Echipamentul audio pentru consumatori are adesea contoare VU, atât
în scopuri de utilitate (de exemplu, în echipamente de î nregistrare), cât și pentru estetică (în
dispozitive de redare).
Contorul VU original este un dispozitiv electromecanic pasiv, și anume un ampermetru de
mișcare DC d'Arsonval de 200 µA alimentat dintr -un redresor cu undă completă de oxid de
cupru montat în carcasa contorului. Masa acului provoacă un răspuns relativ lent, care, de fapt,
integrează sau netezește semnalul, cu un timp de creștere de 300 ms. Aceasta are ca efect
medierea vârfurilor și a jgheaburilor de scurtă durată și reflectă sunetul perceput al materialului
mai îndeaproape decât contoarele PPM mai moderne și inițial mai scumpe. Din acest motiv,
mulți profesioniști audio preferă contorul VU pentru alternativele sale, deși indicația contorului
nu reflectă unele dintre caracteristicile cheie ale semnalului, în special nivelul de vârf al
acestuia, care în multe cazuri nu trebuie să depășească o limită definită. 0 VU este egal cu +4
dBu, sau 1,228 volți RMS, o putere de aproximativ 2,5 miliwati atunci când este aplicată pe o
sarcină de 600 ohmi. 0 V U este adesea denumit "0 dB". Contorul a fost proiectat nu pentru a
măsura semnalul, ci pentru a permite utilizatorilor să direcționeze nivelul semnalului până la un
nivel țintă de 0 VU (uneori etichetat 100%), deci nu este important ca dispozitivul să fie
neliniar și imprecis pentru niveluri scăzute. De fapt, scara variază de la -20 VU la +3 VU, cu -3
VU chiar la mijloc. Dispozitivele pur electronice pot imula răspunsul acului; sunt VU -metri în
măsura în care respectă standardul. În industria de difuzare, monitorizarea sonorității a fost
standardizată, în 2009 în Statele Unite de către ATSC A / 85, în 2010 în Europa de EBU R -128,
în 2011 în Japonia de TR -B32 și în 2010 în Australia de OP -59.

4

Figura 1 -1. Aparat analogic de masurare a nivelului de semnal
2.2 Scurt istoric
VU-meter a fost inițial dezvoltat în 1939 prin efortul combinat al Bell Labs și al
radiodifuzorilor CBS și NBC. În anii ’70 -’80, decatronele cu afișaj dublu plan, plin cu neon,
cu până la 201 segmente pe canal stereo au fost populare în rândul emisiilor, ca contoare de
bare rapide cu grafic de bare.
Coperta tezei ;
• Pagina de titlu ;
• Declarația de originalitate (completată și semnată de către autor) ;
• Formularul de înregistrare a enunțului temei lucrării (completat și semnat în solidar de către
autor și coordonatorul științific) ;
• Referatul coordonatorului științific (completat și semnat de coordonator) ;
• Declarația de mulțumire a autorului (opțională) ;
• Cuprinsul lucrării ;
• Lista figurilor ;

5
• Lista tabelelor ;
• Introducere ;
• Conținutul propriu -zis al lucrării (capitolele constituente) ;
• Concluzii ;
• Bibliografia ;
• Referințele web ;
• Anexele (index, codul sursă, site -ul web al aplicației, etc.) .
2.3 Dimensiuni le lucrării
Nu pot fi acceptate lucrări cu un număr de pagini mai mic decât 50. Prin urmare se dau, cu titlu de
recomandare, următoarele dimensiuni:
• 50 – 80 de pagini pentru o lucrare de licență;
• 60 – 100 de pagini pentru o lucrare de disertație.
În altă ordine de idei, recomandăm următoarea distribuție a paginilor pe diversele secțiuni/capitole
[Olt07] :
• Introducerea reprezintă cca. 10 – 15% din lucrare;
• Conținutul reprezintă cca. 75 – 80% din lucrare;
• Concluziile reprezintă cca. 10%.
2.4 Elemente de tehnoredactare
Pe scurt:
• dimensiunea paginilor va fi A4, 21 x 29,7 cm;
• marginile recomandate sunt: sus/jos/stânga/dreapta – 2,54 cm;
• fontul recomandat este Times New Roman;
• corpul literelor va avea dimensiunea de 11 puncte;

6
• spațiul dintre rânduri va avea dimensiunea de 1 rând și jumătate (1,5);
• indentarea unui paragraf se va face cu 1,27 cm;
• textul paragrafelor trebuie să fie aliniat în mod echilibrat stânga -dreapta (în eng. – justify );
• paginile trebuie să fie nu merotate conform acestui șablon.
2.5 Formulele matematice
Pentru redactarea formulelor matematice recomandăm utilizarea in strumentului Microsoft Equation
Editor și importul lor (o data terminate) în Microsoft Word .
2.6 Ilustrațiile
2.6.1 Figuri le
Partea grafică a lucrării are o pondere semnificativă în nota finală acordată lucrării candidatului. Se
recomandă prin urmare acordarea unei atenții sporite tehnoredactării figurilor.
Actualizarea Listei Figurilor este obligatorie (procedura este similară cu cea exemplificată în secțiunea
2.6.2 ).
2.6.2 Tabele le
Exemplificăm aici utilizarea tabelor . Pentru fiecare tabelă adăugată lucrării, autorul trebuie să prevadă
și adăugarea unei legende (în eng., Caption ). La final, este recomandată actualizarea listei figurilor.
Pașii necesari pentru actualizarea listei tabelelor sunt:
1. Click dreapta pe Lista T abelelor. Va apărea un meniu similar cu cel din Figura 1.

Figura 1. Selectarea prin click dreapta a opțiunii „Update field”

7

2. Selecta rea opțiunii „Update entire table” conform cu Figura 2.

Figura 2. Actualizarea întregului tabel
3. Verificarea fontului folosit pentru conținutul propriu -zis al Listei Tabelelor și alegerea
fontului Times New Roman în caz de incongruență.
Index Nume utilizator Valoarea rezumat a parolei (folosind SHA1)
1 dpopescu 8fb9e6763269ae7cba85f02668c3c32041bf00ed
2 eganea 3b42ba8a586dd1589e949c28c9cf2810f7d65bb4
3 mmarian bfc01d16d1944f3b6caba515556713f4aeeb2d0b
Tabelul 1. Nume de utilizatori și valorile rezumat ale parolelor acestora
În interiorul lucrării, tabelul poate fi citat folosind eticheta și numărul de ordine ale sale precum în
exemplul acesta (vezi Tabelul 1).
2.6.3 Legenda (unei figuri/tabele)
În cele doua secți uni de mai sus s -au demonstrat două modele de legende atașate fiecărei tabele sau
figuri. Microsoft Word permite modificarea, respectiv adăugarea de etichete noi corespunzătoare unui
anumit tip de leg endă.

8
3 TERMENI DE UTILIZARE
3.1 Autor ii
Acest șablon de document a fost creat de colectivul Facultății de Automatică, Calculatoare și
Electronică pentru uniformizarea structurii proiectelor de diplomă ale studenților săi .
3.2 Licența de utilizare
Nu există restricții de utilizare. Documentul nu este constrâns de nicio licență.

9
4 CONCLUZII
Autorul prezintă concluziile sale…

10
5 BIBLIOGRAFIE
Bibliografia va fi ordonată alfabetic dupa eticheta fiecărei element (de ex. DOOM05 î n lista
de mai jos este o etichetă). Etichetele materialelor consultate vor fi formatate folosind:
• primele litere ale primului autor urmate de cele două cifre semnificative ale anului
apariției materialului, sau
• dintr -un acronim popular al lucrării respect ive, urmat din nou de cele două cifre
semnificative ale anului apariției.

[DOOM05] – Dicționarul ortografic, ortoepic și morfologic al limbii române , Editura
Univers Enciclopedic, București, 2005

11
6 REFERINȚE WEB
Recomandăm și aici respectarea regulilor enunțate pentru secțiunea 5.

[Alm08] – Pedro de Almeida, Patrik F uhrer, Documentation Guidelines for Diploma and
Master Th esis, Universitatea din Fribourg, Elveția, 2008, disponibil on -line la adresa
http://diuf.unifr.ch/drupal/softeng/teaching/guidelines

[Olt07] – Th. Olteanu, C. Albu, Ghid pentru redactarea lucrării de diplomă sau a disertației
de masterat , Universitatea Română de Arte și Științe „Gheorghe Cristea”, 2007, disponibil
via web la adresa http://www.ugc.ro/tpl/GHID REDACTARE DIPLOMA LICENTA.pdf

12
A. CODUL SURSĂ
#include <Adafruit_NeoPixel.h>
#define nonLinearLogAudio
#define led_2_rings_24
const int useSensorValues = true;
int leftPin = A0, rightPin = A1;
int brightnessPin = A4, sensitivityPin = A5;
int leftStripPin = 5;
int rightStripPin = 6;
int showPeaksPin = 7;
int showPeaksMomentarySwitch = false;
int reverseShowPeaks = tru e;
int selectButton1Pin = 8;
int useSelectButton1 = true;
int selectButton2Pin = 9;
int useSelectButton2 = true;
#elif defined (led_2_rings_24)
int stripNumOfLeds = 48;
int stripsOn2Pins = false;
uint32_t stripColor[25];
int displayMiddleLed = false;
int splitStrip = true;
int middleOffset = 0;
int startupAnimationDelay = 5;
int orangeLimitAmount = 0;
int swapLeftRight = false;
int dropDelay = 2;
float dropFactor = .96;
int peakTimeNoDropDelay = 250;
int peakTimeFirstDropDelay = 100;
int peakTimeDropDelay = 10;
float peakDropFac tor = .94;
int droppingPeakFade = false;
int bouncingPeaksNumOfLeds = 4;
int bouncingPeaksNumOfLedsMin = 2;
int bouncingPeakDelay = 4;
int bouncingPeakCounterInc = 9;
int pulsing = true;
int spinCircle = tru e;
int animType = 0;
int colorScheme = 10;

int maxColorScheme = 12;
int colorScheme11SpinDelay = stripNumOfLeds / 4 ;
int colorScheme12Factor = 3;
int minValue = 10;
int sensitivityValue = 110;

13

#ifdef highLevelInput
int maxValue = 700;
int maxSensitivity = 2 * 255;
#else
int maxValue = 300;
int maxSensitivity = 4 * 255;
#endif
int ledBrightness = 30;
int sensorDeviationBrightness = 3;
int overflowDelay = 10;
int displayPeaks = false;
int displayTopAsPeak = true;
int droppingPeak = true;
int bouncingPeaks = false;
int dynamicBouncingPeaks = false;
int numOfSegments, halfNumOfSegments, stripMiddle, maxDisplaySegments;
float sensitivityFactor;
float nonLinearRes ponseFactor;
int brightnessValue, prevBrightnessValue;
float ledFactor, ledFactor_div_numOfSegments;
uint32_t stripMiddleColor, stripOverflowColor, stripHoldColor;
uint32_t colorValue;
int leftValue = 0, rightValue = 0, maxReadValue = 0;
int leftValueN = 0 , rightValueN = 0;
int leftAnalogValue = 0, rightAnalogValue = 0;
float log10MaxDisplaySegments;
int prevLeftValue = 0, prevRightValue = 0;
int prevLeftAnalogValue = 0, prevRightAnalogValue = 0;
int selectButton1PinState = 0, prevSelectButton1PinState = 0;
int selectButton2PinState = 0, prevSelectButton2PinState = 0;
int selectButton1PinSetting = colorScheme;
int selectButton2PinSetting = 0;
int i, j;
int dropLeft, dropRight;
int leftDropTime, rightDropTime;
int leftPeak = 0, rightPeak = 0;
int leftPeakTime = 0, rightPeakTime = 0;
int leftFirstPeak = true, rightFirstPeak = true;
int showPeaksPinSetting, prevShowPeaksPinSetting;
int stripPulseMiddle = 0;
int halfLeftValue, halfRightValue, halfPrevLeftValue, halfPrevRightValue;
int leftPeakBouncing = false, rightPeakBouncing = false;
int leftPeakBounce = 0, rightPeakBounce = 0;
int prevLeftPeakBounce = 0, prevRightPeakBounce = 0;
int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0;
int leftPeakBounceDelayCounter = 0, rightPeakBounceDelayCounte r = 0;
int leftBouncingPeaksNumOfLeds = 0, rightBouncingPeaksNumOfLeds = 0;

14
float bounceFactor;
int colorScheme11SpinValue = 0, colorScheme11SpinDelayValue = 0;
int colorSchemeFactor = 1;
long selectButton1Timer;
int spinDelayCounter = 0, spinCounter = 0, spinTurnsCounter = 0, spinTurnsMax = 0,
spinTurnsDelay = 0, spinTurnsDelayMax = 0;
int spinCounterInc = 1;
int spinDelay = 0;
Adafruit_NeoPixel left_strip = Adafruit_NeoPixel(stripNumOfLeds, leftStripPin, NEO_GRB
+ NEO_KHZ800);
Adafruit_NeoPixel right_strip = Adafruit_NeoPixel(stripNumOfLeds, rightStripPin,
NEO_GRB + NEO_KHZ800);
void setup() {
#ifdef DEBUG
Serial.begin(9600);
#endif
randomSeed(analogRead(2));
if (stripsOn2Pins) {
numOfSegments = stripNumOfLeds;
maxDisplaySegments = numOfSegments – 1;
stripMiddle = stripNumOfLeds;
stripPulseMiddle = stripMiddle / 2;
spinCircle = false;
}
else {
numOfSegments = stripNumOfLeds / 2;
stripMiddle = stripNu mOfLeds / 2;
maxDisplaySegments = stripMiddle – 1;

stripPulseMiddle = stripMiddle / 2;
}
halfNumOfSegments = numOfSegments / 2;
bounceFactor = (float) bouncingPeaksNumOfLeds / (maxDisplaySegments –
bouncingPeaksNumOfLeds);
nonLinearRespon seFactor = 90 / (float) maxDisplaySegments;
log10MaxDisplaySegments = log10(maxDisplaySegments);
pinMode(showPeaksPin, INPUT);
if (useSelectButton1)
pinMode(selectButton1Pin, INPUT);
left_strip.begin();
if (stripsOn2Pins)
right_str ip.begin();
if (useSensorValues) {
readSensorValues();
setInitialDisplayPeaks();
}
else {
setStripColors();

15
setSensitivityFactor();
}
#ifdef DEBUG_TEST_LEDS
displayTest();
#endif
startupAnimation();
}
void loop() {
#ifdef DEBUG_PRINT_LOOP_TIME
long time = millis();
#endif
if (useSensorValues)
readSensorValues();
readValues();
#if defined (DEBUG_NO_PEAKS)
displayPeaks = false;
#endif
#if defined (DEBUG_PEAKS)
displayPeaks = true;
#endif
if (pulsing) {
drawPulsingValues();
}
else {
drawValues();
if (displayPeaks) {
getPeaks();
drawPeaks();
}
}
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
storePrevValues();
checkSpinCircle();
#ifdef DEBUG_PRINT_LOOP_TIME
time = millis() – time;
Serial.println(time);
#endif
}
void setInitialDisplayPeaks() {
#if !defined (DEBUG_NO_PEAK_SWITCH)
showPeaksPinSetting = digitalRead(showPeaksPin);
if (showPeaksPinSetting == HIGH)
displayPeaks = false;
#endif
if (reverseShowPeaks) {
if (!displayPeaks)

16
displayPeaks = true;
else
displayPeaks = false;
}

prevShowPeaksPinSetting = show PeaksPinSetting;
}
void readSensorValues() {
#if !defined (DEBUG_NO_PEAK_SWITCH)
showPeaksPinSetting = digitalRead(showPeaksPin);
if (showPeaksMomentarySwitch) {
if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
if (displayPeaks == true) {
displayPeaks = false;
clearLeftPeak();
clearRightPeak();
if (showPeaksMomentarySwitch)
while (digitalRead(showPeaksPin) == LOW) {}
}
else {
displayPeaks = true;
}
}
}
else {
if (reverseShowPeaks) {
if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW)
displayPeaks = true;
else if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
displayPeaks = false;
clearLeftPeak();
clearRightPeak();
}
}
else {
if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH)
displayPeaks = true;
else if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) {
displayPeaks = false;
clearLeftPeak();
clearRightPeak();
}
}
}
if (pulsing) {
if (displayPeaks)
displayTopAsPeak = true;
else

17
displayTopAsPeak = false;
}

prevShowPeaksPinSetting = showPeaksPinSetting;
#endif
if (useSelectB utton1) {
selectButton1PinState = digitalRead(selectButton1Pin);

if (selectButton1PinState == HIGH && prevSelectButton1PinState == LOW)
selectButton1Timer = millis();

if (selectButton1PinState == HIGH && prevSelectButton1PinState == HIGH) {
if ((millis() – selectButton1Timer) > 1000) {
pulsing = !pulsing;
setStripColors();
displayNumber(colorScheme, 250);

while (digitalRead(selectButton1Pin) == HIGH) {}
selectButton1PinState = LOW;
clearValues();
}
}
else if (selectButton1PinState == LOW && prevSelectButton1PinState == HIGH) {
selectButton1PinSetting++;
if (selectButton1PinSetting > maxColorScheme) {
selectButton1PinSetting = 0;
}
colorScheme = selectButton1PinSetting;
if (colorScheme == 12)
colorScheme11SpinValue = (colorScheme11SpinValue * colorScheme12Factor);
setStr ipColors();
displayNumber(colorScheme, 250);
}
prevSelectButton1PinState = selectButton1PinState;
}
if (useSelectButton2) {
selectButton2PinState = digitalRead(selectButton2Pin);
if (selectButton2PinState == HIGH && prevSelectButt on2PinState == LOW) {
selectButton2PinSetting++;
switch(selectButton2PinSetting) {
case 0:
case 3: {
pulsing = false;
spinCircle = false;
selectButton2PinSetting = 0;
break;
}
case 1: {

18
pulsing = true;
spinCircle= false;
break;
}
case 2: {
pulsing = true;
spinCircle = true;
break;
}
}
setStripColors();
displayNumber(colorScheme, 250);
}
prevSelectButton2PinState = selectButton2PinState;
}
brightnessValue = analogRead(brightnessPin);
brightnessValue = map(brightnessValue, 0, 1023, 0, 255);

if (abs(brightnes sValue – prevBrightnessValue) > sensorDeviationBrightness) {
ledBrightness = brightnessValue;
setStripColors();
prevBrightnessValue = brightnessValue;
}
if (colorScheme == 11 || colorScheme == 12) {
colorScheme11SpinDelayValue++;
if (colorScheme11SpinDelayValue == colorScheme11SpinDelay) {
colorScheme11SpinDelayValue = 0;
colorScheme11SpinValue++;
if (colorScheme11SpinValue > maxDisplaySegments * colorSchemeFactor)
colorScheme11SpinValue = 0;
setStripColors();
}
}
sensitivityValue = analogRead(sensitivityPin);
sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255);
setSensitivityFactor();
}

void setSensitivityFactor() {
sensitivityFactor = ((float) sensitivityValue / 255 * (float) maxSensitivity / 255);
}
void readValues() {
#ifdef averageReadings
leftAnalogValue = 0;
rightAnalogValue = 0;
for (i = 0; i <= averageNumOfReadings; i++) {
leftAnalogValue += analogRead(leftPin);
rightAnalogValue += analogRead(rightPin);

19
}
leftAnalogValue /= averageNumOfReadings;
rightAnalogValue /= averageNumOfReadings;
#else
leftAnalogValu e = analogRead(leftPin);
rightAnalogValue = analogRead(rightPin);
#endif
if (swapLeftRight) {
int tempValue = leftAnalogValue;
leftAnalogValue = rightAnalogValue;
rightAnalogValue = tempValue;
}
if (leftAnalogValue < prevLeftAnalogValue) {
leftDropTime++;
if (leftDropTime > dropDelay) {
leftAnalogValue = prevLeftAnalogValue * dropFactor;
leftDropTime = 0;
}
else
leftAnalogValue = prevLeftAnalogValue;
}
if (rightAnalogValue < prevRightAnalogValue) {
rightDropTime++;
if (rightDropTime > dropDelay) {
rightAnalogValue = prevRightAnalogValue * dropFactor;
rightDropTime = 0;
}
else
rightAnalogValue = prevRightAnalogValue;
}

#ifdef DEBUG_PRINT_ANALOGVALUES
Serial.print(leftAnalogValue);
Serial.print(" ");
Serial.println(rightAnalogValue);
#endif
leftValue = map(leftAnalogValue * sensitivityFactor, minValue, maxValue, 0,
maxDisplaySegments);
rightValue = map(rightAnalogValue * sensitivityFactor, minValue, maxValue, 0,
maxDisplaySegments);
boolean flagNonLinear = false;
#if defined (nonLinea rSinAudio)
flagNonLinear = true;
leftValueN = ((sin(((leftValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) *
maxDisplaySegments);
rightValueN = ((sin(((rightValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) *
maxDisplaySegments );
#elif defined (nonLinearReverseSinAudio)

20
flagNonLinear = true;
leftValueN = ((sin(((leftValue * nonLinearResponseFactor)) * 0.0174533)) *
maxDisplaySegments);
rightValueN = ((sin(((rightValue * nonLinearResponseFactor)) * 0.0174533)) *
maxDisplaySegments);
#elif defined (nonLinearLogAudio)
flagNonLinear = true;
leftValueN = ((log10(leftValue + 1) / log10MaxDisplaySegments *
maxDisplaySegments));
rightValueN = ((log10(rightValue + 1) / log10MaxDisplaySegments *
maxDisplaySegm ents));
#endif
if (flagNonLinear == true) {
#if defined (nonLinearAvr2)
leftValue = (leftValue + leftValueN) / 2;
rightValue = (rightValue + rightValueN) / 2;
#else
leftValue = leftValueN;
rightValue = rightValueN;
#endif
}
#ifdef displayOverflow
#ifdef compressOverflowPeaks
for (i = 1; i <= compressOverflowNumOfTimes; i++) {
if (leftValue > maxDisplaySegments) {
leftValue = leftValue – leftValue * compressOverflowFactor * i;
}
}
#endif
#endif
if (leftValue > maxDisplaySegments) {
leftValue = maxDisplaySegments;
#ifdef displayOverflow
drawOverflow();
#endif
}
#ifdef displayOverflow
#ifdef compressOverflowPeaks
if (rightValue > maxDisplaySegments)
rightValue = rightValue – rightValue * compressOverflowFactor;
#endif
#endif
if (rightValue > maxDisplaySegments) {
rightValue = maxD isplaySegments;
#ifdef displayOverflow
drawOverflow();
#endif
}

21
}
void storePrevValues() {
prevLeftAnalogValue = leftAnalogValue;
prevRightAnalogValue = rightAnalogValue;
prevLeftValue = leftValue;
prevRightValue = rightValue;
}
void getPeaks() {
if (leftValue > leftPeak) {
if (dynamicBouncingPeaks || prevLeftPeakBounce > 0)
clearLeftBouncePeak();
leftPeak = leftValue;
leftPeakTime = 0;
leftFirstPeak = true;
if (bouncingPeaks) {
leftPeakBouncing = true;
leftPeakBounceCounter = 0;
leftPeakBounceDelayCounter = 0;
if (dynamicBouncingPeaks)
leftBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (leftPeak *
bounceFactor));
else
leftBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
}
}
else {
leftPeakTime++;
if (droppingPeak) {
if (leftFirstPeak) {
if (leftPeakTime > peakTimeFirstDropDelay) {
clearLeftPeak();
leftF irstPeak = false;
}
}
else {
if (leftPeakTime > peakTimeDropDelay) {
clearLeftPeak();
}
}
}
else {
if (leftPeakTime > peakTimeNoDropDelay) {
clearLeftPeak();
}
}
}
if (leftPeakBouncing) {
if (leftFirstPeak) {

22
leftPeakBounceDelayCounter++;
if (leftPeakBounceDelayCounter >= bouncingPeakDelay) {
leftPeakBounceDelayCounter = 0;
leftPeakBounceCounter += bouncingPeakCounterInc;
if (leftPeakBounceCounter >= 180) {
clearLeftBouncePeak();
clearLeftBounce();
}
else {
leftPeakBounce = min((sin(leftPeakBounceCounter * 0.0174533) *
leftBouncingPeaksNumOfLeds), (maxDisplaySegments – leftPeak));
if (leftPeakBounce != prevLeftPeakBounce) {
clearLeftBouncePeak();
}
prevLeftPeakBounce = leftPeakBounce;
}
}
}
}
if (rightValue > rightPeak) {
if (dynamicBouncingPeaks || prevRightPeakBounce > 0)
clearRightBouncePeak();
rightPeak = rightValue;
rightPeakTime = 0;
rightFirstPeak = true;
if (bouncingPeaks) {
rightPeakBouncing = true;
rightPeakBounceCounter = 0;
rightPeakBounceDelayCounter = 0;
if (dynamicBouncingPeaks)
rightBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (rightPeak *
bounceFactor));
else
rightBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
}
}
else {
rightPeakTime++;
if (droppingPeak) {
if (rightFirstPeak) {
if (rightPeakTime > peakTimeFirstDropDelay) {
clearRightPeak();
rightFirstPeak = false;
}
}
else {
if (rightPeakTime > pea kTimeDropDelay)
clearRightPeak();

23
}
}
else {
if (rightPeakTime > peakTimeNoDropDelay)
clearRightPeak();
}
}
if (rightPeakBouncing) {
if (rightFirstPeak) {
rightPeakBounceDelayCounter++;
if (rightPeakBounceDelayCounter >= bouncingPeakDelay) {
rightPeakBounceDelayCounter = 0;
rightPeakBounceCounter += bouncingPeakCounterInc;
if (rightPeakBounceCounter >= 180) {
clearRightBouncePeak();
clearRightBounce();
}
else {
rightPeakBounce = min((sin(rightPeakBounceCounter * 0.0174533) *
rightBouncingPeaksNumOfLeds), (maxDisplaySegments – rightPeak));
if (right PeakBounce != prevRightPeakBounce) {
clearRightBouncePeak();
}
prevRightPeakBounce = rightPeakBounce;
}
}
}
}
}
void checkSpinCircle () {
if (spinCircle) {
if (spinTurnsMax == 0) {
spinTurnsMax = random(stripNumOfLeds / 4, stripNumOfLeds * 3);
if (random(10) > 4)
spinCounterInc = -spinCounterInc;
spinTurnsDelayMax = random(100, 1000);
spinDelay = random(20, 75);
}
if (spinTurnsCounter == spinTurnsMax) {
spinTurnsDelay++;
if (spinTurnsDelay == spinTurnsDelayMax) {
spinTurnsDelay = 0;
spinTurnsCounter = 0;
spinTurnsMax = 0;
}
}
else {
spinDelayCounter++;

24
if (spinDelayCounter > spinDelay) {
clearZeroAndPeaks();
spinCounter += spinCounterInc;
if (spinCounter > stripNumOfLeds)
spinCounter = 0;
else if (spinCounter < 0)
spinCounter = stripNumOfLeds;
spinTurnsCounter++;
spinDelayCounter = 0;
}
}
}
}
int getSpinCircleValue(int value) {
if (!spinCircle)
return value;
else {
int calcValue = value + spinCounter;
if (calcValue >= stripNumOfLeds)
calcValue -= stripNumOfLeds;
return calcValue;
}
}
void drawValues() {
if (splitStrip) {
for (i = middleOffset; i < leftValue; i++)
left_strip.setPixelColor(getSpinCircleValue(i), stripColor[i]);
if (!displayPeaks && displayTopAsPeak)
left_strip.setPixelColor(getSpinCircleValue(leftValue), stripHoldColor);
for (i = prevLeftValue; i >= leftValue; i –)
left_strip.setPixelColor(getSpinCircleValue(i), 0);
if (stripsOn2Pins) {
for (i = middleOffset; i < rightValue; i++)
right_strip.setPixelColor(i, stripColor[i]);
if (!displayPeaks && displayTopAsPeak)
right_strip.setPixelColor(rightValue, stripHoldColor);
for (i = prevRightValue; i >= rightValu e; i–)
right_strip.setPixelColor(i, 0);
}
else {
for (i = middleOffset; i < rightValue; i++)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);
if (!displayPeaks && displayTopAsPeak)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightValue), stripHoldColor);
for (i = prevRightValue ; i >= rightValue; i –)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
}
}

25
else {
for (i = middleOffset; i < leftValue; i++)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);
if (!displayPeaks && displayTopAsPeak)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + leftValue), stripHoldColor);
for (i = prevLeftValue; i >= leftValue; i –)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
for (i = middleOffset; i < rightValue; i++)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – i), stripColor[i]);
if (!displayPeaks && displayTopAsPeak)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – rightValue), stripHoldCo lor);
for (i = prevRightValue; i >= rightValue; i –)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – i), 0);
}
if (displayMiddleLed)
left_strip.setPixelColor(getSpinCircleValue(stripMiddle), stripMiddleColor);
}
void drawPulsingValues() {
halfLeftValue = (leftValue + 1) / 2;
halfRightValue = (rightValue + 1) / 2;
halfPrevLeftValue = (prevLeftValue + 1)/ 2;
halfPrevRightValue = (prevRightValue + 1) / 2;
if (splitStrip) {
for (i = 0; i < halfLeftValue; i++) {
colorValue = stripColor[i * 2];
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), colorValue);
left_strip.set PixelColor(getSpinCircleValue(stripPulseMiddle – i), colorValue);
}
if (displayTopAsPeak) {
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue),
stripHoldColor);
left_strip.setPixelColor(getSpinCircleValue(stri pPulseMiddle – halfLeftValue),
stripHoldColor);
}
for (i = halfPrevLeftValue; i >= halfLeftValue; i –) {
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), 0);
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle – i), 0);
}
if (stripsOn2Pins) {
for (i = 0; i < halfRightValue; i++) {
colorValue = stripColor[i * 2];
right_strip.setPixelColor((stripPulseMiddle + i), colorValue);
right_strip.setPixelColor((stripPulseMiddle – i), colorValue);
}
if (displayTopAsPeak) {
right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfRightValue),
stripHoldColor);

26
right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle – halfRightValue),
stripHoldC olor);
}
for (i = halfPrevRightValue; i >= halfRightValue; i –) {
right_strip.setPixelColor((stripPulseMiddle + i), 0);
right_strip.setPixelColor((stripPulseMiddle – i), 0);
}
}
else {
for (i = 0; i < halfRightValue; i++) {
colorValue = colorValue = stripColor[i * 2];
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i),
colorValue);
left_strip.setPixelColor(getSpinCircleValue(stri pMiddle + stripPulseMiddle – i),
colorValue);
}
if (displayTopAsPeak) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle +
halfRightValue), stripHoldColor);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle –
halfRightValue), stripHoldColor);
}
for (i = halfPrevRightValue; i >= halfRightValue; i –) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle – i), 0);
}
}
}
else {
for (i = 0; i < halfLeftValue; i++) {
colorValue = colorValue = stripColor[i * 2];
left_strip .setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i),
colorValue);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle – i),
colorValue);
}
if (displayTopAsPeak) {
left_strip.setPixelColor(getSpin CircleValue(stripMiddle + stripPulseMiddle +
halfLeftValue), stripHoldColor);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle –
halfLeftValue), stripHoldColor);
}
for (i = halfPrevLeftValue; i >= halfLeftValue; i –) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle – i), 0);
}
for (i = 0; i < halfRightValue; i++) {
colorValue = colorValue = stripColor[i * 2];

27
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle + i)),
colorValue);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle – i)),
colorValue);
}
if (displayTopAsPeak) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle +
halfRightValue)), stripHoldColor);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle –
halfRightValue)), stripHoldColor);
}

for (i = halfPrevRightValue; i >= halfRightValue; i –) {
left_strip.setPixelColo r(getSpinCircleValue(stripMiddle – (stripPulseMiddle + i)), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle – i)), 0);
}
}
if (displayMiddleLed) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – stripPulseMiddle),
stripMiddleColor);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle),
stripMiddleColor);
}
}
void clearZeroAndPeaks() {
left_strip.setPixelColor(getSpinCircleValue(middleOffset), 0);
left_strip.setPixel Color(getSpinCircleValue(stripMiddle), 0);
if (displayTopAsPeak) {
if (splitStrip) {
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), 0);
left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle – halfLeftValue), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle +
halfRightValue), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle –
halfRightValue), 0);
}
else {
left_strip.setPixelColor( getSpinCircleValue(stripMiddle + stripPulseMiddle +
halfLeftValue), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle –
halfLeftValue), 0);

left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddl e +
halfRightValue)), 0);
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (stripPulseMiddle –
halfRightValue)), 0);
}
}

28
}

void drawPeaks() {
if (leftPeak > 0) {
if (droppingPeakFade && leftPeakBouncing == false)
stripHo ldColor = left_strip.Color(max(1, (255 * leftPeak *
ledFactor_div_numOfSegments)), 0, 0);
else
stripHoldColor = stripColor[numOfSegments];
if (splitStrip)
left_strip.setPixelColor(getSpinCircleValue(leftPeak + leftPeakBounce), stripHold Color);
else
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + leftPeakBounce)),
stripHoldColor);
}
if (rightPeak > 0) {
if (droppingPeakFade && rightPeakBouncing == false)
stripHoldColor = left_strip.Color(max( 1, (255 * rightPeak *
ledFactor_div_numOfSegments)), 0, 0);
else
stripHoldColor = stripColor[numOfSegments];
if (splitStrip) {
if (stripsOn2Pins) {
right_strip.setPixelColor(getSpinCircleValue(rightPeak + rightPeakBounce),
stripHoldColor);
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak +
rightPeakBounce), stripHoldColor);
}
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (rightPeak +
rightPeakBounce)), stripHoldColor);
}
}
}

void clearLeftPeak() {
if (splitStrip)
left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
else
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak +
prevLeftPeakBounce)), 0);
if (droppingPeak)
leftPeak = leftPeak * peakDropFactor;
else
leftPeak = 0;

29
leftPeakTime = 0;
}
void clearRightPeak() {
if (splitStrip ) {
if( stripsOn2Pins) {
right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak +
prevRightPeakBounce), 0);
}
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (rightPeak +
prevRightPeakBounce)), 0);
}

if (droppingPeak)
rightPeak = rightPeak * peakDropFactor;
else
rightPeak = 0;
rightPeakTime = 0;
}
void clearLeftBouncePeak() {
if (splitStrip)
left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
else
left_strip.setPixelColor(g etSpinCircleValue(stripMiddle + (leftPeak +
prevLeftPeakBounce)), 0);
}
void clearRightBouncePeak() {
if (splitStrip) {
if (stripsOn2Pins) {
right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
}
else {
left_strip.setPixelColor(getSpinCircleValue((stripMiddle + rightPeak +
prevRightPeakBounce)), 0);
}
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – (rightPeak +
prevRightPeakBounce)), 0);
}
}
void clearLeftBounce() {
leftPeakBouncing = false;
leftPeakBounceCounter = 0;

30
leftPeakBounce = 0;
prevLeftPeakBounce = 0;
leftBouncingPeaksNumOfLeds = 0;
}
void clearRightBounce() {
rightPeakBouncing = false;
rightPeakBounceCounter = 0;
rightPeakBounce = 0;
prevRightPeakBounce = 0;
leftBouncingPeaksNumOfLeds = 0;
}
void clearValues() {
leftAnalogValue = 0;
rightAnalogValue = 0;
prevLeftAnalogValue = 0;
prevRightAnalogValue = 0;
leftPeak = 0;
rightPeak = 0;
}
void drawOverflow() {
for (i = 0; i <= numOfSegments; i++) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – i), stripOverflowColor);
if (stripsOn2Pins) {
right_strip.setPixelColor(i, stripOverflowColor);
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), str ipOverflowColor);
}
}
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
delay(overflowDelay);
for (i = 0; i <= numOfSegments; i++) {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle – i), 0);
if (stripsOn2Pins) {
right_strip.setPixelColor(i, 0);
}
else {
left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
}
}
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
}
void setStripColors() {
int r, g, b;

31
int p1, p2;
ledFactor = (float) ledBrightness / 255;
ledFactor_div_numOfSegments = (float) ledFactor / (float) numOfSegments;
stripMiddleColor = left_strip.Color(0, 0, 255 * ledFactor);
switch (colorScheme) {
case 0: {
int orangeLimit;
float orangeFactor = orangeLimitAmount / halfNumOfSegments;
for (i = 0; i <= numOfSegments; i++) {
if (i <= halfNumOfSegments)
orangeLimit = (i * orangeFactor);
else
orangeLimit = ((numOfSegments – i) * orangeFactor);
stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 –
orangeLimit) * (numOfSegments – i) * ledFactor_div_numOfSegments), 0);
}
break;
}
case 1: {
for (i = 0; i <= numOfSegments; i++) {
stripColor[i] = left_strip.Color(0, (255 * i * ledFactor_div_numOfSegments), (255 *
(numOfSegments – i) * ledFactor_div_numOfSegments));
}
break;
}
case 2: {
for (i = 0; i <= n umOfSegments; i++) {
stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), 0, (255 *
(numOfSegments – i) * ledFactor_div_numOfSegments));
}
break;
}
case 3: {
for (i = 0; i <= numOfSegments; i++) {
stripColor[i] = left_strip.Color((255 * (numOfSegments – i) *
ledFactor_div_numOfSegments), 0, (255 * i * ledFactor_div_numOfSegments));
}
break;
}
case 4: {
for (i = 0; i <= numOfSegments; i++) {
stripColor[i] = left_strip.Color(0, (255 * (numOfSegments – i) *
ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments));
}
break;
}
case 5: {
for (i = 0; i <= numOfSegments; i++) {

32
stripColor[i] = left_strip.Color((255 * (numOfSegments – i) *
ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments), 0);
}
break;
}
case 6: {
for (i = 0; i <= numOfSegments; i++) {
r = (255 * i * l edFactor_div_numOfSegments);
g = (255 * min(i, numOfSegments – i) * ledFactor_div_numOfSegments);
b = (200 * (numOfSegments – i) * ledFactor_div_numOfSegments);
stripColor[i] = left_strip.Color(r, g, b);
}
break;
}
case 7: {
for (i = 0; i <= numOfSegments; i++) {
b = (255 * i * ledFactor_div_numOfSegments);
g = (255 * min(i, numOfSegments – i) * ledFactor_div_numOfSegments);
r = (255 * (numOfSegments – i) * ledFactor_div_numOfSegments);
stripColor[i] = left_strip.Color(r, g, b);
}
break;
}
case 8: {
for (i = 0; i <= numOfSegments; i++) {
r = (255 * i * ledFactor_div_numOfSegm ents);
b = (255 * min(i, numOfSegments – i) * ledFactor_div_numOfSegments);
g = (255 * (numOfSegments – i) * ledFactor_div_numOfSegments);
stripColor[i] = left_strip.Color(r, g, b);
}
break;
}
case 9: {
for (i = 0; i <= numOfSegments; i++) {
b = (255 * i * ledFactor_div_numOfSegments);
r = (255 * min(i, numOfSegments – i) * ledFactor_div_numOfSegments);
g = (255 * (numOfSegments – i) * ledFactor_div_numOfSegments);
stripCol or[i] = left_strip.Color(r, g, b);
}
break;
}
case 10:
colorScheme11SpinValue = 0;
case 11:
case 12: {
p1 = (85 * numOfSegments / 255);
p2 = (170 * numOfSegments / 255);
int wheel;

33
if (colorScheme == 12)
colorSchemeFactor = colorScheme12Factor;
else
colorSchemeFactor = 1;
for (i = 0; i <= numOfSegments; i++) {
wheel = int(float(i – colorScheme11SpinValue) / colorSchemeFactor + nu mOfSegments)
% numOfSegments;
if (wheel < p1) {
wheel = map(wheel, 0, p1, 0, 255);
r = (wheel * ledFactor);
g = ((255 – wheel) * ledFactor);
b = 0;
}
else if (wheel < p2) {
wheel = map(wheel, p1, p2, 0, 255);
r = ((255 – wheel) * ledFactor);
g = 0;
b = (wheel * ledFactor);
}
else {
wheel = map(wheel, p2, numOfSegments, 0, 255);
r = 0;
g = (wheel * ledFactor);
b = ((255 – wheel) * ledFactor);
}
stripColor[i] = left_strip.Color(r, g, b);
}
break;
}
}

if (colorScheme >= 10)
stripHoldColor = left_strip.Color(255 * ledFactor, 0, 0); // set to red for the color wheels
else
stripHoldColor = stripColor[numOfSegments];
stripOverflowColor = stripHoldColor; // left_strip.Color(min(255, 255 * ledFactor * 1.5),
0, 0);
}
void startupAnimation() {
for (j = 0; j < 2; j++) {
for (i = 0; i <= numOfSegments; i++) {
if (animType == 1)
left_strip.setPixelColor(stripMiddle – (numOfSegments – i), stripColor[i]);
else
left_strip.setPixelColor(strip Middle – i, stripColor[i]);
if (stripsOn2Pins)
right_strip.setPixelColor(i, stripColor[i]);
else

34
left_strip.setPixelColor(stripMiddle + i, stripColor[i]);
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
delay(startupAnimationDelay);
}
for (i = 0; i <= numOfSegments; i++) {
if (animType == 1)
left_strip.setPixelColor(stripMiddle – (numOfSegments – i), 0);
else
left_strip.setPixelColor( stripMiddle – i, 0);

if (stripsOn2Pins)
right_strip.setPixelColor(i, 0);
else
left_strip.setPixelColor(stripMiddle + i, 0);
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
delay(startupAnimationDelay);
}
}
}
void displayNumber (int number, int displayDelay) {
left_strip.clear();
if (stripsOn2Pins)
right_strip.clear();
number++;
for (i = 0; i <= number; i++) {
if (i % 5 == 0)
colorValue = stripMiddleColor;
else
colorValue = stripColor[0];
left_strip.setPixelColor(middleOffset + i, colorValue);
if (stripsOn2Pins)
right_strip.setPixelColor(middleOffset + i, colorValue);
else
left_strip.setPixelColor(stripMiddle + middleOffset + i, colorValue);
delay(45 – number * 3);
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
}
if (pulsing) {
left_strip.setPixelColor(middleOffset + maxDisplaySegments, stripMiddleColor);
if (stripsOn2Pins)
right_strip.setPixelColor(maxDisplaySegments, stripMiddleColor);
else

35
left_strip.setPixelColor(stripMiddle + maxDisplaySegments, stripMiddleColor);
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
}
delay(displayDelay);
left_strip.clear();
if (stripsOn2Pins)
right_strip.clear();
}
#ifdef DEBUG_TEST_LEDS
void displayTest() {
for (i = 0; i <= numOfSegments; i++) {
left_strip.setPixelColor(stripMiddle – i, stripColor[i]);
if (stripsOn2Pins)
right_strip.setPixelColor(i, stripColor[i]);
else
left_st rip.setPixelColor(stripMiddle + i, stripColor[i]);
left_strip.show();
if (stripsOn2Pins)
right_strip.show();
delay(50);
}
delay(5000);
for (i = 0; i <= numOfSegments; i++) {
left_strip.setPixelColor(stripMiddle – i, 0);
if (stripsOn2Pins)
right_strip.setPixelColor(i, 0);
else
left_strip.setPixelColor(stripMiddle + i, 0);
left_strip.show();
if (stripsOn2Pins)
right_strip.sho w();
}
}
void serialDisplayRGB(int r, int g, int b) {
Serial.print(i);
Serial.print(" ");
Serial.print(r);
Serial.print(" ");
Serial.print(g);
Serial.print(" ");
Serial.println(b);
}
#endif

36

37
B. SITE -UL WEB AL PROIECTULUI
Autorul prezintă în această anexă (opțională) site -ul web asociat proiectului său.

38
C. CD / DVD
Autorul atașează în această anexă obligatorie , versiunea electronică a aplicației, a acestei
lucrări, precum și prezentarea finală a tezei .

39
INDEX
B
Bibliografie ………………………….. ………………………. 9
C
CUPRINSUL ………………………….. …………………… xi
D
Dimensiuni ………………………….. ………………………. 3
F
Figuri ………………………….. ………………………….. ….. 4
Formulele matematice ………………………….. ……….. 4
I
Ilustrațiile ………………………….. …………………………. 4 L
Legenda ………………………….. ………………………….. .. 6
LISTA FIGURILOR ………………………….. ………… xii
LISTA TABELELOR ………………………….. ……… xiii
R
Referințe web ………………………….. ………………….. 10
S
Structura documentului ………………………….. ………. 2
T
Tabele ………………………….. ………………………….. …. 5