Matrix neopixel - ovladani

Nedaří se vám s projektem a nenašli jste vhodné místo, kde se zeptat? Napište sem.
Pravidla fóra
Tohle subfórum je určeno pro konzultaci ucelených nápadů, popřípadě řešení komplexnějších projektů, které opravdu není možné rozdělit na menší části.
Většinu problémů jde rozdělit na menší a ptát se na ně v konkrétních subfórech.
peterple
Příspěvky: 156
Registrován: 22 zář 2021, 20:20
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od peterple » 01 lis 2021, 17:51

Prečo voláš funkciu show minimálne dvakrát? A potom sa čuduješ že to bliká. Veď tá knižnica má svoje vlastné pole kde má stav všetkých LED zapamätané. Zmažeš všetko cez clear, to ale neznamená že LED zhasnú. Len sa vynuluje to interné pole.
Potom pozapínaj čo chceš a úplne na konci keď už je všetko nastavené na nový "obrázok" tak zavoláš show.
Tá funkcia koštuje pomerne veľa času. Takže to vyriešili takto, aby to neblikalo.

Ešte malá oprimalizácia

Kód: Vybrat vše

if (minuta == 1 || (minuta == 6 || (minuta == 11 || (minuta == 16 || (minuta == 21 || (minuta == 26 || (minuta == 31 || (minuta == 36 || (minuta == 41 || (minuta == 46 || (minuta == 51 || (minuta == 56 )))))))))))){     
sa dá nahradiť pomocou

Kód: Vybrat vše

if ((minuta % 5)==1){
operácia % sa volá modulo a výsledok je zvyšok po delení. V tomto prípade po delení piatimi. Samozrejme to ide použiť aj na tie ďalšie dlhočitanánske if.

Tiež som si všimol že výpočet počtu prvkov poľa čo som ti tu nalinkoval ťa moc neoslovil.

cz_marek
Příspěvky: 104
Registrován: 31 led 2018, 09:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od cz_marek » 01 lis 2021, 19:01

@ peterple
ten sizeof me zaujal moc a mam to tak udelano ve finalnim kodu :-) tohle je jen dilci kod kde ladim zobrazovani. Uz jsem to mel udelano takhle hloupe pres cisla tak se mi to nechtelo predelavat 2x

ty pole mam to udelano takle:

Kód: Vybrat vše

  for (int LEDon = 0; LEDon < sizeof(hod_1); LEDon++)
hmm to modulo vypada jako hodne elegantni řešení a pekne se mi tim zkrati ty nekonecne "ify"

S tim dvojim pixels.show mi to vubec nedoslo - muzu to dat ze vsech tech bloku pryč a udelat to az na konci jednou spolecne pro vsechny.

Jdu to predelat
Diky za pomoc

peterple
Příspěvky: 156
Registrován: 22 zář 2021, 20:20
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od peterple » 01 lis 2021, 19:18

pozor na to to sizeof nemáš dobre. To si zistil veľkosť poľa v bytoch. To ale nie je počet prvkov. Ten treba vypočítať takto.

Kód: Vybrat vše

(sizeof(pole) / sizeof(pole[0])
Takto by si zase behal za poľom. Lebo jeden prvok má v tomto prípade 2 byte. Teda by si dostal dvojnásobné.
V tom linku to bolo napísane na konci ako poznámka a varovanie
Obecné pravidlo je že keď niečo nové používam tak si to najprv dobre prečítam. A potom si to v reálnej situácii nechám vypísať či to naozaj funguje tak ako som to pochopil. Veľa krát sa mi stalo že som to pochopil zle a musel som svoje predstavy korigovať.

cz_marek
Příspěvky: 104
Registrován: 31 led 2018, 09:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od cz_marek » 01 lis 2021, 19:48

nebo to priste radsi zkopiruju z projektu a nebudu to psat narychlo z hlavy :-) toho upozorneni jsem si tam vsiml jen jsem to ted ted blbe napsal.
kazdopadne diky za upozorneni

cz_marek
Příspěvky: 104
Registrován: 31 led 2018, 09:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od cz_marek » 01 lis 2021, 21:05

@peterple - moc dekuji za pomoc už to funguje jak ma

Tak jsemto prepsal cele - urcite to stoji za to:

Kód: Vybrat vše

#include <Adafruit_NeoPixel.h>

int hod_1 [7]= {100, 101, 106, 107, 108, 109, 110};   // prefix JE + hodina 1
int hod_2 [7]= {102, 103, 104, 105, 97, 98, 99};                // prefix JSOU + hodina 2
int hod_3 [7]= {102, 103, 104, 105, 71, 72, 73};                // prefix JSOU + hodina 3
int hod_4 [9]= {102, 103, 104, 105, 45, 46, 47, 48, 49};        // prefix JSOU + hodina 4
int hod_5 [5]= {100, 101, 94, 95, 96};                // prefix JE + hodina 5
int hod_6 [6]= {100, 101, 74, 75, 76, 77};            // prefix JE + hodina 6
int hod_7 [6]= {100, 101, 78, 79, 80, 81};            // prefix JE + hodina 7
int hod_8 [5]= {100, 101, 56, 57, 58};                // prefix JE + hodina 8
int hod_9 [7]= {100, 101, 89, 90, 91, 92, 93};        // prefix JE + hodina 9
int hod_10 [7]= {100, 101, 67, 68, 69, 70, 71};       // prefix JE + hodina 10
int hod_11 [10]= {100, 101, 59, 60, 61, 62, 63, 64, 65, 66};   // hodina 11
int hod_12 [9]= {100, 101, 82, 83, 84, 85, 86, 87, 88};   // hodina 12

int min_1 [1]= {113};         // minuty 1,6
int min_2 [1]= {112};         // minuty 2,7
int min_3 [1]= {111};         // minuty 3,8
int min_4 [1]= {114};         // minuty 4,9

int min_5 [3]= {9, 10, 11};                    // minuty 5,25,35,45,55
int min_10 [5]= {51, 52, 53, 54, 55};        // minuty 10
int min_15 [7]= {23, 24, 25, 26, 27, 28, 29}; // minuty 15
int min_20 [6]= {34, 35, 36, 37, 38, 39};    // minuty 20
int min_25 [9]= {34, 35, 36, 37, 38, 39, 9, 10, 11};    // minuty 25
int min_30 [6]= {39, 40, 41, 42, 43, 44};    // minuty 30
int min_35 [9]= {39, 40, 41, 42, 43, 44, 9, 10, 11};    // minuty 35
int min_40 [8]= {14, 15, 16, 17, 18, 19, 20, 21};  // minuty 40
int min_45 [11]= {14, 15, 16, 17, 18, 19, 20, 21, 9, 10, 11};  // minuty 45
int min_50 [7]= {1, 2, 3, 4, 5, 6, 7};     // minuty 50
int min_55 [10]= {1, 2, 3, 4, 5, 6, 7, 9, 10, 11};     // minuty 55

int pocetLED = 115;     //pocet LED pixelu 
int hodina = 1;
int minuta = 1;
int jas = 10;

unsigned long interval = 1000;        
unsigned long previousMillis = 0; 

#define PIN 12
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(pocetLED, PIN, NEO_GRBW + NEO_KHZ800);

void setup() {
  Serial.begin(9600);
  pixels.begin(); 
}

void loop(){
       
   pixels.setBrightness(jas);
    
	  unsigned long currentMillis = millis();
   if (currentMillis - previousMillis >= interval) {
       previousMillis = currentMillis;
	  minuta = minuta + 1;
 	}

	if (minuta == 60) {
	   hodina = hodina + 1;
	   minuta = 0; 
	}	
	
    if (hodina == 13) {
	   hodina = 1; 
	}	
	  
   CAShod();
   CASmin();
   pixels.show();
  
  for (int LEDoff = 0; LEDoff < pocetLED; LEDoff++) {
     pixels.setPixelColor(LEDoff, pixels.Color(0,0,0,0)); 
 }
} 

//#########################################################################################
void CAShod() {

Serial.println(hodina);

    if (hodina == 1) {       
  for (int LEDon = 0; LEDon < (sizeof(hod_1) / sizeof(hod_1[0])); LEDon++) {
     pixels.setPixelColor(hod_1[LEDon], pixels.Color(0,0,0,255)); 
 }
 } 
    if (hodina == 2) {
  for (int LEDon = 0; LEDon < (sizeof(hod_2) / sizeof(hod_2[0])); LEDon++) {
     pixels.setPixelColor(hod_2[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 3) {
   for (int LEDon = 0; LEDon < (sizeof(hod_3) / sizeof(hod_3[0])); LEDon++) {
     pixels.setPixelColor(hod_3[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
    if (hodina == 4) {
  for (int LEDon = 0; LEDon < (sizeof(hod_4) / sizeof(hod_4[0])); LEDon++) {
     pixels.setPixelColor(hod_4[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
    if (hodina == 5) {
  for (int LEDon = 0; LEDon < (sizeof(hod_5) / sizeof(hod_5[0])); LEDon++) {
     pixels.setPixelColor(hod_5[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
    if (hodina == 6) {
  for (int LEDon = 0; LEDon < (sizeof(hod_6) / sizeof(hod_6[0])); LEDon++) {
     pixels.setPixelColor(hod_6[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 7) {
  for (int LEDon = 0; LEDon < (sizeof(hod_7) / sizeof(hod_7[0])); LEDon++) {
     pixels.setPixelColor(hod_7[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 8) {
  for (int LEDon = 0; LEDon < (sizeof(hod_8) / sizeof(hod_8[0])); LEDon++) {
     pixels.setPixelColor(hod_8[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
    if (hodina == 9) {
  for (int LEDon = 0; LEDon < (sizeof(hod_9) / sizeof(hod_9[0])); LEDon++) {
     pixels.setPixelColor(hod_9[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 10) {
  for (int LEDon = 0; LEDon < (sizeof(hod_10) / sizeof(hod_10[0])); LEDon++) {
     pixels.setPixelColor(hod_10[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 11) {
  for (int LEDon = 0; LEDon < (sizeof(hod_11) / sizeof(hod_11[0])); LEDon++) {
     pixels.setPixelColor(hod_11[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
     if (hodina == 12) {
  for (int LEDon = 0; LEDon < (sizeof(hod_12) / sizeof(hod_12[0])); LEDon++) {
     pixels.setPixelColor(hod_12[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
}

//#########################################################################################
void CASmin() {
		
	Serial.println(minuta);
	
	// jednotky minut
	
     if ((minuta % 5)==1){     
  for (int LEDon = 0; LEDon < (sizeof(min_1) / sizeof(min_1[0])); LEDon++) {
     pixels.setPixelColor(min_1[LEDon], pixels.Color(0,0,0,255)); 
 } 
 }
     if ((minuta % 5)==2){
  for (int LEDon = 0; LEDon < (sizeof(min_2) / sizeof(min_2[0])); LEDon++) {
     pixels.setPixelColor(min_2[LEDon], pixels.Color(0,0,0,255)); 
 }
 } 
 
     if ((minuta % 5)==3){
  for (int LEDon = 0; LEDon < (sizeof(min_3) / sizeof(min_3[0])); LEDon++) {
     pixels.setPixelColor(min_3[LEDon], pixels.Color(0,0,0,255)); 
 }
 } 
 
     if ((minuta % 5)==4){
  for (int LEDon = 0; LEDon < (sizeof(min_4) / sizeof(min_4[0])); LEDon++) {
     pixels.setPixelColor(min_4[LEDon], pixels.Color(0,0,0,255)); 
 }
 } 

     // minuty po 5
	 
     if ((minuta >= 5) && (minuta < 10)) {
  for (int LEDon = 0; LEDon < (sizeof(min_5) / sizeof(min_5[0])); LEDon++) {
     pixels.setPixelColor(min_5[LEDon], pixels.Color(0,0,0,255)); 
 }
 }

     if ((minuta >= 10) && (minuta < 15)) {
  for (int LEDon = 0; LEDon < (sizeof(min_10) / sizeof(min_10[0])); LEDon++) {
     pixels.setPixelColor(min_10[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 15) && (minuta < 20)) {
  for (int LEDon = 0; LEDon < (sizeof(min_15) / sizeof(min_15[0])); LEDon++) {
     pixels.setPixelColor(min_15[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 20) && (minuta < 25)) {
  for (int LEDon = 0; LEDon < (sizeof(min_20) / sizeof(min_20[0])); LEDon++) {
     pixels.setPixelColor(min_20[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 25) && (minuta < 30)) {
  for (int LEDon = 0; LEDon < (sizeof(min_25) / sizeof(min_25[0])); LEDon++) {
     pixels.setPixelColor(min_25[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 30) && (minuta < 35)) {
  for (int LEDon = 0; LEDon < (sizeof(min_30) / sizeof(min_30[0])); LEDon++) {
     pixels.setPixelColor(min_30[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 35) && (minuta < 40)) {
  for (int LEDon = 0; LEDon < (sizeof(min_35) / sizeof(min_35[0])); LEDon++) {
     pixels.setPixelColor(min_25[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 40) && (minuta < 45)) {
  for (int LEDon = 0; LEDon < (sizeof(min_40) / sizeof(min_40[0])); LEDon++) {
     pixels.setPixelColor(min_40[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 45) && (minuta < 50)) {
  for (int LEDon = 0; LEDon < (sizeof(min_45) / sizeof(min_45[0])); LEDon++) {
     pixels.setPixelColor(min_45[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 50) && (minuta < 55)) {
  for (int LEDon = 0; LEDon < (sizeof(min_50) / sizeof(min_50[0])); LEDon++) {
     pixels.setPixelColor(min_50[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 
      if ((minuta >= 55) && (minuta < 60)) {
  for (int LEDon = 0; LEDon < (sizeof(min_55) / sizeof(min_55[0])); LEDon++) {
     pixels.setPixelColor(min_55[LEDon], pixels.Color(0,0,0,255)); 
 }
 }
 }


peterple
Příspěvky: 156
Registrován: 22 zář 2021, 20:20
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od peterple » 01 lis 2021, 21:29

Super. Ešte jedno drobné vylepšenie. Pri deklarácii poľa s inicializáciou nemusíš zadávať jeho veľkosť. Teda:

Kód: Vybrat vše

int hod_1 []= {100, 101, 106, 107, 108, 109, 110};
Ušetríš si počítanie a prepisovanie ak tam pridáš, uberieš prvok.

cz_marek
Příspěvky: 104
Registrován: 31 led 2018, 09:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od cz_marek » 01 lis 2021, 21:42

Prima dam to pryc - treba mi to nekdy usetri starosti kdybych menil velikost pole. Je nejake jednoduche pravidlo kdy se pocet uvadi a kdy ne?

peterple
Příspěvky: 156
Registrován: 22 zář 2021, 20:20
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od peterple » 01 lis 2021, 22:30

Je - lenivosť. Neinicializované pole samozrejme veľkosť definovanú mať musí. Inicializované príde na to ako. Ak ho inicializujem kompletné tak načo počítať prvky keď to urobí prekladač. Zvlášť výhodné pri reťazcoch. Komu by sa chcelo počítať koľko je tam znakov a hlavne nezabudnúť na ukončovací znak 0. Ak potrebujem inicializovať len pár prvkov, tak nebudem písať všetky. Najmä ak tých prvkov je dajme tomu 1000.

cz_marek
Příspěvky: 104
Registrován: 31 led 2018, 09:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od cz_marek » 03 lis 2021, 16:50

Potřeboval bych jeste jednu radu :-)

Jde nejak rozumne nastavit progrese u funkce MAP? Nastavuji jas LEDek pomoci fotoodporu a potreboval bych to např.
hodnota fotoodporu 0 - 500 byla mapovany rozsah 10 - 20
a mezi 500 - 1024 mapovany rozsah 21 - 99

neco jako...

Kód: Vybrat vše

     jas = map (osvetleni, 0,500,10,20);
     jas = map (osvetleni, 501,1024,21,99);
Mohl bych to dat do If ... ale mozna by to slo nejak elegantneji :-)

ondraN
Příspěvky: 932
Registrován: 08 srp 2019, 20:01
Reputation: 0

Re: Matrix neopixel - ovladani

Příspěvek od ondraN » 03 lis 2021, 19:54

Na nastavení jasu by byl asi vhodnější logaritmus. Se zrakem je to podobné jako se sluchem a oko nevnímá jas lineárně.
Pokud to chceš rozdělit na zóny, tak je if ideální a nic elegantnějšího asi nevymyslíš.

Odpovědět

Kdo je online

Uživatelé prohlížející si toto fórum: Žádní registrovaní uživatelé a 12 hostů