Arduino - Hobbielektronika.hu - online elektronikai magazin és fórum

(#)	Net_Boy_debr hozzászólása	Okt 27, 2017		/

Sziasztok!
Segítséget szeretnék kérni az alábbi Arduino-s projekttel kapcsolatban:
Van egy 12V-os DC táplálású eszközöm (adatgyűjtő), mely 4 db open drain kimenettel rendelkezik. Ezt szeretném illeszteni egy Arduino-s panelhez. Úgy kellene kiviteleznem, hogy ne menjen tönkre sem az eszköz, sem pedig az Arduino. Az Arduino 5V-os táplálású. Segítenétek ebben? A szintillesztést hogyan oldanátok meg?
Előre is köszönöm szépen a segítséget!

A hozzászólás módosítva: Okt 27, 2017

(#)	Bakman válasza Net_Boy_debr hozzászólására (»)	Okt 27, 2017		/

Én így csinálnám, lásd melléklet. Igaz, nem írtad, hogy a kimenet mennyivel terhelhető és milyen gyakori aa kimeneten a kapcsolás.

A hozzászólás módosítva: Okt 27, 2017

Shot_193.jpg

(#)	Net_Boy_debr válasza Bakman hozzászólására (»)	Okt 27, 2017		/

Szia!
Köszönöm! Így már világosabb!
Az adatgyűjtő kimenete sűrűn lesz kapcsolva, van, hogy másodpercenként kétszer, háromszor is. Az adatlap szerint a kimenet max 150 mA és max 28V DC-vel terhelhető.
A tranzisztor milyen legyen?

(#)	Bakman válasza Net_Boy_debr hozzászólására (»)	Okt 27, 2017		/

A tranzisztor kék keretben a nyitott kollektoros kimenetet szimbolizálja, azt a leírásod szerint tartalmazza az adatgyűjtő. Ebben a formában kevesebb, mint 15 mA-rel lesz terhelve egy-egy kimenet. A másodpercenként három-négy kapcsolás bőven belefér az optocsatoló (szinte mindegy, hogy milyen) karakterisztikájába.

(#)	Net_Boy_debr válasza Bakman hozzászólására (»)	Okt 27, 2017		/

Akkor, ha jól értem a tranzisztor elhagyható, és az optocsatoló 2-es lábát ellenállás nélkül a földre kell kapcsolnom? Vagy a 2-es láb az adatgyűjtő kimenetére csatlakozik?
Bocsi az alapvető kérdésért. Inkább szoftveres vagyok, mint hardveres!

A hozzászólás módosítva: Okt 27, 2017

(#)	Bakman válasza Net_Boy_debr hozzászólására (»)	Okt 27, 2017		/

Az optocsatoló kettes lába az adatgyűjtő kimenetére megy egy ellenálláson keresztül.

Shot_194.jpg

(#)	Kera_Will válasza Net_Boy_debr hozzászólására (»)	Okt 27, 2017		/

Nem érted?
A tranzisztor már BENNE VAN TE GYÁRI dobozodba ... TE írtad OPEN COLEKTOR.
A szemléletesség miatt lett oda rajzolva NEKED .
A dobozod kimenetére kell az ellenállás és az opto majd tápra egymás után sorba kötöd az opto másik végét ahogy a rajzon van.

A hozzászólás módosítva: Okt 27, 2017

(#)	Net_Boy_debr válasza Kera_Will hozzászólására (»)	Okt 27, 2017		/

Kera_Will: Rendben, megértettem!
Köszönöm mindenkinek a segítséget!

(#)	csatti2 hozzászólása	Okt 30, 2017		/	2

Nem bonyolítottátok ti ezt egy kicsit túl? Ha azok a kimenetek tényleg open-drain-esek, akkor pontosan nulla darab alkatrészre van szükség az illesztéshez. Az arduino bemenetein be kell kapcsolni a felhúzó ellenállásokat, majd össze kell kötni az eszköz kimenetével, közösíteni kell a földet és kész.

(#)	game4812 válasza jany1966 hozzászólására (»)	Okt 31, 2017		/

A kábel volt a baja, a GPS-ével tökéletes. Végülis csak 5 munkaórát és egy ezrest dobtam ki a rossz kábelre... Ezeken mini USB van,a telefonokon pedig micro, ezért nem tudtam kipróbálni cserekábellel eddig, de így tökéletes, köszi a segítséget!

(#)	mrkatona hozzászólása	Okt 31, 2017		/

Sziasztok,

Kezdő vagyok arduino uno programozásában, ezért egy kérdéssel fordulnék hozzátok.
Adott egy LED vu méter kód, amit egy weboldalon találtam 5 db LED-el.
Összeraktam, működik, majd kibővítettem a programot 14 db LED-re.
Eddig nem lenne gond, viszont a kezdetektől van egy furcsa működési mechanizmusa, amit szeretnék megoldani benne. A LED-ek vibrálnak működése során, ezt szeretném csillapítani egy pici késleltetéssel. Arról van szó, hogy a LED-ekre szeretnék tenni egy kis delayt, tehát az a LED ami egyszer bevillan kb. 20 ms-ig maradjon is bekapcsolva. Nekem most úgy tűnik, hogy ezt nem csinálja, a LED-ek vibrálva gyulladnak fel.
Tudnátok ebben segíteni?
A kód:

/*
* A optimised VU driver for arduino with analog smoothing
*
* Created By:
* Dox Drakes
*/
//settings for leds and smoothing
const int NUMLED = 14; //number of outputs
const int NUMSAMPLE = 10; //Samples taken. More = Smoother but also slower.
const int DELAY = 5; //Delay to keep it stable
//which pins are you using for inputs?
const int refPIN = A0; //this value should always be zero
const int voltPIN = A2; //this is the audio input pin
//which pins are you using for outputs?
const int ledPIN[NUMLED] = {13,12,11,10,9,8,7,6,5,4,3,2,1,0}; //Number of each output pin
//value scaling. change these to make it more or less sensitive.
//the analog input signal ranges from 0 to 1024, so find some numbers in between there.
const int voltTHRESH[NUMLED] = {30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360, 390, 420 }; //Value asscociated on an ON led
int vREF = 0; //Sets reference voltage to 0 (leave this alone)
//sample variables for smoothing (leave these alone)
int SAMP[NUMSAMPLE] = {0}; //value of sample
int INDEX = 0; //number of sample from 1-[NUMSAMPLE]
int TOTAL = 0; //running total of sample values
int AVG = 0; //average of sample values over [NUMSAMPLE]
void setup() {
//Setup for the smoother
for (int READ = 0; READ < NUMSAMPLE; READ++){ //initalizes readings
SAMP[READ] = 0; //sets readings to 0
}
//setup for the led outputs
for (int p = 0; p<=13; p++){ //cycles through pins 0-13
pinMode(p, OUTPUT); //sets the current pin to OUTPUT
}
//setup for analogue inputs
pinMode(refPIN, INPUT);
pinMode(voltPIN, INPUT);
}
void loop() {
//Here is the start of the smoother
TOTAL -= SAMP[INDEX]; //Subtracts the last sample
SAMP[INDEX] = analogRead(voltPIN); //sets the sample to the analoge reading (0-1024)
TOTAL += SAMP[INDEX++]; //adds the sample to the total and moves INDEX to the next value
if (INDEX >= NUMSAMPLE){ //checks if limit of samples is reached
INDEX = 0; //resets INDEX to 0, restarting the process
}
AVG = TOTAL / NUMSAMPLE; //Calculates the average
//Here is where the led control starts
int vREF = analogRead(refPIN); //sets vREF to the value of our reference pin
for (int i=0; i<NUMLED; i++){ //runs through each led until all have been checked
if (AVG >= vREF + voltTHRESH[i]){ //finds out if the led should be on
digitalWrite(ledPIN[i], HIGH); //sets the current PIN to HIGH if true
}
else{
digitalWrite(ledPIN[i], LOW); //sets the current PIN to LOW if false
}
}
delay(DELAY); //delay for stability
}

A hozzászólás módosítva: Nov 1, 2017

Moderátor által szerkesztve

(#)	tbarath válasza mrkatona hozzászólására (»)	Okt 31, 2017		/

Szia,

A kódokat illik code tag-be tenni.
A 20 msec-es kérdésedre: van a loop végén egy delay, a DELAY konstans értéke pedig 5 ms. Próbáltad ezt megemelni 20-ra?

A hozzászólás módosítva: Okt 31, 2017

(#)	mrkatona válasza tbarath hozzászólására (»)		Okt 31, 2017		/

Igen próbáltam. Ha felviszem 20 ms-ra, attól csak az egész reakcióideje, működése lesz lassabb.

(#)	game4812 válasza mrkatona hozzászólására (»)	Okt 31, 2017		/

Valószínűleg az a baja, hogy éppen eléri az átlag a 30-60-90-stb értékeket, utána rögtön kap egy kisebbet, és már csak 29 lesz. Elvileg a delay megemelésének meg kellene oldania, ha közben csökkentet a mintaszámot, ugyanolyan gyors lesz a reakcióideje (pl. delay 25, sample 2), vagy megemeled többszörösére a minták számát, és csökkented a delayt, (pl. delay 2, sample 25) így többszörösére nő a pontosság, ha fix jelről van szó, és pontosabb, mint az előző módszer, viszont zenénél nem biztos, hogy segít a problémán. Ugyanezt elérheted egy kisebb kondenzátorral, ami simítja a jelet. Az igazi szerintem úgy lenne, hogy gyors maradna a mérés (delay 2, sample 25), és a LED control részt csak 20ms-onként futtatnád, ehhez a BlinkWithoutDelay alappélda az IDE-ben tökéletes támpont.

A hozzászólás módosítva: Okt 31, 2017

(#)	game4812 válasza game4812 hozzászólására (»)	Okt 31, 2017		/

Kicsúsztam a módosítási időből, de valahogy így csinálnám, nem teszteltem:

unsigned long previousMillis = 0;
const long interval = 20; //kijelzés gyakorisága
const int NUMSAMPLE = 25; //mintaszám
const int DELAY = 2; //~mintavétel gyakorisága
const int refPIN = A0;
const int voltPIN = A2;
const int ledPIN[NUMLED] = {13,12,11,10,9,8,7,6,5,4,3,2,1,0};
const int voltTHRESH[NUMLED] = {30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360, 390, 420 };
int vREF = 0;
int SAMP[NUMSAMPLE] = {0};
int INDEX = 0;
int TOTAL = 0;
int AVG = 0;
void setup() {
for (int READ = 0; READ < NUMSAMPLE; READ++){SAMP[READ] = 0;}
for (int p = 0; p<=13; p++){pinMode(p, OUTPUT);}
pinMode(refPIN, INPUT);
pinMode(voltPIN, INPUT);
}
void loop() {
TOTAL -= SAMP[INDEX];
SAMP[INDEX] = analogRead(voltPIN);
TOTAL += SAMP[INDEX++];
if (INDEX >= NUMSAMPLE){INDEX = 0;}
AVG = TOTAL / NUMSAMPLE;
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {previousMillis = currentMillis;
int vREF = analogRead(refPIN);
for (int i=0; i<NUMLED; i++){if (AVG >= vREF + voltTHRESH[i]){digitalWrite(ledPIN[i], HIGH);}
else{digitalWrite(ledPIN[i], LOW);}}}
delay(DELAY);
}

(#)	szikorapéter hozzászólása	Okt 31, 2017		/

Sziasztok. Olvasgatok a fórumon de csak nem lelem a megoldást. Arduino mega 2560-hoz szeretnék 16LF01UA3 típusú VFD kijelzőt illeszteni de nem akar összejönni. Van neki egy 12 tűs csatlakozója, amiből a 3-as tű nincs bekötve. Gondolom ennek a vezérlőjéhez még nem készült semmilyen arduino-s mintaprogram így gondoltam magam próbálnék meg írni hozzá egyet.

(#)	vargaf válasza szikorapéter hozzászólására (»)	Okt 31, 2017		/

Ezt már nézted:
Samsung_16LF01_VFD

(#)	szikorapéter válasza vargaf hozzászólására (»)	Okt 31, 2017		/

Ezer hálám.

Így fel tudom használni végre a kijelzőket amik itthon vannak.

(#)	mrkatona válasza game4812 hozzászólására (»)	Nov 1, 2017		/

Szia!

Köszi a kódot, egy hibáért szólt a fordító, azt a sort pótoltam.
(const int NUMLED = 14; //number of outputs)

Működik rendesen, bár még nem teljesen úgy ahogy szeretném.
Most a paramétereket próbálgatom. Kipróbálgatom amit írtál.

(#)	mrkatona válasza mrkatona hozzászólására (»)	Nov 1, 2017		/

Próbálgatom de csak nem az igazi. Az lenne jó, ha a LED ami bevillan kb. 20 ms-ig világítva is maradna. Csak fogalmam sincs ezt hogyan lehetne beleapplikálni a programba.
16f873-as pic-el parsicban korábban tök szuper kivezérlésjelzőt csináltam peakhold kijelzéssel és 2x10 LED-el. Ott is ez a 20 ms adta azt a látványt ami tetszett. Ha pirosba ért ott 500 ms-ig világított. Ezt a látványt szeretném itt is elérni.

(#)	tbarath válasza mrkatona hozzászólására (»)	Nov 1, 2017		/

A ciklusidőd kb. 5 msec, gondolom nagyrészt a delay határozza meg.
Ha 20 msec-en belül nem akarsz kioltást, akkor csinálj egy 4 elemű tömböt, hozzá egy ciklikusan körbemenő index változót. Abban tárold az állapotot, és ha az nagyobb mint az aktuális kivezérlési szint, akkor arra állítod be, majd a kivezérlési szintet eltárolod.

Bár prózában nem biztos hogy érthető, pszeudokód:

const int ize = 4;
int izek[ize] = {0,0,0,0};
int izeMost = 0;
int izeMax = 0;
int AVG2;
loop(){
// mérsz;
AVG2 = AVG;
izeMax = 0;
for (int i=0; i<ize; i++){
if (izeMax < izek[ize]){
izeMax = izek[ize];}
}
if (AVG2 > izeMax){
AVG = AVG2;}
else{
AVG = izeMax;}
if (AVG >= vREF + voltTHRESH[i]){
digitalWrite(ledPIN[i], HIGH);}
else{
digitalWrite(ledPIN[i], LOW);}
}
izek[izeMost] = AVG2;
izeMost++;
izeMost = izeMost % 4;
delay(DELAY); //delay for stability
}

A hozzászólás módosítva: Nov 1, 2017

(#)	kapu48 válasza mrkatona hozzászólására (»)	Nov 1, 2017		/

Elsőnek tisztázzuk, hogy a C-ben:
A változók nevét kisbetűkkel írjuk jó: int index = 0; (rossz: int INDEX = 0

A constansok nevét csupa nagybetűvel jó: const int REFPIN = A0; (rossz: const int refPIN = A0

Ebből látjuk, hogy a csupa nagybetűs értékeket a nem változtathatjuk meg a program futása közben!

A késleltetet műveletek megvalósítása:

//Ezt tömbé alakítjuk:
unsigned long previousMillis[NUMLED];
//Itt fogjuk megadni az egyes LED-ek késleltetett kikapcsolás értékét.
//Írunk rá törlő rutint: (Ezt meghívjuk a setupban)
void previosDel(){
for int i=0; i<NUMLED; i++{
previousMillis[i]=0;
}
}
void setup() {
...
previosDel();
}
//A loopban így állítjuk be az x LED késleltetést:
void loop() {
…
previousMillis[x] = millis()+y; //x=Az aktuális LED pin száma, y=a késleltetés értéke
digitalWrite(ledPIN[x], HIGH); // Bekapcsoljuk a LED-et
…
..
// A loop végén lekezeljük a késleltetéseket:
for int i=0; i<NUMLED; i++{
if (previousMillis[i] > 0){ // Ha nagyobb, mint 0
if (previousMillis[i] < millis()){ // Ha letelt a hozzáadott érték?
previousMillis[i]=0; // töröljük a késleltetést
digitalWrite(ledPin[i], LOW); // Ki kapcsoljuk az aktuállis LED-et
}
}
}
} //loop vége

És lehetőleg ne használj delajt a programban!

A hozzászólás módosítva: Nov 1, 2017

(#)	tbarath válasza kapu48 hozzászólására (»)	Nov 1, 2017		/

Egyrészt: nincs semmilyen kötelező kódolási konvenció. Otthon, magának mindenki úgy csinálja, ahogy neki jó, munkahelyen pedig jellemzően van egy központi előírás amit követni kell. Ez amúgy cégenként jellemzően eltér, néha adott cégen belül csapatonként is. (Pl. a Microsoft-nál használták az ún. "Hungarian Notation"-t, de ha jól tudom ott se minden team, és nem is egyformán.)

És a delay-jel _általában_ semmi baj nincs, noha van amikor tényleg nem javasolt a használata.

(#)	csatti2 válasza tbarath hozzászólására (»)	Nov 1, 2017		/

A delay-el sok probléma van. Az elején hasznos, hisz hamar sikerélményeket érhet el valaki, később viszont lustává tesz és rossz hatásfokú programokat lehet csak vele írni. Ez persze igaz sok egyéb Arduino-s funkcióra is. Például a fent vázolt programnál 5ms-es késleltetésnél kevesebb mint 200Hz-en mintavételez, míg 20ms-nél már csak 50Hz alatt teszi ezt, miközben a hardver képességeit kihasználva több tíz kHz-en is lehetne, az analóg mintavételezést a szűréssel együtt leválasztva a főprogramról (autotrigger + megszakítás).

(#)	kapu48 válasza tbarath hozzászólására (»)	Nov 1, 2017	1	/

Igen otthon magának azt csinál, a mit tud!
Viszont ha már közzé teszi a művét! Akkor már csak udvariasságból is illik úgy csinálni, hogy olvasható legyen. Mert akkor elképzelhető, hogy hamarabb kap segítséget!

Ha kihagyja a delajt? Akkor minden loop ciklusban tud analóg mintavételezni.
Ez által gyorsabban tud reagálni a változásra.

A fentebbi késleletetés logikáját, 1 delajal teljesen tönkre teszi!

Máskor inkább gondolkozz, előbb mit írsz le!
És illene inkább meg köszönni a segítő szándékú tanácsokat!
Vagy egyáltalán ne kérjen tanácsot az olyan ember, aki nem bírja a kritikát!

(#)	nedudgi válasza kapu48 hozzászólására (»)	Nov 1, 2017		/

A probléma főleg ott van, hogy ajánlásokat megfellebezhetetlen szabályként írtál le.

(#)	kapu48 válasza nedudgi hozzászólására (»)	Nov 1, 2017		/

Szerintem meg, ha azon kel bosszankodnom, hogy értelmezhetetlen a kód!
És elmegy a kedvem időt szánni a segítségre! ….

(#)	tbarath válasza csatti2 hozzászólására (»)	Nov 2, 2017		/

A kollega az elején tart, azt vegyük figyelembe.
Másrészt sokszor nincs is szükség arra, hogy a hw képességeit kihasználjuk, vagy ha meg is tennénk akkor se lenne jobb az eredmény, csak a kód lenne bonyolultabb. Lásd az alap blink program,de a mostani kivezérlésjelzőnél is pont elég az akárhány ms-onkénti mintavételezés és LED beállítás, aztán kis delay.

(#)	tbarath válasza kapu48 hozzászólására (»)	Nov 2, 2017		/

No offense, de ami olvashatatlan, az a "delaj" (sic!). És a kódja olvasható, még ha _neked_ nem is tetszik. (Amúgy nekem se, de attól még tudom olvasni.)

Az pedig nagyon remek, hogy delay nélkül egységnyi idő alatt több mintavételezést is csinálhatna (mert így is "minden loop ciklusban tud analóg mintavételezni", és csinálja is), csak épp erre semmi szüksége nincs. Sőt, épp az a baja, hogy a kijelzés túl gyors.

Az ilyen "egy input, egy output, nem kritikus" jellegű feladatokhoz pont jó a delay. Ha pl. valami kritikusabb szabályozást csinálna, akkor én is azt mondanám, hogy hagyja a delay-t, inkább mérjen minél gyakrabban, és ha be kell avatkozni akkor tegye. A kijelzést frissítése pedig mehet millis használatával mondjuk 100-500 msec-enként, és tényleg ne használjon delay-t.

De ez egy kivezérlésjelző, semmilyen szabályozás nincs benne, ide pont tökéletes a delay, erre van kitalálva.

(#)	Balagemann2031 hozzászólása	Nov 2, 2017		/

Sziasztok! Egy ILI9341-es vezérlővel ellátott 2,2" -s TFT kijelzőt tesztelek, arduino uno-val. Az lenne a kérdésem, hogy Adafruit GFX könyvtárat használja-e valaki, és ha igen lehet-e gyorsítani a képfrissítésen? El lehet azt érni sebességben, hogy ne látszódjon a képernyő írása? (pl: nem szeretném látni ahogy végigsöpör egy teljes fekete képernyő lentről felfele)