-
PROHARDVER!
Arduino hardverrel és szoftverrel foglakozó téma. Minden mikrovezérlő ami arduinoval programozható, és minden arduino program, board, és hardverrel kapcsolatos kérdések helye.
Új hozzászólás Aktív témák
-
Janos250
őstag
válasz
ekkold
#16588
üzenetére
Na, csináltam egy memory refresht.
Így is lehet olyan függvényt írni, aminek változó számú paramétere van/*
mintapelda variadic function hasznalatara, azaz
hogyan lehet irni olyan fuggvényt, aminek valtozo szamu parametere van
*/
using namespace std;
void tobbParameter(int hanyParameter...){
va_list argumentumok;
//egyeb deklaraciok, ha kell
va_start(argumentumok,hanyParameter);
// az "argumentumok" lista inicializalasa
for (int i = 0; i < hanyParameter; i++){
int soronKovetkezoParameter = va_arg (argumentumok, int) ;
Serial.println(soronKovetkezoParameter);
};
va_end(argumentumok);
// az "argumentumok" lista bezarasa
} ;
void setup() {
Serial.begin(115200);
delay(1000);
tobbParameter(3,5,10,8);
// 3 parameter lesz meg a 3 utan, amit fel kell dolgozni
} ;
void loop() {
};
/*
ezt irja ki:
5
10
8
*/ -
Dißnäëß
nagyúr
válasz
Janos250
#16598
üzenetére
Köszi !!
Egy hőmérséklet szenzort próbálgatok, alábbi kóddal percenként tudom a konzolra kiiratni a hőmérsékletet:
#include <DS18B20.h>
DS18B20 ds(2);
void setup() {
Serial.begin(9600);
}
int n=0;
void loop() {
while (ds.selectNext()) {
Serial.print(n, DEC);
Serial.print(". perc: ");
Serial.println(ds.getTempC());
delay(60000);
n++;
}
}Mi a különbség print és printf között ? (println sortöréssel, ENTER-el megy, erre már rájöttem).
-
Janos250
őstag
válasz
Dißnäëß
#16596
üzenetére
Egy sorban ezek valamelyikével:
using namespace std;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.printf("Serial.printf-el szoveg a kiiras elott %d es utan\n", 5);
printf("printf-el szoveg a kiiras elott %d es utan\n", 5);
cout << "cout-tal szoveg a kiiras elott "<< 5<< " es utan\n" ;
} ;
void loop() {
};Kiírás:
Serial.printf-el szoveg a kiiras elott 5 es utan
printf-el szoveg a kiiras elott 5 es utan
cout-tal szoveg a kiiras elott 5 es utan -
tibi-d
tag
válasz
razorbenke92
#16593
üzenetére
Az arduino egy hőmérséklet szabályzó része. A belső EEPROM szabályzási, beállítási, és program paramétereket tárol. Ezek optimalizálása hosszadalmas folyamat. Ha az arduino panelt kell cserélni, minden megy a kukába. Lehet mindent előröl kezdeni. Ezért, ha a rendszer optimálisan működik, az adatokat kéne kimenteni egy külső EEPROM-ra, ahonnét az új panelre vissza lehetne tölteni. A kiíró, és visszatöltő programrészt be lehet írni az arduino programjába is.
-
#16593
razorbenke92
őstag
tibi-d
#16591
válasz
tibi-d
#16591
üzenetére
A 2560-ra tudsz kódot feltölteni, vagy pont az lenne a pláne, hogy a babrálása nélkül másold ki az eeeprom-ot?
Előbbi esetben csatold a külső eepromot i2c-n, és byte-ról bytera írd át rá a belső eepromot.
Utóbbiban kell egy icsp programozó (egy másik arduinobol is tudsz csinálni) avrdudával kiolvasod az eepromot, aztán pedig felírod egy olyan arduinoba, aminek babrálhatod a kódját, és goto:előbbi eset.
-
gyapo11
őstag
válasz
Tankblock
#16583
üzenetére
30 éve volt, nehezen tudnám megmondani. Van még másik két OFF példám, a biblia és Marx A tőke című könyve. Kb. mindkettőből 10 oldalt tudtam elolvasni, számomra emészthetetlenek. A C könyvnél valószínűleg nem értettem meg valamit amire később épített, és így nem tudtam benne tovább haladni, a Turbopascal 4.0 könyvben nem volt ilyen, értettem mindent. Akkor még nem volt internet, kevés olyan ember is volt, aki ilyesmit tanult, nehéz volt segítséget kapni. Pechhem volt, hogy az író magyarázatát nem értettem meg.
A legjobb ilyen szempontból az assembly, mert ott a lagalapabb byte mozgatások és műveletek vannak, nagyon könnyű megérteni, ott inkább a programozáskor van több munka. -
gyapo11
őstag
A rajzolás balról jobbra megy, aztán ha követni akarja a kurzort, akkor a görbe jobbról balra halad. Persze a szkóp alapból fűrész jellel megy, vagyis amikor a jobb szélére ér a képernyőnek, akkor átugrik a bal szélre és újrakezdi a rajzolást. Ez a görgetés már inkább vizuális adatfolyam megjelenítés mint szkóp.
-
válasz
Tankblock
#16583
üzenetére
Attiny85 helyett 10db Attiny12-t küldött nekem a kínai, amiben nincs RAM egyáltalán, csak 32db regiszter.
Mérgemben megtanultam az AVR assembly-t.
Mivel semmilyen függvény, library stb. nincs hozzá, írtam rá softwareserial-t, szervo drivert stb. Azóta építettem belőle egy játékot is.
Tényleg jól el lehet vele szórakozni, érdekes kihívás, hogy hogyan passzírozzunk cipőkanállal sok adatot kevés helyre, meg hogy kell kódot optimalizálni. -
Tankblock
aktív tag
válasz
gyapo11
#16563
üzenetére
Melyik része ami nehezen érthető?
C++ ugye a C kiterjesztése, szóval ha a hardcore irányba szeretne valaki inkább mozogni akkor Assembly -t javaslom, na ott derül ki érted -e a HW is vagy sem.
Egy olcsó AVR-en (akár egy AtTiny13A)el lehet játszani eléggé jól. Nem mellesleg kijön a magas szintű programozás overheadje is, mert 1kbyte van programnak és 64 bit byte a memória, szóval lehet creatívan használni a regisztereket is amiket nem használunk.....A magasabb szintű nyelvek szerintem inkább másféle képpen nehéz ... Szálkezelés, Deadlock elkerülés, design patternek és társaik. SW arhitechtúra, oprendszer ismeret is kellhet....
-
#16576
Aryes
nagyúr
its_grandpa
#16574
válasz
its_grandpa
#16574
üzenetére
De jó lenne ezt pdf/ebook formában megszerezni valahonnan...
-
#16575
Tomika86
senior tag
its_grandpa
#16574
Tomika86
senior tag
válasz
its_grandpa
#16574
üzenetére
Köszönöm
-
#16574
its_grandpa
tag
its_grandpa
tag
C könyv, magyarul, érthetően [link]
-
válasz
ekkold
#16571
üzenetére
A Pascal nekem majdnem teljesen kimaradt, illetve egyszer, még az ősidőkben, telefonra akartam játékot írni, és a java-t túl bonyolultnak találva MIDletPascal-ban oldottam meg, ehhez megtanultam, majd teljesen el is felejtettem a Pascal nyelvet.
Én Basic-ben kezdtem C64-en, 6510 assembly-al folytattam, majd kb. 20 év kihagyás után PHP, kis Pascal, kis python (ezt meg a Symbian-on használtam, mert a Symbian-t is túl bonyolultnak találtam ). Az assembly-t valamiért nagyon megkedveltem, úgyhogy az AVR assembly-t is megtanultam (legalábbis egy részét). A C-t a LEGO Minestorms miatt kezdtem el, aztán PIC-el próbálkoztam, de szerencsére jött az Arduino meg a C++. -
ekkold
Topikgazda
Nálam ez fordítva volt, tanultam pascal-t, majd utána c-t. A pascal szigora után, a c szinte megváltás volt. Ugyanaz a feladat sokkal rövidebben megoldható, és hatékonyabb kód is lesz a végeredmény.
A javascript, és a PHP nekem jóval később jött, de a c alapok után mondhatni gyerekjáték volt beletanulni . Persze nem vagyok profi programozó, de sokmindenhez hozzá tudok szólni. -
Janos250
őstag
válasz
Tomika86
#16564
üzenetére
Bosszantott, hogy amit linkeltem, nem néztem meg végig, hogy pont a lényegesebb részek nincsenek benne.
Úgy döntöttem, hogy akkor írok én egy mini tutorialt.
Természetesen én se vagyok profi C++ alkalmazó, én is innen szoktam kérdezni, mert itt vannak nálam százszor jobban hozzáértők, de ők csak akkor írnak, ha kérdezzük.
Íme, ilyenre sikerült gyorsan hamarjában:arduinouser.hu/esp32/object-library-tutorial/osztalyokLibraryk.pdf
-
válasz
gyapo11
#16563
üzenetére
Én se bírtam könyvből felfogni a C-t, aztán elkezdtem PHP-zni, az viszonylag könnyen meglett, onnan pedig már könnyebb volt a C-re átnyergelni.
Az objektumokat már C++-ban tanultam, asszem akkoriban jöttek be a PHP5-be, amikor már inkább mikrokontrollerekkel foglalkoztam. -
gyapo11
őstag
Lehet, nekem kevés összahasonlítási alapom van, és az is turbopascal és turboc. Volt olyan eset még a dosos időkben, hogy file-ban kerestem talán valamilyen karaktereket, megírtam turbopascalban és lassú volt. Vegyük hozzá, hogy akkoriban 386-os gépem volt. Kerestem valami filekezelő turboc mintaprogramot, és átírtam, kb. olyan lett mint a pascal méretre, sorok számára nézve, viszont kétszer olyan gyorsan futott.
Purebasicben írtam lottószám sorsolót, ott is minta, hogy kell kiírni valamit, hogy kell a billentyűnyomást érzékelni, és így sikerült.
Arduinot is így programozok, példaprogram, ha nem értek egy utasítást megkeresem, semmi objektum orientáltság, azt is próbálták nekem tanítani de sajnos eredménytelenül.
Leginkább az assembly vált be, abból tanultam z80-at, motorola 6510-et, intel 286, 386-ot, ezekben tudtam írni kisebb programocskákat, amik iszonyú gyorsan futottak az akkori magasabb szintű nyelvekhez pl. basichez, turbopascalhoz képest.
Csak annyit akartam ebből kihozni, hogy ha valaki működő programot szeretne írni, nem feltétlenül kell a legmodernebb magas szintű nyelv megtanulásába éveket fektetni, lehet úgy is, hogy annyit tanulok belőle amennyi éppen az adott feladathoz kell, így is összegyűlik lassan a tudás, csak sokkal élvezetesebb módon. -
Janos250
őstag
válasz
ekkold
#16566
üzenetére
"ha tudod mit csinálsz, akkor jól is fog működni."
Hát, ez az!
Sokkal könnyebb elbaltázni a programot C-ben, mit bármi másban.
De az Arduino az C++ , itt azért már van némi kontroll !
Én annak idején hagytam is a fenébe a C-t, és csak később a C++ -t használtam/használom, mert a C "mindent szabad" , "ha hülyeséget írsz, én megcsinálom a hülyeséget, nem figyelmeztetlek" szemléletétől feláll a szőr a hátamon.
Azért a pascalok fejlettebb verzióiban is sok mindent meg lehetett csinálni úgy, hogy komolyabb ellenőrzés is volt.x = 'A';
x += 2;Az ilyen megoldásokat én nem kedvelem. C++ esetén legalább jelezni kell átdefiniálással, hogy tényleg ezt akarom.
Persze mindezek ízlés kérdése. Kinek az egyik tetszik jobban, kinek a másik.
Viszont Arduino esetén javasoljuk mindenkinek a C++ használatát! -
ekkold
Topikgazda
válasz
gyapo11
#16563
üzenetére
Egyetértek az előttem szólóval. A c fordító simán megeszi a pascal kódot csak a begin end helyett { } csúcsos zárójeleket kell használni. Viszont c-ben ugyanazt a feladatot sokkal egyszerűbben és tömörebben is meg lehet fogalmazni, pl:
pascal, c: x = x + 1;
c: x++;
-------------------------
pascal, c : x = 10*x;
c: x *= 10;
--------------------------
Persze még egy csomó dolog könnyebb c-ben, mert kevésbé szigorú mint a pascal, illetve sokminden felülbírálható (pl. változó típusok), és ha tudod mit csinálsz, akkor jól is fog működni. Pl.
x = 'A'; //x változóba berakunk egy A karaktert
x += 2; //x változóban a C karakter lesz -
Tomika86
senior tag
válasz
gyapo11
#16563
üzenetére
Mire ideértem a projektemmel, nagyon sok weboldalt átlapoztam. Nem megy középfokon még az angol, de azért megértem amiket írnak (na videóban nem értem meg).
A weboldalakkal voltak olyan gondjaim, hogy egy dolgot máshogy írtak meg. A fórumokban nagyon sok olyan projekt volt, ami hibásan lett közzétéve, ezekre külön kell figyelni. -
gyapo11
őstag
válasz
Tankblock
#16558
üzenetére
Ezt a Ritchie könyvet próbáltam, nagyon nem ment. Előtte a Turbopascal 4.0 könyvből kb. egy hétvége alatt megvoltak az alapok, tudtam programokat írni. De a C-t nem értettem, ma sem tudom, mintákból próbáltam pár programot alakítani, több-kevesebb sikerrel.
Angollal egyetértek, csak nem videó kellene beszélve, hanem weboldal képernyőfotókkal és írásban, az sokkal könnyebben megérthető és a google translate is segíteni tud copy-paste-tel. -
Tomika86
senior tag
válasz
Janos250
#16560
üzenetére
Most esp32-re készült el a kódom, amiben persze van library, és nagyon sok segítséget kaptam innét is. A library belvilágát nézegettem, azokat nem értettem meg, a többit már kapisgálom.
A fejlesztés alatt, a különböző részegységeket külön külön kipróbáltam az ESP32-őn. Átrágtam minden lépést. A tömbökkel még vannak gondjaim, aztán a bonyolultabbakkal osztályok, stb.
Így nagyon sokat tanultam mire ide jutottam a kijelzővel. Majd teszek fel videót róla, hogy sikerült.Köszönöm!
-
Janos250
őstag
válasz
Tomika86
#16559
üzenetére
Még pár megjegyzés:
A C++ tanulásához célszerű valamelyik korszerűbb fordító használata, mert abban minden benne van, ami a leírásokban szerepel. Az ESP32 ilyen, de bizonyára vannak mások is.
Futtasd a mintaprogramokat.
Ami a main()-ben van, az kerüljön a setupba, a return-t hagyd ki. A deklarációk a setup elé. A loop maradhat üresen.
Kiíráshoz, beolvasáshoz általában a cin, és cout szerepel, ezeket az ESP32 tudja.
Egy lehetséges indulás, ami nem a száraz "tudománnyal" kezd:Példának itt van a 3. lecke programja
https://www.webotlet.hu/?p=1726
using namespace std;
int main()
{
int fokozat;
double sebesseg;
char szinkod;
bool metal;
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
return 0;
}Beírva/átírva az Arduino IDE-be:
Feltöltés előtt nyisd meg a soros monitort, mert oda fog írni.
using namespace std;
int fokozat;
double sebesseg;
char szinkod;
bool metal;
void setup() {
// ez kell, hogy a cout a soros monitorra irjon
Serial.begin(115200);
delay(2000);
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
// return 0;
// ezt ki kell hagyni, mert mikrokontrolleren egy progran nem ér véget,
// ez majd a loop-ban az idők végezetéig fut
} ;
void loop() {
} ;Ezt irja ki a soros monitorra:
Ez egy virtualis auto.
Az auto sebessegfokozata: 4
Az auto pillanatnyi sebessege: 48.6
Az auto szinkodja: R
Az auto metalszinu: 1Ez még alap lecke, de van itt minden a későbbiekben.
-
-
Janos250
őstag
válasz
Tomika86
#16555
üzenetére
Célszerűen igen, mert az pl. osztályokat nem tudod megkerülni. Pl. egyből a serial, WiFi, stb.
Sajnos nagyon sok tankönyvnél ha elolvasod az első 10 oldalt, ami úgy kezd, hogy Bezárás, Öröklés, Absztrakció, Polimorfizmus, egyből el is vesztél az erdőben, mert fogalmad sincs, hogy mi az, az elvont, filozófikus megfogalmazásból semmit nem értesz, és kiakadsz, hogy ez nehéz.
Szerintem a példákon kell kezdeni, és amikor már mennek a dolgok, akkor már elolvashatod az első 10 oldalt is, mert akkorra már érted, mik azok a bűvszavak. -
válasz
Tomika86
#16553
üzenetére
C vagy C++? Mivel osztályokról beszélsz, szerintem te C++-ra gondoltál. Én ezt olvastam, elég jó: [link] A Stroustrup-féle C++ bibliát nyugodtan hagyd ki, hacsak nem akarsz megőszülni.
Szerk: persze az alap dolgokhoz /függvények, header fájlok/ teljesen jók a C könyvek is.
-
Tomika86
senior tag
Sziasztok!
Létezik olyan leírás magyarul, ahol C programozásáról írnak, az alapoktól a bonyolultabb műveletekről is? Olyanokat találtam, amik az alapokat adják át. Arduino programozásról.
Kicsit mélyebben szeretném belevetni magamat.
Függvényhívások, osztályok, objektumok. Ha includolok egy h fájlt akkor a .h fájlon kívül van a .cpp. Melyik miért van, mit csinál?Egyébként most vagyok ott, hogy minden működik a programomban, de 100% hogy lehetne optimalizálni még
Most várom a v3 panelemet a kínai gyártótól. -
gyapo11
őstag
A tranzisztor állapotait egy szelephez hasonlíthatjuk: nyitva van, ha áram folyik rajta, és zárva, ha nem folyik az áram.
OK, én is így használtam mindig.
Így van. Még annyit magyarázatként, hogy amikor egy relé tekercsén áram folyik át, akkor felépül egy mágneses tér, pont ez húzza be a relé mágnesezhető részeit. Viszont ha megszűnik az áram, akkor a mágneses tér is megszűnik. A megszűnés változás, és változó mágneses térben a vezetékekben feszültség indukálódik. Mégpedig olyan irányú, ami ellentétes a létrehozó árammal, vagyis mivel az egyik pontja testen van, a másik pontja fog negatív irányba ugrani, így jön létre az induktív tüske. Ami ha elég nagy, akkor a kapcsoló tranyót olyan nagy feszültségnek teheti ki, amitől az tönkremegy, a C-E feszültség túllépheti a megengedettet, mivel az egyik láb a tápon van, ezt akadályozza meg a dióda, ami a testhez képest csak -0.7 V-ig engedi a tüskét.
-
And
veterán
Először is fordítsuk vissza a nevezéktant. A tranzisztor állapotait egy szelephez hasonlíthatjuk: nyitva van, ha áram folyik rajta, és zárva, ha nem folyik az áram. Azon a rajzon a relé a vezérelt eszköz: ha a tranzisztor kinyit, a relé meghúz. Vagyis a relével párhuzamos dióda (gondolom ezt akartad írni) dolga nem a relé 'földre húzása'. Az a dióda csak akkor nyit ki (-> kezd el vezetni), ha a katódja negatívabb az anódnál. Belátható, hogy ez alapesetben, statikus állapotban sosem következik be, hiszen nyitott tranzisztor / meghúzott relé esetén záróirányú feszültség van rajta, zárt tranzisztor / elengedett relé mellett pedig konkrétan nulla. A dióda dolga annyi, hogy a relé behúzótekercsén a kikapcsoláskor (a relé elengedésekor) megjelenő tranziens, negatív irányú feszültségcsúcsot eltüntesse. Ezért ellenállással több okból sem lenne helyettesíthető: utóbbi egy lineáris alkatrész, nem félvezető, és a relével párhuzamosan kapcsolva csak a bekapcsolt / nyitott tranzisztoron átfolyó áramot növelné mindenféle lényegi haszon nélkül.
-
MPM
tag
válasz
gyapo11
#16420
üzenetére
Nah lenne még egy kérdésem: alul a relével párhuzamosan bekötött relé azt a célt szolgálja, hogy ha zár a tranzisztor, akkor lehúzza a földre a relé bemenetét?
Gondolom igen, csak kicsit bezavar az értelmezésemnek, hogy az anódra van a negatív (föld) csatlakoztatva.(A nyitott állapot oké, ekkor nem folyik rajta keresztül áram, a tranzisztortól a föld felé.)
Egyébként nem lehetne egy nagyobb ellenállással helyettesíteni ezt a diódát? Úgy gondolom az is ellátná ezt a feladatot, nyitott tranzisztor esetén arra folyna el az áram, zárt állásban pedig kevés feszültség esne rajta a földtől a bemenet felé.
Javítsatok ki, ha sületlenségeket írok! -
gyapo11
őstag
válasz
Janos250
#16548
üzenetére
Vám 150 EUR fölött van ha nem Európából jön a csomag. A kisebb értékű küldeményeken áfa van és ha a posta vámkezeli, akkor még valamennyi. A BG az áfát vásárláskor beszedi, ezt később átutalja a navnak, Európába behozza valahogy és innen mint európai csomag érkezik az országba, ezért semmi további költség nincs, mivel áfa fizetve, EU-ból érkező csomagra pedig nincs vámkezelés.
-
-
válasz
Dißnäëß
#16545
üzenetére
A 3 feszültségszintet nem pontosan értem, hogy gondoltad, de 2 lábbal és
2 tranyóval1 tranyóval is lehet szerintem NAND kaput létrehozni, hogy a 3. kijelző csak akkor kapjon magas jelet, ha mindkét láb alacsony. Vagy akkor már lehet valódi NAND kaput is használni a feladatra.
És van még pár lábspórolós trükk a tarsolyomban, ha egyszer szükséged lenne rá.nem gond, ha data közös ?
Miért lenne?
-
válasz
Dißnäëß
#16542
üzenetére
Miért kéne külön reset láb? Elég 1 közös, úgyis általában 1x kell resetelni a kijelzőket, vagy egyszer se! Az áramtalanítás többnyire reseteli a kijelzőt is.
Szóval ha a reset lábakat fixen a tápra kötöd, elég 6 láb is.Sőt: ha netán kevés lenne a szabad láb, a CS-el is lehet trükközni: egy láb elég két kijelzőnek, ha egy tranzisztorral invertálod, így magas állapotnál az egyik, alacsonynál pedig a másik kijelzővel tudsz kommunikálni. Egyszerre úgyis csak egy kijelzőre szokás írni.
Update: közben rájöttem, hogy ez csak 2 kijelzőnél működik, de azért itt hagyom, hátha vki hasznát veszi.
-
Dißnäëß
nagyúr
Ahány szabad lábad marad! Ugye a DI, DO, DC közös, viszont minden kijelzőnek kell egy-egy külön CS lábat biztosítani.
DI, DO, DC közös. Ok.
RES ? (Ez is közös, vagy kijelzőként 1 PIN-t befoglal ?)
CS - kijelzőként 1 PIN. OK.Magyarul 3 digital out pin fix, + 3x CS + 3x RES = legrosszabb esetben 9 digital PIN-re volna szükségem ?
Van egy ilyenem, ellőhetném ide akkor. [link]
-
vegyszer
addikt
Sziasztok!
Én most a Black Friday kapcsán futottam bele ebbe a kis cukiságba.
M5Stack M5Stamp C3
13GIO láb, és közvetlenül USB-C segedelmével programozható.
-
-
Dißnäëß
nagyúr
Áhh, 128-step relay attenuator-el megyek, azon a bemeneten, amit egyáltalán csillapítósra tervezek. Szóval van egy távszabályzós motorizált potim, ami annak ellenére, hogy direktben önmaga is tudna csillapítani, igazából csak említett board-ot hajtja meg, az meg elkattog nekem szépen és lőn hifi.
A fogasléc kiváló, még maradt is valahol Technic Lego-m a gyerekkoromból, lomolok hozzá valamit
Arduino kérdés: hány darab kis OLED-es kijelzőkét tudna meghajtani 1 szem Arduino Micro mondjuk, SPI-n, szerinted ? (3-at kellene, I2C-t meg nem választanám, mert ott sokkal lassabb a frissítési idő).
-
Dißnäëß
nagyúr
válasz
ekkold
#16528
üzenetére
Köszönöm és az Előtted szóló 2 kollégának is !
Csöves erősítő bias-t (munkapontot) tartana a helyén, ami idővel is, meg bemelegedés után is - a kapcsolásból adódóan - hajlamos picikét elmászni, illetve figyelne a push-pull kimeneten az input csövek eltéréséből (gyártási szórás) adódó DC offset-t is, ez egy másik kézi trimpoti lenne, amivel néha ez itt megjelenő offset-et érdemes visszakorrigálni 0-ra.
Gondoltam, ilyeneket rábíznék valami "automatikára", ne nekem kelljen ezt az amúgy "fix bias"-ú megoldást kézzel tekergetnem X naponta. (Elvileg ritkábban, de csináljuk jól, pontosan).
-
-
ekkold
Topikgazda
válasz
Dißnäëß
#16522
üzenetére
Ha a potméterek csak feszültséget szabályoznak, akkor kiválthatod megfelelő felbontású PWM + aluláteresztő szűrő kombinációval. Ha ennél precizebb dolog kell, akkor egy A/D-vel vissza is mérheted a szűrő utáni feszültséget, és pontosíthatod vele a PWM-et (akár egy PI vagy PID szabályozással). Ha nem simán DC feszültséget szabályoznak a potik, hanem egy áramkör részei, akkor bonyolódik a helyzet (pl digitális potival). Persze pontosabb válaszhoz ismerni kellene a feladatot.
-
gyapo11
őstag
válasz
Dißnäëß
#16523
üzenetére
A pwm jel szűrése lesz egy kicsit problémás, illetve kellő nagyságú kondival nem az, de akkor meg lassú lesz a jel változása.
Próbálkozhatsz shift regiszterrel és d/a átalakítóval, ekkor bármilyen bithosszúság (finomság) használható és a kimeneti jel azonnal beáll fixen, ahogy a bináris számot kiírtad. -
And
veterán
válasz
Dißnäëß
#16522
üzenetére
Nem bonyolítod túl, illetve csak egy kicsit. Például felesleges LC-szűrés, ha a PWM frekvencia elég magas és a vezérelt eszköz egy tranzisztor / mosfet. Bőven elegendő lehet egy sima egy RC-tag is. Az is számít, hogy mekkora felbontás kell, de az eredendően a PWM-nél sem alacsony, illetve a konkrét áramköri környezet is behatárolhatja a megvalósítást. A digitális potméter sem csodaszer, a szimulált ellenállás / csúszóérintkező potenciálja nem lóghat ki az IC tápfesz tartományából. Sokszor használtam már RC-szűrt PWM-et DC vezérlőjel helyett, az adott célra tökéletesen megfelelt.
-
Tomika86
senior tag
válasz
PeterPH
#16514
üzenetére
Helló
Ezt ma kipróbáltam, hogy lehet ezt kiküszöbölni egy függvényhívásnál?Beolvasok egy analóg értéket globális változóba
Meghívom a függvényt, a beolvasott értékkel elvégzi a számolást
Return visszaadja az értéket, majd visszatér a függvényhíváshoz, ahol folytatja a kódot.Megint beolvasok egy analóg értéket
Meghívom ugyanazt a függvényt, más bemeneti értékkel.Megköszönném ha valaki bevezetne mélyebben a Cbe, mert nagyon az alapoknál vagyok.
Köszönöm szépen!
-
Dißnäëß
nagyúr
Sziasztok ismét
Egy 1K-s és egy 10K-s 20-fordulatú precíziós (1W) trimpotot szeretnék helyettesíteni Arduino-val, hogy ő "forgassa" ezeket, értsd jól.
Hogyan tudnám legegyszerűbben megtenni ? Egyesek javasolnak digitális potmétereket is, én meg arra gondoltam, simán LC aluláteresztő szűrném a PWM kimeneteket és így kapnám meg a mikor milyen fesz.értéket, amivel egy tranyót vezérelve meg is volna a dolog sima analogWrite() használatával, szabályozva így azt, mennyit enged át magán a tranzisztor.
Vagy túlbonyizom, esetleg tök hülyeség ?
-
válasz
Tomika86
#16519
üzenetére
Ez pontosan ugyanazt csinálja, mint a te függvényes-tömbös megoldásod, csak sokkal egyszerűbben.
Ráadásul akár két számítás között is változtathatod a sample-ök számát, nincs hatással az eredményre. Például elkezdedn=1-el, és minden ciklusban eggyel növeled, amíg el nem éri a max (pl. 15) értéket, így már az elejétől fogva helyes adatot mutat, nem 0-ról indul. -
-
-
Tomika86
senior tag
// Akkumulátor feszültség mérés CH0
adc0 = ADS7828_olvasas (ADS7828_ADDRESS, CH0); //Analóg beolvasott feszültség érték
adc0_atlagolt = atlag_szamolas (adc0);
float feszultseg_temp = map(adc0_atlagolt, 0, 4095, akkumulator_fesz_minimum, akkumulator_fesz_maximum); //Analóg átalakítás feszültségre
akkufesz = feszultseg_temp * 1.0 + 0.6; //y=mx+c feszültség végeredmény
akkufesz = constrain(akkufesz, 0.0, 23.0);adc0 változik a különböző méréseknél
-
Tomika86
senior tag
Sziasztok!
Használom ezt a mozgó átlag függvényt:
uint32_t atlag_szamolas(int nyers_jel) {
int i = 0;
uint32_t osszeg = 0;
nyers_jel_buffer[nyers_jel_i++] = nyers_jel;
if (nyers_jel_i == SZURO_HOSSZA) {
nyers_jel_i = 0;
}
for (i = 0; i < SZURO_HOSSZA; i ++) {
osszeg += nyers_jel_buffer[i];
}
return (osszeg / SZURO_HOSSZA);
}Mitől lehet az, hogy akkumulátor feszültségnél átlagolás nélkül jól mutatja a feszültséget, csak tizedben ugrál 0.1 értéket. Ha berakom a függvényt akkor pedig a 13V helyett 3V körüli lesz a kimenete a függvénynek.
7 analóg értéknél használom ezt a függvényt, a többinél nincs ekkora eltérés.Köszönöm!
-
Janos250
őstag
A múltkori késő esti string és String kínlódásom után úgy döntöttem, hogy nincs értelme a brute force módszernek, inkább gondoljuk át logikusan. És tényleg! Ideírom a tapasztalataim, hátha valaha valakinek hasznos lesz a jövőben.
Kösz mindenkinek, aki segített!Arduino String (nagybetűs), és a C++ string (kisbetűs) kapcsolata.
Az Arduino String nem írható be paraméterként olyan helyre, ahol C++ string az elvárás, és ez fordítva is igaz.
A kettő közötti átmenetet a .c_str() tagfüggvény teszi lehetővé.String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
EzekkelString ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03 (ArduinoString_Hello.c_str());
Így új példányok jönnek létre.A szöveget mind a String, mind a string belül egy 0x0 terminált karakter tömbben tárolja, és a .c_str() konstans pointer mutat rá, ezért ha (char*) C típusú sztinget akarunk, akkor "const" miatt (char*) átdefiniálás szükséges.
Például:char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
Ebben az esetben nem jön létre új példány, hanem a char* típusú karaktertömb pointere is az eredeti objektumban tárolt karaktertömb kezdetére mutat. Ha az egyikben megváltoztatjuk valamelyik karaktert, a másikban is megváltozik.Az ESP32-höz használt fordító ismeri az iterátor típust is. A C++ string rendelkezik .begin(), .end() iterátorral.
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // dMintának egy teljes program:
using namespace std;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.println("Arduino String (nagybetus), es a C++ string (kisbetus) kapcsolata.");
String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
String ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
Serial.printf("ArduinoString_Hello :%s\n",ArduinoString_Hello);
Serial.printf("ArduinoString_Hello02 :%s\n",ArduinoString_Hello02);
Serial.printf("ArduinoString_Hello03 :%s\n",ArduinoString_Hello03);
Serial.printf("ArduinoString_Hello[0]:%c\n",ArduinoString_Hello[0]);
Serial.printf("ArduinoString_Hello.c_str()[0]:%c\n\n",ArduinoString_Hello.c_str()[0]);
/*
ArduinoString_Hello :Hello
ArduinoString_Hello02 :World
ArduinoString_Hello03 :World
ArduinoString_Hello[0]:H
ArduinoString_Hello.c_str()[0]:H
*/
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03(ArduinoString_Hello.c_str());
std::cout << "Cpp_string_World :" << Cpp_string_World<< "\n";
std::cout << "Cpp_string_World02 :" << Cpp_string_World02 << "\n";
std::cout << "Cpp_string_World03 :" << Cpp_string_World03 << "\n";
/*
Cpp_string_World :World
Cpp_string_World02 :Hello
Cpp_string_World03 :Hello
*/
char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
ArduinoString_Hello_c_str[2] = 'x';
Cpp_string_World[2]= 'y';
Serial.printf("ArduinoString_Hello is atirodik :%s\n",ArduinoString_Hello);
std::cout << "Cpp_string_World_c_str is atirodik :" << Cpp_string_World << "\n";
/*
ArduinoString_Hello is atirodik :Hexlo
Cpp_string_World_c_str is atirodik :Woyld
*/
// iterator:
std::cout << "Iterator:\n";
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/
std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // d
} ;
void loop() {} ; -
válasz
Tomika86
#16503
üzenetére
Hát én ezt úgy oldanám meg, hogy a uC bekapcsolásakor rögtön futtatnék egy i2c address scan-t, és utána annak az eredménye alapján kezelném a továbbiakban az eszközöket, hogy mit talált meg és mit nem. Nyilván elég csak azokat a címeket szkennelni, amik várhatóan csatlakoztatva lehetnek.
-
hibás... 
(szöveg lemarad).
Ügyes vagy!
Szóval ha a reset lábakat fixen a tápra kötöd, elég 6 láb is.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Új hozzászólás Aktív témák
Hirdetés
- Vidd haza a jövő RAM-ját már ma!
- BESZÁMÍTÁS! Apple MacBook Pro 14 M4 16GB RAM 512GB SSD garanciával hibátlan működéssel
- ÁRGARANCIA! Épített KomPhone i5 14400F 32/64GB DDR5 RTX 5060Ti 8GB GAMER PC termékbeszámítással
- Xbox Ultimate előfizetések
- Telefon felvásárlás!! iPhone 12 Mini/iPhone 12/iPhone 12 Pro/iPhone 12 Pro Max
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest
Cég: Promenade Publishing House Kft.
Város: Budapest