OK Mégsem
Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   626 / 867
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 13, 2020 /
 
Másik ötlet.

Az általad használt if sorozat vizsgálat esetén mindig megtörténik az összes vizsgálat, feleslegesen.
  1. if (noteByte == oldnoteByte1) {
  2.             gorbetime[0] = maxrelease;
  3.           }
  4.           if (noteByte == oldnoteByte2) {
  5.             gorbetime[1] = maxrelease;
  6.           }
  7.           if (noteByte == oldnoteByte3) {
  8.             gorbetime[2] = maxrelease;
  9.           }
  10.           if (noteByte == oldnoteByte4) {
  11.             gorbetime[3] = maxrelease;
  12.           }
  13.           if (noteByte == oldnoteByte5) {
  14.             gorbetime[4] = maxrelease;
  15.           }
  16.           if (noteByte == oldnoteByte6) {
  17.             gorbetime[5] = maxrelease;
  18.           }
  19.                  
  20.         Ha else if kombinációt használsz akkor az első találat után nem vizsgálja a többi feltételt.    
  21.               if (noteByte == oldnoteByte1) {
  22.             gorbetime[0] = maxrelease;
  23.           }
  24.           else if (noteByte == oldnoteByte2) {
  25.             gorbetime[1] = maxrelease;
  26.           }
  27.           else if (noteByte == oldnoteByte3) {
  28.             gorbetime[2] = maxrelease;
  29.           }
  30.           else if (noteByte == oldnoteByte4) {
  31.             gorbetime[3] = maxrelease;
  32.           }
  33.           else if (noteByte == oldnoteByte5) {
  34.             gorbetime[4] = maxrelease;
  35.           }
  36.           else (noteByte == oldnoteByte6) {
  37.             gorbetime[5] = maxrelease;
  38.           }


Bár lehet, hogy pont az egyforma futás idő miatt választottad az első verziót?
(#) Rober_4 válasza kapu48 hozzászólására (») Máj 13, 2020 /
 
Igen, mert szerintem nem segít a dolgon, ha létezik olyan állapot, melynek hosszabb idejű fennállása bizonytalanná teszi a dolgot. Tehát ha mindig az 5-ös hang billentyűjét engedném el akkor nagyobb a terhelés, de akkor mindig pont az 5-ös hangot kéne kiadni, ami lehet lehetetlen... Tehát ez az algoritmus egyszerűsíthető szerintem, de nem így lenne célszerű, nem is véletlen van mögötte a switch-case kommentben, bár az úgy hülyeség...
A hozzászólás módosítva: Máj 13, 2020
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 14, 2020 /
 
Ha már sebességre optimalizálunk!
Próbáld ki ezt is:
  1. byte gomb1 = 2;
  2. byte gomb2 = 3;
  3. byte gomb3 = 4;
  4. byte gomb4 = 5;
  5. byte gomb5 = 6;
  6. byte gomb6 = 7;
  7. byte gomb7 = 8;
  8. byte gomb8 = 9;
  9.  
  10.  
  11. void setup() {
  12.   pinMode(gomb1, INPUT);
  13.   pinMode(gomb2, INPUT);
  14.   pinMode(gomb3, INPUT);
  15.   pinMode(gomb4, INPUT);
  16.   pinMode(gomb5, INPUT);
  17.   pinMode(gomb6, INPUT);
  18.   pinMode(gomb7, INPUT);
  19.   pinMode(gomb8, INPUT);
  20.    
  21. // controller-ben digitalRead(gomb_);gyorsítása:  
  22. // Be olvassa a GPIO regisztert és kimaszkolja a megfelelő bitet
  23. uint32_t  gomb1val = PIOB->PIO_PDSR & 1u << 25  ;// D2 = B.25
  24. uint32_t  PC = PIOC->PIO_PDSR ;
  25. uint32_t  gomb2val = PC & 1u << 28  ;// D3 = C.28
  26. uint32_t  gomb3val = PC & 1u << 26  ;// D4 = C.26
  27. uint32_t  gomb4val = PC & 1u << 25  ;// D5 = C.25
  28. uint32_t  gomb5val = PC & 1u << 24  ;// D6 = C.24
  29. uint32_t  gomb6val = PC & 1u << 23  ;// D7 = C.23
  30. uint32_t  gomb7val = PC & 1u << 22  ;// D8 = C.22
  31. uint32_t  gomb8val = PC & 1u << 21  ;// D9 = C.21
  32. // A kapott értéket eltoljuk jobb szélre bit.0-ba
  33. gomb1val >>= 25;
  34. gomb2val >>= 28;
  35. gomb3val >>= 26;
  36. gomb4val >>= 25;
  37. gomb5val >>= 24;
  38. gomb6val >>= 23;
  39. gomb7val >>= 22;
  40. gomb8val >>= 21;
  41.  
  42.  
  43. }
  44.  
  45. void loop() {
  46.   // put your main code here, to run repeatedly:
  47.  
  48. }
A hozzászólás módosítva: Máj 14, 2020
(#) kapu48 válasza kapu48 hozzászólására (») Máj 14, 2020 /
 
Ha a fenti kód működik? Akkor jó regisztereket olvastam be.

És tovább gyorsítható a műveletek összevonásával:
  1. byte gomb1 = 2;
  2. byte gomb2 = 3;
  3. byte gomb3 = 4;
  4. byte gomb4 = 5;
  5. byte gomb5 = 6;
  6. byte gomb6 = 7;
  7. byte gomb7 = 8;
  8. byte gomb8 = 9;
  9.  
  10.  
  11. void setup() {
  12.   pinMode(gomb1, INPUT);
  13.   pinMode(gomb2, INPUT);
  14.   pinMode(gomb3, INPUT);
  15.   pinMode(gomb4, INPUT);
  16.   pinMode(gomb5, INPUT);
  17.   pinMode(gomb6, INPUT);
  18.   pinMode(gomb7, INPUT);
  19.   pinMode(gomb8, INPUT);
  20.    
  21. // controller-ben digitalRead(gomb1);gyorsítása:  
  22. // Be olvassa a GPIO regisztert és kimaskolja a megfelelő bitet
  23. uint8_t  gomb1val = ((uint32_t)PIOB->PIO_PDSR & 1u << 25)>> 25  ;// D2 = B.25
  24. uint32_t  PioC = PIOC->PIO_PDSR ;
  25. uint8_t  gomb2val = (PioC & 1u << 28)>> 28  ;// D3 = C.28
  26. uint8_t  gomb3val = (PioC & 1u << 26)>> 26  ;// D4 = C.26
  27. uint8_t  gomb4val = (PioC & 1u << 25)>> 25  ;// D5 = C.25
  28. uint8_t  gomb5val = (PioC & 1u << 24)>> 24  ;// D6 = C.24
  29. uint8_t  gomb6val = (PioC & 1u << 23)>> 23  ;// D7 = C.23
  30. uint8_t  gomb7val = (PioC & 1u << 22)>> 22  ;// D8 = C.22
  31. uint8_t  gomb8val = (PioC & 1u << 21)>> 21  ;// D9 = C.21
  32. // A kapott értéket eltoljuk jobb szélre bit.0-ba
  33.  
  34.  
  35. }
  36.  
  37. void loop() {
  38.   // put your main code here, to run repeatedly:
  39.  
  40. }

És még spórolunk a memória foglalással is.
(#) Rober_4 válasza kapu48 hozzászólására (») Máj 14, 2020 /
 
Köszönöm működik, bár csak 5 gombot tudtam kipróbálni, mert elég régiek, de annyi is működött
(#) benjami válasza kapu48 hozzászólására (») Máj 14, 2020 / 2
 
A setup függvényt szerintem inkább kódméretre érdemes optimalizálni, hiszen csak induláskor egyszer fut le (ritkán van jelentősége ott a futási időnek). Normál gcc-ben lehet a program egyes részeinek az optimalizációját a globális beállítástól eltérő módon állítgatni (nem tudom, ez az arduinoban levő fordítóval is működik-e, de tudtommal az is gcc-t használ).
  1. #pragma GCC push_options
  2. #pragma GCC optimize("Os")
  3. // ide mehet a kódméretre optimalizált függvény
  4. #pragma GCC pop_options
  5. ...
  6. #pragma GCC push_options
  7. #pragma GCC optimize("O3")
  8. // ide mehet a max módon optimalizált függvény
  9. #pragma GCC pop_options

Itt vannak a lehetséges optimalizálási szint beállításai.
(#) Rober_4 válasza benjami hozzászólására (») Máj 14, 2020 /
 
Működni látszik. Változik a lefordított programméretem húsz és huszonnyolc százalék között opciótól függően. Köszönöm kísérletezgetek vele!
A hozzászólás módosítva: Máj 14, 2020
(#) kapu48 válasza benjami hozzászólására (») Máj 14, 2020 /
 
Az egész program 9 fájlból áll, a méreteik miatt nem idéztem ide az egészet.
Természetesen a gombok kezelése nem a setupban van. Megjegyzésben oda írtam melyik részre gondoltam.
Idézet:
„// controller.ino-ben digitalRead(gomb1);gyorsítása:”


A példa azért így van megcsinálva, hogy le tudjam ellenőrizni, legalább próba fordítással.
Akinek szólt az megértette.
A hozzászólás módosítva: Máj 14, 2020
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 14, 2020 /
 
Lehet kísérletezni a fordító optimalizálásával.
De sajnos az olyan részeket kapásból kifogja dobálni amiket a jó hangzás céljából raktál-be időzítésnek.
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 14, 2020 /
 
Ok!
Akkor kíváncsiságból lefuttatnád ezt a teszt programot:
  1. #include <LiquidCrystal_I2C.h>
  2. LiquidCrystal_I2C lcd(0x27, 16, 2);
  3.  
  4.  
  5. byte gomb1 = 2;
  6. byte gomb2 = 3;
  7. byte gomb3 = 4;
  8. byte gomb4 = 5;
  9. byte gomb5 = 6;
  10. byte gomb6 = 7;
  11. byte gomb7 = 8;
  12. byte gomb8 = 9;
  13.  
  14. unsigned long starttime, stoptime, eltelttime, eltelttime2 ;
  15.  
  16. void setup() {
  17.   pinMode(gomb1, INPUT);
  18.   pinMode(gomb2, INPUT);
  19.   pinMode(gomb3, INPUT);
  20.   pinMode(gomb4, INPUT);
  21.   pinMode(gomb5, INPUT);
  22.   pinMode(gomb6, INPUT);
  23.   pinMode(gomb7, INPUT);
  24.   pinMode(gomb8, INPUT);
  25.   lcd.init();
  26.   lcd.backlight();
  27.    
  28.   starttime = micros();
  29.   int gomb1val_ = digitalRead(gomb1);
  30.   int gomb2val_ = digitalRead(gomb2);
  31.   int gomb3val_ = digitalRead(gomb3);
  32.   int gomb4val_ = digitalRead(gomb4);
  33.   int gomb5val_ = digitalRead(gomb6);
  34.   int gomb6val_ = digitalRead(gomb5);
  35.   int gomb7val_ = digitalRead(gomb7);
  36.   int gomb8val_ = digitalRead(gomb8);
  37.   stoptime = micros();
  38.   eltelttime = stoptime - starttime;
  39.   lcd.setCursor(0, 0);
  40.   lcd.print(eltelttime);  
  41.   lcd.print(" us.");      
  42. // controller-ben digitalRead(gomb1);gyorsítása:  
  43. // Be olvassa a GPIO regisztert és kimaskolja a megfelelő bitet
  44.   starttime = micros();
  45.   uint8_t  gomb1val = ((uint32_t)PIOB->PIO_PDSR & 1u << 25)>> 25  ;// D2 = B.25
  46.   uint32_t  PioC = PIOC->PIO_PDSR ;
  47.   uint8_t  gomb2val = (PioC & 1u << 28)>> 28  ;// D3 = C.28
  48.   uint8_t  gomb3val = (PioC & 1u << 26)>> 26  ;// D4 = C.26
  49.   uint8_t  gomb4val = (PioC & 1u << 25)>> 25  ;// D5 = C.25
  50.   uint8_t  gomb5val = (PioC & 1u << 24)>> 24  ;// D6 = C.24
  51.   uint8_t  gomb6val = (PioC & 1u << 23)>> 23  ;// D7 = C.23
  52.   uint8_t  gomb7val = (PioC & 1u << 22)>> 22  ;// D8 = C.22
  53.   uint8_t  gomb8val = (PioC & 1u << 21)>> 21  ;// D9 = C.21
  54.   // A kapott értéket eltoljuk jobb szélre bit.0-ba
  55.   stoptime = micros();
  56.   eltelttime2 = stoptime - starttime;
  57.   lcd.setCursor(0, 1);
  58.   lcd.print(eltelttime2);
  59.   lcd.print(" us.");
  60.   eltelttime2 = eltelttime - eltelttime2;
  61.   lcd.setCursor(0, 2);
  62.   lcd.print("elteres: ");
  63.   lcd.print(eltelttime2);
  64.   lcd.print(" us.");  
  65. }
  66.  
  67. void loop() {
  68.   // put your main code here, to run repeatedly:
  69.  
  70. }

Ki írja az LCD-re a két gomb kezelés futás idejét, és a különbséget.
(#) Rober_4 válasza kapu48 hozzászólására (») Máj 15, 2020 /
 
Tíz illetve kettő mikroszekundumot mutat. Ez mindenképpen jelentős különbség.

teszt2.png		    
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 15, 2020 /
 
Igen.
Mivel csak 2us-enként van 1 megszakítás, ennél kevesebb időt nem is tudunk mérni.
És nagy valószínűséggel ennek a 2us-nek is a nagy része a megszakítás lekezelése.
(#) Rober_4 válasza kapu48 hozzászólására (») Máj 15, 2020 / 1
 
Most betettem a kész programba az időmérésedet, a vezérlők eljárásba. Itt tizennégy mikroszekundumot és három mikroszekundumot mértem, a kétfajta beolvasással. Viszont a GPO regiszter olvasása hiába gyorsabb, ha sok billentyűt nyomok le a Midi vezérlőn, akkor "beleaggol" a hangszer. Ha visszateszem a régit, akkor tökéletes... Tehát ezek szerint, valahogy másképpen használja a megszakítást, és az összeakad, vagy a MIDI-vel, vagy az audió, illetve LCD résszel...
Leginkább az LCD a gyanús, de ha működik a sima DigitalRead akkor nem bántom.
Tehát hiába gyorsabb a dolog, egyenlőre marad a régi. Viszont ezt az időmérést lehet beteszem egy rejtett menübe, és tesztelgetek vele máshol is...
Köszönöm a segítséget, ha Miskolcon jársz egyszer, a vendégem vagy!
A hozzászólás módosítva: Máj 15, 2020
(#) Kovidivi válasza Rober_4 hozzászólására (») Máj 15, 2020 /
 
Kell neked az LCD biztosan?
Ha több gombot használsz, esetleg minden funkcióhoz egyet (nem tudom mennyi kellene), akkor az LCD felesleges lenne, nem venne el plusz időt.
(#) Rober_4 válasza Rober_4 hozzászólására (») Máj 15, 2020 /
 
Viszont találtam még tempót az LCD írásnál.
Rámértem a programban az eltelt időkre több clock frekvenciával, nyerek harminc milliszekundumot ha felteszem 1 MHz-re 800 kHz-ről! Csináltam diagramot, hátha hasznos még valakinek...
A hozzászólás módosítva: Máj 15, 2020
Moderátor által szerkesztve

lcdprintvers...png		    
(#) Rober_4 válasza Kovidivi hozzászólására (») Máj 15, 2020 /
 
Körülbelül 120paraméter, többségük 1-127-ig állítható, nem nagyon úszom meg. De ha minden igaz kész a dolog, csinálok egy részletes videót róla, annak linkjével még zaklatlak majd titeket, hogy miről is van szó. Köszönöm a segítségeket!
A hozzászólás módosítva: Máj 15, 2020
(#) benjami válasza Rober_4 hozzászólására (») Máj 15, 2020 / 1
 
Ha ezt a library-t használod, akkor nézz bele a pulseEnable függvényébe. Ez minden íráskor várakozik kétszer 50usec-et. Nem lehetne ezt az i2c kijelzőt sima 6 vezetéken is működtethető verzióra cserélni? Akkor elég lenne 2msec sűrűséggel kb 1usec idő a folyamatos frissítéséhez.
(#) kapu48 válasza Rober_4 hozzászólására (») Máj 16, 2020 /
 
Köszönöm! De Nem ellenszolgáltatásért segítettem! Inkább azért mert sokat lehetett tanulni tőled, hang technikai megoldások terén. Viszont nagyon kíváncsi leszek a végleges program változatra. Vajon menyit tudtál javítani rajta?
(#) kapu48 válasza benjami hozzászólására (») Máj 16, 2020 /
 
Erre már többen felhívtuk a figyelmet,hogy az I2C nagyon lassú!
De valamiért nagyon ragaszkodik hozzá?
(#) mateatek válasza benjami hozzászólására (») Máj 16, 2020 / 1
 
Az én LiquidCrystal_I2C.cpp fájlomban nincsen benne ez a késleltetés.
I2C-vel hajtott kijelzőn a következő kód 3404 mikroszekundum alatt fut le. 32 MHz-es órajelen 2500 mikroszekundumig tudom lefaragni:
  1. lcd.setCursor(0, 0);
  2.   lcd.print("01234567");
  3.   lcd.setCursor(0, 1);
  4.   lcd.print("01234567");


Ha valaki gyorsan lefuttatna egy tesztet egy másik rendszeren, az tényszerűen mutatná a sebességeket.
(#) mateatek válasza mateatek hozzászólására (») Máj 16, 2020 / 1
 
Addig-addig találtam itthon egy vasat, amin a "6 vezetékes" rendszerrel van a kijelző. 5048 mikroszekundum alatt futott le a fenti kódrészlet.
Tehát, szerintem gyorsabb az I2C, de a 8 bites vezérlés kipróbálása még vissza van.
(#) Rober_4 válasza kapu48 hozzászólására (») Máj 16, 2020 /
 
Most tesztelek, tesztelek, tesztelek. Valamiért nagyon nem működnek a tömbök. Ha különálló programban összehasonlítom a sebességeket kb. 10 százalékot rávernek a különálló változókra, egy egymilliószoros értékadáson. A baj az, hogy amikor a programban, feltehetően megszakításos környezetben használom őket, habár a saját sebességük jobb, összességében még is problémát okoznak az időzítésekben, mindezt ciklus nélkül értsd, ami hihetetlen számomra. És mivel nem tudom az okát, ezért vizsgálódom még...
A hozzászólás módosítva: Máj 16, 2020
(#) Rober_4 válasza mateatek hozzászólására (») Máj 16, 2020 /
 
Köszönöm a tesztet nagy segítség!
Nem az i2c az igazi probléma, hanem a tömbök. Amit nem értek...
(#) benjami válasza Rober_4 hozzászólására (») Máj 16, 2020 / 1
 
Ha ezt az audio drivert használod, én megmérném mennyi időt tölt el az write függvényében levő várakozásban (56. sor, amíg a félbufferek DMA írása véget nem ér). Ha sokat, akkor azt az időt érdemes lenne a kevésbé időkritikus dolgok elvégzésére fordítani inkább.
(#) Rober_4 válasza benjami hozzászólására (») Máj 16, 2020 /
 
Most látom üres utasításokat hajt végre, amíg nem végez, de hogy tudok ide betenni valamit? Írjam bele az audió osztályba mint függvény, amit itt meghívok az üres utasítás helyén. Az egy változó értékét kiszámolja amit majd a főprogramban kiolvasok az audió osztályon keresztül?
Vagy érdemesebb lenni az Audió függvényeket átemelni a főprogramba, és akkor azonos hierarchiába vagyunk?
Bocs ha hülyeség!
(#) benjami válasza Rober_4 hozzászólására (») Máj 16, 2020 /
 
Én kiegészíteném egy foglaltsági függvénnyel:
  1. int AudioClass::busy(void)
  2. {
  3.   return (next == running);
  4. }

És csak akkor hívnám meg a write-ot, meg előtte a prepare-t, ha nem jelez foglaltat. Csak annyi a lényeg, hogy addig a hanggeneráló részt is szüneteltetni kell.
A hozzászólás módosítva: Máj 16, 2020
(#) david10 hozzászólása Máj 16, 2020 /
 
Sziasztok,
Ezzel a szenzorral és egy LM386-os előerősítővel amit egy Arduino Nano analog bemenetére csatlakoztatok tudok-e annyira precízen mérni hogy megtudjam különböztetni 0.3 bár nyomást 0.4 bártól?
A választ előre is köszönöm.
A hozzászólás módosítva: Máj 16, 2020
(#) Bell hozzászólása Máj 16, 2020 /
 
Sziasztok!
A legfrissebb Arduino-val, a legfrissebb RF24-el, Pro-micro-kal, NRF24L01+ kínai klónokkal szeretném az "ack"-ot kijelezni az adó oldalon.
De az itt található (Bővebben: Link) leírás és a programok segítségével ez nem sikerül.
A radio.write(...) sosem ad igaz értéket.
Kondi van a modulokra forrasztva. Mit rontok el? A modullal lehet gond, vagy a programmal?
Az RX programja:
  1. #include <RF24.h>
  2. #include <SPI.h>
  3.  
  4. const byte rAddress[] =  "1Node" "2Node" "3Node" "4Node" "5Node";
  5. byte ackData = 1;
  6. byte theMessage[32];
  7.  
  8. RF24 radio(8, 10);
  9.  
  10. void loadAckData(byte pipe) {
  11.   radio.writeAckPayload(pipe, &ackData, sizeof(ackData));
  12.   ackData++;
  13. }
  14.  
  15. void setup(void) {
  16.   Serial.begin(9600);
  17.   radio.begin();
  18.   radio.setChannel(108);
  19.   radio.setDataRate( RF24_2MBPS );
  20.   radio.enableAckPayload();
  21.   radio.enableDynamicPayloads();
  22.   for (byte i = 0; i < 5; i++) {
  23.     radio.openReadingPipe(i + 1, &rAddress[i * 5]);
  24.   }
  25.   loadAckData(2);
  26.   loadAckData(3);
  27.   loadAckData(4);
  28.   radio.startListening();
  29. }
  30.  
  31. void loop(void) {
  32.   byte pipeNum = 0;
  33.   if (radio.available(&pipeNum)) {
  34.     if (pipeNum == 2 || pipeNum == 3 || pipeNum == 4) {
  35.       loadAckData(pipeNum);
  36.     }
  37.     byte len = radio.getDynamicPayloadSize();
  38.     radio.read(theMessage, len);
  39.     Serial.print(F("received ["));
  40.     Serial.print(len);
  41.     Serial.print(F("] "));
  42.     for (int x = 0; x < len; x++) {
  43.       if (theMessage[x] < 16) {
  44.         Serial.write('0');
  45.       }
  46.       Serial.print(theMessage[x], HEX);
  47.     }
  48.     Serial.print(F(" via "));
  49.     Serial.println(pipeNum);
  50.   }
  51. }

A TX programja:
  1. #include <RF24.h>
  2. #include <SPI.h>
  3.  
  4. const byte wAddress[] =  "1Node" "2Node" "3Node" "4Node" "5Node";
  5. byte testData[32] = ">12345Test1234567890String12345";
  6. byte ackMessg;
  7.  
  8. RF24 radio(8, 10);
  9.  
  10. void setup(void) {
  11.   Serial.begin(9600);
  12.   radio.begin();
  13.   radio.setDataRate( RF24_2MBPS );
  14.   radio.setChannel(108);
  15.   radio.enableAckPayload();
  16. }
  17.  
  18. void loop() {
  19.   static byte index = 0xFF;
  20.   static unsigned long lastSend;
  21.   unsigned long topLoop = millis();
  22.   if (topLoop - lastSend >= 1000) {
  23.     lastSend = topLoop;
  24.     if (++index > 4) {
  25.       index = 0;
  26.     }
  27.     const byte* ptr = &wAddress[index * 5];
  28.     radio.openWritingPipe(ptr);
  29.     if (radio.write(testData, sizeof(testData))) {
  30.       if (radio.isAckPayloadAvailable() ) {
  31.         radio.read(&ackMessg, sizeof(ackMessg));
  32.         Serial.print(F("Acknowledge for "));
  33.         for (byte i = 0; i < 5; i++) {
  34.           Serial.write(*ptr++);
  35.         }
  36.         Serial.print(F(" received: "));
  37.         Serial.println(ackMessg);
  38.       }
  39.     } else {
  40.       Serial.print(F("Send to "));
  41.       for (byte i = 0; i < 5; i++) {
  42.         Serial.write(*ptr++);
  43.       }
  44.       Serial.println(F(" failed "));
  45.     }
  46.   }
  47. }
A hozzászólás módosítva: Máj 16, 2020

Várt eredmén...png
Eredmény.png		   
(#) Nanok hozzászólása Máj 16, 2020 /
 
Sziasztok!
A Nano és az UNO között, mik az alapvető különbségek?
Eddig, csak UNO-m volt. A Nano-t is ugyanúgy, ugyanazon a felületen tudom programozni?
Ugyanúgy vannak analóg kimenetei is?
A hozzászólás módosítva: Máj 16, 2020
(#) vargham válasza Nanok hozzászólására (») Máj 16, 2020 /
 
Mindkettőn ugyanaz a mikrokontroler van, teljesen megegyezik a programozásuk. Analóg kimenet (DAC) egyiken sincs.
Ezekre szükség lehet! - HESTORE.HU

LM386M-1
RF24-RGB
NRF24L01-AM-MINI
SIMON-SAYS
430 R 1%
Következő: »»   626 / 867
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem