Szerintem valami client.read függvénnyel kapod meg, kívánt méretű darabokban, és oda teszed/egymás után fűzöd, ahogy akarod. A kért méret célszerűen egy packet hosszának többszöröse ami ha jól emlékszem 1460? (FTP progikban láttam hogy nagyobb adattömegnél gyorsít) De talán lehet akár 10k is.

Tökéletes választás Arduino-t használni. Csak azért írtam a lehetőségeket, hogy lásd jó nagy a tervezési tér a befektetett energia, pénz és az eredmény elvárt tulajdonságai függvényében.

Nekem is egyik kedvencem ez a modul, egyedül a stab. ic nem tetszik a "pont az épp bírja a 12V" végett(nagyon könnyen füstöl ha meghaladja a 12V -ot) , de ez megoldható és nincs rajta "fölösleges" ic ami energiát fogyaszt, talán a ledek de az is megoldható . Van is belőle jópár darab itthon

Én ebből használtam eddig kettöt, még nem volt gondom velük(kopp-kopp). Most van szabadidöm ugyhogy elkezdtem tervezni egy sajátot itthonra ami persze nem kap ilyen olyan ipari minősítést de igaz nem is oda szánom és viszon árban jobb lessz. Amit lehet modulokból szeretném megvalósítani

Én is vettem ilyet, és azt kell hogy mondjam, nem vagyok elájulva tőle.

Ide írtam is róla egy blogbejegyzést: https://hup.hu/node/165133

Elég hosszú lett, a lényeg, hogy az egyik relé nagyfeszültségű lába és a TTL szintű jel közötti elválasztás összesen 2mm: https://pasteboard.co/IoK0a8a.jpg

Az alapötlet, hogy Arduino-kompatibilis PLC legyen, az jó. De az, hogy valóban beletegyünk egy hitelkártya méretű Arduino-t? Ráadásul Leonardot? Kéremszépen ez hülyeség. Ez egy hobbistáknak kitalált board. A funkcionalitást fele méretben is meg lehet oldani. Az Industrialshields-en pedig látszik, hogy amiatt szenvedtek a tervezésével, mert a csatlakozók mint rossz helyre esnek nekik. Az a tippem, hogy végül ezért nem lett meg a kellő elválasztás sem. Ha még egy Pro-minit tettek volna rá, ahogy a te terveden van. De nekik Leonardo kellett.

Controllino-ra cseréltem. Annak a belsejéről neten találtam fotót és leírást, elvileg rendben vannak a távolságok benne. Viszont magam még nem szedtem szét.

Köszönöm!
Ha jól látom van egy pár verziója ennek az Arduinonak.
Ezek közül melyiket ajánlod?

Amint már írtam: ízlés kérdése. A feladat annyira egyszerű, hogy bármi elbírja, és talán 5 láb elég hozzá. Tehát egy 8 lábú ATTiny is megoldaná.

Az Arduino boardokkal amit kapsz egy nyers csiphez képest:

* 3.3V-5V táp
* 8 vagy 16 MHz kvarc. Pontos órajelet ad, így például a serial kapcsolatok megbízhatóan működnek
* USB-serial átalakító, vagy egyéb USB-s PC elérés: programozás és debug trace üzenetek céljára kiváló. (De ez sincs mindegyiken, például a kedvenc Arduino Pro Mini-met egy USB-UART átalakítóval kell PC-re dugni. Ez is filléres tétel, és nincs benne semmi ördöngősség, de mégis plusz egy hibalehetőség, kezdőnek inkább olyat ajánlanék, amin van beépített USB.)

Amit mindenképpen meg kell valósítanod áramkörrel, az a kimeneti/bemeneti áramkörök illesztése. Ehhez boardot kell tervezni, vagy kész modult választani. Ha boardot tervezel, akkor már miért ne legyen az 5V táp és ISCP header is a boardon? Akkor máris felesleges az Arduino. Ha modult használsz, akkor a legjobb olyan boardot választani, amihez tervezték eredetileg. Tényleg végtelen a tervezési tér, és ezeket a kérdéseket senki nem tudja eldönteni helyetted.

Írtad, hogy kicsire akarod megépíteni. Nézd meg ezzel a szemmel, hogy mi fér el ott ahova szánod. Egy Arduino nano simán jó lehet minden szempontból: https://www.hestore.hu/prod_10035585.html

Jujj, ez dúrva! Nem nyittam szét, lehet kellett volna. Én a relé nélküli változatokat vettem, DIN sínre ültethetö reléket hajt a doboz. Ez tényleg nem való hálózati feszültség-re. De csodálkozom hogyan kapott ez engedélyt a forgalombahozatalhoz? Én is relé nélkülire tervezem, TBD62783 -et és pin védelmet teszek a kimenetre és ezt az új kedvencem -el fogom elkészíteni, alias Blue Pill -el a nagyobb számú IO végett hogy ne kelljen portbővítőket használnom (de viszont ha találnák SPI vagy I2C -s portbővítő IC -t hasonló kimeneti paraméterekkel mint a TBD, akkor inkább a Pro Mini -t választanám mivel azt jobban ismerem) mert ugye bele kell hogy férjek a 100x100mm -es NYÁK hobbyhatárba.

Ha előre tudod, hogy mi kimenet és mi bemenet, akkor a legegyszerűbb port bővítés a shift regiszter. SPI portra rákötöd őket és hardver vezérelten ki/be tudsz utaztatni annyi bitet amennyi jólesik. Pár vezérlő láb kell pluszba (output latch, input latch. Output enable-t érdemes úgy bekötni, hogy amig a proci nem indul el, addig ne legyen aktív a kimenet.), de a számuk független attól, hogy hány lábat kezelsz. A kimenetinél arra kell figyelni, hogy legyen benne latch, amivel a shiftelés után egyszerre teszed a kimenetre az értékeket. És kész is vagy.

Ez a változat például önmagában alkalmas relék kapcsolására: https://www.hestore.hu/prod_10036374.html Amennyit sorba kötsz, annyi relét tudsz vezérelni vele. Csak győzd táppal.

Egy kis segitség kellene, már belegabalyodtam a kodomba:

A kod jelentös része müködik.
A feladat:
van két motor X és Y motor.
Az Ymotor simán forog a megszakitás alapján. Ennek a motornak 200 lépés kell fordulatonként.
Az X motor lassabban követi, azaz akkor lép xxSTEP, amikor a stepcounter leszámol bizonyos Ymotor lépést. (ezek az adatok elöre ki vannak számolva).
Ami nem akar menni az a következö fejezetben van:
Az Xmotornak xsize lépés után irányt kell váltania XDIR. Azaz xxsize amikor nullázodik irányt vált a motor, az xxsize ujra felveszi az xsize adatot és ismétlödik a folyamat ellenkezö irányba. Gyakorlatilag az Xmotor megtesz bizonyos lépést az egyik irányba, majd vissza. Azaz ide oda mozgat valamit.
Csak ezzel az irányváltással van gondom, illetve az xxsize--; nem ugy müködik ahogy kellene, annak az Xmotor lépéseit kellene számolnia.

Kösz!

Ami ránézésre rossznak tűnik, az az & operátor: ez bitenkénti ést valósít meg. Neked meg logikai és kell, ha jól gondolom. Ez a dupla és && operátor.

Az ==HIGH és ==LOW is dodgy: logikai értéket a true, false konstansokhoz illik hasonlítani. De felesleges is: == HIGH helyett elég a logikai kifejezés, ==LOW helyett pedig !(..)-ba kell tenni.

Ez úgy okozhat gondot, ha valamelyik változóban nem 1 a logikai igaz érték. Ugye régen az volt, hogy minden igaz, ami nem 0. Általában így is működik, de ha ilyen érték van benne, akkor nem lesz jó az aritmetika eredménye.

Ez az if a teljesen rossz: "if (xxSTEP&stepcounter == LOW)" a stepcounter és az xxSTEP közötti bitenkénti és-nek nincs értelme. Az egész if-et az előzőbe be lehet tenni: mindig az X lépés után ellenőrizzük, hogy kell-e irányt váltani. És a feltételben csak az xxSTEP-et kell ellenőrizni így már.

Helyesen:

Ez a kifejezés is dodgy, csak éppenséggel pont működik:

STEP & !ADJ & !RUN

Helyesen el kell dönteni, hogy a változók boolean-ek-e, vagy számok-e? Ha számok, akkor lehet & műveletet csinálni rajtuk, ha boolean-ek, akkor lehet ! műveletet csinálni. A logikai és a bitenkénti műveleteket keverni nem illik. Egy jó megoldás pl, ha mindegyik logikai érték:

Köszönöm szépen.

A baj, az, hogy minden bemeneti adat aktiv állapotában 0 (alacsony a GND szinten). Ezért forditgattam öket a ! jellel. Elvben a nagybetüs változok booleanok, csak negativ logikával.

Az irányváltás sajnos továbbra sem müködik, minden más teszi a dolgát. A kodom olyan volt amit irtál:

Itt egy printout:

STEPCOUNTER = 0
xmove =0
xxsize =13
XDIR =5
STEPCOUNTER = 0
xmove =0
xxsize =3
XDIR =5
STEPCOUNTER = 0
xmove =0
xxsize =-7
XDIR =0
STEPCOUNTER = 0
xmove =0
xxsize =-16

láthato, hogy az xxsize átmegy negativ értékbe aminek nem kellene, mert 0 értéknél ismét fel kell tölteni az xsize értékre, az adott esetben ez 40:

xxsize =40
XDIR =5

szoval innen kellene leszámolnia 0-ra majd irányt váltani ami stimmel XDIR, (lehet hogy atdefiniálom booleanra).

A 9. sorban lévő if a felette lévőn belül legyen! A stepcounter ugye osztóként működik, hogy hányadik ciklusokban kell ennek a motornak működni, nem? És itt az if (stepcounter==0) blokkon belül kellene lenni mindennek, ami az x motorra vonatkozik, hiszen ez csak itt mozdul. Még így is fura, hogy hogy tud negatívba menni... Kivéve, ha xsize arra inicializálja. Csak kellene látni a konstansokat is, meg a változók típusait.

Az XDIR értéke is nagyon fura: ez 0 és 1 lehetne csak elvben, nem? Hogy lehet 5?

Nincs valami memory vagy stack overflow, ami mindent felülír össze-vissza? Akkor aztán nézhetjük a kódrészletet évekig, akkor sem fejtjük meg. Az egész kód kellene hozzá.

Kösz most mennem kell.
A konstansok egyszerüek:
A stepcounter minden 10. YSTEP-léptet ( azaz ekkor nullázodik) és az müködik.
Az xsize=40 amit elöször beir az xxsize-be. Innen kell leszámolnia 0-ig majd irányt váltani és ujbol betölteni az xxsize-be az xsize értéket.

Majd kb 2-3 ora mulva folytatom, addig még elgondolkodok a gondon. A nagybetüs változoka mind átirtam booleanra.
Érdekes modon beraktam a 12. Sor utánba egy lcd.print (">") sort ( kijelezni az LCD-n az XDIR irányát ( természetesen If stb.vel) ilyenkor mindig leállt a motor egy kisebb moccanás után).
Az XDIR-t én sem tudom miért ir ki induláskor 5-t menet közben már csak 0 meg 1. Ugyanugy az xxsize-re is induláskor -1. ir holott definiáltam a bevezetöben higy int xxsize=0;. Amint átveszi a xsize értéket akkor már jo, de nem áll meg a 0 értéken.

Kösz.

Igen, SPI - s Daisy Chain -ben gondolkodtam hogy készítek külön IO modulokat amelyekkel tetszés szerint bővíthetném. Ez a shift regiszter jó is lenne ha P csatornás kimenete lenne. Minden esetre köszi, feljegyzem magamnak.

Sziasztok,
(Nem épp Arduino, de itt láttam AM2315-öt használókat)
Stamp BS2p-vel próbálom életre kelteni, de nem megy. Ha jól értelmezem a leírását, a 0xB8 címen a 03,00,04 parancs után kellene tudni olvasni az első 4 bájtot.
Ezzel a kis programmal próbálkozok:

' {$STAMP BS2px}
' {$PBASIC 2.5}

SDA PIN 8
addr CON $b8

t1 VAR Byte
t2 VAR Byte
p1 VAR Byte
p2 VAR Byte

Main:

I2COUT SDA, addr, [$03]
PAUSE 10
I2COUT SDA, addr, [$00]
PAUSE 10
I2COUT SDA, addr, [$04]
PAUSE 10

olvas:

I2CIN SDA, addr, 0, [t1, t2, p1, p2]
DEBUG CLS, DEC t1,"..", DEC t2,"..",DEC p1, "..",DEC p2
PAUSE 1000
GOTO olvas
END

Sziasztok
Találtam ezt az oldalt:Bővebben: Link
DHT11 mérését loggolná egy webes felületre.
Fordításkor nem dob hibát, de nem működik.
Feltűnt, hogy a kód elején inklúdolt

nem aktív, sőt ha kiremelem, akkor se hiányolja.
Miért lehet ez?

1 karakter ' közé kell rakni, nem " közé.

Ezt nem értem.

A baj ott van, hogy valamiért nem számolja le a stepcountert 10-röl 0-ra. Elkezd számolgatni, de a 0-t nem éri el.
stepcounter--;

Itt van egy & bit operátor valami negált változóval

"Érdekes modon beraktam a 12. Sor utánba egy lcd.print (">") sort ( kijelezni az LCD-n az XDIR irányát ( természetesen If stb.vel) ilyenkor mindig leállt a motor egy kisebb moccanás után)." - erre értettem.
Egyébként a feltételeket isnle tudod ellenőrizni, hogy miért nem a megfelelően működik, ha a soros portra debuggolsz folyamatosan. Ott pedig fel fog tűnni, ha más lesz az eredménye egy &-t tartalmazó feltételnek, mint amit te szerettél volna.

Helló!

A teljes kódot nem látjuk, nem is értem pontosan a feltételeket, nem tudom miért nem logikai változókkal operálsz, vagy ha egészekkel akkor miért nem = vagy < >. De mindegy, lehet így is jó.

Azonban, ha ez egy interrupton lévő függvény, akkor minden ilyen globális változónak Volatile- előtaggal kellene szerepelnie.

A másik, hogy az xxsize soha nem lesz nulla. Nem vágom, miért, de kiírattad. 3 után RÖGTÖN negatív értéket vesz fel, ezért az az if soha nem fut le ami újra felvetetné a helyes értéket, mert a nullát egyszerűen átugorja.

Helló!

Ez lehet jó? Nekem nem tetszik, lehet jó ez, de más nyelveken belefutottam ilyen hibába.
if (STEP & !ADJ && !RUN == HIGH) {

A high pontosan mire vonatkozik? Az utolsó tagadott értékre, vagy az egész ÉS láncolatra? Inkább zárójelezni kellene, biztos ami biztos alapon.

A végén a !RUN==High az véletlenül nem egyenlő RUN==LOW-al?

Így jobban látszik szerintem: (A high az true-nak felel meg nem?) ÉS KÉT & jellel ahogy mondod.

if (STEP && !ADJ && !RUN)

Ha a változók nem logikai értékeket vesznek fel, akkor lehetnek érdekes eredmények itt. Ha nem 0 akkor igaz. Még -1-nél is. Ezeknek a változóknak unsigned-nek kellene lenniük, mert gond lehet.

ilyesmi jobb lenne szerintem, ha ezek numerikus változók:

if(STEP!=0 && ADJ!=0 && RUN!=0) már ha ezek egészek, bájtok, de nem logikai változók.

Véletlenül a másik léptetésben (Másik kód, ami YSTEP(?) ) ben van nem maradt egy
xxsize--;

utasítás?

Gyanús, mert épp 10-el csökken úgy, hogy a fenti kódban nem szerepel ennyi. 3 utána -7 majd -16. Az utolsónál kimarad éppen egy. Máshol lesz a gond (meg itt is a volatile, &&, unsigned stb után.)

Így simán átlépi 0-t, ezért soha nem veszi fel a kezdeti helyes adatot.

Nem néztem át a kódodat, de arra figyelj, hogy a C-ben egy logikai feltétel kiértékelésénél csak addig megy el a program, amíg határozott igaz nem lesz a feltétel és hátulról előre fele dolgoz fel(!), ha az if-ben műveletvégzés is van, akkor lehet, hogy le se fut, mert előbb már igaz lesz az egész és így kimaradhat lépés.
A másik a műveletek prioritása. Lehet, hogy egy összehasonlítás és egy bitenkénti művelet nem megfelelő sorrendben értelmeződik, ha nincs zárójelezve. És a prioritás a fordításkor eldől, tehát a műveletvégzés sorrendje is.
Tehát értékadást, függvényhívást az if logikai részébe, ahol eldől a futás iránya, nem jó beletenni, mert a kiértékelésnél borulhat minden, ráadásul állapotfüggően, tehát egyszer-kétszer jó, de néha nem.

"digitalWrite(XDIR, XDIR);" - azért ebbe is érdemes lenne belegondolni, hogy mi lesz az eredménye...
A kódnak sokkal tisztábbnak, érthetőbbnek kell lennie, hogy a hibakeresést megkönnyítse!

A másik meg, hogy érdemes az helyett formát használni, és így ha véletlenül le is menne negatívba (márpedig látjuk hogy lemegy), akkor is megfogod vele.

Ezt is már kiprobáltam, de addig amig a stepcounter nem éri el a nullát az xxsize sem igen változhat.
A legérdekesebb, hogy az egész program 10-12 alprogrambol áll mindegyiket külön kiprobáltam és egyen kivül mind ment ( az az egy még nincs beépitve).
Holnap ki kell deritenem miért nem számol a stepcounter nulláig.