- iPhone topik
- Hónap végén érkezik a Xiaomi Band 10, ára is van
- CMF Phone 2 Pro - a százezer forintos kérdés
- Hat év támogatást csomagolt fém házba a OnePlus Nord 4
- Milyen okostelefont vegyek?
- Samsung Galaxy Note20 Ultra - a tollnak nincs ellenfele
- Google Pixel topik
- Poco X5 Pro - ránézésre jó
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Beárazták az projektoros Ulefone-t
-
Mobilarena
Arduino hardverrel és szoftverrel foglakozó téma. Minden mikrovezérlő ami arduinoval programozható, és minden arduino program, board, és hardverrel kapcsolatos kérdések helye.
Új hozzászólás Aktív témák
-
Janos250
őstag
válasz
Dißnäëß
#16687
üzenetére
"lehet más fejlesztőkörnyezetben és más library-vel jó."
Ezért szeretem én - ha nem nagyon bonyolult - saját magam megírni a kezelést, más által megírt könyvtár helyett.
Látom, közben ESP32-t is bekommenteltél. Ha azon csinálod, akkor többet tudok segíteni, mert azt jobban ismerem. -
Janos250
őstag
válasz
Dißnäëß
#16687
üzenetére
"Ha pedig önkényesen mégis megadom azt neki ugyanúgy, mint az SW verziónál (ahol viszont kéri), hibára fut a fordító."
Ne add meg neki, de kösd be!Mivel csak ESP32-n használtam az SPI-t, ESP8266-on nem, ezért csak általánosságban tudok hozzászólni.
Az általad linkelt képen látszik, hogy két SPI van. Zölddel vannak jelölve.
Általánosságban az SPI használ MOSI , MISO (Master Out Slave Input, a másik fordítva), és egy CLK clock jelet. Az ESP a master, a kijelző, stb. a slave. Van egy-egy CS (chip select láb). Be lehet úgy állítani, hogy a CS-t is a hardver kezelje, általában ez a default. Viszont ezzel az a baj, hogy akkor csak egy slave használható, holott az SPI több slave kezelésére alkalmas. Ebben az esetben minden slave-nek külön CS láb kell, és ezeket szoftverből kell vezérelni, hogy most éppen kihez akarsz szólni. Mivel nálad egyetlen slave (a kijelző) van, ezért célszerű a default választás. Általában a könyvtárakban, ha olyan konstruktort használunk, amiben nem szerepel a CS, akkor a default lesz érvényes, és a hw kezeli. Esetedben ez azt jelenti, hogy HSPI esetén a GPIO15 lesz automatikusan a CS, míg VSPI esetén a CMD-vel jelzett láb. Ha pl. kijelzőt hajtunk meg, akkor vissza irány (MISO) nem is kell. A H-nak, V-nek ne akarj értelmet tulajdonítani, tekintsd egyszerűen egy megkülönböztető jelnek.Az, hogy hány lábat kell a konstruktorban megadni, az még nem jelenti azt, hogy a többi lábat nem kell megadni.
Itt úgy látom, a CS mindig megadandó, nincs default.
Természetesen a /* clock=*/ 14, /* data=*/ 12, bármelyiket használod is, mindenképpen bekötendő akkor is, ha a konstruktorban nem adod meg, hanem defaultként kezeli. -
Janos250
őstag
válasz
gyulank
#16678
üzenetére
Régen én is PIC-et használtam, míg meg nem találtam az Arduinot. A régi PIC fejlesztő így már kipróbálás nélkül szomorkodik a fiókban a PICKIT mellett.
Az STM32 előnye - egyebek mellett - hogy ARM, amihez rengeteg minden van.
Én is Arduino alatt használtam, és kedveltem, amíg az ESP32 támogatottsága el nem érte azt a szintet, aminél már érdemesnek láttam átállni.
Akkor átálltam, és nagyon megkedveltem.
A PICBASIC-et én is használtam, de így utólag azt látom, hogy gyermeteg játék volt.
A PIC-en szerzett ismereteimet nem tudtam a későbbiekben felhasználni, a chipeket elajándékoztam, ami meg már annyira régi, hogy nem kellett senkinek, azt kidobtam.
Kedveltem, hogy a ChipCAD-nél mindent viszonylag tűrhető áron be lehetett szerezni, de persze a mostani kontroller árakkal nem versenyezhetne.
Az STM32-ből a nagyobbak, és a komolyabb fejlesztő készletek ára húzósabb, de a már említett kicsik olcsók, és jók, nagyon sok mindent tudnak, Arduino alatt is lehet jól használni a hardver lehetőségeiket.
Én az ESP32 mellett azért maradok, mert valós 2 magja van, és a hozzá illesztett fordító C++11, és a benne lévő WiFi nekem nagy előny, mert én nem használok se kijelzőt, se gombot, tekertyűt, miegymást, nekem minden a WEB lapon van, mert az ingyenes, és univerzális, a telefon meg kéznél van. És persze fel akarom hívni a figyelmet erre az "okos otthon", stb irányvonalra, aminek én komoly jövőt jósolok. Persze tévedhetek is. -
Janos250
őstag
De, egyetértek. Én még Bangoodról is szoktam rendelni. Gyors, és szintén futár hozza, nincs külön fizetni való, de drágább, mint az Ali, és kisebb a választék. Amióta van ez a dili, ebay-ről nem rendeltem, azt nem tudom, mi van ott most.
Például 48V-ot is tudó DC/DC-t Bangoodon csak egyet láttam, csillagászati áron, Aliról rendeltem párat egy hete kb, majd meglátjuk. -
Janos250
őstag
válasz
Tankblock
#16642
üzenetére
Az igaz, hogy kell a sikerélmény, és ebben az UNO verhetetlen, mert túlcsordul tőle a net. Hogy kinek mit ajánlunk, az egy sokkal általánosabb didaktikai probléma. Van, aki azt mondja, hogy a kezdő kezdjen a régebbi dolgokkal, van aki azt, hogy a kezdő is a korszerűvel kezdje. Nekem ezidáig egyetlen pattern se volt hasznomra, de lehet, nem igazán kerestem. A C++ az UNO-n és a többin is ugyanaz - kibővítve néhány spec Arduino dologgal - és persze régebbi, vagy újabb verziójú fordító, de az újabban is (majdnem) minden benne van, ami ami a régiben, alig van valami, ami obsolete.
Az FPGA dolgot nem tudom. Elég közeli ismerősöm diplomamunkája volt az FPGA, de azóta elő se vette, mondván, nincs rá igazán igény, inkább az általánosabb megoldásokat kedvelik.
Majd meglátjuk, én csak néha ránéztem, mit csinál, de soha nem foglalkoztam FPGA-val.
Egyébként az a véleményem, hogy ami UNO-n elmegy, az általában korszerűbbön is elmegy, és akkor a felhasználót idővel csak hajtja a kiváncsiság, hogy továbblépjen, de ha ehhez lapot kéne váltani, akkor inkább ott ragad. -
Janos250
őstag
válasz
Tankblock
#16638
üzenetére
Igazad van, de éppen a mikrokontrolleres alkalmazásban gyakran vannak egymástól teljesen független teendők. Például az egyik szál nem csinál mást, csak egy hőmérsékletet olvas, és ez alapján állít egy PWM-et, és ezeket senki más nem használja. A másik szál meg figyeli a lángérzékelő detektort, hogy nem lángol-e az Anetka (kigyulladni szerető 3D nyomtató), és ha igen, akkor mindent áramtalanít, vagy szirénázik, vagy akármi. Hát az ilyennel nagy tudomány lenne deadlockot generálni.
Aztán, ha egy több bájtos adatot egy valaki ír, de többen olvassák, akkor meg lehet flaget használni.
És persze - mint írtad - a freeRTOS tudja ezeket kezelni. A minták szerintem nem igazán használhatók a sokszálazáshoz.Megnéztem, tényleg rendben van a PWM.
Én továbbra is úgy vagyok vele, hogy ha ott van a ládafiában a Mega, akkor ne dobja ki, használja, de venni már ne vegyen, hanem vegyen korszerűbbet. Elsősorban azért, hogy megtanulja.Én mindenesetre maradok az ESP-nél, pedig valóban van még nekem Z80 is. Amit mellesleg - a maga idejében - kedveltem is. Lehet, ezért szerettem a ZX81-et, és a Spektrumot is.
-
#16637
Janos250
őstag
tonermagus
#16629
Janos250
őstag
válasz
tonermagus
#16629
üzenetére
"Egyszerűen csak profibbnak érezné ha ESP/STM-en futna..."
Nem az a lényeg a váltásnál, hogy "profibb"!
A korszerűbb technikára való áttérésnek az az elsődleges előnye, hogy megtanulod.
Évek múltával úgyis mindenből a korszerűbb jön elő. Én használtam a Z80-at. Ami akkor kellett, meg tudtam vele oldani, mert nem is gondoltam olyan dolgokra, ami azzal ne lett volna megoldható. Ma már nagyon nem szívesen dolgoznék Z80-al, pedig még valószínűleg kerülne 1-2 darab belőle, és vannak olyan dolgok, amit azzal is meg tudnék oldani.
A jelen problémára visszatérve: Az, hogy egy csomó minden hardverben meg van oldva, ha azokat az emberfia megismeri, azok azért hasznosak.
Továbbá a multitasking szisztéma is olyan, hogy nagyon sok mindent világosabban, áttekinthetőbben lehet vele megoldani. Mondok egy példát a saját dolgomból.
Hőmérő méri a hőmérsékletet (akár Z80-al is meg tudnám oldani, de nem teszem), és időnként WiFi-n átküldi egy másik lapra, ami mindenféléket csinál. Hogyan oldjuk ezt meg? Időnként lekérdezzük a ciklusban, hogy jött-e új adat, ha igen, akkor azt beolvassuk, és beírjuk, hogy onnantól kezdve azzal számoljunk.
ESP32-n: egyik task semmi mást nem csinál, csak megnézi, érkezett-e új adat, ha igen, akkor azt beteszi a globális változóba, így mindig automatikusan a legfrissebb adattal történik a további meló. Az "időnként megnézi" azt jelenti, hogy semmi más nincs egyik taskban, mint "megnézi", ha van beolvassa, majd delay. Ugyanis a multitasking esetén a delay nem jelenti azt, hogy ténylegesen várakozik, hanem, hogy a várakozás alatt egyszerűen nem megy rá a vezérlés arra a taskra, hanem fut a többi. Az már csak hab a tortán, hogy két mag van, és megválogathatjuk, ha akarjuk, hogy melyik task melyik magon fusson. Így ídőkritikus dolgokat lehet tenni önállóan az 1-es magra, ami meg ráér, az mehet minden a 0-ra. Ha meg nem akarjuk, akkor rábízhatjuk az oprendszerre, hogy válogasson, azaz egyszerűen használjuk a C++ thread-jét
Például:thread szal1(helloWorld1);
thread szal2(helloWorld2);Ha kell:
szal1.join();
szal2.join();
Ő majd eldönti, mit hova tegyen.
Ha ezeket megtanulod, akkor jössz rá, mire is használd. Evés közben jön meg az étvágy."- 8 db PWM értéket mérek digitális bemeneten
- 10 db PWM értéket írok ki digitális kimeneteken"Nem tudom, mennyire jól van a PWM a Megán megoldva, de STM-en, ESP32-n például igen kényelmesen, hardverből.
-
Janos250
őstag
Régebben én is megnéztem, de úgy döntöttem, maradok az ESP32-nél:
Okok:
A legfontosabb, hogy az ESP32-n bótilag ott a WiFi
Ugyanígy 2 mag van benne, amihez elég jó a kezelés, nem tudom, ez hogyan van a RP-nél
C++11 fordító van hozzáillesztve, lehet, hogy az RP-nél ez jobb, mert ARM proci van benne.
Vannak, akik szidják az Arduino kezelő felületét, de én megszoktam, nekem jó.
Az ESP32-n van még egy csomó hardver (periféria) lehetőség, ami hasznos, de az RP-n nincs.
Az, hogy az ESP32 összes lábát bármire tudom használni, azaz bármit át tudok helyezni bármelyik lábró bármelyik másikra, az számomra előny.
Az ESP32-re rengeteg kidolgozott program, könyvtár van, fene tudja, mi a helyzet az RP-vel. -
-
Janos250
őstag
válasz
Tankblock
#16614
üzenetére
Igazad van, az RTOS nem operációs rendszer olyan értelemben, hogy nem tudok konzolról ilyen-olyan userként bejelentkezni, programokat futtatni, de nekem erre egy mikrokontrolleren nincs is szükségem. Amire szükségem van, azt tudja. Legalábbis az Espressif kiegészítéseivel. Tudja a fájlok kezelését úgy, hogy ha írok neki egy fájlnak a C szerinti megnyitását, tudja mi az, vagy ha azt mondom neki, hogy cout, tudja miről beszélek.
Ha valamelyik perifériát fájlként akarom használni, akkor persze meg kell hozzá írnom a drivert, de ezt be tudom illeszteni az ő rendszerébe, beírja a fájl leíró táblába, és onnantól már fájlként (is) tudom használni. Kell persze saját magamnak írni drivert, de már a DOS-hoz is saját magunk írtunk COM port kezelő drivert, mert az eredeti nem megszakítással dolgozott, pedig az Ix86x proci tudta.
Vagy, ha nem akarom az ő thread kezelését használni, hanem a programban szerepel a thread és a join, tudja, mit akarok, a fordító le tudja fordítani az ő API-jaira.
Végezetül, ami elvárásom nekem van egy mikrokontroller nem tudom, minek nevezzemjétől, az ebben az ESP32-ben benne van. Mellesleg viszonylag korszerű fordítót használ, bár nagyon sok mindent nem használok ki, mert például lambdát csak minden második szökőévben, bár azzal számos dolog tömörebb.
-
Janos250
őstag
válasz
Tankblock
#16612
üzenetére
(I)"FreeRTOS használ és az nem egy operációs rendszer sokkal inkább egy scheduler."(/I)
Hát, azért az OS, ha nem is hejde...
Igaz ugyan, hogy boldog és boldogtalan ráhúzta a freeFTOS-t a legkülönbözőbb kontrollerekre, és gondolom, pl. az AVR-ekre megírt verziók csak schedulerek.
A freeRTOS tartalmazza például az lwip-t, ami egyértelműen UNIX filozófia.
Onnan tudom, hogy az ESP32 net kezeléséről kevés info van a neten, de a UNIX-hoz rengeteg, és azt kell nézni, mert teljesen passzol az ESP-hez. A teljes socket kezelés, miegymás. A nevek is megegyeznek.
Espéék nem találták fel a spanyol viaszt, hanem - jó kínai módra - alkalmazzák azt, amit mások megcsináltak.
Van file leíró tábla, ahova a file-ok be vannak jegyezve. A soros port sorszáma (file descriptor) például 2.
Futtasd le a következő programot:void setup() {
Serial.begin(115200);
delay(2000);
FILE* filePointer = fdopen(2, "r+");
fprintf (filePointer, "Szevasz ESP!\nEn vagyok a soros port\n") ;
fclose(filePointer);
} ;
void loop() {};Vagyis eredendően a Serial is file, csak rá van ültetve mindenféle Arduino dolog.
-
Janos250
őstag
Való igaz, hogy mondjuk az UNO-n és se akartam fájlként kezelni semmit, a PIC-eken meg végképp nem. Attól függetlenül, hogy nincs háttértároló, még a UNIX-ból adódóan eléggé elterjedt a "minden fájl" szemlélet. Tényleg az ESP-ben gondolkodom, de én azt hiszem, növekszik azoknak a tábora, akik áttérnek valamilyen 32 bitre.
ESP32-n például a WiFi is fájl. Lehet rá fájlként írni, róla fájlként olvasni, és nem kell hozzá külön library, hanem a C-ben szokásos file kezelési módon használható.
Például:FILE* filePointer = fdopen(fileSorszama, "r+");
fprintf (filePointer, "Szevasz!\n") ; -
-
Janos250
őstag
válasz
Tankblock
#16605
üzenetére
Igen, így van.
"előre meg nem határozott számú paramétert"
Rossz volt a megfogalmazás, mert valóban egy paramétert visz be.
A helyes megfogalmazás az lett volna, hogy "előre meg nem határozott számú adatot" . Ezalatt azt értettem, hogy a függvény írásakor nem tudjuk, hogy hány beviendő adat lesz. Persze, a ... a feladathoz jobban passzoló. Ezért is kerestem ki a neten először azt, mert már nagyon régen csináltam, gőzöm nem volt, hogyan is kell. Ezt tettem a 16600-ba.
"Amit csinász az standard C ben is egy láncolt listára is mutathatna.... akár egy pointer is". Teljesen igazad van, de én azok közé tartozom akiknek feláll a szőr a hátukon a standard C nagyon széles pointer használatától. Nem is foglalkoztam a C-vel, csak később a C++ -al. Igyekszem nem lemenni alacsonyabb szintekre, ha nem muszáj. Épp eleget programoztam assemblyben ahhoz, hogy kerüljem az alacsonyabb szinteket. Persze azért nem akarom a COBOL szószátyár szintjét sem, de a C++ az szimpatikus, szimpatikusabb, mint a pascal bővítések.
"ennyi erővel struct ba tehetnél". Igen az általánosabb, nem macerás.Én azért úgy gondoltam/lom, hogy nem káros emlékeztetni/megmutatni/memóriát frissíteni (ki hol tart a programozásban) azt, hogy a vektor, list, deque, és egyéb konténerekről se feledkezzünk meg, és hogy az iterátorok nem felesleges dolgok, meg az auto se, ezek néha egyszerűbbé teszik az életünket, mintha visszamennénk a standard C szintre. Ott nem kell se iterátor, se auto.
Mellesleg most muszáj a standard C-vel foglalkoznom, mert kíváncsiságból az ESP32 net kezelését bogarászom mélyebben, és az LWIP ugyebár a standard C-ben íródott.
Ez legalább emlékeztet arra, hogy minden külvilággal való kapcsolat "file". Tulajdonképpen nem is tudom, hogy a mikrokontrolleres világban a perifériákra miért nem a bevált file kezelést alkalmazzuk, ahelyett, hogy ezerféle könyvtárat használnánk, és összevissza hibákat okoz, hogy egy neten talált program nem megy, mert más könyvtárat használ.
Az SPI, stb. kényelmesen kezelhető file-ként is az ESP32-n is.
Hű, hosszú lett, bocs mindenkitől.
-
Janos250
őstag
válasz
ekkold
#16588
üzenetére
Hogyan tudunk függvénybe bevinni előre meg nem határozott számú paramétert?
Közben csináltam mintapéldát, hogyan tudjuk belerakni containerbe, akármennyi van is, és a függvényben iteratorral annyit használunk fel, amennyi van./*
mintapelda elore meg nem hatarozott szamu parameter atadasa fuggvenybe iteratorral
Minden olyan container hasznalhato, aminek van .begin() es .end() iteratora
peldaul: vector, list, deque, map, set, stack, stb
*/
#include <iostream>
#include <vector>
#include <list>
#include <deque>
using namespace std;
//void parameterAtadasVectorral(auto parameter){ // ez csak C++14 -tol el
void parameterAtadasVectorral(vector <int> parameter){
Serial.println("\nfelhasznaljuk a vector elemeit:");
for (auto i = parameter.begin(); i != parameter.end(); ++i){
//vagy: for (vector<int>::iterator i = parameter.begin(); i != parameter.end(); ++i){
Serial.println(*i);
};
} ;
void parameterAtadasListaval(list <int> parameter){
Serial.println("\nfelhasznaljuk a lista elemeit:");
for (auto i = parameter.begin(); i != parameter.end(); ++i){
Serial.println(*i);
};
} ;
void parameterAtadasDequeSorral(std::deque <String> parameter){
Serial.println("\nfelhasznaljuk a deque elemeit:");
for (auto i = parameter.begin(); i != parameter.end(); ++i){
Serial.println(*i);
};
} ;
void setup() {
Serial.begin(115200);
delay(1000);
vector <int> enVectorom {10,115} ;
enVectorom.push_back(8); // a vegere betesz egy elemet
parameterAtadasVectorral(enVectorom) ;
std::list<int> enListam = { 9,7,3,29 };
enListam.push_back(50);
parameterAtadasListaval(enListam) ;
std::deque<String> enDqueueDuplaveguSorom= { "macska","kutya","lo" };
enDqueueDuplaveguSorom.push_front("kismalac"); // elejere teszi
enDqueueDuplaveguSorom.push_back("pipi"); // veger teszi
parameterAtadasDequeSorral(enDqueueDuplaveguSorom) ;
} ;
void loop() {
};
/*
Ezt irja ki:
felhasznaljuk a vector elemeit:
10
115
8
felhasznaljuk a lista elemeit:
9
7
3
29
50
felhasznaljuk a deque elemeit:
kismalac
macska
kutya
lo
pipi
*/ -
Janos250
őstag
válasz
Dißnäëß
#16599
üzenetére
"Mi a különbség print és printf között ?"
A printf-ben megadsz egy szöveg mintát, hogy "így nyomtasd ki", és ebben szövegben a printf-ben az idézőjeles szöveg után felsorolt, kinyomtatandó változók helyét egy % jellel jelzed, és hogy milyen formában, azt meg közvetlenül a % után megadott specifikáló kóddal.
Pl: előjeles decimális d, vagy i, előjel nélküli decimális u, hexa x, stb.
Azt is megadhatod, hogy hány jegyre nyomtasson, stb.
A sortörést a \n -nel adod meg. -
Janos250
őstag
válasz
ekkold
#16588
üzenetére
Na, csináltam egy memory refresht.
Így is lehet olyan függvényt írni, aminek változó számú paramétere van/*
mintapelda variadic function hasznalatara, azaz
hogyan lehet irni olyan fuggvényt, aminek valtozo szamu parametere van
*/
#include <iostream>
#include <cstdarg>
using namespace std;
void tobbParameter(int hanyParameter...){
va_list argumentumok;
//egyeb deklaraciok, ha kell
va_start(argumentumok,hanyParameter);
// az "argumentumok" lista inicializalasa
for (int i = 0; i < hanyParameter; i++){
int soronKovetkezoParameter = va_arg (argumentumok, int) ;
Serial.println(soronKovetkezoParameter);
};
va_end(argumentumok);
// az "argumentumok" lista bezarasa
} ;
void setup() {
Serial.begin(115200);
delay(1000);
tobbParameter(3,5,10,8);
// 3 parameter lesz meg a 3 utan, amit fel kell dolgozni
} ;
void loop() {
};
/*
ezt irja ki:
5
10
8
*/ -
Janos250
őstag
válasz
Dißnäëß
#16596
üzenetére
Egy sorban ezek valamelyikével:
#include <iostream>
using namespace std;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.printf("Serial.printf-el szoveg a kiiras elott %d es utan\n", 5);
printf("printf-el szoveg a kiiras elott %d es utan\n", 5);
cout << "cout-tal szoveg a kiiras elott "<< 5<< " es utan\n" ;
} ;
void loop() {
};Kiírás:
Serial.printf-el szoveg a kiiras elott 5 es utan
printf-el szoveg a kiiras elott 5 es utan
cout-tal szoveg a kiiras elott 5 es utan -
Janos250
őstag
válasz
Tomika86
#16564
üzenetére
Bosszantott, hogy amit linkeltem, nem néztem meg végig, hogy pont a lényegesebb részek nincsenek benne.
Úgy döntöttem, hogy akkor írok én egy mini tutorialt.
Természetesen én se vagyok profi C++ alkalmazó, én is innen szoktam kérdezni, mert itt vannak nálam százszor jobban hozzáértők, de ők csak akkor írnak, ha kérdezzük.
Íme, ilyenre sikerült gyorsan hamarjában:arduinouser.hu/esp32/object-library-tutorial/osztalyokLibraryk.pdf
-
Janos250
őstag
válasz
ekkold
#16566
üzenetére
"ha tudod mit csinálsz, akkor jól is fog működni."
Hát, ez az!
Sokkal könnyebb elbaltázni a programot C-ben, mit bármi másban.
De az Arduino az C++ , itt azért már van némi kontroll !
Én annak idején hagytam is a fenébe a C-t, és csak később a C++ -t használtam/használom, mert a C "mindent szabad" , "ha hülyeséget írsz, én megcsinálom a hülyeséget, nem figyelmeztetlek" szemléletétől feláll a szőr a hátamon.
Azért a pascalok fejlettebb verzióiban is sok mindent meg lehetett csinálni úgy, hogy komolyabb ellenőrzés is volt.x = 'A';
x += 2;Az ilyen megoldásokat én nem kedvelem. C++ esetén legalább jelezni kell átdefiniálással, hogy tényleg ezt akarom.
Persze mindezek ízlés kérdése. Kinek az egyik tetszik jobban, kinek a másik.
Viszont Arduino esetén javasoljuk mindenkinek a C++ használatát! -
Janos250
őstag
válasz
Tomika86
#16559
üzenetére
Még pár megjegyzés:
A C++ tanulásához célszerű valamelyik korszerűbb fordító használata, mert abban minden benne van, ami a leírásokban szerepel. Az ESP32 ilyen, de bizonyára vannak mások is.
Futtasd a mintaprogramokat.
Ami a main()-ben van, az kerüljön a setupba, a return-t hagyd ki. A deklarációk a setup elé. A loop maradhat üresen.
Kiíráshoz, beolvasáshoz általában a cin, és cout szerepel, ezeket az ESP32 tudja.
Egy lehetséges indulás, ami nem a száraz "tudománnyal" kezd:Példának itt van a 3. lecke programja
https://www.webotlet.hu/?p=1726#include <iostream>
using namespace std;
int main()
{
int fokozat;
double sebesseg;
char szinkod;
bool metal;
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
return 0;
}Beírva/átírva az Arduino IDE-be:
Feltöltés előtt nyisd meg a soros monitort, mert oda fog írni.
#include <iostream>
using namespace std;
int fokozat;
double sebesseg;
char szinkod;
bool metal;
void setup() {
// ez kell, hogy a cout a soros monitorra irjon
Serial.begin(115200);
delay(2000);
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
// return 0;
// ezt ki kell hagyni, mert mikrokontrolleren egy progran nem ér véget,
// ez majd a loop-ban az idők végezetéig fut
} ;
void loop() {
} ;Ezt irja ki a soros monitorra:
Ez egy virtualis auto.
Az auto sebessegfokozata: 4
Az auto pillanatnyi sebessege: 48.6
Az auto szinkodja: R
Az auto metalszinu: 1Ez még alap lecke, de van itt minden a későbbiekben.
-
Janos250
őstag
válasz
Tomika86
#16555
üzenetére
Célszerűen igen, mert az pl. osztályokat nem tudod megkerülni. Pl. egyből a serial, WiFi, stb.
Sajnos nagyon sok tankönyvnél ha elolvasod az első 10 oldalt, ami úgy kezd, hogy Bezárás, Öröklés, Absztrakció, Polimorfizmus, egyből el is vesztél az erdőben, mert fogalmad sincs, hogy mi az, az elvont, filozófikus megfogalmazásból semmit nem értesz, és kiakadsz, hogy ez nehéz.
Szerintem a példákon kell kezdeni, és amikor már mennek a dolgok, akkor már elolvashatod az első 10 oldalt is, mert akkorra már érted, mik azok a bűvszavak. -
-
Janos250
őstag
A múltkori késő esti string és String kínlódásom után úgy döntöttem, hogy nincs értelme a brute force módszernek, inkább gondoljuk át logikusan. És tényleg! Ideírom a tapasztalataim, hátha valaha valakinek hasznos lesz a jövőben.
Kösz mindenkinek, aki segített!
Arduino String (nagybetűs), és a C++ string (kisbetűs) kapcsolata.
Az Arduino String nem írható be paraméterként olyan helyre, ahol C++ string az elvárás, és ez fordítva is igaz.
A kettő közötti átmenetet a .c_str() tagfüggvény teszi lehetővé.String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
EzekkelString ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03 (ArduinoString_Hello.c_str());
Így új példányok jönnek létre.A szöveget mind a String, mind a string belül egy 0x0 terminált karakter tömbben tárolja, és a .c_str() konstans pointer mutat rá, ezért ha (char*) C típusú sztinget akarunk, akkor "const" miatt (char*) átdefiniálás szükséges.
Például:char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
Ebben az esetben nem jön létre új példány, hanem a char* típusú karaktertömb pointere is az eredeti objektumban tárolt karaktertömb kezdetére mutat. Ha az egyikben megváltoztatjuk valamelyik karaktert, a másikban is megváltozik.Az ESP32-höz használt fordító ismeri az iterátor típust is. A C++ string rendelkezik .begin(), .end() iterátorral.
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // dMintának egy teljes program:
#define __cplusplus 201103L
#include <iostream>
using namespace std;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.println("Arduino String (nagybetus), es a C++ string (kisbetus) kapcsolata.");
String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
String ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
Serial.printf("ArduinoString_Hello :%s\n",ArduinoString_Hello);
Serial.printf("ArduinoString_Hello02 :%s\n",ArduinoString_Hello02);
Serial.printf("ArduinoString_Hello03 :%s\n",ArduinoString_Hello03);
Serial.printf("ArduinoString_Hello[0]:%c\n",ArduinoString_Hello[0]);
Serial.printf("ArduinoString_Hello.c_str()[0]:%c\n\n",ArduinoString_Hello.c_str()[0]);
/*
ArduinoString_Hello :Hello
ArduinoString_Hello02 :World
ArduinoString_Hello03 :World
ArduinoString_Hello[0]:H
ArduinoString_Hello.c_str()[0]:H
*/
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03(ArduinoString_Hello.c_str());
std::cout << "Cpp_string_World :" << Cpp_string_World<< "\n";
std::cout << "Cpp_string_World02 :" << Cpp_string_World02 << "\n";
std::cout << "Cpp_string_World03 :" << Cpp_string_World03 << "\n";
/*
Cpp_string_World :World
Cpp_string_World02 :Hello
Cpp_string_World03 :Hello
*/
char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
ArduinoString_Hello_c_str[2] = 'x';
Cpp_string_World[2]= 'y';
Serial.printf("ArduinoString_Hello is atirodik :%s\n",ArduinoString_Hello);
std::cout << "Cpp_string_World_c_str is atirodik :" << Cpp_string_World << "\n";
/*
ArduinoString_Hello is atirodik :Hexlo
Cpp_string_World_c_str is atirodik :Woyld
*/
// iterator:
std::cout << "Iterator:\n";
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/
std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // d
} ;
void loop() {} ; -
#16461
Janos250
őstag
its_grandpa
#16458
Janos250
őstag
válasz
its_grandpa
#16458
üzenetére
Egyébként ezt írja ki:
HTTP/1.1 200 OK
Date: Mon, 15 Nov 2021 09:54:09 GMT
Expires: -1
Cache-Control: private, max-age=0
Content-Type: text/html; charset=ISO-8859-1Szerény hálózati ismereteim szerint ez jó!
Mellesleg ott van az elején, hogy tutorial, nem használatra szól, mert ennek így semmi értelme nincs, hogy a Google válaszának első 5 sorát kiíratjuk! -
Janos250
őstag
-
#16459
Janos250
őstag
its_grandpa
#16458
Janos250
őstag
válasz
its_grandpa
#16458
üzenetére
Nem akarlak meggyőzni. Szabad az út, lehet bárkinek szebben megírni, és megosztani.
Van hely a prohardveren, nem foglal túl sok helyet, egy szöveges program. Nem a szépség, hanem a minél könnyebben érthetőség volt a cél.Mitől lenne terminálva?
Attól, hogy van terminálva a bejövő karakter sorról.
"A költő vélhetően 5*200 karaktert szeretne olvasni és kiírni."
Bizony, nem mindig sikerül a költő szándékát kitalálni.![;]](//cdn.rios.hu/dl/s/v1.gif)
fgets: https://www.tutorialspoint.com/c_standard_library/c_function_fgets.htm
-
Janos250
őstag
válasz
ekkold
#16450
üzenetére
Azt hiszem, mindketten ugyanarról beszélünk, csak más nyelven:
Idézet a netről:
Az egydimenziós tömbök (vektorok) és az egyszeres indirektségű („egycsillagos”) mutatók között teljes a tartalmi és a formai analógia.int *p;
p = &a[0]; vagy p = a;A legtöbb C++ fordító az a hivatkozásokat automatikusan *(a+i) alakúra alakítja, majd ezt a pointeres alakot lefordítja.
-
Janos250
őstag
Na, már van némi haladás, de még mindig nem OK.
Hogyan tudom beletenni egy cpp stringbe?char* buf = new char[encoded2.length()+1];
encoded2.toCharArray(buf, encoded2.length()) ;
buf[encoded2.length()+1] = '\0';
printf("buf:%s\n",buf); // ez jó
string encoded2_cpp_string ;
encoded2_cpp_string = string(buf) ; / ehelyett mi kell????
printf("encoded2_cpp_string:%s\n",encoded2_cpp_string); // ez nem jót ír ki -
Janos250
őstag
válasz
Tankblock
#16445
üzenetére
Köszi!
Ott még mindig el vagyok akadva, hogy a String-ből hogy csinálok string-et.
A String-nek van a .c_str -je, de ez tulajdonképpen mit ad eredményül?
Ez nem egy char* ? A C stílusú string az nem karaktertömb? Vagy a
char akarmi[ ] az nem char* ?Hogyan rakom ezt a Stringet bele egy string-be?
-
Janos250
őstag
A függvény így néz ki:
String base64::encode(const uint8_t * data, size_t length)
{
size_t size = base64_encode_expected_len(length) + 1;
char * buffer = (char *) malloc(size);
if(buffer) {
base64_encodestate _state;
base64_init_encodestate(&_state);
int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state);
len = base64_encode_blockend((buffer + len), &_state);
String base64 = String(buffer);
free(buffer);
return base64;
}
return String("-FAIL-");
}Mitől lesz ez const? A fene se érti
-
Janos250
őstag
Amit példának leírtam, még csak érteném a const okát, de ahonnan a probléma eredt, az ez volt:
String toEncode2 = "Hello World";
String encoded2 = base64::encode(toEncode2) ;
char proba_c_str[20];
proba_c_str = encoded2.c_str() ; //incompatible types in assignment of 'const char*' to 'char [20]'Miért lesz ez const, hiszen ő egy eredmény, amit a base64 ad?
-
Janos250
őstag
válasz
PeterPH
#16439
üzenetére
De, az megy, és jót csinál!
Kösz!
Na, el kell mélyednem ebben, hogy ezzel miért megy, és értékadással miért nem.Ezt se értem:
"char * strcpy ( char * destination, const char * source );Copy string
Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point)."A C string az nem egy char tömb?
-
Janos250
őstag
Szevasztok!
Már megint nyelvi problémáim akadtak ebben kérném a gyakorlottabbak segítségét!Mert ugyebár Luci Feri behozta az Arduinoba a szabványos (kisbetűs) string mellé a saját (nagybetűs) String típusát, és nekem valahogy nem megy a konvertálása ennek a Stringnek se stringbe, se C stílusú stringbe, mert Feri valahogy nem engedi. Pedig a Stringnek is van egy .c_str() tagfüggvénye, de ennek eredményét valahogy nem tudom beletenni semmibe. Különösen az utolsó sort nem értem. Mi a megoldás?
Ja, azt ne mondjátok, hogy ne akarjam konvertálni, mert én olyan vagyok, hogy akarom.String probaArduinoString = "Hello World" ;
printf("probaArduinoString=%s\n",probaArduinoString); // badarsagot nyomtat
printf("probaArduinoString.c_str()=%s\n",probaArduinoString.c_str()); // ez jo
// string probaCpp_string = probaArduinoString ; forditasi hiba
string probaCpp_string = probaArduinoString.c_str() ;
printf("probaCpp_string=%s\n",probaCpp_string); // badarsagot nyomtat
char proba_c_str[20];
// proba_c_str = probaArduinoString.c_str() ; // incompatible types in assignment of 'const char*' to 'char [20]' -
Janos250
őstag
Ide is bemásolom, hátha valamikor valakinek szüksége lesz rá, hogy szabványosan, fájlként írjon egy távoli szerverre, illetve olvasson róla:
/*
tutorial
receive data from remote server
*/
#include <WiFi.h>
#include <lwip/sockets.h>
const char* ssid = "**********";
const char* password = "**********";
void setup() {
Serial.begin(115200);
delay(2000);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
printf("\nconnected to WiFi \n");
int socket_descriptor = socket(AF_INET , SOCK_STREAM , 0);
if (socket_descriptor == -1) {
printf("Could not create socket");
}
struct sockaddr_in connect_to_remote_server_addr;
connect_to_remote_server_addr.sin_family = AF_INET;
connect_to_remote_server_addr.sin_addr.s_addr = inet_addr("216.58.208.110"); // Google
connect_to_remote_server_addr.sin_port = htons( 80 );
if (connect(
socket_descriptor ,
(struct sockaddr *)&connect_to_remote_server_addr ,
sizeof(connect_to_remote_server_addr)
) < 0
)
{ // if < 0
printf("Connect error to remote server\n");
}
else {
printf("Connected to remote server\n\n");
} ; // end if
FILE* filePointer = fdopen(socket_descriptor, "r+");
if (filePointer == nullptr){ printf("\n\nnullpointer\n\n\n");};
fprintf (filePointer, "GET / HTTP/1.1\r\n\r\n") ;
char inputChars[200];
for (int i = 0;i<5;i++){
fgets(inputChars, 199, filePointer);
printf("%s", inputChars);
} ;
close(socket_descriptor);
} ; // end setup
void loop() {
} -
Janos250
őstag
válasz
JozsBiker
#16425
üzenetére
"Én az oldalamra ennek segítségével tettem be a kódot."
Én is
http://arduinouser.hu/esp32/wifisocket/index.htmRégebben itt ajánlottátok nekem a WEB-socketot, de fogalmam se volt mi az. Azt hittem, a klasszikus internet socket. Amikor rájöttem, hogy az egész más, elhatároztam, hogy írok egy hevenyészett leírást az ESP32-n az LWIP internet socket használatáról. Ez most történt meg. Majd egyszer a WEB-socketról is.
-
Janos250
őstag
válasz
wakula778
#16391
üzenetére
Itt egy minta a használatára az egyik nálam futó programból. ESP32-n.
Mivel két szenzor van, ezért kell kézzel állítani a CS-t.SPI.beginTransaction(SPISettings(100000, MSBFIRST, SPI_MODE1)); // Set the settings to work with SPI bus
digitalWrite(CSpinForralo, LOW); // Select slave
Hbyte = SPI.transfer(0);
Lbyte = SPI.transfer(0);
digitalWrite(CSpinForralo, HIGH); // Release slave again
SPI.endTransaction();
readed16bit = ((uint16_t)Hbyte)<<8 ;
readed16bit = readed16bit + Lbyte;
forraloHomerseklet = readed16bit >> 6 ;
printf("forralo homerseklet= %d \n ",forraloHomerseklet); -
-
Janos250
őstag
válasz
ekkold
#16383
üzenetére
Egy ilyen szenzor 1200 Ft.
https://www.aliexpress.com/item/32334119287.html
Megéri ennyiért kínlódni egy erősítő kapcsolással, aztán mérni a feszültséget, majd korrigálni, és átszámítani fokra, amikor a meglévő MAX áramköre mindezt elvégzi, és digitálisan küldi az értéket szabványos, SPI protokoll szerint?
Persze, ha nem az élvezet a cél! -
Janos250
őstag
Egy kis fejtágítás hőelem/hidegpont ügyben:
https://ms.sapientia.ro/~elektronika/fileok/jelerzekelok/szt_lab04_hoelemek_v1.pdf -
Janos250
őstag
válasz
wakula778
#16377
üzenetére
Alin kell szétnézni.
Maga a termoelem bírja közel 1300 fokig, akár K, akár N típusú.
A vezetékezés a gond, hogy annak a szigetelése meddig bírja, és hogy milyen mélyen van bedugva.
Mert mint tudjuk, az lényeges :-) Vagy tehetsz rá védőeszközt, ami az adott esetben saválló acél, ilyen lezárt végű csőszerűségeket árulnak. Itt is a vezeték szigetelése az irányadó.
A következő példára se igaz az, amit írnak, hogy 1200 fokig használható.
https://www.aliexpress.com/item/32333761484.html?spm=a2g0o.productlist.0.0.6fe325bfoM8DZb -
Janos250
őstag
válasz
wakula778
#16373
üzenetére
Nem egyszerű a megoldás, a hőelemek működési elvéből következően :-(
A hőelemmel klasszikusan úgy kell hőmérsékletet mérni, hogy hogy két hőelemet használsz, az egyik egy ismert hőmérsékleten van ("hidegpont"), a másik pedig a mérendőn, és úgy kötöd be őket, hogy a fesz. mérő felé már egyforma anyagú vezetékek menjenek, és a feszültségből tudod a két pont hőmérsékletének a különbségét.
Ha csak egy hőelemed van, akkor kétféle anyagú vezeték megy a mérőbe, ami ugyebár a csatlakozásnál szintén feszültséget generál, és borul az egész.
A K-type szenzorokhoz van olyan áramkör (MAX6675,MAX31855) , ami nem pontosan tudom, milyen elven, de valahogy megoldja a hőkompenzációt, ezért elég hozzá egy szenzor is.
Az N-type az újabb, nem tudok róla, hogy lenne hozzá ilyen lapka, de attól még lehet.
A MAX6675-el N-type szenzort mérni - azt hiszem - reménytelen, mert más anyaguak.
A MAX6675-öt K-type szenzorhoz használom, jól működik. -
Janos250
őstag
válasz
Tomika86
#16343
üzenetére
A témát kevésbé ismerők kedvéért:
AZ ESP32-ben van egy "mátrix", amiben minden sorhoz tartozik egy jelforrás, (például serial rx, serial tx, stb.) és minden oszlophoz az IC-nek egy lába.
Ahova beteszünk egy 1-est, (az össze van kötve) az a láb fog kapcsolódni az adott jelhez.
Viszont a programozónak ezt nem kell ilyen alapszinten kezelni, mert a könyvtárak az inicializáló részben ezt le szokták kezelni.
Lásd a Serial portot:void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)Úgy van megcsinálva, hogy ha a végéről lehagyod a megadást (pl. int8_t rxPin stb.), akkor a default érték lép életbe. Ezért elég pl. csak annyit írni, hogy
Serial.begin(9600) -
Janos250
őstag
És ha floating állapotban hagyod?
ESP32 GPIO pinjeinek az állapotai:
pinMode(pin, mode)
//mode:
INPUT //input is floating
INPUT_PULLUP
INPUT_PULLDOWNmode bitjeinek jelentése: (esp32-hal-gpio.h)
//GPIO FUNCTIONS
#define INPUT 0x01
#define OUTPUT 0x02
#define PULLUP 0x04
#define INPUT_PULLUP 0x05
#define PULLDOWN 0x08
#define INPUT_PULLDOWN 0x09
#define OPEN_DRAIN 0x10
#define OUTPUT_OPEN_DRAIN 0x12
#define SPECIAL 0xF0
#define FUNCTION_1 0x00
#define FUNCTION_2 0x20
#define FUNCTION_3 0x40
#define FUNCTION_4 0x60
#define FUNCTION_5 0x80
#define FUNCTION_6 0xA0
#define ANALOG 0xC0"GPIOs 34, 35, 36, 39 are input only pins"
"These pins don’t have internal pull-up or pull-down resistors." -
#16284
Janos250
őstag
tonermagus
#16281
Janos250
őstag
válasz
tonermagus
#16281
üzenetére
Nem tudok, csak egy régi ismerősöm mondta valamikor, akit már nem tudok elérni, hogy ő közvetlen az u-blox-tól vásárolt valami.
-
#16280
Janos250
őstag
tonermagus
#16278
Janos250
őstag
válasz
tonermagus
#16278
üzenetére
"csak 19K-ért"
Annyiért már a NEO RTK-s, kétfrekis chipje is megvehető. Nem jut eszembe hirtelen a típus neve. -
#16279
Janos250
őstag
tonermagus
#16278
Janos250
őstag
válasz
tonermagus
#16278
üzenetére
NEO-t nem jobb közvetlenül Svájcból venni? Nem tudom, de talán.
Igen, ezeket a régi processzoros lapokat a Bangood már nem igazán forgalmazza, de idővel úgyis átállsz korszerűbbekre. -
#16277
Janos250
őstag
tonermagus
#16274
Janos250
őstag
válasz
tonermagus
#16274
üzenetére
Egy példa:
Most például 1750 Ft darabja az ESP32-nek tízes tételben, szállítással, ÁFÁ-val, ügyintézéssel együtt, de lehet, hogy pár óra múlva már sokkal több lesz.
https://www.banggood.com/10Pcs-ESP-32S-ESP32-Development-Board-Wireless-WiFi+Bluetooth-2-in-1-Dual-Core-CPU-Low-Power-Control-Board-ESP-32S-p-1896926.html -
#16276
Janos250
őstag
tonermagus
#16274
Janos250
őstag
válasz
tonermagus
#16274
üzenetére
Pár évvel ezelőtt érdemes volt, mert néha gombokért lehetett venni dolgokat, ha figyeltél. Az utóbbi 2-3 évben nemigen vannak értelmes leárazások. Amiket nagy bf akcióként hirdetnek, azok előtte (és utána ) ugyanazon az áron, vagy olcsóbban megvehetők.
Nagyon változnak az árak. Amit például itt írtam
https://prohardver.hu/tema/arduino/hsz_16273-16273.html
jelenleg már jóval drágább, mint pár nappal ezelőtt. -
Janos250
őstag
válasz
Tomika86
#16270
üzenetére
Én meg szoktam nézni a Bangood kínálatát, mert nagyon változik.
Most talán ezt venném:
https://www.banggood.com/Geekcreit-ESP32-WiFi+bluetooth-Development-Board-Ultra-Low-Power-Consumption-Dual-Cores-Pins-Unsoldered-p-1214159.html?cur_warehouse=CN -
Janos250
őstag
válasz
JozsBiker
#16264
üzenetére
Az Ebay sajnos nem intézi az adó adminisztrációt, az a magyar postához megy, és akkor megszívtad, mert nem csak a plusz díjukat kell az ÁFA fölött fizetni, de gyakori az adminisztrációs tévedés is.
Persze egyik-másik futár esetén is (pl. DHL) igen mélyen a zsebedbe kell nyúlni.
A nagyok közül tehát az Alinak, és a Bangoodnak van olyan szállítási módja, ahol elintézik az Eu-ba léptetés adminisztrációját, az adó kifizetésével együtt. Pl. Bangoodon eleve olyan árat mutat az országod alapján, ami már tartalmaz mindent. Alin ez nem mindig sikerül. Rólam pl. rendszeresen azt hiszi, hogy Kaliforniában vagyok, de a végén a fizetéskor jó árat számít, amiben minden benne van.
Régebben jó volt a Gearbest is, de az döglődik, attól az Isten mentsen meg mindenkit, mert a pénzt ugyan elteszik, de az árut gyakori, hogy nem küldik. Ez számukra jó üzlet.
-
Janos250
őstag
válasz
ekkold
#16260
üzenetére
Persze, de nekem erre a munkára, amit ő végez, nincs szükségem, ezért nem is akarok fizetni érte. Az ismert V... oldalon meg a hirdetők többnyire azt csinálják, hogy megrendelik ők is Kínából a Te nevedre, de kétszer annyit kérnek tőled, mint amit ők kifizetnek érte. Hozzájuk nem is kerül a csomag.
-
Janos250
őstag
Hogyan válasszunk szállítási módot kérdésre itt válaszolok, nem privátban, mert másokat is érdekelhet, továbbá egyáltalán nem illegális, minden be van fizetve, csak a magyar posta nyavalygásait, és díjait ússzuk meg.
A szállítási módot kell megfelelően megválasztani, hogy a szállító elvégezze a teljes vámügyintézést.
Ezek változnak, célszerű a megfelelő topicban, és annak összefoglalójában szétnézni.
Bangoodnál jelenleg a Bangood express az, ami minden papírmunkát elvégez, és az árba, vagy a szállítási díjba ezeket eleve beszámítja, nem kell külön fizetni.
https://prohardver.hu/tema/banggood/friss.html
Alinál úgy rémlik jelenleg az Aliexpress szállítás a nyerő, de mindig meg kell nézni, mert változnak. A topic :
https://prohardver.hu/tema/kulfoldi_rendelesek_nyomkovetes_stb/friss.html -
Janos250
őstag
válasz
Tomika86
#16256
üzenetére
Ha megfelelően rendelted, nem lesz plusz VÁM és kezelési költség, mert ALI már leáfázza, levámolja, futár hozza vagy a lakásodra, vagy valami átvételi pontra. Alinál is, Bangoodnál is ez a helyzet. Az Ali általában valamivel olcsóbb, és sokkal nagyobb a választék, viszont a Banggod dolgai sokkal gyorsabban érkeznek.
Mindenki ugyanúgy a nagykereskedőktől vásárol, csak a nagy kínai áruházak egyben, konténerszámra szállíttatják, vámkezeltetik Eu-ba érkezéskor, és azonnal a futárnak adják át, aki kapudig viszi mondjuk Belgiumból. Egyébként a tévhitektől eltérően nem szürkén, feketén, hanem teljesen legálisan jut el hozzád, nem kell félni egy esetleges finánc ellenőrzéstől.
A magyar kereskedő esetén végig kell járnia a sok apró szállítási, bürokratikus adminisztrációs szabályokat. Csak gondolj bele, hányféle dolgot kell - feleslegesen - fizetnie. Külön könyvelő, adótanácsadó, fizetni a banknak minden külön számlára utalásért, stb. A kínai ezt egyben elintézi: egyben átutalja az ÁFÁ-t, VÁM-ot a magyar, belga, stb. adóhivatalnak, nincs vele több gondja, nem kell a méregdrága bankokat etetni a sok apró tétel átutalásáért, stb. -
#16253
Janos250
őstag
tonermagus
#16251
Janos250
őstag
válasz
tonermagus
#16251
üzenetére
"Egyáltalán mi történik ha kevés a baudráta?"
Próbáld ki! -
#16250
Janos250
őstag
tonermagus
#16246
Janos250
őstag
válasz
tonermagus
#16246
üzenetére
"ezek szerint a software oldalon dől el, hogy RTK-s vagy sem?"
Igen. A bázisban szoftver kérdése, hogy ha tudod a pontos pozíciódat, akkor a holdról érkező jelek alapján eldöntsd az adott holdra vonatkozóan a légköri egyenetlenségből adódó hibát, órahibát, stb.
Ezeket, ha továbbítod a rovernek, akkor ő ezekkel korrigálni tud holdankét külön-külön, és így már elég pontos lesz a mérés.
Régebben valahol olvastam olyan ajánlást, hogy ha a két ugyanolyan chip ugyanúgy tiszta égbolt alatt van, egymástól nem száz kilométerekre, akkor általában ugyanazokat a holdakat használja, így ha a "bázis" H és V pozíciójának a hibáját méterben elküldöd a "rovernek", akkor ő egyszerűen hozzáadja a hibákat a saját méréseihez,
ami ugrásszerű javulást eredményez a pontosságban, de én ezt se próbáltam ki. -
#16249
Janos250
őstag
tonermagus
#16246
Janos250
őstag
válasz
tonermagus
#16246
üzenetére
Mivel a mai chipekben - állítólag - ROM-ban van a firmware, reménytelen. Továbbá a régi firmware-ek csak a GPS holdakat tudták használni. Mikor még én is olyan RTK chipet használtam, ami csak a GPS holdakat tudta, napi 2-3 óra volt összesen, amikor lehetett RTK-t használni az egyfrekis vevővel. A mai RTK-s chipek kétfrekisek, és tudják az "összes" nálunk elérhető holdat használni. Így már RTK nélkül is jóval pontosabb értéket adnak, de az áruk 100 $-nál kezdődik, és határ a csillagos ég. A hozzá való antenna szintén 50 $ körül kezdődik.
Én egyébként soha nem próbáltam az M8N-nel RTK-t, csak amikor még az én chipjeimmel macerás volt az RTK, akkor az irodalomból emlékszem ezekre. -
#16243
Janos250
őstag
tonermagus
#16241
Janos250
őstag
válasz
tonermagus
#16241
üzenetére
"Az M8N nem RTK-s"
De a korábbi firmware-nek voltak olyan undocumented utasításai, amivel ki lehetett csalogatni a RAW adatokat, és így meg lehetett hekkelni, hogy RTK legyen, de erre rájött a gyártó is, és az újabb firmware-ből törölte ezeket a parancsokat. Erre az élelmes felhasználók downgrade-elték a fw-t. Lépett a gyártó is: ROM-ba tette a fw, így már muszáj megvenni gyakorlatilag ugyanazt, drágábban, ha RTK-t akar valaki.
Biznisz az biznisz! -
#16242
Janos250
őstag
tonermagus
#16241
Janos250
őstag
válasz
tonermagus
#16241
üzenetére
És amikor a GPS chip bd-jét átállítod, akkor ugye hozzáilleszted a fogadó Arduino bd-jét is?
Ilyenkor jön jól az analizátor, amit már sokat emlegettünk itt, azzal meg lehet nézni, mi jön ki a GPS-ből. Lehet semmi, akkor valami a konfigban rossz, vagy más bd-n, akkor viszont a fogadó nem illeszkedett ahhoz a bd-hez.
1-2 métert a maiak általában tudnak. Néha viszont jóval nagyobb hiba is előfordul, de az ritka. A baj az, hogy nem tudod, mikor mekkora a hiba. -
#16240
Janos250
őstag
tonermagus
#16236
Janos250
őstag
válasz
tonermagus
#16236
üzenetére
Közben megpróbáltam megkeresni, de már nincs meg a vásároltak listáján, viszont teljesen elhűltem.
Srácok! Teljesen megbolondult a piac? A GPS chipek ára a csillagos egekbe szökött. A korábban 3-5 dolláros chipek is 10-15 dollárnál kezdődnek, és 20-30 dollárig mennek. Mi a fene történt?
Vagy én ittam túl sokat, és képzelődöm?
-
#16239
Janos250
őstag
tonermagus
#16236
Janos250
őstag
válasz
tonermagus
#16236
üzenetére
Hoppá!
Most jutott eszembe, hogy talán 2 éve, amikor a Bangoodon akciósan nagyon olcsó volt egy M8N chipen alapuló eszköz, vettem belőle, de csak kipróbáltam. Ha sikerül megtalálnom, majd kipróbálom a bd állítást. -
#16238
Janos250
őstag
tonermagus
#16236
Janos250
őstag
válasz
tonermagus
#16236
üzenetére
Szakértő azért nem vagyok!
Csak nagyon-nagyon régen használtam u-blox chipet, ezért csak általánosságban tudok hozzászólni. Az M8N nem RTK alapú chip, vagyis elég nagy a pontatlansága. Minek akkor 5 másodpercenkénti olvasás? Meg kellene nézni, hogyan lehet állítani a bd-t, mit kell kiküldeni a porton a chipnek, és azt gyalog kiküldeni, mindenféle könyvtári funkciók helyett.
Azt se tudom, ha megváltoztatod a bd-t, (pl. így: https://www.navilock.com/service/fragen/gruppe_59_uCenter/beitrag/40_uBlox-and-Change-the-Baudrate.html)
megmarad-e kikapcsolás után is. Ha szerencséd van, igen.
Baudrate ügyében én a "puding próbája" elvet követem: ki kell próbálni.
Az én chipemmel nekem eddig nem voltak bd problémáim, igaz, másodpercenként egyszer olvasok. Inkább a bázisról a korrekciós adatoknak mobilneten a roverhez való továbbítása a szűk keresztmetszet.
(Azoknak, akik nem ismerik az RTK elvet:
Van egy ismert pozícióban lévő állomás, ez a bázis. Ez megadja az ismert pontos, és a mért hibás adatok alapján a hiba korrekcióját, amit a rovernek küldünk, és az korrigálja a saját méréseit. Persze azért nem ennyire egyszerű, mert műholdanként és típusonként kell a hibát számítani, és ugyanúgy kell korrekcióba venni.)
Terv, (a következő évezredben) egy GPS vezérlésű mobil eszköz irányítása, na ott majd kelleni fog a nagy frekvenciával való olvasás, hogy 5-10 cm alatt maradjon az eszköz pályán tartása során a követett pálya hibája. -
Janos250
őstag
válasz
Tankblock
#16234
üzenetére
"HW ismerete megment egy csomó felesleges kódolástól is"
Így igaz! Én is kipróbáltam pár verziót passzióból.
Közben kibogarásztam az RMT regisztereket, az undokumentedeket is.
https://arduinouser.hu/esp32/ESP32_RMT_Register_Summary.pdf -
Janos250
őstag
válasz
ekkold
#16230
üzenetére
"Nem akartam saját könyvtárat írni erre"
Pedig szerintem az a legcélravezetőbb, nem egy bonyolult a bitek kivitele.
Én ESP32-re csináltam ugyanezt, mert akkor legalább tudom, hogy mit csinál.
Ha párszáz nano időzítési pontossággal tudsz kiírni, azzal már be lehet lőni.
Kíváncsiságból megcsináltam GPIO billegtetéssel (ESP32), és úgy is működött, bár az ESP32-n van erre célhardver (RMT) -
Janos250
őstag
válasz
Tomika86
#16169
üzenetére
A stack méretet szerintem csak próbálgatással lehet belőni. Adsz valami jó nagyot, aztán addig csökkented, amíg jó. Minél több változót definiálsz a függvényen belül, annál nagyobb kell. Ha globálisak a változóid, akkor kevesebb.
Igen, simán szétszedheted gyakorlatilag akárhány részre, és megszabhatod, hogy melyik rész hol fusson. -
Janos250
őstag
válasz
Tomika86
#16165
üzenetére
Az egyik felét hagyod a loopban, az fut majd az 1-es magon.
Csinálsz egy függvényt, abba teszed a másik felét, és az megy ./*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
TaskHandle_t Task1;
//TaskHandle_t Task2;
// LED pins
//const int led1 = 2;
//const int led2 = 4;
void setup() {
Serial.begin(115200);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
//create a task that will be executed in the Task1code() function, with priority 1 and executed on core 0
xTaskCreatePinnedToCore(
Task1code, /* Task function. */
"Task1", /* name of task. */
10000, /* Stack size of task */
NULL, /* parameter of the task */
1, /* priority of the task */
&Task1, /* Task handle to keep track of created task */
0); /* pin task to core 0 */
delay(500);
/*
//create a task that will be executed in the Task2code() function, with priority 1 and executed on core 1
xTaskCreatePinnedToCore(
Task2code,
"Task2",
10000,
NULL,
1,
&Task2,
1);
Ez nem kell, mert a loop automatikusan a 0. magra megy.
*/
delay(500);
}
//Task1code: blinks an LED every 1000 ms
void Task1code( void * pvParameters ){
Serial.print("Task1 running on core ");
Serial.println(xPortGetCoreID());
/*
for(;;){
digitalWrite(led1, HIGH);
delay(1000);
digitalWrite(led1, LOW);
delay(1000);
*/
// ide jön a 0-án futtatandó programrész
Serial.print("Task1 running on core ");
Serial.println(xPortGetCoreID());
}
}
/*
//Task2code: blinks an LED every 700 ms
void Task2code( void * pvParameters ){
Serial.print("Task2 running on core ");
Serial.println(xPortGetCoreID());
for(;;){
digitalWrite(led2, HIGH);
delay(700);
digitalWrite(led2, LOW);
delay(700);
Serial.print("Task2 running on core ");
Serial.println(xPortGetCoreID());
*/
}
}
void loop() {
// ide jön, ami az 1-es magon fusson
} -
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Új hozzászólás Aktív témák
Hirdetés
- BESZÁMÍTÁS! Asus M5A99FX PRO R2.0 990FX chipset alaplap garanciával hibátlan működéssel
- Zebra ZP505 EPL - Hőpapíros címkenyomtató
- 118 - Lenovo Legion Pro 5 (16ARX8) - AMD Ryzen 9 7945HX, RTX 4070 - UK billentyűzet
- iKing.Hu - Motorola Edge 50 Ultra - Nordic Wood - Használt, karcmentes
- BESZÁMÍTÁS! Gigabyte A620M R5 7500F 32GB DDR5 512GB SSD RTX3070 8GB ZALMAN S2 TG Enermax 750W
Állásajánlatok
Cég: CAMERA-PRO Hungary Kft
Város: Budapest
Cég: Liszt Ferenc Zeneművészeti Egyetem
Város: Budapest