60 nap alatt Arduino #15 Nemfelejtő memória

A "60 nap alatt Arduino" tanfolyam házi feladatai és közvetlen témái
Avatar
szuperp
Bitmanipulátor
Hozzászólások: 116
Csatlakozott: 2012. november 17. szombat, 7:00

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: szuperp » 2013. január 10. csütörtök, 10:50

az eeprom egy nem felejtő memória... elvileg, ha kikapcsolod és újra be, akkor is folytatja a számolást... nem kezdi előröl...

Avatar
llori
DrótVégénSzéndarab
Hozzászólások: 18
Csatlakozott: 2011. március 12. szombat, 7:00
Tartózkodási hely: Százhalombatta

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: llori » 2013. január 10. csütörtök, 11:12

Igen ezt vártam én is!
De nem tette!
Míg nem a böngészgetés közben ráleltem egy elbújt tördelési hibára:

Kód: Egész kijelölése

bekapcsolas =
word(bekapcsolasH,bekapcsolasL);
// wordde alakitas


Nem is értettem mi célt szolgál ez a három sor. És ezért eltölttöm vele kis időt.

javítottam:

Kód: Egész kijelölése

bekapcsolas = word(bekapcsolasH,bekapcsolasL); // wordde alakitas

És ki is írta hogy 1287. start program 8O 8O 8O :D :D

Lenne még két kérdésem:

1.

Miért van két, alacsony és magas helyiérték:

Kód: Egész kijelölése

bekapcsolasH = EEPROM.read(2);       // magas helyiertek
bekapcsolasL = EEPROM.read(1);       // alacsony helyiertek


2.

És ezeket miért osztjuk 256-tal:

Kód: Egész kijelölése

bekapcsolasH = bekapcsolas/256; 
bekapcsolasL = bekapcsolas % 256;
EEPROM.write (1, bekapcsolasL);
EEPROM.write (2, bekapcsolasH);


És ebből a kettőből, hogy lesz decimális szám ennek segítségével:

Kód: Egész kijelölése

bekapcsolas = word(bekapcsolasH,bekapcsolasL);

Avatar
szuperp
Bitmanipulátor
Hozzászólások: 116
Csatlakozott: 2012. november 17. szombat, 7:00

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: szuperp » 2013. január 10. csütörtök, 11:27

kicsit nézz utána szerintem a számrendszereknek... főleg a hexadecimálisnak (16-os) és akkor ez nem lesz kérdés.

Avatar
llori
DrótVégénSzéndarab
Hozzászólások: 18
Csatlakozott: 2011. március 12. szombat, 7:00
Tartózkodási hely: Százhalombatta

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: llori » 2013. január 10. csütörtök, 11:41

lerajzolós típus vagyok!
Lerajzoltam!

Köszi a megerősítést.
Közben rájöttem, hogy 256-os számrendszer van, és ha 255 főlé kell számolni, akkor kell indul a bekapcsolásH váltózó.

Feltételezem a

Kód: Egész kijelölése

word(bekapcsolasH,bekapcsolasL);
parancs ezt teszi helyre...

Nem találom viszont, a WORD változó hány byte-on van tárolva.
BYTE változó 1, INT - 2, tán a WORD is 2-n?

Kellene egy megerősítés:
Azt olvastam, hogy a Atmega328P-PU chip, ami az arduino-n van, 1kB eeprom-ot tartalmaz.
Ez azt jelenti programozás technikailag, hogy az EEPROM.write(cím,adat) parancsba 0 és 1023 tudom a címet állítni INT típussal (tanfolyam anyag szerint a 0-ásat ne használjuk), a adat helyére pedig BYTE adattípust írok, (0-255).
Jól értem?

Avatar
Robert
Elektronbűvölő
Hozzászólások: 9948
Csatlakozott: 2005. december 9. péntek, 7:00
Tartózkodási hely: Budapest
Kapcsolat:

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: Robert » 2013. január 10. csütörtök, 12:02

Word, integer: 2byte
Byte, char: 1 byte


Jól érted az eepromot. BYTE-alapú a cellája. Címe 0...utolsó cella lehet.

Attila61
Újonc
Újonc
Hozzászólások: 7
Csatlakozott: 2017. december 23. szombat, 15:05

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: Attila61 » 2018. január 18. csütörtök, 21:29

Az #include "EEPROM.h" nekem is fejtörést okozott.
Így legalább a hsz.ekben utánnanéztem.
Nekem is a start sor elé írja a növekvő számot, noha az arduinot is lekapcsolom, s a progit újra beolvastatom.
Az EPROM nem felejt. ):

_jani_
DrótVégénSzéndarab
Hozzászólások: 20
Csatlakozott: 2019. február 26. kedd, 16:17

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: _jani_ » 2019. március 5. kedd, 15:59

Sziasztok!
Van egy kis problémám a következő sor értelmezésében:

Kód: Egész kijelölése

   bekapcsolasL = bekapcsolas % 256; 


Azt értem, hogy integer-ként van definiálva a "bekapcsolasL" és a "bekapcsolasH".
S Word ként a "bekapcsolas". ( Word, Integer : 2 Byte )

Ahhoz, hogy maradékképzéssel lehessen számolni ( modulo-val ),
long vagy float típusú változót kellene definiálni. ?

Idészet:
Az alacsony helyi érték kiszámítása lehet érték-((érték/256)*256) számolással, vagy egyszerűen a maradékképzéssel.
Ezt az aritmetikéban modulo-nak hívják. Az Arduino ( és a C nyelvben ) a % jellel jelölhető. Azaz az előbbi kifejezés esetén érték % 256.


A maradékképzéses számítás a programba szerintem így működne:

Kód: Egész kijelölése

  bekapcsolasH = bekapcsolas / 256; 
  bekapcsolasL = bekapcsolas % 256;
/* Maradékosztásos számítás:
 *  XH = X / 256 ( Az XH = 0-255 egész szám!)
 *  XL = ((X/256)-XH)*256
 *  Így a X változó vagy LOG vagy FLOAT. (?)
 */


Az
érték-((érték/256)*256)
kiszámításánál is van valami, amit nem értek. :roll:
Ha levezetem a képletet eredményül 0-t kaptam. Valamit elnéztem?

S itt a teljes program segítségül:

Kód: Egész kijelölése

/* (10.)
            15. EEPROM

    SerialLED - EEPROM
    Soros porton kapcsolható LED és üzemóra számláló
    60 nap alatt Arduinó tanfolyam
    (c) TavIR http://www.tavir.hu

    A program az alap sorosporti LED-kapcsolgatásra épül,
    EEPROM-os üzemszámlálóval (bekapcsolás számlálással)
    kiegészítve. Az EEPROM kezeléshez a függvény
    könyvtárakat az Arduinó keretrendszerben a _libraries_
    könyvtárban találhatjuk meg, mig a programozás során a
    _Sketch->Import library_ alatt szúrhatjuk be a
    programunkba. ( Kis és nagybetű érzékeny a fájlnév!!! :( )
    Az eredeti programot lefuttatva az első bekapcsolás
    65535-el indult. Következő resetre 0++. Ez inkébb
    csak megjegyzés mint probléma.
*/

int inByte = 0;    // Beolvasott adat
int adatjott = 0;  // Eddig hány adat jött?
char be = 'B';     // Változó a bekapcsoláshoz
char ki = 'K';     // Változó a kikapcsoláshoz
char c;            // C -karakteres változó definiálása.

                   // Belső változók
byte bekapcsolasH;
byte bekapcsolasL;
word bekapcsolas; 

#include "EEPROM.h";
/*  Az "eeprom.h" = "EEPRON.h" néven található!
    A _kicsi_ vagy _NAGY_ nem UA. !!! */

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);         // Sorosport bekapcsolása
                              // és sebessége
  pinMode(13, OUTPUT);        // D13 beépített LED


/* EEPROM.olvasás(honnan)   
   A honnan = 0-65535.  Az eredmény = 0-255.
 */
  bekapcsolasH = EEPROM.read(2); // Magas helyiérték
  bekapcsolasL = EEPROM.read(1); // Alacsony helyiérték
  bekapcsolas = word (bekapcsolasH,bekapcsolasL);
                              // word-dé alakítás
                              // ( word = szó azaz két byte )
 
  Serial.print(bekapcsolas);  // Bekapcs-érték kiírása
  Serial.println(". Start program."); // Legelső sorunk a
                              // "Start..." visszaküldése
                              // a terminál programra.
  bekapcsolas++; // bekapcsolas = bekapcsolas + 1
  bekapcsolasH = bekapcsolas / 256; 
  bekapcsolasL = bekapcsolas % 256;
/* Maradékosztásos számítás:
 *  XH = X / 256 ( Az XH = 0-255 egész szám!)
 *  XL = ((X/256)-XH)*256
 *  Így a X változó vagy LOG vagy FLOAT. (?)
 */
  EEPROM.write (1, bekapcsolasL); // EEPROM.irás (hova.mit)
  EEPROM.write (2, bekapcsolasH); // A hova = 0-65535. (cím)
                                  // A mit = 0-255.    (adat)
}

 /*  A program "magja" nem változott az első 09-es
      mintatrogram fut... */
 
void loop() {
  // put your main code here, to run repeatedly:
  if (Serial.available() > 0 ) {
                                    // van adat feldolgozásra?
      inByte = Serial.read();       // 1 byte beolvasása
      c = inByte;                   // A "c" felveszi az
                                    // "intByte" értékét.
     /*
      c = Serial.read();            // 1 byte beolvasása
      inByte = c;                   // AZ "intByte felveszi
                                    // a "c" értékét.
      */
      delay(100);                   // 100ms szünet
      adatjott++;                   // adatjött -
                                    // számláló növelése
      if (inByte == be) {
        digitalWrite(13, HIGH);     // Ha B jött a LED BE.
      }
      if (inByte == ki) {
        digitalWrite(13, LOW);      // Ha K jött a LED KI.
      }
      Serial.print(F("Bejött Byte: "));
      Serial.print(inByte);         // Számként küldjük
                                    // vissza.
      Serial.print(F(". CHAR: "));
      Serial.print(c);              // char-t küldjük vissza.
      Serial.print(F(". Adat: "));
      Serial.println(adatjott, DEC); // Számláló.
  }
}

A program teszi a dolgát!
Csak erre a pár kérdésre kérnék választ! :wink:
Bocs a rengeteg megjegyzésért a programban, de a HF-emet másik mappában tartom. :)

_jani_
DrótVégénSzéndarab
Hozzászólások: 20
Csatlakozott: 2019. február 26. kedd, 16:17

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: _jani_ » 2019. március 5. kedd, 16:34

Visszaolvasva az INTEGER az egész típusú szám 2 byte-nyi helyen. ( Elkevertem a Byte típussal. )
Ez kicsit más megvilágításba teszi a dolgokat.
A programomban, változók leírásánál a WORD értelmezését sem biztos, jól gondolom ...

_jani_
DrótVégénSzéndarab
Hozzászólások: 20
Csatlakozott: 2019. február 26. kedd, 16:17

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: _jani_ » 2019. március 5. kedd, 20:38

Utánaolvasva a maradékképzéses számításnak már értem kicsit, hogy mit tesz a programsor:

Kód: Egész kijelölése

  bekapcsolasH = bekapcsolas / 256; 
  bekapcsolasL = bekapcsolas % 256;


A bekapcsolasH = bekapcsolas / 256 a magasabb helyértéket adja...
A bekapcsolasL = bekapcsolas % 256 az alacsonyabb helyértéket adja maradékképzéssel.

Vagyis a modulo egy osztás, ami az egész értéket elveti és a maradékkal számol egész addig, amíg az eredmény nulla nem lesz.
A kapott eredmény az osztás értéke, ahányszor azt el tudta végezni, amíg nulla nem lett a kapott eredmény.
Jól gondolom?
Ha jól olvastam, pozitív számok esetén működik.

A Word az egyenlő Integer-rel?

Elvégeztem a házim, mert kiszámoltam oda és vissza a kapott eredményeket... :wink:
Azért még van mit tanulnom...

Avatar
Robert
Elektronbűvölő
Hozzászólások: 9948
Csatlakozott: 2005. december 9. péntek, 7:00
Tartózkodási hely: Budapest
Kapcsolat:

Re: 60 nap alatt Arduino #15 Nemfelejtő memória

HozzászólásSzerző: Robert » 2019. március 7. csütörtök, 6:02

Ige: Integer = Word. Előjel nélkül 0...65535-ig vehet fel értéket, 2 byte a SRAM tárfoglalása.
http://www.tavir.hu - a gazda :)


Vissza: “60 nap alatt Arduino - Házi feladatok”

Ki van itt

Jelenlévő fórumozók: nincs regisztrált felhasználó valamint 0 vendég