Színes, animált kijelzésű hangfrekvenciás spektrum-analizátor - Hobbielektronika.hu

Hobbivasút | HESTORE | Kislexikon

Fórum témák

» Több friss téma

Fórum » Színes, animált kijelzésű hangfrekvenciás spektrum-analizátor

Új kérdés a topikon belül

Színes, animált kijelzésű hangfrekvenciás spektrum-analizátor

Témaindító: dB_Thunder, idő: Márc 3, 2021

Témakörök:

Technika » Fénytechnika
Mikroprocesszorok » Egyéb
Technika » Audiotechnika

(#)	dB_Thunder hozzászólása	Márc 3, 2021		/

Sziasztok!

Direkt szeretnék ennek a projektnek külön témát!
Az alap ötlet PLATINUM által közzétett videókból származik, eldöntöttem nekem is kell egy ilyen!
Mivel a megvalósítás, a fizikai méret, a költségvetés, programok, animációk lehetősége szinte határtalan, én több verziót, kivitelt is összeszedtem. Ezeket majd külön hozzászólásokban felteszem!

A készítő WS2812 led szalaggal, Arduiono Megával, és MSGEQ7 ic-vel építkezett.
Verziótól függően 7, vagy 14 sávos, Led oszlopok magassága a szerző szerint max 20 led lehet, de úgy vettem észre kisebb módosítássokkal több is!

Költségvetés: kb 60e Ft-tól megvehető
A mechanikai kivitelezés költségeit most nem nézem, mert számtalan lehetőség van rá!
Led szalag, magyarországi forrásból a 60LED/m szalag vagy 27ezerFT! Érdemes kínából rendelni.
MSGEQ7, sok a hamisítvány! Rögtön rendeltem az ebay-on 8db hamisat, szerencsére visszafizették az árát!
Egy magyar forrás találtam, nem olcsó, de legalább nem hamis ic-t kaptam!

A hozzászólás módosítva: Márc 3, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Szóval MSGEQ beszerzés: Ardushop
Arduinót is érdemes kínából megvenni, de ez nekem polcon volt.
Használ a projekt még egy frekvencia generátor panelt is, ez is filléres kínában. De ez csak a 14 sávos verzióhoz kell!

A hozzászólás módosítva: Márc 3, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Kezdjük kicsit messzebb a hasonló projektek bemutatását!
Ezek a projektek vagy a FASTLED, vagy a NEOPIXEL lib-at használják a led szalag vezérléséhez, érdemes mind2 letölteni.

Én magam nem próbáltam ki egyik kódját sem, nem túl komoly animációk jellemzik, de a 42 valós sáv érdekesen hangzik!
generatorlabs
Nincs minden dokumentálva, szájba rágva, de a kódok sokat elárulnak!

A több MSGEQ7 ic gyári frekvenciáit, úgy tolják el, hogy megváltoztatják a működésükhöz szükséges órajelet! Erről pontos leírás nincs, csak utalás az adatlapon.

A hozzászólás módosítva: Márc 3, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Egy olasz produkció: 7 sáv, dot és bar kijelzés, igényes kivitelezés!
A programkód a lap alján!
denislanfrit

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Ezt a kódot nem tudom már honnan kukáztam! Igazából nem is spektrum analizátor csak egy színes kivezérlés jelző!!
VU_meter_multicolor_code:

//************
//Sound Level to light show sketch for the
//autogain microphone Amplifier from Adafruit on pin AO
//plus neopixel led functions (pin 6) mapped on to different sound levels to give music to light effects
//
//*************
//lines below set variables for neopixels
#include <Adafruit_NeoPixel.h>
#define NUMBER_PIXEL 12
#define LEDPIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMBER_PIXEL, LEDPIN, NEO_GRB + NEO_KHZ800);
int lng = 100;//long delay
int sht = 50;//short delay
//lines below are for the microphone sampling from Adafruit autogain mic
const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
unsigned int sample;
void setup()
{
strip.begin();//initialises neopixels
strip.setBrightness(255);// set brightness from 0 to max is 255
strip.show();//clears any previous data in the strip
Serial.begin(9600);//set up for checking mic is working
}
void loop()
{
//open void loop
//first run the sound sampling
unsigned long startMillis = millis(); // Start of sample window
unsigned int peakToPeak = 0; // peak-to-peak level
unsigned int signalMax = 0;
unsigned int signalMin = 1024;
// collect data for 50 mS
while (millis() - startMillis < sampleWindow)
{
//open while loop
sample = analogRead(0);
if (sample < 1024) // toss out spurious readings
{
//open 1st if loop in while
if (sample > signalMax)
{
//open 2nd if
signalMax = sample; // save just the max levels
}//close 2nd if
else if (sample < signalMin)
{
//open 3rd if
signalMin = sample; // save just the min levels
}//close 3rd if
}//close 1st if
}//close while loop
peakToPeak = signalMax - signalMin; // max - min = peak-peak amplitude
double volts = (peakToPeak * 3.3) / 1024; // convert to volts
//section below maps the signal from the microphone on to 12 options for LED effects
int sound = (volts * 10);
int soundLevel = map(sound, 1, 10, 0, 11);
Serial.print("The volt level is ");
Serial.println(volts);//for debugging
//next section is a series of 12 (0-11) 'if' statements which trigger different patterns.
//it is a combination of a traditional VU style meter fill of the strip
// combined with randomised animated patterns to keep it interesting
if (soundLevel == 0)
{
//open if 0. When there is silence a rainbow pattern runs
rainbowCycle(3);//from the neopixel library
}//close if 0 statement
if (soundLevel == 1)
{
//open level 1 if statement which contains 4 randomised options
int level1Color = random(1, 4);//choose random number 1 - 4
if (level1Color == 1) //if random no 1 chosen light up pixels 1 and 2 red:
{
strip.setPixelColor(0, 255, 0, 0); // this turns on pixel 1 100% red (range runs 0 - 255) and leaves green and blue off
strip.setPixelColor(1, 255, 0, 0); // - you get the idea
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close red random no. 1
else if (level1Color == 2) //if random no 2 choses show green
{
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close random no. 2 green
else if (level1Color == 3) //run blue
{
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close blue
else if (level1Color == 4) //run yellow
{
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close yellow
}//end of if sound level 1 options
if (soundLevel == 2)
{
//open level 2
int level2Color = random(1, 5);//choose one of 5 options if sound level 2
if (level2Color == 1) //run red mix
{
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level2Color == 2) //run green mix
{
//open option 2
strip.setPixelColor(0, 0, 206, 209);
strip.setPixelColor(1, 0, 206, 209);
strip.setPixelColor(2, 0, 206, 209);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close green
else if (level2Color == 3) //run blue mix
{
//open option 3
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level2Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close yellow
else if (level2Color == 5)//for a bit of variation 1 in 5 of level 2 will show a pattern across whole strip:
{
//open if 5
strip.setPixelColor(0, 200, 75, 109);
strip.setPixelColor(1, 252, 203, 198);
strip.setPixelColor(2, 255, 216, 209);
strip.setPixelColor(3, 253, 215, 130);
strip.setPixelColor(4, 181, 198, 130);
strip.setPixelColor(5, 141, 189, 193);
strip.setPixelColor(6, 177, 217, 242);
strip.setPixelColor(7, 100, 165, 187);
strip.setPixelColor(8, 133, 105, 128);
strip.setPixelColor(9, 140, 166, 95);
strip.setPixelColor(10, 198, 44, 58);
strip.setPixelColor(11, 149, 69, 103);
strip.show();
delay(lng);
strip.setPixelColor(1, 200, 75, 109);
strip.setPixelColor(2, 252, 203, 198);
strip.setPixelColor(3, 255, 216, 209);
strip.setPixelColor(4, 253, 215, 130);
strip.setPixelColor(5, 181, 198, 130);
strip.setPixelColor(6, 141, 189, 193);
strip.setPixelColor(7, 177, 217, 242);
strip.setPixelColor(8, 100, 165, 187);
strip.setPixelColor(9, 133, 105, 128);
strip.setPixelColor(10, 140, 166, 95);
strip.setPixelColor(11, 198, 44, 58);
strip.setPixelColor(0, 149, 69, 103);
strip.show();
delay(lng);
}//close of option 5
}//close level 2
if (soundLevel == 3)
{
//open if sound level 3
int level3Color = random(1, 5);
if (level3Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level3Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 245, 116, 97);
strip.setPixelColor(1, 169, 221, 20);
strip.setPixelColor(2, 245, 116, 97);
strip.setPixelColor(3, 169, 221, 20);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2green
else if (level3Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 169, 221, 199);
strip.setPixelColor(1, 245, 116, 97);
strip.setPixelColor(2, 169, 221, 199);
strip.setPixelColor(3, 245, 116, 97);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level3Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level3Color == 5)
{
//open option 5
strip.setPixelColor(0, 255, 255, 255);
strip.setPixelColor(1, 255, 105, 180);
strip.setPixelColor(2, 255, 255, 255);
strip.setPixelColor(3, 255, 105, 180);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 255, 105, 180);
strip.setPixelColor(6, 255, 255, 255);
strip.setPixelColor(7, 255, 105, 180);
strip.setPixelColor(8, 255, 255, 255);
strip.setPixelColor(9, 255, 105, 180);
strip.setPixelColor(10, 255, 255, 255);
strip.setPixelColor(11, 255, 105, 180);
strip.show();
delay(sht);
}//close of option 5
}//close level 3
if (soundLevel == 4)
{
//open if sound level 4
int level4Color = random(1, 5);
if (level4Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close red
else if (level4Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close green
else if (level4Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 0, 255);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close blue
else if (level4Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close yellow
else if (level4Color == 5)
{
////open option 5
strip.setPixelColor(0, 255, 01, 165);
strip.setPixelColor(1, 255, 187, 218);
strip.setPixelColor(2, 228, 194, 191);
strip.setPixelColor(3, 153, 87, 205);
strip.setPixelColor(4, 176, 284, 218);
strip.setPixelColor(5, 67, 142, 200);
strip.setPixelColor(6, 107, 167, 214);
strip.setPixelColor(7, 168, 204, 232);
strip.setPixelColor(8, 59, 198, 182);
strip.setPixelColor(9, 100, 212, 199);
strip.setPixelColor(10, 164, 231, 223);
strip.setPixelColor(11, 176, 124, 218);
strip.show();
delay(lng);
}//close option 5
}//close if sound level 4
else if (soundLevel == 5)
{
//open if sound level 5
int level5Color = random(1, 6);
if (level5Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 255, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level5Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 255, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green
else if (level5Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 0, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level5Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close yellow
else if (level5Color == 5)
{
//open option 5
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 0, 255);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 0, 255, 0);
strip.setPixelColor(8, 0, 0, 255);
strip.setPixelColor(9, 255, 0, 0);
strip.setPixelColor(10, 0, 255, 0);
strip.setPixelColor(11, 0, 0, 255);
strip.show();
delay(lng);
}//close option 5
else if (level5Color == 6)
{
//open option 6
colorWipe(strip.Color(255, 0, 255), 50); // magenta
colorWipe(strip.Color(0, 255, 0), 50); // green
strip.show();
}//close option 6
}//close if sound level 5
else if (soundLevel == 6)
{
//open if soundlevel 6
int level6Color = random(1, 6);
if (level6Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 255, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1red
else if (level6Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 255, 0);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green
else if (level6Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 0, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 0, 255);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level6Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 148, 0, 211);
strip.setPixelColor(1, 75, 0, 130);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 127, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(sht);
}//close yellow
else if (level6Color == 5)
{
//open option 5
colorWipe(strip.Color(0, 0, 255), 50); // Blue
colorWipe(strip.Color(255, 255, 0), 50); // yellow
strip.show();
}//close option 5
else if (level6Color == 6)
{
//open option6
theaterChase(strip.Color(200, 0, 0), 50); // Red
strip.show();
delay(lng);
}//close option 6
}//close if sound level 6
else if (soundLevel == 7)
{
//open if sound level 7
int level7Color = random(1, 7);
if (level7Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 255, 0, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 255, 0, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level7Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 255, 0);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 255, 0);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 255, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green
else if (level7Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 0, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 0, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 0, 255);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level7Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 255, 255, 0);
strip.setPixelColor(7, 255, 255, 0);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level7Color == 5)
{
//open option 5
colorWipe(strip.Color(255, 20, 147), 50); // pink
colorWipe(strip.Color(0, 206, 209), 50); // turquoise
strip.show();
delay(lng);
}//close option 5
else if (level7Color == 6)
{
//open option 6
theaterChase(strip.Color(255, 20, 100), 50); // Red
strip.show();
delay(sht);
}//close option 6
else if (level7Color == 7)
{
//open option 7
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(1, 0, 100, 0);
strip.setPixelColor(2, 255, 0, 70);
strip.setPixelColor(3, 50, 0, 150);
strip.setPixelColor(4, 0, 70, 70);
strip.setPixelColor(5, 0, 100, 0);
strip.setPixelColor(6, 255, 0, 70);
strip.setPixelColor(7, 50, 0, 150);
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(8, 255, 0, 70);
strip.setPixelColor(9, 0, 100, 0);
strip.setPixelColor(10, 255, 0, 70);
strip.setPixelColor(11, 50, 0, 150);
strip.show();
delay(sht);
}//close option 7
}//close if sound level 7
else if (soundLevel == 8)
{
//open if sound level 8
int level8Color = random(1, 8);
if (level8Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 255, 0, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 255, 0, 0);
strip.setPixelColor(8, 255, 0, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level8Color == 2) //run green/blue
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 255, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green/blue
else if (level8Color == 3) //run turquoise / blue
{
//open option 3
strip.setPixelColor(0, 0, 206, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 206, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 206, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 206, 255);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 206, 255);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level8Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 255, 255, 0);
strip.setPixelColor(7, 255, 255, 0);
strip.setPixelColor(8, 255, 255, 0);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level8Color == 5)
{
//open option 5
colorWipe(strip.Color(255, 20, 147), 20); // pink
colorWipe(strip.Color(0, 206, 209), 20); // turquoise
strip.show();
}//close option 5
else if (level8Color == 6)
{
//open option 6
theaterChase(strip.Color(0, 206, 209), 50); // Red
strip.show();
delay(sht);
}//close option 6
else if (level8Color == 7)
{
//open option 7
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(1, 0, 100, 0);
strip.setPixelColor(2, 255, 0, 70);
strip.setPixelColor(3, 50, 0, 150);
strip.setPixelColor(4, 0, 70, 70);
strip.setPixelColor(5, 0, 100, 0);
strip.setPixelColor(6, 255, 0, 70);
strip.setPixelColor(7, 50, 0, 150);
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(8, 255, 0, 70);
strip.setPixelColor(9, 0, 100, 0);
strip.setPixelColor(10, 255, 0, 70);
strip.setPixelColor(11, 50, 0, 150);
strip.show();
delay(lng);
strip.setPixelColor(0, 0, 255, 255);
strip.setPixelColor(1, 0, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 255, 255);
strip.setPixelColor(7, 0, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 7
}//close if sound level 8
else if (soundLevel == 9)
{
//open if sound level 9
int level9Color = random(1, 8);
if (level9Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 255, 0, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 255, 0, 0);
strip.setPixelColor(8, 255, 0, 0);
strip.setPixelColor(9, 255, 0, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level9Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 255, 0);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green
else if (level9Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 255, 0, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 255, 0, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 255, 0, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 255, 0, 255);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 255, 0, 255);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3blue
else if (level9Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 255, 255, 0);
strip.setPixelColor(7, 255, 255, 0);
strip.setPixelColor(8, 255, 255, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level9Color == 5)
{
//open option 5
colorWipe(strip.Color(255, 255, 255), 60); // white
colorWipe(strip.Color(0, 206, 209), 20); // turquoise
strip.show();
}//close option 5
else if (level9Color == 6)
{
//open option 6
theaterChase(strip.Color(50, 190, 209), 50); // turquise
strip.show();
delay(lng);
}//close option 6
else if (level9Color == 7)
{
//open option 7
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(1, 0, 100, 0);
strip.setPixelColor(2, 255, 0, 70);
strip.setPixelColor(3, 50, 0, 150);
strip.setPixelColor(4, 0, 70, 70);
strip.setPixelColor(5, 0, 100, 0);
strip.setPixelColor(6, 255, 0, 70);
strip.setPixelColor(7, 50, 0, 150);
strip.setPixelColor(8, 255, 0, 70);
strip.setPixelColor(9, 0, 100, 0);
strip.setPixelColor(10, 255, 0, 70);
strip.setPixelColor(11, 50, 0, 150);
strip.show();
delay(lng);
strip.setPixelColor(0, 0, 255, 255);
strip.setPixelColor(1, 0, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 255, 255);
strip.setPixelColor(7, 0, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
strip.setPixelColor(0, 255, 50, 50);
strip.setPixelColor(1, 0, 255, 0);
strip.setPixelColor(2, 255, 50, 50);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 50, 50);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 255, 50, 50);
strip.setPixelColor(7, 0, 255, 0);
strip.setPixelColor(8, 255, 50, 50);
strip.setPixelColor(9, 255, 0, 0);
strip.setPixelColor(10, 255, 50, 50);
strip.setPixelColor(11, 0, 0, 255);
strip.show();
delay(lng);
}//close option 7
else if (level9Color == 8)
{
//open option 8
strip.setPixelColor(0, 255, 255, 255);
strip.setPixelColor(1, 0, 0, 0);
strip.setPixelColor(2, 255, 255, 255);
strip.setPixelColor(3, 0, 0, 0);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 255, 255, 255);
strip.setPixelColor(7, 0, 0, 0);
strip.setPixelColor(8, 255, 255, 255);
strip.setPixelColor(9, 0, 0, 0);
strip.setPixelColor(10, 255, 255, 255);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay (lng);
strip.setPixelColor(0, 0, 0, 0);
strip.setPixelColor(1, 255, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 255);
strip.setPixelColor(4, 0, 0, 0);
strip.setPixelColor(5, 255, 255, 255);
strip.setPixelColor(6, 0, 0, 0);
strip.setPixelColor(7, 255, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 255);
strip.setPixelColor(10, 0, 0, 0);
strip.setPixelColor (11, 255, 255, 255);
strip.show();
delay(lng);
}//close option 9
}//close if sound level 9
else if (soundLevel == 10)
{
//open if sound Level 10
int level10Color = random(1, 8);
if (level10Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 255, 0, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 255, 0, 0);
strip.setPixelColor(8, 255, 0, 0);
strip.setPixelColor(9, 255, 0, 0);
strip.setPixelColor(10, 255, 0, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level10Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 255, 0);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 2 green
else if (level10Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 206, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 206, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 206, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 206, 255);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 206, 255);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 206, 255);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 3 blue
else if (level10Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 255, 255, 0);
strip.setPixelColor(7, 255, 255, 0);
strip.setPixelColor(8, 255, 255, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level10Color == 5)
{
//open option 5
colorWipe(strip.Color(200, 40, 147), 50); // pink
colorWipe(strip.Color(0, 206, 209), 20); // turquoise
strip.show();
delay(sht);
}//close option 5
else if (level10Color == 6)
{
//open option 6
theaterChase(strip.Color(0, 206, 209), 50);
strip.show();
delay(sht);
}//close option 6
else if (level10Color == 7)
{
//open option 7
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(1, 0, 100, 0);
strip.setPixelColor(2, 255, 0, 70);
strip.setPixelColor(3, 50, 0, 150);
strip.setPixelColor(4, 0, 70, 70);
strip.setPixelColor(5, 0, 100, 0);
strip.setPixelColor(6, 255, 0, 70);
strip.setPixelColor(7, 50, 0, 150);
strip.setPixelColor(8, 255, 0, 70);
strip.setPixelColor(9, 0, 100, 0);
strip.setPixelColor(10, 255, 0, 70);
strip.setPixelColor(11, 50, 0, 150);
strip.show();
delay(lng);
strip.setPixelColor(0, 0, 255, 255);
strip.setPixelColor(1, 0, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 255, 255);
strip.setPixelColor(7, 0, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
strip.setPixelColor(0, 255, 255, 255);
strip.setPixelColor(1, 255, 255, 255);
strip.setPixelColor(2, 255, 255, 255);
strip.setPixelColor(3, 255, 255, 255);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 255, 255, 255);
strip.setPixelColor(6, 255, 255, 255);
strip.setPixelColor(7, 255, 255, 255);
strip.setPixelColor(8, 255, 255, 255);
strip.setPixelColor(9, 255, 255, 255);
strip.setPixelColor(10, 255, 255, 255);
strip.setPixelColor(11, 255, 255, 255);
strip.show();
delay(sht);
}//close option 7
}//close if sound level 10
else if (soundLevel == 11)
{
//open if sound Level 11
int level11Color = random(1, 8);
if (level11Color == 1) //run red
{
//open option 1
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 255, 0, 0);
strip.setPixelColor(2, 255, 0, 0);
strip.setPixelColor(3, 255, 0, 0);
strip.setPixelColor(4, 255, 0, 0);
strip.setPixelColor(5, 255, 0, 0);
strip.setPixelColor(6, 255, 0, 0);
strip.setPixelColor(7, 255, 0, 0);
strip.setPixelColor(8, 255, 0, 0);
strip.setPixelColor(9, 255, 0, 0);
strip.setPixelColor(10, 255, 0, 0);
strip.setPixelColor(11, 255, 0, 0);
strip.show();
delay(lng);
}//close option 1 red
else if (level11Color == 2) //run green
{
//open option 2
strip.setPixelColor(0, 0, 255, 0);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 255, 0);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 255, 0);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 255, 0);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 255, 0);
strip.setPixelColor(11, 0, 0, 255);
strip.show();
delay(lng);
}//close option 2 green
else if (level11Color == 3) //run blue
{
//open option 3
strip.setPixelColor(0, 0, 206, 255);
strip.setPixelColor(1, 0, 0, 255);
strip.setPixelColor(2, 0, 206, 255);
strip.setPixelColor(3, 0, 0, 255);
strip.setPixelColor(4, 0, 206, 255);
strip.setPixelColor(5, 0, 0, 255);
strip.setPixelColor(6, 0, 206, 255);
strip.setPixelColor(7, 0, 0, 255);
strip.setPixelColor(8, 0, 206, 255);
strip.setPixelColor(9, 0, 0, 255);
strip.setPixelColor(10, 0, 206, 255);
strip.setPixelColor(11, 0, 0, 255);
strip.show();
delay(lng);
}//close option 3 blue
else if (level11Color == 4) //run yellow
{
//open option 4
strip.setPixelColor(0, 255, 255, 0);
strip.setPixelColor(1, 255, 255, 0);
strip.setPixelColor(2, 255, 255, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 255, 255, 0);
strip.setPixelColor(6, 255, 255, 0);
strip.setPixelColor(7, 255, 255, 0);
strip.setPixelColor(8, 255, 255, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 255, 255, 0);
strip.show();
delay(lng);
}//close option 4 yellow
else if (level11Color == 5)
{
//open option 5
colorWipe(strip.Color(0, 40, 255), 50); // pink
colorWipe(strip.Color(0, 209, 206), 20); // turquoise
strip.show();
delay(sht);
}//close option 5
else if (level11Color == 6) //open option 6
{
//open option 6
theaterChase(strip.Color(0, 206, 109), 50);
strip.show();
delay(sht);
}//close option 6
else if (level11Color == 7)//open option 7
{
//open option 7
strip.setPixelColor(0, 0, 70, 70);
strip.setPixelColor(1, 0, 100, 0);
strip.setPixelColor(2, 255, 0, 70);
strip.setPixelColor(3, 50, 0, 150);
strip.setPixelColor(4, 0, 70, 70);
strip.setPixelColor(5, 0, 100, 0);
strip.setPixelColor(6, 255, 0, 70);
strip.setPixelColor(7, 50, 0, 150);
strip.setPixelColor(8, 255, 0, 70);
strip.setPixelColor(9, 0, 100, 0);
strip.setPixelColor(10, 255, 0, 70);
strip.setPixelColor(11, 50, 0, 150);
strip.show();
delay(lng);
strip.setPixelColor(0, 0, 255, 255);
strip.setPixelColor(1, 0, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 255, 255);
strip.setPixelColor(7, 0, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
strip.setPixelColor(0, 255, 255, 255);
strip.setPixelColor(1, 255, 255, 255);
strip.setPixelColor(2, 255, 255, 255);
strip.setPixelColor(3, 255, 255, 255);
strip.setPixelColor(4, 255, 255, 255);
strip.setPixelColor(5, 255, 255, 255);
strip.setPixelColor(6, 255, 255, 255);
strip.setPixelColor(7, 255, 255, 255);
strip.setPixelColor(8, 255, 255, 255);
strip.setPixelColor(9, 255, 255, 255);
strip.setPixelColor(10, 255, 255, 255);
strip.setPixelColor(11, 255, 255, 255);
strip.show();
delay(lng);
strip.setPixelColor(0, 0, 255, 255);
strip.setPixelColor(1, 0, 255, 255);
strip.setPixelColor(2, 0, 0, 0);
strip.setPixelColor(3, 255, 255, 0);
strip.setPixelColor(4, 255, 255, 0);
strip.setPixelColor(5, 0, 0, 0);
strip.setPixelColor(6, 0, 255, 255);
strip.setPixelColor(7, 0, 255, 255);
strip.setPixelColor(8, 0, 0, 0);
strip.setPixelColor(9, 255, 255, 0);
strip.setPixelColor(10, 255, 255, 0);
strip.setPixelColor(11, 0, 0, 0);
strip.show();
delay(lng);
}//close option 7
}//close if sound level 11
}//close void loop()
//neopixel functions below
void colorWipe(uint32_t c, uint8_t wait)
{
//open colowipe
for(uint16_t i = 0; i < strip.numPixels(); i++)
{
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}//close colorWipe function
void theaterChase(uint32_t c, uint8_t wait)
{
//open theaterchase function
for (int j = 0; j < 3; j++) //do 3 cycles of chasing
{
for (int q = 0; q < 3; q++)
{
for (int i = 0; i < strip.numPixels(); i = i + 3)
{
strip.setPixelColor(i + q, c); //turn every third pixel on
}
strip.show();
delay(wait);
for (int i = 0; i < strip.numPixels(); i = i + 3)
{
strip.setPixelColor(i + q, 0); //turn every third pixel off
}
}
}
}//close theater chase function
void rainbowCycle(uint8_t wait) //open rainbow function
{
uint16_t i, j;
for(j = 0; j < 256; j++) // 1 cycles of all colors on wheel
{
for(i = 0; i < strip.numPixels(); i++)
{
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
}
strip.show();
delay(wait);
}
}//close rainbow function
//you need to included the code below for the neopixel functions that use the 'wheel' code:
uint32_t Wheel(byte WheelPos)
{
WheelPos = 255 - WheelPos;
if(WheelPos < 85)
{
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if(WheelPos < 170)
{
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
//end

A hozzászólás módosítva: Márc 4, 2021

Moderátor által szerkesztve

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Itt van még egy 7 sávos kódja, forrás: HeinzKetschup

//https://create.arduino.cc/projecthub/HeinzKetschup/spectrum-analyzer-with-rgb-leds-eb9785
//Arduino Spectrum Analyzer with RGB-LED Stripe and MSGEQ7 by HeinzKetchup
// declarations for the Neopixel by Adafruit
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 4 // Pin for the RGB Stripe
#define NUMPIXELS 70 // Number of Pixels
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
int strobePin = 2; // Strobe Pin on the MSGEQ7
int resetPin = 3; // Reset Pin on the MSGEQ7
int outPin = A0; // Output Pin on the MSGEQ7
int level[7]; // An array to hold the values from the 7 frequency bands
int l;
uint32_t aus = pixels.Color(0,0,0);
uint32_t gr = pixels.Color(0,200,0);
uint32_t grb = pixels.Color(0,160,40);
uint32_t grbl = pixels.Color(0,120,80);
uint32_t gbl = pixels.Color(0,80,120);
uint32_t bl = pixels.Color(0,40,160);
uint32_t blr = pixels.Color(0,0,200);
uint32_t blro = pixels.Color(40,0,160);
uint32_t bro = pixels.Color(80,0,120);
uint32_t ro = pixels.Color(120,0,80);
uint32_t rog = pixels.Color(160,0,0);
void setup()
{
Serial.begin(9600);
pinMode(strobePin, OUTPUT); // Define our pin modes
pinMode(resetPin, OUTPUT);
pinMode(outPin, INPUT);
pinMode(3,OUTPUT);
digitalWrite(resetPin, LOW); // Create an initial state for our pins
digitalWrite(strobePin, LOW);
delay(1);
digitalWrite(resetPin, HIGH); // Reset the MSGEQ7 as per the datasheet timing diagram
delay(1);
digitalWrite(resetPin, LOW);
digitalWrite(strobePin, HIGH);
delay(1);
pixels.begin(); // enables Adafruit Neopixels
pixels.show(); // reset Pixels
for (int i = 0; i < 70; i++)
{
int ii = i-5; //snake effect at the start
pixels.setPixelColor(i, gr);
pixels.setPixelColor(ii, aus);
pixels.show();
delay(20);
}
}
void LEDaus1(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
for (int i=a; i <=k; i++)
{
pixels.setPixelColor(i, aus);
pixels.show();
}
}
void LEDaus2(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
for (int i=a; i >=k; i--)
{
pixels.setPixelColor(i, aus);
pixels.show();
}
}
void LED0(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k, uint32_t gr)
{
pixels.setPixelColor(a, gr);
for (int i=b; i <= k; i++) pixels.setPixelColor(i, aus);
}
void LED1(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
for (int i=k; i <= c; i++) pixels.setPixelColor(i, aus);
}
void LED2(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
for (int i=d; i <= k; i++) pixels.setPixelColor(i, aus);
}
void LED3(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
for (int i=k; i <= e; i++) pixels.setPixelColor(i, aus);
}
void LED4(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
for (int i=f; i <= k; i++) pixels.setPixelColor(i, aus);
}
void LED5(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
pixels.setPixelColor(f, blr);
for (int i=k; i <= g; i++) pixels.setPixelColor(i, aus);
}
void LED6(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
pixels.setPixelColor(f, blr);
pixels.setPixelColor(g, blro);
for (int i=h; i <= k; i++) pixels.setPixelColor(i, aus);
}
void LED7(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
pixels.setPixelColor(f, blr);
pixels.setPixelColor(g, blro);
pixels.setPixelColor(h, bro);
for (int i=k; i <= j; i++) pixels.setPixelColor(i, aus);
}
void LED8(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
pixels.setPixelColor(f, blr);
pixels.setPixelColor(g, blro);
pixels.setPixelColor(h, bro);
pixels.setPixelColor(j, ro);
pixels.setPixelColor(k, aus);
}
void LED9(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
pixels.setPixelColor(a, gr);
pixels.setPixelColor(b, grb);
pixels.setPixelColor(c, grbl);
pixels.setPixelColor(d, gbl);
pixels.setPixelColor(e, bl);
pixels.setPixelColor(f, blr);
pixels.setPixelColor(g, blro);
pixels.setPixelColor(h, bro);
pixels.setPixelColor(j, ro);
pixels.setPixelColor(k, rog);
}
void abfolge(int a,int b,int c,int d,int e,int f,int g,int h,int j,int k)
{
switch (l)
{
case 93 ... 104:/*<---------------------------------------first LED area--------------------------------------------------------*/
LED0(a,b,c,d,e,f,g,h,j,k,gr);
break;
case 105 ... 139:/*<---------------------------------------second LED area------------------------------------------------------*/
LED1(a,b,c,d,e,f,g,h,j,k);
break;
case 140 ... 164:/*<---------------------------------------third LED area-------------------------------------------------------*/
LED2(a,b,c,d,e,f,g,h,j,k);
break;
case 165 ... 199:/*<---------------------------------------fourth LED area------------------------------------------------------*/
LED3(a,b,c,d,e,f,g,h,j,k);
break;
case 200 ... 234:/*<---------------------------------------fith LED area--------------------------------------------------------*/
LED4(a,b,c,d,e,f,g,h,j,k);
break;
case 235 ... 269:/*<---------------------------------------sixth LED area-------------------------------------------------------*/
LED5(a,b,c,d,e,f,g,h,j,k);
break;
case 270 ... 304:/*<---------------------------------------seventh LED area-----------------------------------------------------*/
LED6(a,b,c,d,e,f,g,h,j,k);
break;
case 305 ... 339:/*<---------------------------------------eighth LED area------------------------------------------------------*/
LED7(a,b,c,d,e,f,g,h,j,k);
break;
case 340 ... 374:/*<---------------------------------------nineth LED area------------------------------------------------------*/
LED8(a,b,c,d,e,f,g,h,j,k);
break;
case 375 ... 1000:/*<---------------------------------------tenth LED area------------------------------------------------------*/
LED9(a,b,c,d,e,f,g,h,j,k);
break;
}
}
void loop()
{
// Cycle through each frequency band by pulsing the strobe.
for (int i = 0; i < 7; i++)
{
digitalWrite (strobePin, LOW);
delayMicroseconds (100); // Delay necessary due to timing diagram
level[i] = analogRead (outPin);
digitalWrite (strobePin, HIGH);
delayMicroseconds (100); // Delay necessary due to timing diagram
}
/*-----------------------------------------------------------Band1(For the first LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [0];
abfolge(0,1,2,3,4,5,6,7,8,9);
if (l < 92) LEDaus1(0,1,2,3,4,5,6,7,8,9);
/*-----------------------------------------------------------Band2(For the second LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [1];
abfolge(19,18,17,16,15,14,13,12,11,10);
if (l < 92) LEDaus2(19,18,17,16,15,14,13,12,11,10);
/*-----------------------------------------------------------Band3(For the third LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [2];
abfolge(20,21,22,23,24,25,26,27,28,29);
if (l < 92) LEDaus1(20,21,22,23,24,25,26,27,28,29);
/*-----------------------------------------------------------Band4(For the fourth LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [3];
abfolge(39,38,37,36,35,34,33,32,31,30);
if (l < 92) LEDaus2(39,38,37,36,35,34,33,32,31,30);
/*-----------------------------------------------------------Band5(For the fifth LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [4];
abfolge(40,41,42,43,44,45,46,47,48,49);
if (l < 92) LEDaus1(40,41,42,43,44,45,46,47,48,49);
/*-----------------------------------------------------------Band6(For the sixth LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [5];
abfolge(59,58,57,56,55,54,53,52,51,50);
if (l < 92) LEDaus2(59,58,57,56,55,54,53,52,51,50);
/*-----------------------------------------------------------Band7(For the seventh LED stripe)---------------------------------------------------------------*/
// allocation for the Numbers of LEDs
l = level [6];
abfolge(60,61,62,63,64,65,66,67,68,69);
if (l < 92) LEDaus1(60,61,62,63,64,65,66,67,68,69);
}

A hozzászólás módosítva: Márc 3, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 3, 2021		/

Egy orosz megoldás! Ez sem tud komoly animációt, viszont a videóban mintha a led szalagra merőlegesen villognának az oszlopok! Ezt sem próbáltam még.

cxem.net

#include "Adafruit_NeoPixel.h"
#define PIN 6
// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(150, PIN, NEO_GRB + NEO_KHZ800);
#define MAX_X 10
#define MAX_Y 15
byte maska[135]={
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,
0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,
0,1,1,0,0,0,1,1,1,0,0,1,1,1,1,
0,1,1,0,1,1,1,1,1,0,0,1,1,1,1,
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
};
int colors[14][3]={{0,150,0},{0,255,0},
{100,255,0},{255,255,0},
{150,0,0},{255,0,0},
{255,0,100},{255,0,255},
{150,0,255},{0,0,255},
{0,0,150},{0,150,255},
{0,255,255},{0,255,100}
};
int offcolor=0;
unsigned long millis1=0;
// плохие светодиоды
int badleds[]={0,1,15,30};
//
#define msg7RESET 11
#define msg7Strobe 12
#define msg7DCout 0
int arr1[7]={0,0,0,0,0,0,0};
void setup() {
Serial.begin(9600);
pinMode(msg7RESET, OUTPUT);
pinMode(msg7Strobe, OUTPUT);
strip.begin();
for(int i=0;i<135;i++)
{
correctstrip(i,0,0,0);
}
strip.show();
Serial.println("oksetup");
}
void loop() {
digitalWrite(msg7RESET, HIGH); // осуществляем сброс MSGEQ7
delay(5);
digitalWrite(msg7RESET, LOW);
for (int x = 0; x < 7; x++){ // семь частот - семь стробирующих импульсов
digitalWrite(msg7Strobe, LOW);
delayMicroseconds(35); // ждем установления значения 35 мкс
int spectrumRead = analogRead(A0); // считываем значение с аналогового входа
int PWMvalue = map(spectrumRead, 0, 1024, 0, 255); // преобразовываем диапазон 0-1024 к диапазону 0-255 для ШИМ
setVals(x,PWMvalue);
arr1[x]=spectrumRead;
digitalWrite(msg7Strobe, HIGH);
}
for(int i=0;i<7;i++)
{Serial.print(" ");Serial.print(arr1[i]);}
Serial.println();
strip.show();
if(millis()-millis1>1000)
{millis1=millis();offcolor=(offcolor+1)%7;
}
}
/////
//удалить испорченные
void correctstrip(int place,int color1,int color2,int color3)
{
int offset=0;
for(int i=0;i=j*28)
{
correctstrip((9-j)*15+i*2+1,colors[((i+offcolor)%7)*2][0],colors[((i+offcolor)%7)*2][1],colors[((i+offcolor)%7)*2][2]);
correctstrip((9-j)*15+i*2+2,colors[((i+offcolor)%7)*2+1][0],colors[((i+offcolor)%7)*2+1][1],colors[((i+offcolor)%7)*2+1][2]);
}
else
{
correctstrip((9-j)*15+i*2+1,0,0,0);
correctstrip((9-j)*15+i*2+2,0,0,0);
}
}
}

A hozzászólás módosítva: Márc 3, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 6, 2021		/

Még egy kód. A forrásra már nem találtam vissza, franc se tudja hol találtam. Csak 7 csatorna viszont valami infra távot is kezel! Filenév: FNMJOTIJA8JN8KZ.ino

#include <FastLED.h>
#include <IRLib.h>
int analogPin = 0; //msgeq7 pin 3
int strobePin = 2; //msgeq7 pin 4
int resetPin = 3; // msgeq7 pin 7
int spectrumValue[7]; //array to hold values
int minval = 90;
int maxval = 900;
boolean mode = 1; //by Default, play matrix animation
///////////////////////////IR Receiver///////////////////////////
int recv_pin = 11;
IRrecv My_Receiver(recv_pin);
IRdecode My_Decoder;
IRdecodeHash My_Hash_Decoder;
/////////////////////////IR Receiver End/////////////////////////
/////////////////////////////For Matrix/////////////////////////////
#define UPDATES_PER_SECOND 100
#define BRIGHTNESS 255
#define COLOR_ORDER GRB
CRGBPalette16 currentPalette;
TBlendType currentBlending;
extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
/////////////////////////////For Matrix End/////////////////////////////
//The amount of LEDs in the setup
#define NUM_LEDS 49
//The pin that controls the LEDs
#define LED_PIN 8
//No of LEDs in a column
int NUM_LEDS_SINGLE = (NUM_LEDS / 7);
//Led array
CRGB leds[NUM_LEDS];
//How many previous sensor values effects the operating average?
#define AVGLEN 5
//How many previous sensor values decides if we are on a peak/HIGH (e.g. in a song)
#define LONG_SECTOR 20
//Mnemonics
#define HIGH 3
#define NORMAL 2
//How long do we keep the "current average" sound, before restarting the measuring
#define MSECS 30 * 1000
#define CYCLES MSECS / DELAY
/*Sometimes readings are wrong or strange. How much is a reading allowed
to deviate from the average to not be discarded? **/
#define DEV_THRESH 0.8
//Arduino loop delay
#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(int specVal, int row_no);
//How many LEDs do we display
int curshow = NUM_LEDS_SINGLE;
//Showing different colors based on the mode.
int songmode = NORMAL;
//Average sound measurement the last CYCLES
unsigned long song_avg;
//The amount of iterations since the song_avg was reset
int iter = 0;
//The speed the LEDs fade to black if not relit
float fade_scale = 1.2;
/*Short sound avg used to "normalize" the input values.
We use the short average instead of using the sensor input directly */
int avgs[AVGLEN] = { -1};
//Longer sound avg
int long_avg[LONG_SECTOR] = { -1};
//Keeping track how often, and how long times we hit a certain mode
struct time_keeping {
unsigned long times_start;
short times;
};
//How much to increment or decrement each color every cycle
struct color {
int r;
int g;
int b;
};
struct time_keeping high;
struct color Color;
/////////////////////////////Setup/////////////////////////////
void setup() {
// put your setup code here, to run once:
delay( 3000 );
Serial.begin(9600);
My_Receiver.enableIRIn(); // Start the receiver
pinMode(analogPin, INPUT);
pinMode(strobePin, OUTPUT);
pinMode(resetPin, OUTPUT);
digitalWrite(resetPin, LOW);
digitalWrite(strobePin, 1);
FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);
//bootstrap average with some low values
for (int i = 0; i < AVGLEN; i++) {
insert(250, avgs, AVGLEN);
}
//Initial values
high.times = 0;
high.times_start = millis();
Color.r = 0;
Color.g = 0;
Color.b = 1;
//delay(1000);
currentPalette = RainbowColors_p;
currentBlending = LINEARBLEND;
}
/////////////////////////////Setup End/////////////////////////////
///////////////////////////////Loop///////////////////////////////
void loop() {
// put your main code here, to run repeatedly:
if (My_Receiver.GetResults(&My_Decoder))
{
My_Hash_Decoder.copyBuf(&My_Decoder);
My_Decoder.decode();
float hexvalue = My_Decoder.value;
if (hexvalue == 0x1fe48b7)
{ mode = !mode;
// for (int q = 0; q < 50; q++)m
// {
// leds[q] = CRGB::Black;
// }
}
if (mode == 1) {
digitalWrite(resetPin, 1);
digitalWrite(resetPin, 0);
for (int i = 0; i < 7; i++) {
digitalWrite(strobePin, 0);
delay(30);
spectrumValue[i] = analogRead(analogPin);
digitalWrite(strobePin, 1);
}
///////////////Change values here for test///////////////
for (int p = 0; p < 7; p++)
{
visualize_music(spectrumValue[p], p);
Serial.print(spectrumValue[p]);
Serial.print(" ");
}
Serial.println();
/////////////////Check in serial monitor/////////////////
}
else
{
Serial.println("Here I am!");
ChangePalettePeriodically();
static uint8_t startIndex = 0;
startIndex = startIndex + 1; /* motion speed */
FillLEDsFromPaletteColors( startIndex);
FastLED.show();
FastLED.delay(1000 / UPDATES_PER_SECOND);
}
My_Receiver.resume();
}
delay(DELAY);
}
///////////////////////////////Loop End///////////////////////////////
/**Funtion to check if the lamp should either enter a HIGH mode,
or revert to NORMAL if already in HIGH. If the sensors report values
that are higher than 1.1 times the average values, and this has happened
more than 30 times the last few milliseconds, it will enter HIGH mode.
TODO: Not very well written, remove hardcoded values, and make it more
reusable and configurable. */
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;
//Serial.println("HIGH");
}
else if (millis() - high.times_start > 200) {
high.times = 0;
songmode = NORMAL;
//Serial.println("NORMAL");
}
}
//Main function for visualizing
void visualize_music(int specVal, int row_no) {
int sensor_value, mapped, avg, longavg;
//Actual sensor value
sensor_value = specVal;
/*
//If 0, discard immediately. Probably not right and save CPU.
if (sensor_value == 0)
return;
*/
//Discard readings that deviates too much from the past avg.
mapped = (float)fscale(minval, maxval, minval, (float)maxval, (float)sensor_value, 2.0);
avg = compute_average(avgs, AVGLEN);
if (((avg - mapped) > avg * DEV_THRESH)) //|| ((avg - mapped) < -avg*DEV_THRESH))
return;
//Insert new avg. values
insert(mapped, avgs, AVGLEN);
insert(avg, long_avg, LONG_SECTOR);
//Compute the "song average" sensor value
song_avg += avg;
iter++;
if (iter > CYCLES) {
song_avg = song_avg / iter;
iter = 1;
}
longavg = compute_average(long_avg, LONG_SECTOR);
//Check if we enter HIGH mode
check_high(longavg);
if (songmode == HIGH) {
fade_scale = 3;
Color.r = 5;
Color.g = 3;
Color.b = -1;
}
else if (songmode == NORMAL) {
fade_scale = 2;
Color.r = -1;
Color.b = 2;
Color.g = 1;
}
//Decides how many of the LEDs will light up
curshow = fscale(minval, maxval, 0.0, (float)NUM_LEDS_SINGLE, (float)avg, -1);
/*Set the different leds. Control for too high and too low values.
Fun thing to try: Dont account for overflow in one direction,
some interesting light effects appear! */
for (int i = 0; i < NUM_LEDS_SINGLE; i++)
//The leds we want to show
if (i < curshow) {
if (leds[7 * row_no + i].r + Color.r > 255)
leds[7 * row_no + i].r = 255;
else if (leds[7 * row_no + i].r + Color.r < 0)
leds[7 * row_no + i].r = 0;
else
leds[7 * row_no + i].r = leds[7 * row_no + i].r + Color.r;
if (leds[7 * row_no + i].g + Color.g > 255)
leds[7 * row_no + i].g = 255;
else if (leds[7 * row_no + i].g + Color.g < 0)
leds[7 * row_no + i].g = 0;
else
leds[7 * row_no + i].g = leds[7 * row_no + i].g + Color.g;
if (leds[7 * row_no + i].b + Color.b > 255)
leds[7 * row_no + i].b = 255;
else if (leds[7 * row_no + i].b + Color.b < 0)
leds[7 * row_no + i].b = 0;
else
leds[7 * row_no + i].b = leds[7 * row_no + i].b + Color.b;
//All the other LEDs begin their fading journey to eventual total darkness
} else {
leds[7 * row_no + i] = CRGB(leds[7 * row_no + i].r / fade_scale, leds[7 * row_no + i].g / fade_scale, leds[7 * row_no + i].b / fade_scale);
}
FastLED.show();
}
//Compute average of a int array, given the starting pointer and the length
int compute_average(int *avgs, int len) {
int sum = 0;
for (int i = 0; i < len; i++)
sum += avgs[i];
return (int)(sum / len);
}
//Insert a value into an array, and shift it down removing
//the first value if array already full
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;
}
//Function imported from the arduino website.
//Basically map, but with a curve on the scale (can be non-uniform).
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;
// condition curve parameter
// limit range
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
// Check for out of range inputValues
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
// Check for originalMin > originalMax - the math for all other cases i.e. negative numbers seems to work out fine
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;
}
///////////////////Matrix Function Definitions///////////////////
void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
uint8_t brightness = 255;
for ( int i = 0; i < NUM_LEDS; i++) {
leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
colorIndex += 3;
}
}
// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly. All are shown here.
void ChangePalettePeriodically()
{
uint8_t secondHand = (millis() / 1000) % 60;
static uint8_t lastSecond = 99;
if( lastSecond != secondHand) {
lastSecond = secondHand;
if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
}
}
// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{
for( int i = 0; i < 16; i++) {
currentPalette[i] = CHSV( random8(), 255, random8());
}
}
// This function sets up a palette of black and white stripes,
// using code. Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{
// 'black out' all 16 palette entries...
fill_solid( currentPalette, 16, CRGB::Black);
// and set every fourth one to white.
currentPalette[0] = CRGB::White;
currentPalette[4] = CRGB::White;
currentPalette[8] = CRGB::White;
currentPalette[12] = CRGB::White;
}
// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{
CRGB purple = CHSV( HUE_PURPLE, 255, 255);
CRGB green = CHSV( HUE_GREEN, 255, 255);
CRGB black = CRGB::Black;
currentPalette = CRGBPalette16(
green, green, black, black,
purple, purple, black, black,
green, green, black, black,
purple, purple, black, black );
}
// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM. A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
CRGB::Red,
CRGB::Gray, // 'white' is too bright compared to red and blue
CRGB::Blue,
CRGB::Black,
CRGB::Red,
CRGB::Gray,
CRGB::Blue,
CRGB::Black,
CRGB::Red,
CRGB::Red,
CRGB::Gray,
CRGB::Gray,
CRGB::Blue,
CRGB::Blue,
CRGB::Black,
CRGB::Black
};
/////////////////Matrix Function Definitions End/////////////////

A hozzászólás módosítva: Márc 6, 2021

(#)	dB_Thunder hozzászólása	Márc 6, 2021		/

Ééés akkor most ugorjunk végre a PLATINUM kódjaihoz!!
Elsőnek az alap 7 sávos, a DMS-307 programja. Ezt már próbáltam!!
Ami tetszik: minden sávnak meg lehet adni az erősítését, illetve a "zaját". Ettől függetlenül én valamiért mégis túl zajosnak ítéltem.
Mellékletben a szükséges H file.

//7 BAND SPECTRUM ANALYZER MSGE07
//DESIGN PLATINUM 2019 www.youtube.com/c/PLATINUMKIT
//FACEBOOK https://www.facebook.com/LegendMasters/
//YOUTUBE VIDEO DIY ACRYLIC PART.1 https://youtu.be/xDKbpwumgF8
//YOUTUBE VIDEO DIY ACRYLIC PART.2
//YOUTUBE VIDEO DIY INFINITY MIRROR https://youtu.be/j2-0d9xBDJk
//THIS IS NOT FOR SALE ONLY FOR HOBBIES.
//WE SHARE TO ADD A KNOWLEDGE SCIENCE.
#include <math.h>
#include <Adafruit_NeoPixel.h>
#include "MSGEQ7V1.h"
Timer t;
#define Acolor A0
#define Scolor A6
#define Pcolor A7
#define MAX_BRIGHTNESS 255
#define MIN_BRIGHTNESS 10
const int brightnessInPin = A2;
int led = 5;
unsigned long x;
unsigned long y = 0;
const byte analogPin = A1;
const byte strobePin = 3;
const byte resetPin = 2;
const byte dataPin = 4;
const byte numBand = 20; //number of LEDs
const byte numTop = 0;
const int noise[] = {20, 20, 20, 20, 20, 20, 20};
const float gain[] = {2.05, 2.05, 2.05, 2.05, 2.05, 2.05, 2.05}; //Frequency GAIN
//Frequency = 63Hz, 160Hz, 400Hz, 1kHz, 2.5kHz, 6.25kHz, 16kHz
const unsigned long dlay = 30;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(numBand*7, dataPin, NEO_GRB + NEO_KHZ800);
enum audio {
MONO,
RIGHT,
LEFT };
int spectrumReadR;
int spectrumReadL;
int audio = MONO;
int mag = 0;
int numON = 0;
float fl_mag = 0.0;
int k;
int a;
int s;
int peakArray[7];
byte
peak = 0,
dotCount = 0;
void setup() {
Serial.begin(9600);
pinMode(resetPin, OUTPUT);
pinMode(strobePin, OUTPUT);
pinMode(dataPin, OUTPUT);
strip.begin();
strip.show();
digitalWrite(resetPin,HIGH);
delayMicroseconds(5);
digitalWrite(strobePin,HIGH);
delayMicroseconds(50);
digitalWrite(strobePin,LOW);
delayMicroseconds(50);
digitalWrite(resetPin,LOW);
delayMicroseconds(5);
digitalWrite(strobePin,HIGH);
delayMicroseconds(100);
t.every(80,peakLower);
}
void loop() {
CReSet();
x = millis();
}
int dimH = 0;
int p = 0;
const long interval = 1;
void CReSet(){
if(x - y >= interval){
y = x;
dimH = map(p, 0, 4000, 0, 255);
analogWrite(led, dimH);
if(p >= 4000){ p = 0; }
else { p = p + 1; }
}
int mappedValue = map(analogRead(brightnessInPin), 0, 1023, 0, 255);
strip.setBrightness(constrain(mappedValue, MIN_BRIGHTNESS, MAX_BRIGHTNESS));
a = analogRead(Acolor);
a = map(a, 0, 1023, 0,400);
s = analogRead(Scolor);
s = map(s, 0, 1023, 35,1500);
k = analogRead(Pcolor);
k = map(k, 0, 1023, 0,750);
for(byte band = 1; band <= 7; band++) {
digitalWrite(strobePin, LOW);
delayMicroseconds(40);
spectrumReadL = analogRead(analogPin);
digitalWrite(strobePin, HIGH);
mag = (spectrumReadR + spectrumReadL) / 2;
mag = max(0, (mag - noise[band-1]));
fl_mag = gain[band-1] * float(mag);
numON = map(fl_mag, 0, 1024, 1, numBand+1);
anyBand(band);
if(peakArray[band-1]==0) strip.setPixelColor(peakArray[band-1] + numBand*(band-1), strip.Color(0,0,0));
else strip.setPixelColor(peakArray[band-1] + numBand*(band-1), Wheel(map(10,0,numBand-0,k,255)));
t.update();
}
strip.show();
delay(dlay);
}
void readBand(byte band) {
for(byte band = 1; band <= 7; band++) {
digitalWrite(strobePin, LOW);
delayMicroseconds(40);
spectrumReadL = analogRead(analogPin);
digitalWrite(strobePin, HIGH);
mag = (spectrumReadR + spectrumReadL) / 2;
mag = max(0, (mag - noise[band-1]));
fl_mag = gain[band-1] * float(mag);
numON = map(fl_mag, 0, 1024, 1, numBand+1);
anyBand(band);
}
}
void anyBand(byte band) {
for(byte i = 0; i < numBand; i++){
if(i < (numON - numTop - 1)){
strip.setPixelColor(i + numBand*(band-1), Wheel(map(i,0,numBand-s,a,255)));
}
else if(i >= numON){
strip.setPixelColor(i + numBand*(band-1), strip.Color(0,0,0));
}
else{
if(i > peakArray[band-1]) peakArray[band-1] = i;
}
}
}
void peakLower() {
for(byte i = 0; i < 7; i++) {
if(peakArray[i] > 1) peakArray[i]--;
else continue;
}
}
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if(WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if(WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

MSGEQ7V1.h

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 6, 2021		/

Most pedig a 14 sávos kódja! Legtöbb utánépítő erre a kódra hivatkozik, de a videókban látható színösszeállításoknak látványosabb részét ez sem tudja! Gyanúsan vissza butított progi, vannak benne olyan sorok amiket nem használ! A videók alatti leírásban pl. ezt a programot nem is lehet elérni, csak a előlapi embléma úszó szivárnyányos programját!
A zajt jobban kezeli. Én is most ezen a kódon dolgozom. Megpróbálom értelmezni, kommenteket fordítom, kiegészítem. Már átírtam, hogy 24 pixel magas oszlopot is tudjon.

sketch_may11a.ino:

// Project: 14 Band Spectrum Analyzer using WS2812B/SK6812
// Target Platform: Arduino Mega2560 or Mega2560 PRO MINI
// The original code has been modified by PLATINUM to allow a scalable platform with many more bands.
// It is not possible to run modified code on a UNO,NANO or PRO MINI. due to memory limitations.
// The library Si5351mcu is being utilized for programming masterclock IC frequencies.
// Special thanks to Pavel Milanes for his outstanding work. https://github.com/pavelmc/Si5351mcu
// Analog reading of MSGEQ7 IC1 and IC2 use pin A0 and A1.
// Clock pin from MSGEQ7 IC1 and IC2 to Si5351mcu board clock 0 and 1
// Si5351mcu SCL and SDA use pin 20 and 21
// See the Schematic Diagram for more info
// Programmed and tested by PLATINUM
// Version 1.0
//***************************************************************************************************
#include <avr/wdt.h>
#include <Adafruit_NeoPixel.h>
#include <si5351mcu.h> //Si5351mcu library
Si5351mcu Si; //Si5351mcu Board
#define PULSE_PIN 13
#define NOISE 20 //was 50
#define ROWS 20 //num of row MAX=20
#define COLUMNS 14 //num of column
#define DATA_PIN 9 //led data pin
#define STROBE_PIN 6 //MSGEQ7 strobe pin
#define RESET_PIN 7 //MSGEQ7 reset pin
#define NUMPIXELS ROWS * COLUMNS
int Intensity = 20;
int pauzeTop = 1;
int Sensitivity = 1;
int mode = 0;
//bool modechange=false;
bool Showmode = false;
char barRed = 0, barGreen = 255, barBlue = 100;
char topRed = 205, topGreen = 50, topBlue = 0;
char randomRed = 0, randomGreen = 0, randomBlue = 0;
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 200; // the debounce time; increase if the output flickers
long LastDoNothingTime = 0;
long DoNothingTime = 60000;
/*
Mode 0 = green column with red top holding
Mode 1 = blue column with red top holding
Mode 2 =
Mode 3 =
Mode 4 =
Mode 5 =
Mode 6 =
Mode 7 =
Mode 8 =
Mode 9 =
Mode 10 =
*/
struct Point {
char x, y;
char r, g, b;
bool active;
};
struct TopPoint {
int position;
int peakpause;
};
Point spectrum[ROWS][COLUMNS];
TopPoint peakhold[COLUMNS];
int spectrumValue[COLUMNS];
long int counter = 0;
int long pwmpulse = 0;
bool toggle = false;
int long time_change = 0;
int effect = 0;
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, DATA_PIN, NEO_GRB + NEO_KHZ800);
void setup()
{
Si.init(25000000L);
Si.setFreq(0, 104570);
Si.setFreq(1, 166280);
Si.setPower(0, SIOUT_8mA);
Si.setPower(1, SIOUT_8mA);
Si.enable(0);
Si.enable(1);
pinMode (STROBE_PIN, OUTPUT);
pinMode (RESET_PIN, OUTPUT);
pinMode (DATA_PIN, OUTPUT);
pinMode (PULSE_PIN, OUTPUT);
digitalWrite(PULSE_PIN, HIGH);
delay(100);
digitalWrite(PULSE_PIN, LOW);
delay(100);
digitalWrite(PULSE_PIN, HIGH);
delay(100);
digitalWrite(PULSE_PIN, LOW);
delay(100);
digitalWrite(PULSE_PIN, HIGH);
delay(100);
pixels.setBrightness(20); //set Brightness
pixels.begin();
pixels.show();
pinMode (STROBE_PIN, OUTPUT);
pinMode (RESET_PIN, OUTPUT);
digitalWrite (RESET_PIN, LOW);
digitalWrite (STROBE_PIN, LOW);
delay (1);
digitalWrite (RESET_PIN, HIGH);
delay (1);
digitalWrite (RESET_PIN, LOW);
digitalWrite (STROBE_PIN, HIGH);
delay (1);
pinMode(59, INPUT_PULLUP); // switch
randomSeed(analogRead(0));
}
void loop()
{
counter++;
clearspectrum();
if (millis() - pwmpulse > 3000) {
toggle = !toggle;
digitalWrite(PULSE_PIN, toggle);
pwmpulse = millis();
}
digitalWrite(RESET_PIN, HIGH);
delayMicroseconds(3000);
digitalWrite(RESET_PIN, LOW);
for (int i = 0; i < COLUMNS; i++) {
digitalWrite(STROBE_PIN, LOW);
delayMicroseconds(1000);
spectrumValue[i] = analogRead(0)-NOISE;
if (spectrumValue[i] < 120)spectrumValue[i] = 0;
spectrumValue[i] = constrain(spectrumValue[i], 0, Sensitivity);
spectrumValue[i] = map(spectrumValue[i], 0, Sensitivity, 0, ROWS); i++; //1023
spectrumValue[i] = analogRead(1)-NOISE;
if (spectrumValue[i] < 120)spectrumValue[i] = 0;
spectrumValue[i] = constrain(spectrumValue[i], 0, Sensitivity);
spectrumValue[i] = map(spectrumValue[i], 0, Sensitivity, 0, ROWS);
if (spectrumValue[i] > 6)LastDoNothingTime = millis();
digitalWrite(STROBE_PIN, HIGH);
}
// Read de set intensity
Intensity = analogRead(2);
Intensity = map(Intensity, 0, 1023, 150, 0);
pixels.setBrightness(Intensity); //set Brightness
// read pauzetijd van de top
pauzeTop = analogRead(3);
pauzeTop = map(pauzeTop, 0, 1023, 100, 0);
//read the sensitivity
Sensitivity = analogRead(4);
Sensitivity = map(Sensitivity, 0, 1023, 120, 1023);
// read switch
if (digitalRead(59) == LOW) {
if ( (millis() - lastDebounceTime) > debounceDelay) {
mode++;
if (mode == 8)mode = 0;
ChangeMod();
lastDebounceTime = millis();
}
}
// do nothing timer....showdown if no input for long time
if ((millis() - LastDoNothingTime) > DoNothingTime) {
//mode++;
// if (mode == 8)mode = 0;
// ChangeMod();
// Showmode=true;
rainbow(25);
LastDoNothingTime = millis();
}
//if(Showmode==true)StartDemo();
// enter demo mode because long time no input
for (int j = 0; j < COLUMNS; j++) {
// randomRed=random(255);
//randomGreen=random(255);
//randomBlue=random(255);
for (int i = 0; i < spectrumValue[j]; i++) {
if (mode == 6) { // random colors om all tiles
spectrum[i][j].active = 1;
spectrum[i][j].r = random(255); //COLUMN Color red
spectrum[i][j].g = random(255); //COLUMN Color green
spectrum[i][j].b = random(255); //COLUMN Color blue
}
else if (mode == 4) { // random color per column
spectrum[i][j].active = 1;
switch (j) {
case 0:
spectrum[i][j].r = 0; //COLUMN Color red
spectrum[i][j].g = 0; //COLUMN Color green
spectrum[i][j].b = 255; //COLUMN Color blue
break;
case 1:
spectrum[i][j].r = 0; //COLUMN Color red
spectrum[i][j].g = 255; //COLUMN Color green
spectrum[i][j].b = 0; //COLUMN Color blue
break;
case 2:
spectrum[i][j].r = 0; //COLUMN Color red
spectrum[i][j].g = 255; //COLUMN Color green
spectrum[i][j].b = 255; //COLUMN Color blue
break;
case 3:
spectrum[i][j].r = 255; //COLUMN Color red
spectrum[i][j].g = 0; //COLUMN Color green
spectrum[i][j].b = 0; //COLUMN Color blue
break;
case 4:
spectrum[i][j].r = 255; //COLUMN Color red
spectrum[i][j].g = 0; //COLUMN Color green
spectrum[i][j].b = 255; //COLUMN Color blue
break;
case 5:
spectrum[i][j].r = 255; //COLUMN Color red
spectrum[i][j].g = 255; //COLUMN Color green
spectrum[i][j].b = 0; //COLUMN Color blue
break;
case 6:
spectrum[i][j].r = 255; //COLUMN Color red
spectrum[i][j].g = 80; //COLUMN Color green
spectrum[i][j].b = 205; //COLUMN Color blue
break;
case 7:
spectrum[i][j].r = 50; //COLUMN Color red
spectrum[i][j].g = 100; //COLUMN Color green
spectrum[i][j].b = 255; //COLUMN Color blue
break;
case 8:
spectrum[i][j].r = 255; //COLUMN Color red
spectrum[i][j].g = 255; //COLUMN Color green
spectrum[i][j].b = 0; //COLUMN Color blue
break;
case 9:
spectrum[i][j].r = 215; //COLUMN Color red
spectrum[i][j].g = 40; //COLUMN Color green
spectrum[i][j].b = 120; //COLUMN Color blue
break;
case 10:
spectrum[i][j].r = 120; //COLUMN Color red
spectrum[i][j].g = 100; //COLUMN Color green
spectrum[i][j].b = 40; //COLUMN Color blue
break;
case 11:
spectrum[i][j].r = 50; //COLUMN Color red
spectrum[i][j].g = 10; //COLUMN Color green
spectrum[i][j].b = 90; //COLUMN Color blue
break;
case 12:
spectrum[i][j].r = 90; //COLUMN Color red
spectrum[i][j].g = 150; //COLUMN Color green
spectrum[i][j].b = 55; //COLUMN Color blue
break;
case 13:
spectrum[i][j].r = 95; //COLUMN Color red
spectrum[i][j].g = 155; //COLUMN Color green
spectrum[i][j].b = 25; //COLUMN Color blue
break;
}
}
else {
spectrum[i][j].active = 1;
spectrum[i][j].r = barRed; //COLUMN Color red
spectrum[i][j].g = barGreen; //COLUMN Color green
spectrum[i][j].b = barBlue; //COLUMN Color blue
}
}
if (spectrumValue[j] - 1 > peakhold[j].position)
{
spectrum[spectrumValue[j] - 1][j].r = 0;
spectrum[spectrumValue[j] - 1][j].g = 0;
spectrum[spectrumValue[j] - 1][j].b = 0;
peakhold[j].position = spectrumValue[j] - 1;
peakhold[j].peakpause = pauzeTop;// 1; //set peakpause
}
else
{
spectrum[peakhold[j].position][j].active = 1;
spectrum[peakhold[j].position][j].r = topRed; //Peak Color red
spectrum[peakhold[j].position][j].g = topGreen; //Peak Color green
spectrum[peakhold[j].position][j].b = topBlue; //Peak Color blue
}
}
flushMatrix();
if (counter % 3 == 0)topSinking(); //peak delay
}
void topSinking()
{
for (int j = 0; j < ROWS; j++)
{
if (peakhold[j].position > 0 && peakhold[j].peakpause <= 0) peakhold[j].position--;
else if (peakhold[j].peakpause > 0) peakhold[j].peakpause--;
}
}
void clearspectrum()
{
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLUMNS; j++)
{
spectrum[i][j].active = false;
}
}
}
void flushMatrix()
{
for (int j = 0; j < COLUMNS; j++)
{
for (int i = 0; i < ROWS; i++)
{
if (spectrum[i][j].active)
{
pixels.setPixelColor(j * ROWS + i, pixels.Color(
spectrum[i][j].r,
spectrum[i][j].g,
spectrum[i][j].b));
}
else
{
pixels.setPixelColor( j * ROWS + i, 0, 0, 0);
}
}
}
pixels.show();
}
void ChangeMod()
{
switch (mode) {
case 0:
barRed = 0;
barGreen = 255;
barBlue = 0;
topRed = 255;
topGreen = 0;
topBlue = 0;
break;
case 1:
barRed = 0;
barGreen = 0;
barBlue = 255;
topRed = 0;
topGreen = 255;
topBlue = 0;
break;
case 2:
barRed = 255;
barGreen = 0;
barBlue = 0;
topRed = 0;
topGreen = 0;
topBlue = 255;
break;
case 3:
barRed = 255;
barGreen = 0;
barBlue = 0;
topRed = 255;
topGreen = 0;
topBlue = 0;
break;
case 4:
//each column diff color implemented elsewhere
break;
case 5:
// rainbow accross
break;
case 6:
// random collors implemented elsewhere
break;
}
}
void StartDemo()
{
// rainbow should start
rainbow(25);
}
void rainbow(int wait) {
pixels.setBrightness(20);
for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {
if (millis() - pwmpulse > 3000) {
toggle = !toggle;
digitalWrite(PULSE_PIN, toggle);
pwmpulse = millis();
}
digitalWrite(RESET_PIN, HIGH);
delayMicroseconds(3000);
digitalWrite(RESET_PIN, LOW);
delayMicroseconds(1000);
digitalWrite(STROBE_PIN, HIGH);
delayMicroseconds(1000);
digitalWrite(STROBE_PIN, LOW);
delayMicroseconds(1000);
digitalWrite(STROBE_PIN, HIGH);
delayMicroseconds(1000);
digitalWrite(STROBE_PIN, LOW);
// delayMicroseconds(1000);
// digitalWrite(STROBE_PIN, HIGH);
// delayMicroseconds(1000);
//digitalWrite(STROBE_PIN, LOW);
spectrumValue[1] = analogRead(1);
spectrumValue[1] = constrain(spectrumValue[1], 0, Sensitivity);
spectrumValue[1] = map(spectrumValue[1], 0, Sensitivity, 0, ROWS);
if (spectrumValue[1] >6){return;}
digitalWrite(STROBE_PIN, HIGH);
for (int i = 0; i < 280; i++) { // For each pixel in strip...
/*
* First check to see if there is activity on one of the bands. If true then reset
*
*/
// if (millis() - pwmpulse > 3000) {
// toggle = !toggle;
// digitalWrite(PULSE_PIN, toggle);
// pwmpulse = millis();
// }
//***
int pixelHue = firstPixelHue + (i * 65536L / 280);
pixels.setPixelColor(i, pixels.gamma32(pixels.ColorHSV(pixelHue)));
}
pixels.show(); // Update strip with new contents
// delay(wait); // Pause for a moment
}
}

A hozzászólás módosítva: Márc 6, 2021

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 6, 2021		/

Egy utánépítő szépen részletező lapja: Bővebben: Link

(#)	sznyeg hozzászólása	Márc 8, 2021		/

Igazság szerint a professzionális audió megfejtésekben ( hangosításokon, stúdió megfejtésekben is ) csak 1/3 oktávos (32 sávos) felbontást használnak, mert sűrűbbnek nincs értelme, ehhez igazodnak a frekvenciasávok.
Ehhez igazodik természetesen az equalizerek sávleosztása is, pont azért, mert egyébként az állandó jóságú szűrők átfednék egymást és az egyik sáv állítása beleszólna a mellette levőbe.

De persze, lehet sűrűbbet is csinálni, látványos lesz.

A hozzászólás módosítva: Márc 8, 2021

DN370_P0ACA_...png

dn60.jpg

(#)	dB_Thunder válasza sznyeg hozzászólására (»)	Márc 8, 2021		/

Számomra is egy kicsit elmebeteg a Generatorlabs 42sávja!
Az már 6 db MSGEQ7, és rengeteg led!! A legnagyobb problémát abban látom, hogy az MSGEQ7 belső szűrőinek a jósága, sávszélessége annyi amennyi, de némileg függ az órajelétől! Ha csökken az órajel, csökken a jóság. És mi pont csökkentjük az órajelet, hogy a megfelelő irányba elhangoljuk a szűrőket.
Szóval a végén hiába lesz egy halom sávunk, mert a szűrők sávszélessége nem elegendően szűk(alacsony jóság), hogy rendesen szétválassza a frekvenciákat. Hiszen az ic-t 7 sávra találták ki, ahhoz optimalizálták a szűrők sávszélességét.
Gyakorlatilag egyetlen frekire is több oszlop fog valamilyen arányban jelezni.

Tesztjeim alapján úgy látom, hogy a 14 sáv még egész jól működik. Talán a 21 sáv is még elfogadható lesz, az pont kihasználná a Si5351A 3 órajel kimenetét!

Ha tervezek ehhez nyákot, szerintem az 3db MSGEQ7 ic-nek csinálok helyet!! Aztán azt vagy beülteti, használja, az utánépítő, vagy nem! Programot meg hozzá lehet igazítani.

(#)	dB_Thunder válasza dB_Thunder hozzászólására (»)	Márc 8, 2021		/

A másik probléma a sok sávval, és hozzá tartozó rengeteg leddel, hogy ki is kell számolni, ki is kell íratni azokat! Ez mind-mind idő, és a végén már nem mondható "real time"-nak az egész.

Már a mostani 14 sávost sem mondanám túl gyors kijelzésűnek! Lehet látni némi késedelmet.
Arra vagyok most kíváncsi, hogy ezt a 336 ledet (eredetileg 280)mennyi idő végigcímezni!!
Emiatt már elgondolkoztam egy "duál processzoros" megoldáson is. Minden msgeq-t külön proc olvas, külön számol, és a hozzá tartozó oszlopokat önállóan írja. Csak meg kellene oldani, hogy mind2 azonos kijelzési üzemmódba legyen.
Sajnos jelen pill. ehhez sovány a programozási tudásom.

(#)	benjami válasza dB_Thunder hozzászólására (»)	Márc 8, 2021		/

Ha nem elég az MSGEQ7 által nyújtott 7 sáv nem volna egyszerűbb elfelejteni ezeket a tokokat és megcsinálni az egészet 1-2 műveleti erősítővel meg egy 32 bites kontrollerrel (mondjuk FFT-t alkalmazva) ?

(#)	dB_Thunder válasza benjami hozzászólására (»)	Márc 9, 2021		/

FFT-vel mennyire lehet megfelelő jóságú szűrés csinálni, és azt mennyi idő alatt számolja ki a proci?? Illetve mennyibe kerül egy olyan proci ami ezt tudja?

Van egyébként FFT-t használó projek ugyanilyen led szalaggal!

Nekem nem az egyszerűség, olcsóság a fontos, hanem a gyorsaság !
Régen is utáltam a legtöbb kivezérlésjelzőt mert késet! Sima, direkt, analóg, kicsi időtaggal, az jó volt.

Most olvasom a NeoPixel lib leírását a kiíratás sebességéről:

Idézet:
„about 30 microseconds per RGB pixel”

Tehát a bő 330 led kiíratása 0,01 másodperc, és ilyenkor nem számol animációt, nem olvas be jelszintet...

Azon is gondolkozom, hogy tudnám megmérni a program ciklus idejét! Mert a mostani sebessége is határeset a számomra, gyorsítani kellene...

Kicsit más:
Abban sem vagyok biztos, hogy az ilyen MSGEQ ic-ben van valós 7db kapcsolt kapacitás szűrő!!
Néztem árakat az ilyen fajta szűrő ic-nek, horror!! És az csak 1 sáv lenne...
Tehát az is elképzelhető, hogy fizikailag csak egyetlen szűrőtag van az ic-ben, és azt hangolják nagyon gyorsan végig a teljes spektrumon.

Idő-idő-idő...

(#)	benjami válasza dB_Thunder hozzászólására (»)	Márc 9, 2021		/

Minden attól függ, hány pontos FFT-t használsz. Nagyobb felbontás -> több processzoridő, nagyobb késleltetés (már csak az miatt is, mert meg kell várni amíg előáll az a minta mennyiség).
A másik módszer, ha nem FFT-t használsz, hanem FIR szűrőt. Annak nincs késleltetése. Viszont annyi FIR szűrőt kell használnod, ahány sávot szeretnél. Minél több sávot szeretnél, annál meredekebb szűrőt kell csinálnod hozzá, a meredekebb szűrő meg több együtthatót igényel.
Itt egy FIR szűrő tervező oldal.
Egy 100 lábú stm32f407-t tartalmazó board most 10$ körül van (+2$ egy olcsó st-link programozó hozzá). Ez a chip 168MHz max frekvencián tud futni, hardveres lebegőpontos egységet is tartalmaz. Ha ez kevés, akkor 20$ körül van 400MHz-es chip-et tartalmazó board is (stm32h743).

(#)	Oszipapa hozzászólása	Márc 9, 2021		/

Sziasztok.
Ez a projekt engem is érdekelne Ha lesz már müködö darab, (nekem elég lenne a 14 sávos is),esetleg
ha publikus lenne a nyák terv,(akár kész ,megvehetö nyákkal), kapcsolási rajz,esetleg felprogramozott
vezérlövel, azt nagyon
megköszönném.( a programozás nem az erösségem

(#)	dB_Thunder válasza Oszipapa hozzászólására (»)	Márc 9, 2021		/

Bármit tudunk!

Van más pár videóm a sajátomról, hogy az hogy áll, mert én, ugyan más projektekkel párhuzamosan, kb fél éve foglalkozok ezzel!
Most ez össze van dugdosva egy próba panelon.

Szóval, itt egy videó a sajátomról, egyenlő csak egy panelre ragasztottam fel az 5m szalagot.Hang nincs!

VID_20210308...3gp

(#)	dB_Thunder válasza benjami hozzászólására (»)	Márc 9, 2021		/

Huh..

Nem vagyok ennyire otthon a programozós, jelfeldolgozós témakörben!
PLC-kel szo-szo elboldogulok, C programozás nagyon alapjai még mennek, aztán vége is a tudásomnak
Hátulgombolósoknak való szinten kifejtenéd ezeket a FIR szűrőket??
Azt látom, hogy ez is program, de mit adunk neki, és mit kapunk? És ha program, csak kell neki némi futási idő...

Kezdjük ott, hogy van 1 audió analóg szignálunk!

(#)	Oszipapa válasza dB_Thunder hozzászólására (»)	Márc 10, 2021		/

Szia. Ez eddig hibátlannak néz ki. Esetleg publikus lenne a rajza, panelje, stb? Esetleg készitesz e megrendelésre?

(#)	dB_Thunder válasza Oszipapa hozzászólására (»)	Márc 10, 2021		/

Ennek teljesen publikus a rajza, a panelja, még a programja is!

7 sávos építési leírása

Nálam ez most így néz ki:

A hozzászólás módosítva: Márc 10, 2021

IMG_20210310...jpg

(#)	Peter65 válasza dB_Thunder hozzászólására (»)	Márc 13, 2021		/

Szerintem Fourier analízissel viszonylag egyszerű szűrőt készíteni, és a jósága is könnyen kézben tartható, azonban ilyen széles spektrumú vizsgálat esetében nem biztos, hogy nyerő lesz. A számítási torzítások és speciális ablakolási technikák elkerülése érdekében az egyes spektrumok meghatározásánál célszerű a szűrési frekvencia periódus idejének egész számú többszöröse hosszúságú ablakokat használni, ami miatt a szélesebb spektrumoknál viszonylag kevés a választás. Hogy érthetőbb legyek, legyen egy f frekvencia, és a hozzá tartozó periódusidő T hosszú. Ha az ablak szélessége 1T, akkor a spektrum szélessége 0,5f-től 1,5f-ig tart. DFT-vel ennél rosszabb jóság nem érhető el. Ha 2T periódus az ablak szélessége, akkor a spektrum 0,75f-től 1,25f-ig tart. A spektrum szélessége df=1/T összefüggéssel számolható.
Ezek alapján a Fourier szűrést akkor célszerű választanod, ha a spektrumok frekvenciái oktávonként vagy féloktávonként vannak. A 20-20000Hz-es tartomány nagyjából 10 oktávra bontható, azaz ha 10 vagy 20 spektrumot szeretnél, szerintem akkor érdemes ebben az irányban tájékozódnod.

(#)	flaci76 válasza dB_Thunder hozzászólására (»)	Márc 13, 2021		/

IIR szűrővel érdemes megcsinálni és fixpontos számábrázolással. Egy Blue Pill board 32 bites STM32F103-al pl. 10 sávot 48kHz audio mintavételi freki mellett könnyedén lekezel, valós időben, minden bejövő mintát elkapva és így is csak kb 50% CPU időt vesz el a szűrők működtetése ADC IRQ rutinban. Mivel nem bufferel, hanem minden érkező mintával számol, így a sávszűrő rendszer gyors, késés mentes és semmit nem hagy ki a streamből, ellenben az FFT-sekkel. Elrontani gyakorlatilag csak a kijelzés FPS-el lehet. Ezt Arduinoban csináltam, Keil-el ugyanezen a board-on 2x7 sávos sztereó megoldást is csináltam, de nyilván ez megoldható 1x14 sáv változatban is, sőt kb olyan 16 sáv az ami véleményem szertin a plafon egy ilyen boarddal. Ezek a példányok OLED kijelzőre dolgoznak, kicsit felhúzva az OLED órajelét, így 135Hz FPS-el renderelve. Nagyon szép sima mozgásokat és gyors képet ad. Tudok feltenni forráskódot mindkettőről, de át kell írni őket ha LED-szalagra kell dolgoznia.
A frekvenciák és a szűrőjóságok is megadhatók, de nem futásidőben. Egy python kódot írtam a szűrők együtthatóinak kiszámítására, ezel konstansok lesznek a forráskódban.
A kódok amúgy sajnos kicsit kaotikusak, még nem volt igazán időm letisztítani, meg rendesen felkommentelni.

Screenshot_2...png

(#)	dB_Thunder válasza flaci76 hozzászólására (»)	Márc 17, 2021		/

Helló!

Nézegettem ezeket a digi filtereket, ITT elég érthetően leírják! Ez mellett még elolvastam pár leírást.
Most már én is nagyjából megemésztettem a működésüket! Tetszik, hogy igen nagy meredekségű szűrőt is tudunk csinálni, alkatrészhalom nélkül!

Később biztos megnézzük a teljes digitális jelfeldolgozás! De addig nekem nagyon, de nagyon sokat kell tanulnom még programozni!

Csináltam jelgenerátorral egy "ellenőrzést", videó a lentebbi linken. Szerintem a 21 sáv még egy értelmes felbontás lehet! De azért látszik az analóg szűrés hibája, a szomszédos sávok áthallása!

Másik apró hiba, a kijelzés lineáris! Lehalkítom, nagyon hamar nem mutat semmit.

Kicsit elmélkedtem, kísérleteztem a fizikai kivitelezéssel: Plexi hasábok ideális méretei, rögzítésük, a fény eloszlása a hasábban.
Vágtam 25db 50x60mm hasábokat 10es anyagból.
Elsőre zavart, hogy a plexi közepén nagyon erős a led, de a "gyáriban" is. Fúrtam egy kb 5ös furatot a led elé, az sokat javított fényeloszláson, viszont a fényerő nem túl sok a plexin keresztül! Lehet duplán kellene szalagozni....

PROJEKT VIDEÓK

A hozzászólás módosítva: Márc 17, 2021

(#)	dB_Thunder válasza flaci76 hozzászólására (»)	Márc 17, 2021		/

Szeretnék kérni egy kis kezdő lökést ezekhez az ARM cumókhoz! Pl milyen fejlesztői környezetben érdemes használni? Van erősebb lap mint a Blue Pill??

(#)	flaci76 válasza dB_Thunder hozzászólására (»)	Márc 18, 2021		/

Én annó digit szűrőkből írtam a szakdogám. De még így is csak a felszínt kapargatom már ami az elméleti dolgokat illeti. Azért valóban sok jó szűrőtervező cucc van, pl. a Matlab Fdatools, vagy a python nyelv scipy pluginja. Azt azért jó kézzel tapintani, amikor egy digit szűrő működni kezd pl. egy mikrovezérlőben

Ez a MSGEQ7 IC jó cucc, régebben már én is szemeztem vele, csak elfogadható beszerzési forrást nem találtam rá. A frekik eltologatása az órajellel tényleg jó ötlet, lényegében az összes freki arányosan fog eltolódni vele. Eredetileg 2,5-szeres ugrások vannak, így pl. egy gyök(2,5)=1,58-szoros óra emelés vagy csökkentés pont a meglévő frekik közé lövi be az új spektrumvonalakat. (köbgyök 2,5-el lehetne harmadolni) Viszont ha túl gyakoriak lesznek a frekik, akkor már mosott lesz a frekiszelektivitás, mert a szűrők meredekségét is növelni kellene, vagy a jóság megemelésével hozni létre keskeny sávátvitelt, de ezt már nem lehet állítani az IC-n. A lecsengés vezérléssel úgylátom nem lesz gond,az nem az órajeltől függ, hanem minden kiolvasáskor csökken 10%-ot. Nekem amúgy tetszik, mert így tényleg a legkisebb képességű Arduino board is elég lehet.
Talán még az játszhat, hogy ilyen MSGEQ7 szerű funkciójú dolgot csinálni egy STM32 BluePill-ből, csak nincs D/A konvertere, SPI vagy I2C-n lehetne lekérdezhetni róla az értékeket, vagy PWM, de arra meg aluláteresztő kell, bonyolódik. Visszatérve a szűrőkre, azért el lehet játszani vele. Gondolj csak bele, hogy van egy 72MHz-es órajellel rendelkező procid, és szeretnél egy 48kHz-es mintavételezést, ahol minden bejövő ADC mintára rá akarsz ugrani. Mondjuk nem akarsz DMA-t, mert akkor az már késik, azaz tényleg minden ADC mintára lefut egy megszakítási rutin. Két mintavétel között 72M/48k=1500 cpu órajel ketyeg el, jól meg kell gondolni, hogy ebbe mit, mennyit, és hogyan írsz be. Pl. ha float vagy double számokkal kezdesz szűrőt számolni akkor már ki is estél, hacsak nincs hardveres float támogatás. Én integerre tettem minden számítást, szűrőegyütthatót, sok helyen az osztás helyett bit shift-et használok stb, hogy spóroljak azon az 1500 órán, amibe úgy kell beleférni, hogy jusson a főprogramnak is cpu idő.

A logaritmikus kijelzést meg lehet szerintem oldani, át lehet számítani log értékekre, de a kb 20dB átfogás nem lesz nagyobb, kb ennyit tud az IC. BluePill-nél ez kb 30dB, mert kb ott jön az ADC zajszintje magasfrekin, mivel nincs a board-on szétválasztva az analog és digitális táp és föld, így nagyon zajos az ADC-je.

BluePill:

Jó cucc, nekem bevált. kb 2000Ft darabja (kvázi olcsóbb, mint maga a mikrovezérlője!), ár/érték arányban igen jó. Hasonló/jobb 32 biteseket 8-10kHUF-tól mérnek.
Elindulni többféle úton is lehet vele, egyik az Arduino. Én az STM32duino alaplapi csomagot töltöttem le, ill. azt használom hozzá. Van az STM microelecktronics féle mondhatni "hivatalos" csomagja, de nekem azzal voltak problémáim. Kell hozzá STlink V2 programozó is, az a biztos, de ez se drága cucc. Lehet fejleszteni még STM32cube vagy Keil környezetben is és ehhez nagyon jó magyar nyelvű cucc is van Bővebben: Link Azért azt halkan megjegyezném, hogy ugyanaz a funkcionalitású programom Arduinoban 26kB, Keilben 4.7kB-ra fordult le, ill. a futási sebesség is valahogy mindig jobb Keil-ben.

Amivel most babrálok (sajnos eddig nem túl sok sikerrel) az az, hogy i2s ADC/DAC konvertereket kössek valahogy össze ilyen-olyan board-okkal. Leszedtem egy SB Audigy4-ről egy UDA1361T 96kHz/24bit stereo ADC ic-t és próbapanelon el is indítottam master i2s-ként. Működik is, logikai analizátorral sikerült dekódolni is a kimenetet, adtam a bemenetére szinusz jelet stb. Még így is kb 80-90dB jel/zaj viszonyt produkált. Messze sokkal jobb, mint a mikrokontrollerbe integrált ADC, ezzel akár 40-60dB átfogású kijelzéseket is lehetne csinálni, sőt konkrétan precíz audió méréseket lehetne lezavarni vele. (pl hangszóró impedancia és T/S mérőt mikrokontroller alapon, saját kijelzéssel, user interface-el, önállóan és PC-vel is működőt, az igen jól hangzana)

ui: a sávelválasztás nálam sem a legjobb, sima 6-6dB/okt, csak a szűrő Q-ja fel van egy kicsit húzva. Hasonló, mint sok analog műveletierősítős változat, igazából azokból vettem a szűrőkaraktert.
Sweep video

A hozzászólás módosítva: Márc 18, 2021

(#)	dB_Thunder válasza flaci76 hozzászólására (»)	Márc 19, 2021		/

Mérnökként, akinek még oktatták is ezt, könnyű!

Én csak egyszerű drótos vagyok! Minden infót, okosságot magamnak kell felcsipegetni.
Néztem az adatlapodat, meg a honlapodon a munkásságaidat!
Nagyon hasonló az érdeklődési körünk, Te egy szinttel komolyabban műveled. Túl messze sem lakunk egymástól.

Arduinóhoz való bővítményt hirtelen nem találtam, feladtam. A Keil-t letöltöttem majd ránézek.

Találtam egy ilyet hogy NUCLEO, ezen van már programozó rész is. Lehet fejlesztéshez jobb lenne. Az kérdéses számomra, hogy csak saját magát képes programozni vagy rávehető másik eszköz programozására is?
Az elkészült eszközbe, a lehető legegyszerűbb, és csak a szükséges alkatrészeket tartalmazó modul elég.

Most már azt is tudom miért zajos a játék szkópom (DSO-SHELL)! Próbáltam tenni is ellene de arra jutottam hogy tokon belül van a baj. Nem kellett volna 5mV/DIV méréshatárt csinálni rá a kitalálójának...

(#)	dB_Thunder hozzászólása	Ápr 10, 2021		/

Közben, pár hete Platinum kijött a 21 sávos verziójával!
Már 32bites procival operál, de a hangsávokat még mindig msgeq7-tel dolgozza fel.
Kapott pár animációt, a zene szünet idejére is!
Persze a teljes programot most se tárja elénk, akinek kell fizethet csak a vezérlőért kb 60 ezret!
21 band Spectrum

Én közben vettem 2 öreg, de 64 bites Nucleo lapot, lassan ideér még egy adag led szalag, és poti. Van pár gondolatom amit ki akarok próbálni. Illetve még mindig gondolkozom, hogy milyen, és mekkora legyen a végső fizikai megvalósulása! Ez a fekete hátterű nekem nem elég légies, Viszont a talpa tetszik! De valahova el kell rakni az elektronikát is! Azon is gondolkozom hogy kicsit old-school kinézet okán fából csinálom meg a talpat, hogy menjen a Orion hangfalaimhoz