A hozzávaló lib tartalmazza a .cpp és .h fájlokat. (<UTFT.h><UTouch.h>) és az ugyanilyen nevű .cpp fájlok) Abban pontosan meg tudod nézni a függvények nevét és a paramétereit, hogy mit milyen formában vár.

Például rögtön rá lehet keresni a fenti függvényekre, ha nincs, akkor meg kell keresni azt, ami épp ezt csinálja csak más néven, esetleg más paraméterekkel. Nem kivitelezhetetlen, hiszen a lib-ek éppen ezért vannak. A másik, hogy a lábakat is elenőrizni kell, hogy az adott lib melyikeket használja.

Elvileg minden lib ki lett próbálva, szóval mennie kellene. A példakódok nem feltétlenül az adott lib-hez tartoznak.

Kedves Kollégák! Amatőr kérdés lesz, mert alapvetően az Arduino alapú plc topicban a mechnanikával foglalkozom. Arduino NANO összes felhasználható lába mennyire tehető? A kérdés azért fontos mert eredeti terv szerint lett volna 8 kimenet 8 bemenetű PLC. Közben addig agyaltam amíg rájöttem, hogy legalább egy vagy két kimenet lehetne 0-10 voltos, valamint célszerű lenne ilyen bemenet is csinálni. Nem én vagyok a legélesebb kés programozást tekintve, így ha valakinek lenne ideje segíteni megköszönöm.

Kérdések: Arduino nano analóg jelet 0-5 volt között kezel? Melyik a két legjobb kivezetés erre a funkcióra? Adná magát ha a berendezésbe nem kell analóg jel, ezek használhatóak DI nek is.

2. Szintén kérdés hogy melyik a legjobb kivezetés analóg és PWM kimenetre. Utóbbinak mik a paraméterei/ határai. Adja magát, ha nem kell analóg kimeneti, vagy PWM jel, használható DO ként.

3. A fentiek kihasználása mellett, hány kimenetem és bemenetem marad maximálisan?

Köszönöm előre is.

Kiegészítés: Mechanikai és gazdasági okok miatt mindenképpen a Nano ban gondolkodom, akkor is ha kevesebb a kimenet és bemenet. Akkor a nem ipari plc eszköz kicsit butább lesz.Bővebben: Link Erről az alap projektről van szó.

Hali! Megnézed a proci tipusát, utána az adatlapját... De figyelem, egyszerre az összes láb valószinűleg nem terhelhető a max árammal, a chipre meg lesz adva az össz. fogyasztás is

Ha raksz mellé pl. egy ilyen bővítőt: Bővebben: Link
Akkor lesz elég digitális Portod, és az analóg bemenetek megmaradnak választható alkalmazásokhoz.

A relék vezérlését pedig opto csatolókkal oldjak meg: Bővebben: Link

Azzal a TFT LCD Mega Schild-el.

Azért érdekes a leirás, méghogy SSR-k vannak a modulokon.

Bocs, csak elvesztem egy kicsit, köszi a válaszod!

A kérdéseidre a választ nem az Arduino adja meg, tekintve hogy az ARDUINO a szoftver környezet, hanem a hardveren lévő MCU típusa. Ami jelen esetben Atmega328.

1.a ADC értéke függ a beállított referencia feszültségtől (Max 5V) Adatlap: ADC rész
1.b Azt hogy melyik lábakon mi van kivezetve szintén adatlapon látható.
1.c ADC láb használható Digitálisnak, de a referencia lábon lévő feszültséget veszi fel.
2. ADC, PWM adatlapon látható
3. Adatlapon látható.

Ha elhagyod az Arduinot, és közvetlenül az Atmega328-at programozod valami mással (C++, Bascom, stb.) több felhasználható lábad lesz, és hozzá férsz olyan funkciókhoz is amihez a Nano kialakítása végett nem tudsz (pl. 20Mhz órajel, beépített RTC, stb.)
Érdemes olvasgatni az AVR miértek fórum témát is.

De a felsorolt kitételek miatt érdemes váltatni a Nano-ról STM32F***-re
Sokkal több portja van. Több és nagyobb felbontású ADC, több PWM, nagyobb sebesség. Arduino környezet támogatja, mechanikailag épp úgy rendben van mint a Nano, és gazdasági okoknak is megfelel tekintve hogy olcsóbb mint a Nano.

Mindenkinek köszönöm az eddigi válaszokat! Értem az érvelést a mikroprocesszor ügyében. Valószínű az lesz a megoldás, hogy az igényekez csökkentem. Első megközelítésben maradok a NANO nál. 7 DÓ biztosan ban a mintában 4AI és 5 DI. A 4 AI-t bérmikor tudom használni DI nek és valójában ezzel már nagyon sokféle feladatot meg lehet oldani.

Megnézem az STM32 paramétereit is. Pár nap és jelenkezem mire jutottam.

Ha speciális ki/be menetek kellenek (PWM, Interrupt, I2C, stb.) nézd át tervezés előtt az ic adatlapját, miből mennyi van, és hova kell kötni az ATMEGA 328-ban lévő hardveres támogatás végett. Sok kellemetlen meglepetést el tudsz kerülni ezáltal.

Egy kis segítség az STM-hez megtestesules

Megint szeretnék segítséget kérni, a következőkben.
Adott egy véletlenszerűen generált szám, amit egy változóban tárolok, de egyelőre még csak kiíratom. Ennek a változónak az értéke 5-ször változik meg. Ezeket a változásokat egy tömbben vagy egy listában szeretném eltárolni. Majd kiválasztani a legnagyobb elemet. Hogyan tudnám feltölteni ezt a tömböt vagy listát a megadott elemekkel?
Azt gondoltam létrehozok egy üres listát, és for ciklussal beleteszem az elemeket. Ezt meglehetne oldani Arduinoban is? Esetleg erre tudnátok példát mutatni, hogy néz ki egy ilyen struktúra?
Köszi a segítséget!

Mindenképpen el kell tárolni? Mert a legnagyobb elem kiválasztásához nem kell tárolni, elég akkor vizsgálni mikor létrehozod. De persze lehet tárolni is.

minta:

int i;
float maximum=0.0;
float veletlen=0.0;

for i=0; i<5;i ++
veletlen=random_generátor;//arduino véletlen generátora.....
if veletlen>maximum
maximum=veletlen;

Ezzel 5 véletlen számból kiválasztod a legnagyobbat. Persze nem tökéletes a kód, dolgozz vele, csak gondolatébresztőnek szánom. Így tárolni sem kell a tömbben. Ha meg kell, akkor az is igen könnyen megoldható.

de ez sem tökéletes, de már majdnem jó... A legjobb, ha az első maximum egyben az első véletlen is, mert mi van a fenti kóddal, ha mindegyik nulla, vagy valami...

így az első maximum is véletlen, ezért aciklussal csak 4-ig kell menni.

int i;
float maximum=0.0;
float veletlen=0.0;
maximum=random_generátor;//arduino véletlen generátora.....

for i=0; i<4;i ++
veletlen=random_generátor;//arduino véletlen generátora.....
if veletlen>maximum
maximum=veletlen;

Szerintem igen, muszáj lesz eltárolni.
Ezek az elemek sorba jönnek, nem egyszerre. Elfelejtődnek.
De... adtál ötletet.

Vagy így valahogy (elmélet);

Így már lehetne, hogy működjön, de nem fog...

A tömb indexei nem jók, mindenhol csak a 0. -ik indexűnek adsz értéket!

Jó az, valamit tárol. Gyorsan írtam.

Köszönöm!
A max kiíratása már ismerős.

Nincs mit!

Egy másik megközelítés ha sorba rendezed a tömb elemeit. Ilyenkor könnyen tudsz legkisebb, legnagyobb, de akár középérték körülit is kiválasztani.



Működési elve: qsort

De itt van egy másik, igaz nem Arduino hanem Bascom, de könnyen implementálható:

Köszi a segítséget. Bamba voltam és nem jutott eszembe, hogy ezekben a file-okban meg tudom nézni a fügvényeket
A problémát megoldottam pár egyszerű sorral:
///////////////TIMER////////////////
if (timer == 1){
sec = sec + 1;
delay(1000);
if (sec == 60)
{
sec = 00;
Min = Min + 1;
}
if (Min == 60)
{
Min = 00;
hrs = hrs + 1;
}
}
Még egyszer köszi a segítséget.

Üdv!

Akkor jók lehetnek a kijelzések, de ezt a kódot nem értem pontosan. Az idő nem lesz pontos. Miért nem használsz timert? Az pontosabb lehet, mert a fenti kódodban a műveletek elvégzéséhez időre van szüksége az mcu-nak. Volatile változót növelhetsz, ha a timer beüt. Elvileg az Atmega is tud olyat, hogy a Timer valmilyen kezdőértékről indulva fusson. Azt beállítva lehet pontosítani még. Bár az IDE erre nem nagyon alkalmas.

if (timer == 1){
sec = sec + 1;
delay(1000); //Ez nem vágja agyon a hardveres timert????

Bár itt van timer, de nem tudom az pontosan micsoda, de a delay tuti nem a legjobb ide. Vagy még jobb megoldás az RTC modul használata lenne.

Itt valamiről beszélgetnek:

Bővebben: Link

A PIC-nél (annak sem pontos a pll-je) úgy kell beállítani a timert, hogy a fő oszcillátort le lehet osztani kettő hatvényaival. Azaz pl 64-el. Feltéve, ha az Arduino 16MHz-en fut, akkor 0.25MHz-en fut a timer 64 -es leosztás mellett. Ha a timer 66535-ig tud számiolni, akkor a túlcsordulás kb 0.27s -enként történik. Ez nem elég, de le lehet osztani többel is:

3. Available division factors:
CS12 - CS10 = 000 : no clock source TC1 is OFF
CS12 - CS10 = 001 : divide by 1
CS12 - CS10 = 010 : divide by 8
CS12 - CS10 = 011 : divide by 64
CS12 - CS10 = 100 : divide by 256
CS12 - CS10 = 101 : divide by 1024

Ha 256-al osztod, akkor már több mint 1s. Az jó. Ha tudod, hogy 16/256MHz (62500Hz)-en számol a timer és tudod, hogy ha 16 bites a timer (saccolom, remélem ennyi) akkor 65535-62500=3035-ről kell indtani. A PIC-nél lehet tudni, hogy maga a beállítás mennyi órajelbe telik, azt le lehet vonni. De 256 prescale-nél mát más lehet a dolog...

Szóval, ha pontos külső 16MHz-es kvarcról hajtod, még pontos is lehet.

De lehet ezt is csinálod, de akkor a delay-t nem értem...

Atmega szériára rá lehet akasztani 32kHz-es kristályt is. Az pontos 1 sec időzítést ad (függ a ppm értéktől). De ezt a funkciót az Arduino nem támogatja.

Atmega128-ra raktam 32kHz-es kristályt, közben a proci a belső 8MHz-es órajeléről járt. Jól működött.

Sziasztok!

Egy vasútmodell terepasztal állomásának jelzőit (lámpáit) szeretném arduinoval vezérelni. A lámpák vezérlésében van valamennyi szabály. Pl ha szabad jelzést adunk egy kapcsolóval ÉS a vágányút egyenes, akkor más lámpáknak kell világítania, mint hogy ha pl a vágányút kitérő (a logika ebben az, hogy ilyen esetben pl a vonat nem mehet full sebességgel, tehát ha jól emlékszem pl sárga jelzés a szabad és nem a zöld. Ami egyébként nem is zöld, de ez itt most részlet, nem mennék bele). Ezeket simán leprogramozom, ez nem probléma és van is már ardionos tapasztalatom elegendő.

Ahol bizonytalankodom: kb 80-100 LED-et kell meghajtani, illetve kb 50 bemenet kezelését megoldani (ezek mechanikus kapcsolók jelei, amivel be van állítva a szabad vagy vörös jelzés illetve a váltóktól visszajelzés, arról, hogy áll a váltó (tulajdonképpen azok is kapcsolók). A bemenetek, kimenetek száma miatt fontos, hogy kevés arduino portot használjanak el és lehessen őket chain-be vagy egymás után kötni (tehát ha pl 6 port extendert használok, akkor is csak mondjuk 4 arduino portot használjon el)

Abban szeretnék tanácsot kérni, hogy melyek a legjöbb eszközök ezekre az esetekre. Nyilván a vezérlés Arduino-s lesz, azt megoldom, a kérdés csak a perifériák illesztése.

Én jelenleg arra gondoltam, hogy TLC5947-tel hajtanám meg a ledeket és valószínűleg SX1509-tel kezelném a bemeneteket. Van-e jobb megoldás?



Amiket néztem:

Ledek meghajtására:
Ezt választanám: TLC5947 - 24-Channel, 12-Bit PWM LED Driver (előnye: sok led és nem kell plusz ellenállás a ledeknek, illetve végül is ezt pont ledek meghajtására lehet használni, illetve ez tud elég áramot adni a sok lednek, amit rákötök (24 LED egy ilyen IC-n azért már számottevő áram))
gondolkoztam ezen is, de ez macerásabb. Kevesebb ledet tud kezelni és kellene nekik ellenállás is, illetve nem bírna elég nagy áramot kezelni: 74HC595 8-bit Serial In – Parallel Out

Arra is gondoltam még, hogy mivel a jelzőkön több led van különböző színnel, lehet, hogy csoportosítani fogom, hogy pl az első TLC5947 a piros ledeket hajtja meg, a másik a sárgákat stb. Bár lehet, hogy egyenként lehet a PWM-mel fényerőt állítani a ledeken, ezt nem néztem még meg (mert a különböző színű led-ek esetleg külöböző áramot igényelnek)


Bemenetek kezelésére:
74HC165 8-bit Parallel In – Serial Out
MCP23017 port expander
SX1509 16 I/O Expander

Itt igazából az SX1509 és a MCP23017 között nem tudok dönteni, de az SX1509 felé hajlok.

Csak érdekességképpen: egy jelző kb így néz ki és lehet vásárolni úgy is, hogy nincs benne ellenállás (mert egyébként akkora ellenállás van benne "gyárilag", ami 12 voltról való működést tesz lehetővé: https://minibox.hu/termek/mb304_mav_fenyjelzo_4_led_187.html

Ha kábelezés megoldható akkor célszerűbb lenne a ledek meghajtására mátrix meghajtót használni pl. MAX7219

De lehet cél IC-t is használni, ami kezeli a ledeket és a gombokat is, pl. TM1628 és klónjai. Kínából rendelve pár száz Ft/db, de ingyen is hozzá lehet jutni régi eszközökből Hogyan működik

Arduino alá is találni mintakódokat hozzájuk.

Ledek meghajtásához ws2811 ?

Ezeknek a jelzőknek sajnos egy közös kivezetése van, és fényenként egy-egy szál. Így a mátrix, meg még néhány csoportos meghajtás nem kivitelezhető.