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   343 / 845
(#) jeges válasza tbarath hozzászólására (») Máj 14, 2017 /
 
EEPROMAnything ezt csinálná ha változó int32 ez 4byte helyet foglal irás/olvasákor de soros porton keresztül kezelem int32 változoval csak 2byte jön át!
(#) hepi02 válasza vargham hozzászólására (») Máj 14, 2017 /
 
Kijelző (manuáis mutatós). Jön adat, ki is írom: ID 73 és 0. Nem ismerem a rendszert, csak tipp, hogy oda vissza kommunikálnak az eszközök a hálózaton, emiatt gondoltam, hogy küld magáról valamit. Csak a példa file-t használom, nem módosítottam rajta:
  1. // demo: CAN-BUS Shield, receive data with check mode
  2. // send data coming to fast, such as less than 10ms, you can use this way
  3. // loovee, 2014-6-13
  4.  
  5.  
  6. #include <SPI.h>
  7. #include "mcp_can.h"
  8.  
  9.  
  10. // the cs pin of the version after v1.1 is default to D9
  11. // v0.9b and v1.0 is default D10
  12. const int SPI_CS_PIN = 10;
  13. const int LED = 8;
  14. boolean ledON = 1;
  15. MCP_CAN CAN(SPI_CS_PIN);                                    // Set CS pin
  16.  
  17. void setup()
  18. {
  19.   Serial.begin(115200);
  20.   pinMode(LED, OUTPUT);
  21.  
  22.   while (CAN_OK != CAN.begin(CAN_500KBPS))              // init can bus : baudrate = 500k
  23.   {
  24.     Serial.println("CAN BUS Shield init fail");
  25.     Serial.println(" Init CAN BUS Shield again");
  26.     delay(100);
  27.   }
  28.   Serial.println("CAN BUS Shield init ok!");
  29. }
  30.  
  31.  
  32. void loop()
  33. {
  34.   unsigned char len = 0;
  35.   unsigned char buf[8];
  36.  
  37.   if (CAN_MSGAVAIL == CAN.checkReceive())           // check if data coming
  38.   {
  39.     CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf
  40.  
  41.     unsigned char canId = CAN.getCanId();
  42.  
  43.     Serial.println("-----------------------------");
  44.     Serial.println("get data from ID: ");
  45.     Serial.println(canId);
  46.  
  47.     for (int i = 0; i < len; i++) // print the data
  48.     {
  49.       Serial.print(buf[i]);
  50.       Serial.print("\t");
  51.       if (ledON && i == 0)
  52.       {
  53.  
  54.         digitalWrite(LED, buf[i]);
  55.         ledON = 0;
  56.         delay(500);
  57.       }
  58.       else if ((!(ledON)) && i == 4)
  59.       {
  60.  
  61.         digitalWrite(LED, buf[i]);
  62.         ledON = 1;
  63.       }
  64.     }
  65.     Serial.println();
  66.   }
  67. }
  68.  
  69. /*********************************************************************************************************
  70.   END FILE
  71. *********************************************************************************************************/


jeges: ne haragudj, ezt most nem értem.
(#) vargham válasza hepi02 hozzászólására (») Máj 14, 2017 /
 
Tehát a CAN buszon semmi más nincs rajta, csak az Arduino a CAN shielddel és a fordulatszámmérő?
Igy azt látod, hogy t időközönként jön egy 73 ID-jű CAN data frame, ami 1 byte hosszú, és az az egy bájt mindig 0.
Mennyi a t?

"csak tipp, hogy oda vissza kommunikálnak az eszközök a hálózaton"
Ez egyáltalán nem biztos. Egy kijelző akár csendben is lehet. Ha jön számára értelmes adat, akkor megjeleníti, és kész.

"Mivel nem tudom az ID-t, így gondoltam előbb meghallgatom, hogy mit küld."
Sajnos ezzel nem jutsz közelebb. Nem tudhatod, hogy a kijelző milyen ID-jű üzenetet vár, és az hány bájból áll, és azok mit jelentenek. A CAN buszon az eszközöknek nincsen ID-jük, se feladójuk, se címzettjük. Kizárólag az üzenetnek van ID-je. Az üzenet még lehet data vagy remote frame. A data frame pedig tartalmazhat 0-8 db közötti mennyiségű adat bájtot.
A CAN busz megértéséhez nekem ezek a dokumentumok segítettek:Wikipedia
BOSCH CAN specifikáció
TI CAN leírás

"A csatolt képen látható üzenetet küldi."
Ez bármit jelenthet. Például az eszköz státusza. Dokumentáció vagy teljes oda-vissza log nélkül nem lehet megmondani a jelentését.

"A kérdésem az lenne, hogy hogyan szólítsam meg és hogyan küldjek neki adatot?"
Dokumentáció nélkül az az egyetlen esélyed, ha egy működő rendszerbe rakod bele a kijelzőt, és monitorozod a CAN forgalmat. (Ehhez az Arduino lassú lesz. Akkor is, ha a delay-t kiveszed.) Aztán elkezdesz üzenetküldéssel próbálkozni, hogy a feljegyzettek közül mely üzenet(ek) hatására mozdul meg a mutató.

"Akárhogyan próbáltam sehogy sem reagál."
Mit próbáltál?

"Eleve furcsa, hogy miért csak 1 byte-nyi adatot küld, mikor a fordulatszámnak 2 byte hosszúságúnak kellene lennie."
Honnan tudod, hogy mit jelent ez az üzenet?
Miért lenne ez fordulatszám adat? Hiszen nem a motorvezérlő küldi...
Honnan tudod, hogy nem 1 byte a fordulatszám?

"ID azonositoval nyitod egyben a portot is eszközné crc 16 nem jön vissza id azonositás bukik a komunikációd!"
Ez egy nem túl értelmes mondat. Megpróbáltam magyarra fordítani, de a tartalma sem értelmesebb.
CAN busz esetén nincsen se port nyitás, se más ilyesmi. Az ACK-t és egyebeket, ami a busz működtetéséhez kell, elintézi az alacsonyabb réteg.
A mellékelt program semmi mást nem csinál, csak kiírja a buszon lévő üzeneteket. Ehhez (szigorúan CAN busz szemszögből) semmit nem kell a buszra írni. Simán lehet csak hallgatózni is. Az más kérdés, ha vannak olyan eszközök a buszon, amik csak bizonyos üzenetekre hajlandóak megszólalni. De itt még nincs ilyenről szó, a kolléga semmit nem küld a buszra.
(#) tbarath válasza jeges hozzászólására (») Máj 14, 2017 /
 
Hát akkor nézd meg soros port nélkül hogy jól működik-e. Ha igen, akkor a soros portos kódban van valami hiba.
(#) jeges válasza vargham hozzászólására (») Máj 14, 2017 /
 
Ok!
Nézve a protokolt nagyon hasonlo a rs485 hez....
(#) jeges válasza tbarath hozzászólására (») Máj 14, 2017 /
 
Soros port nélkül ok az elsö mintapélda jol müxik!
Soros port felöl van valami más konverzios hibba de az mi lehet ami hadveresen long?
A hozzászólás módosítva: Máj 14, 2017
(#) hepi02 válasza vargham hozzászólására (») Máj 14, 2017 /
 
Köszönöm szépen a részletes és kimerítő választ. Ezek alapján az autó canbuszán kellene hallgatóznom, hogy lássam, milyen byte sorozatban jön a fordulatszám. Az a baj, hogy ilyen autó nem áll rendelkezésemre. Olvasgatok akkor tovább és igyekszem keríteni egy autót, amiben tudok hallgatózni.
(#) djusee válasza jeges hozzászólására (») Máj 14, 2017 /
 
Szia. Én igy használom.
  1. //////EEPROM iras, olvasas long////////
  2.  
  3. unsigned long EEPolvas(int address){
  4.   long negy = EEPROM.read(address);
  5.   long harom = EEPROM.read(address + 1);
  6.   long ketto = EEPROM.read(address + 2);
  7.   long egy = EEPROM.read(address + 3);
  8.   return ((negy << 0) & 0xFF) + ((harom << 8) & 0xFFFF) + ((ketto << 16) & 0xFFFFFF) + ((egy << 24) & 0xFFFFFFFF);
  9. }
  10.  
  11. void EEPiras(int address, long adat){
  12.    byte negy = (adat & 0xFF);
  13.    byte harom = ((adat >> 8) & 0xFF);
  14.    byte ketto = ((adat >> 16) & 0xFF);
  15.    byte egy = ((adat >> 24) & 0xFF);
  16.    EEPROM.write(address, negy);
  17.    EEPROM.write(address + 1, harom);
  18.    EEPROM.write(address + 2, ketto);
  19.    EEPROM.write(address + 3, egy);
  20. }
(#) szeg76 válasza jeges hozzászólására (») Máj 14, 2017 /
 
Honnan, milyen formában érkeznek adatok a soros portra?
(#) jeges válasza szeg76 hozzászólására (») Máj 14, 2017 /
 
Pc uart terminal rol beirom az értékét "int32_t frequency ;" ami eepromba beirodna ezt probálom össze barkácsolni!

  1. #include <PWM.h>
  2.  
  3.  
  4. int led = 9;                
  5. int brightness = 128;        
  6. int32_t frequency = 35; //frequency (in Hz)
  7.  
  8. void setup()
  9. {
  10.  
  11.   InitTimersSafe();
  12.  
  13.  
  14.   bool success = SetPinFrequencySafe(led, frequency);
  15.  
  16.  
  17.   if(success) {
  18.     pinMode(13, OUTPUT);
  19.     digitalWrite(13, HIGH);    
  20.   }
  21. }
  22.  
  23. void loop()
  24. {
  25.  
  26.   pwmWrite(led, brightness);
  27.  
  28.  
  29.  
  30.   delay(30);      
  31. }
(#) jeges válasza djusee hozzászólására (») Máj 14, 2017 /
 
Szia!
ok probálom is!
(#) szeg76 válasza jeges hozzászólására (») Máj 14, 2017 /
 
Akkor az alábbi teljesen mást csinál, mint szeretnéd.
(A 9:47-kor írt hozzászólásod második programjából másolva)
  1. int32_t frequency2;
  2. frequency2=Serial.read();


Egyetlen byte-ot olvas be a soros portról, és azt teszi bele a 32bites frequency2-be.
A soros porton ráadásul nem a frekvencia értéke érkezik, hanem az általad begépelt karakterek ASCII kódjai egyesével egymás után, a végén sortörés és/vagy kocsi vissza kóddal.

Alatta viszont ott van ez a sor, valamiért kommentbe téve:
  1. //frequency2=Serial.parseInt();

A Serial.parseInt()-tel el kellene csinálnod a soros portról beolvasást, az egy lépésben megcsinálja.
(#) jeges válasza szeg76 hozzászólására (») Máj 14, 2017 /
 
int32_t érték csak 2byte irodik be eeprom észre Serial.parseInt..Serial.read is mind kettöt megoldásal probáltam!
Az elsö példában int32_t eeprom 4 byte foglal és ugy vissza jön a int32_t értéke ez mind sorosport nélküli elsö példába jól is müködik!
(#) jeges válasza djusee hozzászólására (») Máj 14, 2017 /
 
Mit szurok el ?

  1. #include <PWM.h>
  2. #include <EEPROM.h>
  3.  
  4.  
  5.  
  6. int led = 9;                
  7. int brightness = 128;
  8. int address = 1;
  9. long adat;
  10. int32_t frequency = 1; //frequency (in Hz)
  11.  
  12. void setup()
  13. {
  14.  
  15.   Serial.begin (9600);
  16.  
  17.   InitTimersSafe();
  18.  
  19.   bool success = SetPinFrequencySafe(led, frequency);
  20.  
  21.  
  22.   if(success) {
  23.     pinMode(13, OUTPUT);
  24.     digitalWrite(13, HIGH);    
  25.   }
  26. }
  27.  
  28. void loop()
  29. {
  30. if(Serial.available()) {
  31.  
  32.  
  33. adat=Serial.read();
  34.  
  35.   unsigned long EEPolvas(int address);
  36.  
  37.   {
  38.   long negy = EEPROM.read(address);
  39.   long harom = EEPROM.read(address + 1);
  40.   long ketto = EEPROM.read(address + 2);
  41.   long egy = EEPROM.read(address + 3);
  42.   return ((negy << 0) & 0xFF) + ((harom << 8) & 0xFFFF) + ((ketto << 16) & 0xFFFFFF) + ((egy << 24) & 0xFFFFFFFF);
  43.  
  44.  
  45. }
  46. }
  47. }
  48. void EEPiras(int address, long adat){
  49.  
  50. adat=Serial.parseInt();
  51.  
  52.    byte negy = (adat & 0xFF);
  53.    byte harom = ((adat >> 8) & 0xFF);
  54.    byte ketto = ((adat >> 16) & 0xFF);
  55.    byte egy = ((adat >> 24) & 0xFF);
  56.    EEPROM.write(address, negy);
  57.    EEPROM.write(address + 1, harom);
  58.    EEPROM.write(address + 2, ketto);
  59.    EEPROM.write(address + 3, egy);
  60.  
  61.  
  62. delay(30);
  63.  
  64.   pwmWrite(led, brightness);
  65.  
  66.  Serial.println(address);
  67.  Serial.println(adat);
  68.   Serial.println(frequency);
  69.   }
(#) Gelez válasza Kera_Will hozzászólására (») Máj 14, 2017 /
 
Kapcsolási rajzra gondoltam. A mostani táp 24V AC egyenirányítva pufferelve megy a 12V kockára, utána 1000u+100n-L-1000u+100n. Ez az agyonszűrt 12V megy az ardu 5V stabilizátorára. Ezzel is vannak ugrások, meg fagyások a progban.
(#) Gelez válasza Kera_Will hozzászólására (») Máj 14, 2017 /
 
Kösz, ezt csináltam eddig, csak gondoltam annyira adná magát az a lehetőség, hogy a forráskódban piros legyen a sor ahol éppen tart a futásban a program.
(#) SzAndras00 válasza szeg76 hozzászólására (») Máj 14, 2017 /
 
Szia, ez a Serial.parseInt() software.serial esetben is működik? 3 byte jön rs485 vonalon, amit egyben szeretnék látni,
  1. void loop() {
  2.  
  3.  
  4. if(RS485Serial.available()){
  5.     bejovo=RS485Serial.parseInt();
  6.     Serial.println(bejovo,HEX);
  7.   }
  8.  
  9.  
  10.  
  11.   }


Így csak mindig 0-t ír ki a soros monitor.
A hozzászólás módosítva: Máj 14, 2017
(#) szeg76 válasza SzAndras00 hozzászólására (») Máj 14, 2017 /
 
Még nem használtam, de itt nincs említve, szerintem magadnak kell megírni.
(#) szeg76 válasza jeges hozzászólására (») Máj 14, 2017 /
 
  1. #include <EEPROM.h>
  2. #include <EEPROMAnything.h>
  3.  
  4. #define ADDRESS 0
  5.  
  6. uint32_t  be, E;
  7.  
  8. void setup()
  9. {
  10.   EEPROM_readAnything(ADDRESS,E);
  11.  
  12.   Serial.begin(9600);
  13.   Serial.print("\n\nEEPROM tartalma :");
  14.   Serial.print(E);
  15.   Serial.print('\t');
  16.   Serial.println(E,HEX);
  17.  
  18.   Serial.println("Irj be egy szamot (0-4294967295). Ha kulonbozik az eepromban tarolttol, beirom.");
  19. }      
  20.  
  21.  
  22. void loop()
  23. {
  24.   if(Serial.available()>0)
  25.     {
  26.       be=Serial.parseInt();
  27.      
  28.       if(Serial.available())
  29.         while(Serial.read()!=-1);
  30.  
  31.       Serial.print("Soros portrol   :");
  32.       Serial.print(be);
  33.       Serial.print('\t');
  34.       Serial.println(be,HEX);      
  35.      
  36.       EEPROM_readAnything(ADDRESS,E);
  37.       Serial.print("EEPROM tartalma :");
  38.       Serial.print(E);
  39.       Serial.print('\t');
  40.       Serial.println(E,HEX);
  41.  
  42.       if(E!=be)  
  43.          {
  44.          Serial.println(" *** Valtozas, beirom eepromba! ***");
  45.          EEPROM_writeAnything(ADDRESS,be);
  46.          }
  47.     }
  48.    
  49. }
(#) Kera_Will válasza Gelez hozzászólására (») Máj 14, 2017 /
 
Külön trafó a uC és a nagy áramú eszközöknek.
Akkor ISP-n keresztüli debuggert használjál.
(#) jeges válasza szeg76 hozzászólására (») Máj 14, 2017 /
 
Soros port beirom pl 44444 de fizikailag üres továbra is az eeprom!

Lehet hogy nem jó EEPROM_writeAnything syntax erre?

vissza elenözöm ezzel....

  1. #include <EEPROM.h>
  2.  
  3. // start reading from the first byte (address 0) of the EEPROM
  4. int address = 0;
  5. byte value;
  6.  
  7. void setup() {
  8.   // initialize serial and wait for port to open:
  9.   Serial.begin(9600);
  10.   while (!Serial) {
  11.     ; // wait for serial port to connect. Needed for native USB port only
  12.   }
  13. }
  14.  
  15. void loop() {
  16.   // read a byte from the current address of the EEPROM
  17.   value = EEPROM.read(address);
  18.  
  19.   Serial.print(address);
  20.   Serial.print("\t");
  21.   Serial.print(value, DEC);
  22.   Serial.println();
  23.  
  24.   /***
  25.     Advance to the next address, when at the end restart at the beginning.
  26.  
  27.     Larger AVR processors have larger EEPROM sizes, E.g:
  28.     - Arduno Duemilanove: 512b EEPROM storage.
  29.     - Arduino Uno:        1kb EEPROM storage.
  30.     - Arduino Mega:       4kb EEPROM storage.
  31.  
  32.     Rather than hard-coding the length, you should use the pre-provided length function.
  33.     This will make your code portable to all AVR processors.
  34.   ***/
  35.   address = address + 1;
  36.   if (address == EEPROM.length()) {
  37.     address = 0;
  38.   }
  39.  
  40.   /***
  41.     As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
  42.     EEPROM address is also doable by a bitwise and of the length - 1.
  43.  
  44.     ++address &= EEPROM.length() - 1;
  45.   ***/
  46.  
  47.   delay(500);
  48. }
(#) KoblogPerGyok válasza jeges hozzászólására (») Máj 15, 2017 /
 
Sziasztok!

Nem vágom ennyire az eeprom írást, azonban a minap írtam egy programot vb.net-ben, ami soros porton kommunikál az aruino nanoval.

A serial print, és println esetén nem csak a szöveg megy át, hanem MINDEN kocsi vissza, soremelés stb. karakter.

Szöveget olvasni Arduino felől a

(Setup előtt

String Olvasott_szam;
int32 szam;
.
.
.
Olvasott_szam=Serial.readString();


Ez beolvassa rögtön szövegben a számot is.

Utána szerintem a
szam=Olvasott_szam.toint(); -el lökd át rendes számmá, majd azt próbáld meg a eepromba írni azzal az anything-el, vagy másképp.

Másik:

A beépített EEPROM kezdőcíme lehet 0? Ok, mindenhol ezt olvastam én is, de korábban mintha azt olvastam volna, hogy nem minden esetben, mert le van foglalva másnak. Ez nem 100%.
(#) kapu48 válasza jeges hozzászólására (») Máj 15, 2017 /
 
Van 1 fontos lépés, amit még nem említettetek!

A mindenkori soros terminálban, be kell állítani, hogy Enterre mit küldjön a sor végén.
Pl.: Arduino Soros monitoron, alul van a lenyíló, amiben kiválasztod az: Újsor parancsot.

(Már ha magyar nyelven használod? Angolul: New line)
A hozzászólás módosítva: Máj 15, 2017
(#) KoblogPerGyok válasza kapu48 hozzászólására (») Máj 15, 2017 /
 
Szia!

Erre gondoltam én is, ezért kellene kipróbálni ezt a szam=Olvasott_szam.toint(); -es megoldást, mert ha azt visszaküldi serial-al, akkor annak megint meg kell egyeznie a küldött értékkel. Ha ez a toint(); nem tudja lekezelni a kapott szövegben a kocsi vissza stb karaktereket, akkor vagy beállítja ahogy mondtad, vagy a konverzió előtt megoldja saját maga a levágásokat. Le lehet csettinteni a CR és LF karaktereket a végéről, ha ez lesz a gond.

Próbáld meg a memória közepére írni az adatot, hátha a 0-ás cím már nem megy. Fizikailag lehet tönkrement.
A hozzászólás módosítva: Máj 15, 2017
(#) KoblogPerGyok válasza KoblogPerGyok hozzászólására (») Máj 15, 2017 /
 
Amennyiben ezek az extra vezérlőkarakterek okozzák a problémát akkor:

Bővebben: Link


egyszeűen:
Olvasott_szam=Serial.readString();
Olvasott_szam=Olvasott_szam.trim();
szam=Olvasott_szam.toint();

majd ezután a szam-ot az eepromba. Kezdetnek elég lenne ha 1 től 255-g próbálná ki, megfelelő címmel.
(#) kapu48 hozzászólása Máj 15, 2017 /
 
Én nem szeretem az Arduino buta terminálját!

Inkább használom az ingyenes: Bővebben: YAT

Itt az <LF> kell beállítani.
(#) KoblogPerGyok válasza KoblogPerGyok hozzászólására (») Máj 15, 2017 /
 
A gond az, hogy az adat long típus, de értéket adsz neki a serial.read-el, ami sztring típus.
Utána hiába alakítod át, nem lesz jó.

Ha nem szeretnél segédváltozót, akkor:

adat= Serial.parseInt(Serial.readString());

És reménykedjünk, hogy a vezérlőkarakterekkel elbánik. A másik praseint ekkor már nem kell a kódodba.
(#) kapu48 válasza jeges hozzászólására (») Máj 15, 2017 /
 
Mit szursz el?

adat=Serial.read();

Beolvasol 1 int-et, ami esetedben az első 4-esnek az ASC2 kodja.
És ezt akarob 4 Byte-ként felhasználni?
(#) kapu48 válasza jeges hozzászólására (») Máj 15, 2017 /
 
Teszteld:
  1. int incomingByte = 0;   // for incoming serial data
  2.  
  3. void setup() {
  4.        // Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
  5.         Serial.begin(115200);
  6. }
  7.  
  8. void loop() {
  9.  
  10.         // send data only when you receive data:
  11.         if (Serial.available() > 0) {
  12.                 // read the incoming byte:
  13.                 incomingByte = Serial.read();
  14.  
  15.                 // say what you got:
  16.                 Serial.print("I received: ");
  17.                 Serial.print(incomingByte, DEC);
  18.                 Serial.print("  hex:");
  19.                 Serial.print(incomingByte, HEX);
  20.                 Serial.print("  char:");
  21.                 Serial.println((char)incomingByte);
  22.         }
  23. }


Be írod: 4444enter
Válasz:
4444
I received: 52 hex:34 char:4
I received: 52 hex:34 char:4
I received: 52 hex:34 char:4
I received: 52 hex:34 char:4
I received: 10 hex:A char:

123456
I received: 49 hex:31 char:1
I received: 50 hex:32 char:2
I received: 51 hex:33 char:3
I received: 52 hex:34 char:4
I received: 53 hex:35 char:5
I received: 54 hex:36 char:6
I received: 10 hex:A char:
A hozzászólás módosítva: Máj 15, 2017
(#) djusee válasza jeges hozzászólására (») Máj 15, 2017 /
 
Nem épp igy gondoltam használni öket. Töltsd fel ezt és tanulmányozd. Reset után beolvassa az EEPROM ba tárolt long adatot(4 byte) majd kiküldi serial ra, serialba beirsz egy unsigned long adatot majd enter leütése után elmenti az EEPROM ba, reset után kiolvassa

  1. #include <EEPROM.h>
  2. #define EEPRCIM 10
  3.  
  4. unsigned long akarmi;
  5.  
  6. void setup() {
  7.  Serial.begin(9600);
  8.  akarmi =  EEPolvas(EEPRCIM);
  9.  Serial.println(akarmi);
  10. }
  11.  
  12. void loop() {
  13.   if (Serial.available()>0){
  14.     akarmi = Serial.parseInt();
  15.     EEPiras(EEPRCIM, akarmi);
  16.   }
  17.  
  18. }
  19.  
  20. //////EEPROM iras, olvasas long////////
  21.  
  22. unsigned long EEPolvas(int address){
  23.   long negy = EEPROM.read(address);
  24.   long harom = EEPROM.read(address + 1);
  25.   long ketto = EEPROM.read(address + 2);
  26.   long egy = EEPROM.read(address + 3);
  27.   return ((negy << 0) & 0xFF) + ((harom << 8) & 0xFFFF) + ((ketto << 16) & 0xFFFFFF) + ((egy << 24) & 0xFFFFFFFF);
  28. }
  29.  
  30. void EEPiras(int address, long adat){
  31.    byte negy = (adat & 0xFF);
  32.    byte harom = ((adat >> 8) & 0xFF);
  33.    byte ketto = ((adat >> 16) & 0xFF);
  34.    byte egy = ((adat >> 24) & 0xFF);
  35.    EEPROM.write(address, negy);
  36.    EEPROM.write(address + 1, harom);
  37.    EEPROM.write(address + 2, ketto);
  38.    EEPROM.write(address + 3, egy);
  39. }
Következő: »»   343 / 845
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