Vannak esetek amikor elég lenne byte tipusú változót használni (pl pinek deklarálásában) de sokan az int -et használják. Szerintetek mikor érdemesebb inkább byte-ot használni? Mivel a byte csak 1 bájt az int meg kettő ezért számit-e pl a gyorsaság terén ? Mikor ajánlott és mikor nem byte-ot használni?

Ha Atmega chip-ekről beszélünk, akkor duplán is érdemes. Egyrészt 8 bites, tehát ez jól megy neki. Másrészt kevés bennük a memória, amiből minél kevesebbet használsz egy byte-nyi tartalomra, annál több marad másra.

Van nekem jobb is (ARM®32-bit Cortex®-M4 CPU) de maradhatunk az atmegánál.
És milyen esetnél mondod azt , hogy inkább int mint byte?



(0 alatti értéknél és 255 feletti értéknél nem használható a byte )

A Pin-ek deklarálásakor a változó nem fordul bele a kódba, az bármilyen lehet, semennyit nem fog elfoglalni a RAM-ból.
Az int valójában nem 2 byte, hanem változó méretű egész, csak az int default definíciója előjeles 2 byte-os.
Igen, számít a mérete a memória foglalásnál és a sebességnél is. A 8 bites aritmetika sokkal gyorsabb, mintha 16 bites számokkal kellene számolni. De szerintem nem fogod észrevenni a különbséget a programkód végrehajtásában.

Köszi! És szerinted mikor nem érdemes byte változót használni?

Amikor a 0-255 tartományon kívül eshet bármilyen számítási művelet. Pl. analogRead() 2 byte-os. De szerintem nem nagyon kell vele foglalkozni, a nagyobb hosszúságúként kell deklarálni. Az Arduino fordítója blokkokban kezeli a memória foglalást, a változók típusával eléggé nehéz optimalizálni.
Amúgy miért kérdezed, van valamilyen konkrét probléma, ami miatt optimalizálni kellene?

Nincs konkrét probléma, csak arra törekszek, hogy a program is meg a hardver is minnél hatékonyabb legyen.



Azt hittem az int cseréje (már ahol lehet) byte-ra nagy változást hoz

Sziasztok ! Segítséget szeretnék kérni , egy CNC vel kapcsolatos arduinó projektem megoldásához. Nem tudom hogy mennyire ismeritek a MACH3 CNC vezérlő programot. Van ebben a programban egy lehetőség arra , hogy a MODBUS rendszer segítségével , külső vezérlő gombokat és egyéb kezelő egységeket csatlakoztathassunk egy Arduinó , analóg vagy digitális bemenetein keresztül szoftweresen a MACH 3 kezelőprogramhoz. Konkrétan azt szeretném elérni, hogy az Arduino A0 és A1 analóg lábához kötve 2 darab potméterrel vezérelhessem a CNC gép előtolási sebességét megmunkálás közben. Ugyanakkor szeretnék a D2 ,D3,D4 digitális lábaira nyomógombos kapcsolókat szerelni ,aminek a segítségével megállíthatnám vagy indíthatnám a megmunkálás folyamatát. Sikerült a netről letöltenem ,mások által megírt sketcheket, amivel mind a két művelet működik, de sajnos csak külön külön , eltérő MODBUS beállításokkal. A problémám az hogy az eltérő beállítások kellenek a MODBUS konfigurálásánál a potméteres feladathoz és a nyomógombos feladathoz. Azt szeretném elérni hogy az arduinóra egy olyan program legyen megírva ,ami ötvözi a két feladat működéséhez szükséges adatokat ,és azonos beállítást alkalmazhassak a MODBUS konfigurálásánál ahhoz , hogy a kétfajta feladat együtt működhessen. Nagyon örülnék ha valaki hozzá értő ebben segíteni tudna.

Ha számít a állapotváltozás gyorsasága kimeneti pinek esetében, akkor érdemesebb direkt, a port regisztereken keresztül elérni a portok bitjeit.
Nem a sima digitalwrite() függvénnyel.
Kb.:sokszorosan gyorsabb lesz digitalwrite: ~4usec , másik esetben ~64nanosec.
Van erről 1 tutorial is csak nem rémlik a linkje.
no közben megvan:

Arduino direkt port elérés

másik direkt port bit elérést bemutató oldal

Az a fő probléma, hogy úgy állítod be a kérdésed, mintha érdekelne a téma, és szeretnéd magadnak megcsinálni, majd utána kiderül, hogy valakit keresel, aki csokiért sörért ezt neked leprogramozza. Na erre van az apróhirdetés részleg! Ha soha sem peogramoztál, akkor ne vágj bele ebbe a projektbe. Ha simán ráraknál egy 7S BMS-t az akksipakkodra, és a kimenetét figyelnéd, vagy a kimeneti FET-eket meghajtó kis SMD félvezetőket, pontosan azt kapnád, ami neked kell. Túlfesz., túlmerítés védelem. Minek ide Arduino, hogy aztan kalibrálnod kelljen az ADC-t, meg feleslegesen fogyasszon? Ha analóg áramkörökkel jól boldogulsz, akkor seperc alatt átalakítasz egy 7S BMS-t, a csokit meg sört pedig eltudod fogyasztani, nem kell postáznod sem! Amúgy is túl sok lenne a postaköltsége egy tálca sörnek, meg szegény postásbácsi, gondoljunk rá is! Főleg, ha külföldre postáznád, még vámot is kellene fizetned.

Hi

Igazából a pinek deklarálását csak 1 példának szántam . Elolvastam a cikket de talán nem kell enyire túlbonyolitani a kódot.




Esetleg ha lessz olyan feladat ahol indokolt ott majd jó lessz

Itt van pár Arduino-s kód kiváltása. Kisebb lesz, gyorsabb és áttekinthető marad a kódod.

Ahha... Azt megirnád , hogy pl a blink hogy nézne ki ha ezekkel lenne kihelyetesitve?

Miért?
setup

DDRB |= _BV (5);

loop

{
delay(xx)
PORTB &= ~_BV (5);
delay(xx)
PORTB |= _BV (5);
}

Na ezt kipróbálom majd.

Azt is megnézheted, hogy proba által küldött kód mekkora, és az eredeti, Arduino-s. Lesz különbség.

Kedves Tagok!
Szeretnék segítséget kérni , esp8266(esp-01) 2 db ds18b20 szenzor adatait kellene elküldenem a thingspeak oldalra , 1 db ot sikerült összehoznom, nem vagyok programozó és igazából nem is értek hozzá!
Így ez a feladat is elég nagy kihívás volt számomra ,
Nincs valakinek ehez megfelelő kapcsolási rajza és programja ?
Nem lennék hálátlan , nagyon megköszönném .
A napkollektorom hőmérsékleteit kellene megfigyeni mivel nem tarózkodunk ott ahol a kollektor van.
Hálás lennék ha valaki tudna ebben segíteni nekem .
Köszönettel
Gábor
Mod: ***** email cím törlve.

Hello

Itt van egy részlets leirás arról amit akarsz , ott van a source kód is , annyi különbséggel hogy ő nem a thingspeak oldalra küldi az adatot hanem ha jól látom Web Serverre. Ha csak 2 dallas sensort kapcsolsz hozzá akkor 1-es láb =GND, 2-es láb= dataout, 3-as láb = +5V vagy +3.3V-al is elmegy. Majd a 2-es és 3-as láb kőzé kötsz egy 4,7K ellenállást, majd mindkét szenzor 2-es lábát bekötöd az esp D2-es lábára de ez is le van irva az oldalon.


Miből? Hogy?

Köszönöm szépen a választ
1 db ot sikerült összehoznom ami 1 szenzort kezel :
dataout az esp-01 GPIO2 es lábán van

Nagyot nem, de sokszor csak egy kicsin múlik az, hogy valami már pont jó, vagy még pont nem jó. Az adott uC adatlapján szinte biztosan megtalálod, hogy hány órajel alatt végez el adott változóval adott műveletet, de többszörös különbség is elhanyagolható, ha pármillió órajelenként végzel el pár ilyen műveletet.

És ezzel kóddal müködik?

Igen ,ezzel 1 db ds18b20 működik
de sajna nekem 2 hőérzékelő kell

Az oldalon igy használnak több szenzort egyszerre



Használod agetDeviceCount()módszer a DS18B20 érzékelők számának lekérésére az adatsorban.

numberOfDevices = sensors.getDeviceCount();
AzgetAddress()módszer megkeresi az érzékelők címét:

if(sensors.getAddress(tempDeviceAddress, i)){
A cím minden érzékelő esetében egyedi. Így minden érzékelő azonosítható a címe alapján.

Ezután használja agetTempC()metódus, amely argumentumként elfogadja az eszköz címét. Ezzel a módszerrel megkaphatja a hőmérsékletet egy adott érzékelőtől:

float tempC = sensors.getTempC(tempDeviceAddress);
A hőmérséklet Fahrenheit-fokban történő meghatározásához használhatja agetTemF(). Alternatív megoldásként átválthatja a Celsius-fokozatban mért hőmérsékletet Fahrenheit-re a következőképpen:

DallasTemperature::toFahrenheit(tempC)

Valoszinü a ds18b20-s mintaprogramját használod ( ahogy Jonni is ajánlotta), az mindegyik DS-t egymás után olvassa le ( általában tempC-be van a hömérséklet.)
Neked ezt át kell irnod, hogy a megfelelö DS IDhez tartozo hömérsékletet külön változokba mentse el, azaz legyen temp0 meg temp1.
Akkor egyszerre lesz jelen mindkét hömérséklet és lehet öket küldeni ahova akarod.

Ket ilyen sort kell beillesztened a Dallasba

Temp0=sensors.getTempCByIndex(0);
Temp1=sensors.getTempCByIndex(1);

> Azt hittem az int cseréje (már ahol lehet) byte-ra nagy változást hoz
Az adott változóval végrehajtott utasítások valóban legalább kétszer gyorsabbak lesznek, azonban a legtöbb esetben ez alig számít. Akkor kezd el számítani, amikor a feladat megközelíti az adott kontroller képességeinek a határait. A legtöbb programban a kontroller az idő 99%-ban várakozik valamilyen eseményre és teljesen lényegtelen a program teljesítménye. A jó programozó tudja, hogy mikor számít mégis a teljesítmény és akkor minden optimalizációt meg tud tenni. Ezért nem haszontalan ismerni, hogy milyen ASM kódra fordul le ami programot írsz, és annak milyen a futás idejű időzítése.
Érdemes az stdint.h-ban definiált típusokat használni: int8_t, uint8_t, int16_t, uint16_t, int32_t stb.: ennek az az előnye, hogy minden platformon pontosan ugyanakkora a tárolási egység, és pontosan ugyanúgy fog működni függetlenül attól, hogy 8 bites, vagy 32 bites mikrovezérlőre fordítod-e le a programodat. Ezeken a típusokon belül pedig én a legszűkebbet szoktam választani ami ábrázolni tud mindent amire szükségem van. Első szempont, hogy helyes legyen a program és a második, hogy hatékony.

Köszi


Itt a Flash tárterületére gondolsz?



Erre tudnál egy rővid példát irni?

Szerintem inkább arra gondolt, amikor realtime videójelet renderelsz, és számít minden egyes órajel

Program tárterületre, RAM-ra és futásidőre is. Mindig arra kell optimalizálni, ami elfogy.

Például ebben a topikban fentebb írtam egy példát, ami időbélyegekkel számol, ott az uint32_t van unsigned long helyett használva: https://www.hobbielektronika.hu/forum/topic_post_2526582.html#2526582
Annak a megoldása, hogy egy program minden fordítóval fordítva pontosan ugyanúgy működjön sajnos ennél összetettebb probléma, a platformfüggetlen típusok használata önmagában nem oldja meg. Programozok professzionálisan is mikrovezérlőre, és ott a MISRA-C szabványt használjuk. Ez egy olyan szabálykészlet, amit betarva a programkód bármilyen C fordítóval fordítva pontosan ugyanúgy fog működni. Egyszerűnek hangzik, de sajnos egyáltalán nem triviális ezt elérni, a MISRA szabvány maga sokszor tíz oldal és nem triviális megérteni sem. Szerencsére automatikus ellenőrzők vannak, amik betartatják, mert szabad szemmel könnyű benézni. Az alap probléma az, hogy amikor a C nyelvet tervezték, akkor még másképpen gondolkodtak, nem ez volt fontos, és emiatt a C szabvány tele van kellemetlen megoldásokkal. Például az előjeles számok átfordulása nem specifikált, akármit adhat. Ezt a legtöbben nem is tudják, nekem is mellbevágó volt amikor először hallottam, annyira triviális, hogy a 32767 után a -32768 jön. De sajnos ez minden általam ismert platformon így van, de a szabvány szerint meg nem.
A fentebbi linkelt hozzászólásomba írt példa például szerintem nem felel meg a MISRA-C-nek, mert egy kifejezésben keveredik egy előjeles és az előjel nélküli érték. Explicit castolni kellene a millis() értékét előjel nélkülire.

Az Arduino mivel C++ alapú, ezért örökli ezeket a problémákat. Eleve az Arduino könyvtári függvények a platfromfüggő típusokkal vannak megadva, ami nagyon gagyi. Példa: https://www.arduino.cc/reference/en/language/functions/time/millis/ ugye unsigned long van megadva típusnak. Utána le is van írva, hogy kb 50 naponta körbefordul. De azt már nem írja le, hogy ha egy platformon 64 bit az unsigned long, akkor mit kell ennek a számlálónak csinálni? Pláne, hogy 32 bites vezérlőkre is van Arduino, ahol szerintem az int már 32 bites, a long pedig 64 bites szokott lenni. Szerencsére csak ATMEGÁn Arduinoztam eddig, úgyhogy nem is kell tudnom hogy mi ennek a problémának a megoldása.

Igazad van.
Profi környezetben illik adni SoC-ot (Statement of Compliance), hogy melyik szabvány melyik verziójával kompatibilis. Ja, meg az összes felhasznált free and open source szoftvert is illik verzió szerint nevesítve felsorolni, beleértve a copyright szöveget is.