OK Mégsem
Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   860 / 872
(#) kameleon2 válasza Lamprologus hozzászólására (») Máj 22, 2025 /
 
1.8.5 is lassú esp-vel. Igaz egy mázsa lib kellett hozzá. De nálam a lassó 5-7 perc egy ezer éves 2. generációs i7-en.
(#) toth1996 hozzászólása Máj 22, 2025 /
 

Komfort index

Sziasztok.
Megcsináltam egy alap kapcsolást arról hogy igy képzelném el a komfort index vezérlését.
Az index kar gnd vezérelt ami 8mA áram folyik mikor testre van húzva.
A működésé program szinten hogy D2 vagy D3 alacsony állapotba kerül 1 sec-500milisec idő között akkor "pöccintés" történt.
Ha ez igaz akkor vagy D5-D6 alacsony állapotba került 3 másodpercig.
(Az auto modulja vezérli a reléket igy a villogtatás nem az én részem)

Azon is gondolkodtam elég lehet 2 láb figyelésre és vezérlésre.
De ennyire nem vagyok jártas a dologba.
Segítséget kérnék a kapcsolás javításába ha nem helyes vagy ha van valakinek jobb megoldása szívesen meghallgatnám.

assssss.png		    
(#) Jonni válasza toth1996 hozzászólására (») Máj 23, 2025 /
 
Mi volna a feladata ennek a "komfort index-nek" ? Mit kell csináljon az arduino ha pöccintés történt?
(#) toth1996 válasza Jonni hozzászólására (») Máj 23, 2025 /
 
Annyit csinál ha pöccintés történt hogy D5 vagy D6 lábát testre húzza igy a led világit és behúzza a tranzisztort.

  1. unsigned long balStartTime = 0, jobbStartTime = 0;
  2. unsigned long balLowStart = 0, jobbLowStart = 0;
  3. bool balActive = false, jobbActive = false;
  4. bool balWasLow = false, jobbWasLow = false;
  5.  
  6. const int balIndexInputPin = 2;  // Ezt írd át a tényleges bemeneti pinre
  7. const int jobbIndexInputPin = 3; // Ugyanígy
  8. const int balIndexOutputPin = 5; // Kimenet pl. reléhez vagy LED-hez
  9. const int jobbIndexOutputPin = 6;
  10.  
  11.  
  12. void setup() {
  13.   Serial.begin(9600);
  14.  
  15.   pinMode(balIndexInputPin, INPUT_PULLUP);
  16.   pinMode(jobbIndexInputPin, INPUT_PULLUP);
  17.  
  18.   pinMode(balIndexOutputPin, OUTPUT);
  19.   pinMode(jobbIndexOutputPin, OUTPUT);
  20.  
  21.   digitalWrite(balIndexOutputPin, HIGH);
  22.   digitalWrite(jobbIndexOutputPin, HIGH);
  23. }
  24.  
  25. void loop() {
  26.  
  27.   unsigned long milisec = millis();
  28.   int stateBal = digitalRead(balIndexInputPin);
  29.   int stateJobb = digitalRead(jobbIndexInputPin);
  30.  
  31.   // === Bal index figyelése ===
  32.   if (stateBal == LOW) {
  33.     if (!balWasLow) {
  34.       balLowStart = milisec;
  35.       balWasLow = true;
  36.     }
  37.   } else {
  38.     if (balWasLow) {
  39.       if (!balActive && (milisec - balLowStart <= 1000)) {
  40.         digitalWrite(balIndexOutputPin, LOW);
  41.         balStartTime = milisec;
  42.         balActive = true;
  43.       }
  44.       balWasLow = false;
  45.     }
  46.   }
  47.  
  48.   // === Jobb index figyelése ===
  49.   if (stateJobb == LOW) {
  50.     if (!jobbWasLow) {
  51.       jobbLowStart = milisec;
  52.       jobbWasLow = true;
  53.     }
  54.   } else {
  55.     if (jobbWasLow) {
  56.       if (!jobbActive && (milisec - jobbLowStart <= 1000)) {
  57.         digitalWrite(jobbIndexOutputPin, LOW);
  58.         jobbStartTime = milisec;
  59.         jobbActive = true;
  60.       }
  61.       jobbWasLow = false;
  62.     }
  63.   }
  64.  
  65.   // === Bal visszaállítása 3 mp után ===
  66.   if (balActive && milisec - balStartTime >= 3000) {
  67.     digitalWrite(balIndexOutputPin, HIGH);
  68.     balActive = false;
  69.   }
  70.  
  71.   // === Jobb visszaállítása 3 mp után ===
  72.   if (jobbActive && milisec - jobbStartTime >= 3000) {
  73.     digitalWrite(jobbIndexOutputPin, HIGH);
  74.     jobbActive = false;
  75.   }
  76. }


De elküldöm a programkódomat.
(#) WWalter válasza asch hozzászólására (») Máj 23, 2025 /
 
Szia!
Volt egy olyen tippem, hogy túl lehet tölteni, de nem volt rá konkrét példa vagy utalás így elkerültem. Szerintem a példádat fogom követni - persze megépítem a kapcsolást egy próbapadon és kitesztelem az éles helyzet előtt.
Köszi!
A hozzászólás módosítva: Máj 23, 2025
Moderátor által szerkesztve
(#) benjami válasza toth1996 hozzászólására (») Máj 23, 2025 /
 
Szerintem a 66 és a 72. sorokba kellene még némi zárójel (mint ahogy az 56. sorban van).
(#) kameleon2 válasza tufatofu hozzászólására (») Máj 27, 2025 /
 
Ha feltettem a szükséges alaplapi támogatást az 1.8...alá, akkor ment. 2... ismeri élből. Mindkét IDE alól megy. Néha az eredetivel többet szívtam. Illetve a HEstore klónokkal. Igaz - olcsóak. De ha összehasonlítom az Aliexpressel, amit külföldről rendeltem - egyrészt hamarabb megjött, másrészt sokkal stabilabbak voltak.
(#) toth1996 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
A kapcsolás jó lehet?
Azért kérdezem mert kipróbáltam az autónál és sajnos azt vettem észre hogy a tranziztoron 1mA folyik ha rá kötöm az index lábakat pedig tisztán testre 8-10mA folyik. 5v ágon 20mA folyik a ledeken .
PC817 használok.
(#) proli007 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
Hello! A hibák ott kezdődnek, hogy a rajzodon nincsenek alkatrész értékek, sem pozíciószámok. Így hivatkozni is keserves bármire.
- Az opto-nak van egy CTR tényezője. Ez azt mutatja meg, hogy a Led árama milyen viszonyban van a tranyó kollektor-emitter áramával. Csak ez a tényező, ennél a típusnál, nagyon szélsőséges tartományban van megadva. Az értéke 50..600%. 5mA Ledáram és 5V kollektor-emitter feszültségnél van megadva.CTR
Tervezni, a legrosszabb esetre kell vagy is "pesszimista tervezési módszerrel".
Tehát az 50%-ra. Vagy is ha 20mA a Led árama, akkor fogja a 10mA-t lehúzni.

- De ha az index bemenet lehúzásakor 8..10mA folyik, akkor ehhez még hozzá jön a másik optocsatoló Led árama, mert azt is le kell húzni. Mivel az AVR bemenete Pull-Up áramkörrel van felhúzva, ott csak 140uA áram fog folyni. Tehát 50%-al a Led áramának 280uA áramnak kell lenni. De mivel a CTR tényező áramfüggő is, így 1mA Ledáramot adva, megfelelő lesz a port bemenetlehúzása. A dióda előtét ellenállását ez szerint kell megválasztani.
Mivel a Led Vf feszültsége 1.2V, az AVR tápja meg 5V, Re=(5V-1,2V)/1mA=3,8kohm, tehát egy 3,6k megfelelő lehet.
Az AVR meghajtó oldalról nézve, 20mA terhelésnél, 4,4V-ot ad ki, ebből levonva az 1,2V Led feszültségét, Re=(4,4V-1,2V)/20mA=160 ohm előtét ellenállás kell.

Ha így jársz el, vélhetően lehúzza majd az index bemenetet is. Mivel a Led reverz feszültsége maximum 6V, kicsit necces amikor az index 12V-on van, a Led meg V-n, mert az 7V. De el fogja viselni.

(Precízebben kell fogalmazni, rajzolni és nézni az adatlapot. Mind az opto,mind az AVR esetén.)
A hozzászólás módosítva: Jún 1, 2025
(#) Saggitarius válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
A 3-as es 4-es optonak nincs munkaellenallasa a +12V fele >>> ha vezerlest kap a 5-os vagy 6-os porton akkor eloall a 12V vs 0V osszekapcsolasa az indexkaron keresztul.
Valamint az 1-es es 2-es opto munkaellenallasa utan szukseges lenne 1-1 diodara, mert az optok ledjei nem szeretik a 6V-nal nagyobb elleniranyu feszultseget.
(#) toth1996 válasza proli007 hozzászólására (») Jún 1, 2025 /
 
Kedves Proli007

Köszönöm a segítséged .

Feltüntettem az ellenállás értékeket a leírásod alapján.

Ahogy értem a Led reverz feszültség adhat aggodalomra okot.

kapcsolas.png		    
(#) proli007 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
Igen, ha korrektek szeretnénk lenni, a Led-el soros 3k ellenállással sorba kell kötni egy pld. 1N4148-as diódát.
Viszont a tranyók kollektorával sorba lévő 3k felesleges.
(#) toth1996 válasza proli007 hozzászólására (») Jún 1, 2025 /
 
Ne haragudjon hogy ilyennel terhelnèm a diódák helyét és irányát be rajzolná köszönöm.
(#) proli007 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
Nagyon egyszerű, a Led-el soros 3k után kell bekötni, anód az optocsatoló Led felé.
(#) zn4416 hozzászólása Jún 1, 2025 /
 

Unsigned long vagy mégse ?

Tisztelt Fórumlakók !

Nagyon rég írtam már a HE fórumra, de most igazán szükségem lenne a segítségre
Egy hülye kérdéssel fordulok a nagyközönséghez, mert nem látom és nem értem, hogy hol vagy mi a hiba. Már csináltam egy sosor monitoros program részletet, de így sem értem, hogy hol a gebasz.....
A program 4 bájton kezeli a bevitt összeget. Egy külső epromban tárolódik I2C vonalon keresztül ( szerintem ez lényegtelen ). A 1-4-es memória címen tárolja az összeget persze megfelelő lebontásban ( 1 bájt -- x*16777216 + 2 bájt --- x*65536 + 3 bájt --- x*256 + 4 bájt adja a végeredményt ).Ezt minden esetben beolvasva és hozzáadva a bevitt összeget újra felbontja a megfelelő bájtokra és kiírja az epromba.
A helyzet a következő :
- Van egy számláló kezelő program ami a mega vagy uno alaplapokon nem működik jól. A probléma, hogy ha adatbevitel esetében pl 32000-es összeget választjuk addig jól írja be, rádobunk még 500-at, szintén jó. Még 500, és borul a dolog ( 32768-nál tulcsordulás, de miért ? )
Kiolvasásnál meg már értelmezhetetlen számokat jelenít meg. Amennyiben 64000 a bevitt összeg, azt jól írja be a memóriába de kiolvasva már hülyeséget ír. És innentől már tökmindegy milyen összegek kerülnek bevitelre borul az egész memória kezelés.
A véletlen szám generátorral bevitt összegek is csak abban az esetben lesznek helyesek ha 32768 alatt vannak....
- Due alaplapon kifogástalanul üzemel és számol. Nem találtam hibát bármekkora számokkal is kezelte rendesen ahogy kellene neki.

Hol a gond pedig az "adat" változót unsigned long tipusúként kezelem.

A rövid progi a következő, ha valaki veszi a fáradtságot és megnézi, kipróbálja.
  1. #include <Wire.h>
  2. #include <Eeprom24C32_64.h>
  3.  
  4. static Eeprom24C32_64 eeprom(0x50);
  5. byte w,x,y,z;
  6. unsigned long adat,randoM;
  7.  
  8.  
  9. void setup()
  10. {
  11.   Serial.begin(9600);
  12.   Wire.begin();
  13.   eeprom.initialize();
  14.   randomSeed(analogRead(A2));
  15. }
  16.  
  17.  
  18. void loop()
  19. {
  20.   char command=getCommand();
  21.   switch(command)
  22.   {
  23.     case('t'):
  24.       Serial.println(F("Memoria torles..."));
  25.       eeprom.writeByte(1,0);
  26.       delay(10);
  27.       eeprom.writeByte(2,0);
  28.       delay(10);
  29.       eeprom.writeByte(3,0);
  30.       delay(10);
  31.       eeprom.writeByte(4,0);
  32.       delay(10);
  33.       Serial.print(F("Memoria olvasas : "));
  34.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  35.       Serial.println(adat);
  36.       Serial.println();
  37.     break;
  38.     case('r'):
  39.       randoM=random(0,16777216);
  40.       Serial.print(F("Veletlen szam : "));
  41.       Serial.println(randoM);
  42.       Serial.println();
  43.       Serial.print(F("Memoria olvasas : "));
  44.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  45.       Serial.println(adat);
  46.       szamlalo(1,randoM);
  47.     break;
  48.     case('o'):
  49.       Serial.println(F("Memoria olvasas"));
  50.       Serial.print(F("eeprom 1 : "));
  51.       Serial.println(eeprom.readByte(1));
  52.       Serial.print(F("eeprom 2 : "));
  53.       Serial.println(eeprom.readByte(2));
  54.       Serial.print(F("eeprom 3 : "));
  55.       Serial.println(eeprom.readByte(3));
  56.       Serial.print(F("eeprom 4 : "));
  57.       Serial.println(eeprom.readByte(4));
  58.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  59.       Serial.println(adat);
  60.       Serial.println();
  61.     break;
  62.     case('1'):
  63.       Serial.println(F("adatbevitel----500"));
  64.       Serial.print(F("Memoria olvasas : "));
  65.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  66.       adat=adat+500;
  67.       Serial.println(adat);
  68.       szamlalo(1,500);
  69.     break;
  70.     case('2'):
  71.       Serial.println(F("adatbevitel----1000"));
  72.       Serial.print(F("Memoria olvasas : "));
  73.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  74.       adat=adat+1000;
  75.       Serial.println(adat);
  76.       szamlalo(1,1000);
  77.     break;
  78.     case('3'):
  79.       Serial.println(F("adatbevitel----2000"));
  80.       Serial.print(F("Memoria olvasas : "));
  81.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  82.       adat=adat+2000;
  83.       Serial.println(adat);
  84.       szamlalo(1,2000);
  85.     break;
  86.     case('4'):
  87.       Serial.println(F("adatbevitel----5000"));
  88.       Serial.print(F("Memoria olvasas : "));
  89.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  90.       adat=adat+5000;
  91.       Serial.println(adat);
  92.       szamlalo(1,5000);
  93.     break;
  94.     case('5'):
  95.       Serial.println(F("adatbevitel----10000"));
  96.       Serial.print(F("Memoria olvasas : "));
  97.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  98.       adat=adat+10000;
  99.       Serial.println(adat);
  100.       szamlalo(1,10000);
  101.     break;
  102.     case('6'):
  103.       Serial.println(F("adatbevitel----20000"));
  104.       Serial.print(F("Memoria olvasas : "));
  105.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  106.       adat=adat+20000;
  107.       Serial.println(adat);
  108.       szamlalo(1,20000);
  109.     break;
  110.     case('7'):
  111.       Serial.println(F("adatbevitel----32000"));
  112.       Serial.print(F("Memoria olvasas : "));
  113.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  114.       adat=adat+32000;
  115.       Serial.println(adat);
  116.       szamlalo(1,32000);
  117.     break;
  118.     case('8'):
  119.       Serial.println(F("adatbevitel----64000"));
  120.       Serial.print(F("Memoria olvasas : "));
  121.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  122.       adat=adat+64000;
  123.       Serial.println(adat);
  124.       szamlalo(1,64000);
  125.     break;
  126.     case('9'):
  127.       Serial.println(F("adatbevitel----16777000"));
  128.       Serial.print(F("Memoria olvasas : "));
  129.       adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  130.       adat=adat+16777000;
  131.       Serial.println(adat);
  132.       szamlalo(1,16777000);
  133.     break;
  134.   }
  135. }
  136.  
  137.  
  138.  
  139. char getCommand()
  140. {
  141.   char c='\0';
  142.   if(Serial.available()) c=Serial.read();
  143.   return c;
  144. }
  145.  
  146.  
  147.  
  148. void szamlalo(int cim,unsigned long ertek)                          //összeg számláló, tetszőleges összeggel értékkel 4 bájton
  149. {
  150.   Serial.println(F("A szamlalo ciklus"));
  151.   Serial.print(F("eeprom 1 : "));
  152.   Serial.println(eeprom.readByte(1));
  153.   Serial.print(F("eeprom 2 : "));
  154.   Serial.println(eeprom.readByte(2));
  155.   Serial.print(F("eeprom 3 : "));
  156.   Serial.println(eeprom.readByte(3));
  157.   Serial.print(F("eeprom 4 : "));
  158.   Serial.println(eeprom.readByte(4));
  159.   adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);
  160.   Serial.print(F("Osszeadott adat : "));
  161.   Serial.println(adat);
  162.   adat=adat+ertek;
  163.   Serial.print(F("Osszeadott adat+ertek : "));
  164.   Serial.println(adat);
  165.   if(adat<256)                                                      //a megfelelő számítási értékek tárolása 256 alatti összegnél
  166.   {
  167.     Serial.println(F("Adat<256"));
  168.     eeprom.writeByte(cim,0);
  169.     delay(10);
  170.     Serial.print(F("eeprom 1 : "));
  171.     Serial.println(eeprom.readByte(1));
  172.     eeprom.writeByte(cim+1,0);
  173.     delay(10);
  174.     Serial.print(F("eeprom 2 : "));
  175.     Serial.println(eeprom.readByte(2));
  176.     eeprom.writeByte(cim+2,0);
  177.     delay(10);
  178.     Serial.print(F("eeprom 3 : "));
  179.     Serial.println(eeprom.readByte(3));
  180.     eeprom.writeByte(cim+3,adat);
  181.     delay(10);
  182.     Serial.print(F("eeprom 4 : "));
  183.     Serial.println(eeprom.readByte(4));
  184.   }
  185.   else if((adat>=256)&(adat<65536))                                 //a megfelelő számítási értékek tárolása 256 feletti összegnél
  186.   {
  187.     Serial.println(F("Adat>=256 es adat<65536"));
  188.     eeprom.writeByte(cim,0);
  189.     delay(10);
  190.     Serial.print(F("eeprom 1 : "));
  191.     Serial.println(eeprom.readByte(1));
  192.     eeprom.writeByte(cim+1,0);
  193.     delay(10);
  194.     Serial.print(F("eeprom 2 : "));
  195.     Serial.println(eeprom.readByte(2));
  196.     x=adat/256;
  197.     eeprom.writeByte(cim+2,x);
  198.     delay(10);
  199.     Serial.print(F("eeprom 3 : "));
  200.     Serial.println(eeprom.readByte(3));
  201.     y=adat-(x*256);
  202.     eeprom.writeByte(cim+3,y);
  203.     delay(10);
  204.     Serial.print(F("eeprom 4 : "));
  205.     Serial.println(eeprom.readByte(4));
  206.   }
  207.   else if((adat>=65536)&(adat<16777216))                            //a megfelelő számítási értékek tárolása 65536 feletti összegnél
  208.   {
  209.     Serial.println(F("Adat>=65536 es adat<16777216"));
  210.     eeprom.writeByte(cim,0);
  211.     delay(10);
  212.     Serial.print(F("eeprom 1 : "));
  213.     Serial.println(eeprom.readByte(1));
  214.     x=adat/65536;
  215.     eeprom.writeByte(cim+1,x);
  216.     delay(10);
  217.     Serial.print(F("eeprom 2 : "));
  218.     Serial.println(eeprom.readByte(2));
  219.     y=(adat-x*65536)/256;
  220.     eeprom.writeByte(cim+2,y);
  221.     delay(10);
  222.     Serial.print(F("eeprom 3 : "));
  223.     Serial.println(eeprom.readByte(3));
  224.     z=adat-((x*65536)+(y*256));
  225.     eeprom.writeByte(cim+3,z);
  226.     delay(10);
  227.     Serial.print(F("eeprom 4 : "));
  228.     Serial.println(eeprom.readByte(4));
  229.   }
  230.   else if(adat>=16777216)                                           //a megfelelő számítási értékek tárolása 16777216 feletti összegnél
  231.   {
  232.     Serial.println(F("Adat>=16777216"));
  233.     w=adat/16777216;
  234.     eeprom.writeByte(cim,w);
  235.     delay(10);
  236.     Serial.print(F("eeprom 1 : "));
  237.     Serial.println(eeprom.readByte(1));
  238.     x=(adat-w*16777216)/65536;
  239.     eeprom.writeByte(cim+1,x);
  240.     delay(10);
  241.     Serial.print(F("eeprom 2 : "));
  242.     Serial.println(eeprom.readByte(2));
  243.     y=(adat-((w*16777216)+(x*65536)))/256;
  244.     eeprom.writeByte(cim+2,y);
  245.     delay(10);
  246.     Serial.print(F("eeprom 3 : "));
  247.     Serial.println(eeprom.readByte(3));
  248.     z=adat-((w*16777216)+(x*65536)+(y*256));
  249.     eeprom.writeByte(cim+3,z);
  250.     delay(10);
  251.     Serial.print(F("eeprom 4 : "));
  252.     Serial.println(eeprom.readByte(4));
  253.   }
  254.   Serial.println(F("Vege"));
  255.   Serial.println(F(" "));
  256. }
A hozzászólás módosítva: Jún 1, 2025
(#) Bakman válasza zn4416 hozzászólására (») Jún 1, 2025 / 1
 
Nem ismerem a feljesztőkörnyezetet de ez talán segít.

  1. adat=(eeprom.readByte(1)*16777216)+(eeprom.readByte(2)*65536)+(eeprom.readByte(3)*256)+eeprom.readByte(4);

sor helyett ezt:

  1. adat=eeprom.readByte(1);
  2. adat=adat<<8;
  3. x=eeprom.readByte(2);
  4. adat=adat | x;
  5. adat=adat<<8;
  6. x=eeprom.readByte(3);
  7. adat=adat | x;
  8. adat=adat<<8;
  9. x=eeprom.readByte(4);
  10. adat=adat | x;

Az adatok mentését lehet egyszerűsíteni, nem kell annyi feltételes elágazás:

  1. unsigned long adat2
  2.  
  3. adat2=adat;
  4.  
  5. x=adat2&0xFF;
  6. eeprom.writeByte(4,x);
  7. adat2=adat2>>8;
  8. x=adat2&0xFF;
  9. eeprom.writeByte(3,x);
  10. adat2=adat2>>8;
  11. x=adat2&0xFF;
  12. eeprom.writeByte(2,x);
  13. adat2=adat2>>8;
  14. x=adat2&0xFF;
  15. eeprom.writeByte(1,x);

Ha mentés után az adat nevű változó nem fog kelleni, akkor az adat2 nevű változó felesleges.
(#) moltam válasza (Felhasználó 32034) hozzászólására (») Jún 1, 2025 /
 
Jobban jár az ember ha az stdint féle típusokat használja, nincs kavarodás a különböző architektúrák között. uint8_t uint16_t satöbbi.
(#) zn4416 válasza Bakman hozzászólására (») Jún 1, 2025 /
 
Az adatolvasás parádés, rendben működik.
Miért nem jutott eszembe a biteltolás...
Az adatrögzítés viszont valahol hibás majd még kibogozom ( a sajátom az if hegyekkel viszont jól megy így is ).
(#) zn4416 válasza (Felhasználó 32034) hozzászólására (») Jún 1, 2025 /
 
Igen a DUE 32 bites proci, a z UNO és a MEGA pedig 8 bites.
Az UL-t próbáltam és úgy sem volt jó.
Már az avr core magban turkáltam, hogy hol tud elmenni ez az egész.
(#) zn4416 válasza moltam hozzászólására (») Jún 1, 2025 /
 
Próbáltam, semmit sem változott a helyzet.
Ezért voltam bajban
Használtam a guglit rendesen
Mindenesetre köszi mindenkinek aki foglalkozik ezzel !
(#) Bakman válasza zn4416 hozzászólására (») Jún 1, 2025 /
 
Íráskor a cím nem konstans adat, nálad szerepel benne egy cim nevű változó. Pl.:

eeprom.writeByte(cim+1,x);

Lehet, hogy ez kever meg. Konkrétan nem néztem végig, honnan jön ide érték, csak egy módszert szerettem volna bemutatni.
(#) zn4416 válasza Bakman hozzászólására (») Jún 1, 2025 /
 
Minden jó!
Elírtam, én hibáztam.
Köszönöm a segítségedet !
(#) toth1996 válasza (Felhasználó 32034) hozzászólására (») Jún 1, 2025 /
 
Kedves Tki.
Kíváncsi lennék a te elképzelésedre szívesen meghallgatom.
Ha lehet egyszerűbben vagy jobban .
(#) toth1996 válasza proli007 hozzászólására (») Jún 1, 2025 /
 
Kedves Proli007.
A dióda miért szükséges oda??
Csak megérteni szeretném.
A hozzászólás módosítva: Jún 1, 2025
(#) toth1996 válasza (Felhasználó 32034) hozzászólására (») Jún 1, 2025 /
 
Semmi baj.
(#) proli007 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
Ezek szerint nem olvastad, vagy nem jól olvastad amit írtunk..
Az opto Led anódja az 5V-os tápon van. Amikor az index kapcsoló nincs megnyomva, akkor ott 12V van. Ez az opto Led-en zárófeszültségként jelenik meg. 12V-5V az 7V. A Led-nek meg adatlap szerint csak 6V van megengedve. A dióda meg ilyenkor lezár.
(#) toth1996 válasza proli007 hozzászólására (») Jún 1, 2025 /
 
Elnézést rendben megvan
(#) proli007 válasza toth1996 hozzászólására (») Jún 1, 2025 /
 
Oké, csak ennek a témának nem itt a helye.
(#) Bell hozzászólása Jún 8, 2025 /
 

ESP32 WROM

Sziasztok!
NAGYON kezdőként a legfrissebb IDE-vel, ESP32 WROM 32-n szeretném futtatni a "Blink"-et,
Sokáig fordít, úgy tűnik a programozás is megtörténik, de bármivel próbálkozom, a program nem fut.
Ezt az üzenetet kapom:
  1. Wrote 296720 bytes (159902 compressed) at 0x00010000 in 2.9 seconds (effective 816.5 kbit/s)...
  2. Hash of data verified.
  3.  
  4. Leaving...
  5. Hard resetting via RTS pin...

Hogyan tovább?
(#) moltam válasza Bell hozzászólására (») Jún 8, 2025 /
 
Az üzenettel nincs gond, felprogramozódik az esp d.
Ezekre szükség lehet! - HESTORE.HU

1N4148
ESP32-2432S028R-CYD
MAX30105-M
4,42K 0,1%
EU7.2-PH40
Következő: »»   860 / 872
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem