A link elején ez van:



Szerintem összeakad a két soros kommunikáció. Ezt megnézted már?

Az az én hibám. Elcsesztem a bemásolást.
....n0.val=201⸮⸮⸮np.val=0⸮⸮⸮t1.txt="Hello!"⸮⸮⸮n0.val=202⸮⸮⸮np.val=0⸮⸮⸮t1.txt="Hello!"⸮⸮⸮.....
Ez a három parancs ismétlődik egymás után.

Köszi, hogy felhívtad a figyelmemet erre!

Ez volt a config fájlban. Ezért próbálkoztam hiába a Serial1-en.
A Serial2-n sikeresen kommunikálnak.

Sziasztok!

PCF8574 expandert használ valaki vegyes módban? p0-tól p3-ig bemenet p4-től p7-ig meg kimenet. Példaprogramot keresnék, de nem találok.

Szuper!

Én azt már nem is láttam, de akkor megoldódott!

Amikor jatszottam az Arduino serial kommunikaciojaval, nekem is ez volt erdekes, hogy nem jelzett az RX-TX led, pedig a kommunikáció működött.
..aztan raneztem a kapcsolasi rajzra, es megvilagosodtam.
..hiszen az rx-tx LED-ek az FT232-es IC-rol kapnak jelet(nanonal), nem az Atmega IC-tol.

Köszi, ezt jó tudni!

Elkezdtem bevinni a kodot, de van egy kis problémám a definiciokkal.
Nem tudom, hogyan kellene a PINA-t meghatározni. A két bemenet adva van a shielden:

int RUP = 4; // S1
int RDW = 7; //S2

A port többi bitje a motorokat és a gombokat kezeli.
Kösz!

Bármelyik input jó, nem kell feltétlenül az A porton lennie. Azt csak azért írtam - viccből - hogy leírhassam azt, hogy PINA. Így hívják az AVR-eken az A port bemeneteket tartalmazó portot.

Itt vannak például a port mappingek az Arduino indexek ATMega328 pinekre való átszámításához:
A https://www.flickr.com/photos/28521811@N04/8520970405/in/album-72157632703854644/

Ha jól értem az Arduino PIN számozás szerinti 4-es és 7-es pineken vannak az inputok bekötve:

Arduino4: PD4
Arduino7: PD7

Tehát neked a PIND kell, nem a PINA és azon belül a 4-edik és 7-edik bit, tehát a RUP és RDW értékek véletlenül pont jók, mivel az Arduino index a D porton lévő indexszel egyezik.

De sima digitalRead-del is beolvashatod, amit én javasoltam, az a csipfüggő direkt megoldás a pin értékek beolvasására. Ha nem rohanunk sehova, akkor az Arduino-s digitalRead is tökéletesen megfelel.

Itt van leírva, hogy hogy kell felkonfolni: https://playground.arduino.cc/Main/PinChangeInterrupt/

Neked ez fog kelleni: ISR (PCINT2_vect)

És ezzel tudod bekapcsolni az interruptot a 4-es Arduino PIN-re - a fent linkeltről másoltam:



Ugyanezt az adatlap kibogarászásával is el tudod érni. A fenti kód kibogarássza, hogy melyik regiszterbe mit kell írni, és beírja magától Arduino PIN index alapján Arduino-s makrókat használva.

Kösz ezzel egy kicsit hadilábon állok ( az ASM meg az Arduino nyelv ötvözete, most tanulgatom). Azért kezdtem az összel az Arduino nyelvet tanulgatni, hogy talán egyszerübben jussak célba - meg a fiam munkáihoz is hozzá tudjak szolni, aki csak Arduinot programozott ( én meg bármilyen AVR-t de csak ASM-ben).
Igen azt tudom, hogy az arduino pinek egy része a D porton van, de ilyen mélyre ahogy te irod még nem mentem.
Na megyek egy kicsit rágodni ezen.

pS: A flickr link nem megy.

Arduino Uno pinout keresőszóra az első értelmes találatot linkeltem. Ezeken rajta van, hogy melyik CPU láb melyik Arduino pin. A proci adatlapjával összenézve mindent tudunk a hardverről. Gondolom az URL-ben lévő kukac a baj.

Szia azokkal a lábokkal meg definiciokkal nincs baj, azokkal már ugy ahogy elvagyok, csak még nem egészen tudom összehozni a dolgokat.
Most már van 4 részprogramom amik müködnek, a számlálo meg nem.
1. Az adatok bevitele a displayre
2. A motorok vezérlése és a függöségük. Az Y motor fordulatonként 200-t lép. Az X motor a drot átméröjétöl függöen DIA*40/100. Ebböl az következik, hogy az Y motor minden 5 lépésére lép egyet az X motor igy jön ki, hogy 40-t lép az X motor egy fordulatára (200 lépésre) ha pl 1 mm vastag a huzal, ha csak 0,5 mm akkor csak a felét stb.
3. Ha az Y motor megteszi a displaybe bevitt menetszámot ( Turn akkor megáll).
4. Az X motor kézzel elmozdithato a tekercs kezdetére ( OFfset) ezzel nullázodik a helye, és a Tekercsméret (Size) függöen megfordul a mozgás irány 40 lépés= 1 mm, azaz ha a Size 10 akkor 400 lépés után jön egy XDIR változás.
5. Számlálo az Y motor minden fordulata ( szenzorok) eggyel csökkenti a Turn értékét és amikor a Turn=0 akkor álljon meg minden.

Ezek már mennek csak még nem tudom összerakni, hogy ez valahogyan müködjön is. ( a számlálást még meg kell oldanom. ).

Üdv.
Ha egy tömbnek változókar adok meg akkor nem adják át egymásnak az értéket?
Pl:

A szamok[0] miert nem kapja meg?

Mert ha így adod meg, akkor fordítási időben nincs "normális" értéke...
De egyébként is a sorrendiség is lényeg, ha a számok-ba beteszel valamit, majd a valami értékét módosítod, attól a számkban nem fog módosulni.
Ha ilyesmit szeretnél, akkor inkább gondolkodj pointerekben, a számok tömbbe a változók címét tárold.

Igen. Közben rájöttem, hogy pointerrel kellene. Köszönöm.

Egy kérdés:

A motorok müködtek egyszerü rutinokkal. Ezt most egyenletesebbé akarom tenni, de ahhoz valahogyan számolnom kellene a megszakitásokat ( max 0-100 tartományban).
Ezzel az a célom hogy az egyik motor minden megszakitásra lépjen ( teszi is) de másik csak mondjuk minden másodikra vagy 40. -re .
Valamitöl a count = count++; nem akar számolni ha az ISR-ben van.
Ha eléri a kivánt számot akkor nullázom. Maga az interrupt nem gyors, max 50 Hz.
Van erre valamilyen trükk?

Van. Emlékeim szerint ha volatile módosító van az int előtt, akkor használható megszakításban. Egyébként nem biztos hogy jól működik a változó.
Szerk. Na most lehet hogy korán van, de miért kell count = count++? Miert nem elég ha count++?

Ahogy azt már sargarigo is írta, a volatile típusú változó kell hozzá. A volatile-nek annyi a lényege, hogy a fordító nem fogja kioptimalizálni, hanem minden használatkor ténylegesen beírja vagy kiolvassa a változót tartalmazó memóriaterületet. Olyan változók esetén amik megszakításban és azon kívül is használva vannak minden esetben volatile változót kell használni. Ugyanez vonatkozik a preemtiv multitask környezetben több programszál által közösen használt változókra is.

Kösz már probálgatom tegnap ota. A count volatile változo, az ISR-n kivül össze kell hasonlitani az ISR-n kivül.

If (count == k) {
//itt kell lépnie a másik motornak
count=0; //. Ha elérte a k érteket, akkor nullázni kell és ujra számolgatni.
}
Valahol azt irja az arduino help, hogy ilyenkor le kellene tiltani az interruptot, amig elvégzi a feladatot, de ilyet még nem csináltam igy nem tudom.

A két parancs cli() és sei(), illetve interrupts() és noInterrupts(). Ezek párban ugyanazt csinálják asszem, felcserélhetőek.

Eh. Kijöttem a gyakorlatból. Ez visszafelé is fog működni? Vagyis ha a tömbelemnek adok értéket a változó átveszi? Bár belegondolva erre nincs szükségem. A kimenő json objektum elfogadja a tömbelemeket is.
Alapjában véve a változókra csak azért van szükségem, mert az ArduinoJSON libbel nem tudtam értéket adni tömbelemnek. Vagyis:

Ezt nem fogadja el az ArduinoJSON lib. Még nem néztem bele mit ad vissza a jdoc[], vagy át tudom e adni tömbelemnek azért választottam ezt:

És ezeket tömbbe ranám azért, mert alapvetően a tömbelemeket használom ciklus miatt. Erre csak a json értékadás miatt van szükség.

Melyik függvényed van interruptra kötve? Miért nem abban a függvényben végzed ezt a feltétel vizsgálatot?

A másik, hogy lehet hogy lassú az Arduino ehhez a feladathoz. Kiszámolgattad, hogy másodpercenként mennyi megszakítás érkezik? Microssal megnézhetnéd, hogy az egyes feladatok mennyi időbe telik, hogy lásd van-e esélye egyáltalán pontosan elvégezni a feladatokat.

A nullázást ki lehet hagyni, ha a számlálót hagyod pörögni, és egy külön változóban számolod, hogy a fő számláló milyen értékeinél kell lépni. Így csak olvasod a számlálót és nem kell cli/sei blokk:



Így mivel a counter 8 bites, ezért nem kell cli() sei()-vel körbevenni. Az egy bájtos változók kiolvasása atomi művelet, és így sosem írjuk, csak olvassuk. Ha már két bájtos változót kell használni, akkor a kiolvasást is védeni kell cli()/sei() párossal. De még akkor is érdemes csak olvashatónak tartani a változót, mert így rövidebb lesz az interrupt kizárt blokk. (Nem mintha most ennyi számítana, de érdemes mindig erre törekedni.)

(Az interrupt rutinban nem kell cli()/sei() párt írni több bájtos számláló esetén sem, mert ott eleve tiltva vannak a további interruptok. Sőt! Nem is szabad sei()-t írni az interruptba, mert akkor előfordulhat, hogy újra interruptba lép kilépés előtt, és annak stack overflow lehet a vége.)

Már sikerült összehoznom. Még nem tudom miért nem ment eddig Kösz!

Megoldottam. Elírtam

Nagyon jól összefoglaltad.
Ha pedig 2byte-os a változó és nem tilthatjuk az interruptot, akkor egymás után 2x kell a változót beolvasni (két másik változóba), és ha különbözőek, akkor tudjuk, az olvasás közben pont bejött egy interrupt. Meg kell ismételni a beolvasást annyiszor, amíg a két változó nem lesz ugyanaz. Jó mélyen belementünk a dolgokba, már szinte el is feledkeztem erről.

Közben már rajöttem a display vert át. Egy meghatározott helyre irtam fel csak a fejlesztés idején a változokat amik akár 4 számjegyüek is lehetnek, azaz pl.
lcd.serCursor (10,1);
lcd.print (xfor).
Ami természetesen mindig az elsö számot irja a 10. Helyre, a többit nem törli, s igy menet közben ha pl 1000 indul, az elsö minuszra 9990 nulla lesz a displayen. Ezt persze a gyors számolásnál nem vettem észre.
Kösz mindenkinek az ötleteket. Holnap megprobálom a 3 rész kodot összehozni egybe...

Ez a szép ebben!!!

Ha belefer az idobe es nem sok eroforrast hasznal, akkor soros portot is hasznalhatod valtozo monitorozasnak.
Persze a vegen a sorosporti irasokat kikell szedni.

Az is megvan, csak körülményesebb volt a használata, mint a displayé. Az utobbi ott van gépen nem kell a számitogépen vacakolni. Most erre fáztam rá egy kicsit.