Soros parancs értelmező program készítés!

Tanfolyamok, oktatások és kapcsolódó házi feladatok...
Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 1. hétfő, 18:29

A téma: Soros parancs értelmező program készítés!

Egy kis újgyakorlat! Programozzunk!
Ötletek, javaslatok, javítások jöhetnek!
Pl.: Írjunk, olvassunk EEPROM-ot, Arduino soros monitoron!

String operátor gyakorlatok.
Használjuk ezt a tankönyvet: A C programozási nyelv (Szeretem, mert könnyű benne témát keresni!)
http://lidi.uw.hu/krc/index.html
Próbáljunk mondatot szavakra bontani, használjuk: http://lidi.uw.hu/krc/files/b.html#B3.

Első nekifutás:

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

// StringTest01.ino

// String operátor gyakorlatok.
// Használjuk ezt a tankönyvet: A C programozási nyelv
// http://lidi.uw.hu/krc/index.html
// Próbáljunk mondatot szavakra bontani, használjuk: http://lidi.uw.hu/krc/files/b.html#B3.

// Karaktersorozat-kezelő függvények:
#include <string.h>
// Kiegészítő rendszerfüggvények:
#include <stdlib.h>

//#include <stdio.h>
#include <EEPROM.h> //EEPROM könyvtár bekérése

// Parancsok:
#define EEP_CIM
#define EEP_WRITE
#define EEP_READ
#define EEP_ADAT


unsigned int addr = 0;  //EEPROM cim
char *s, *t, *rs[10]; // Pointerek a használt Stringeknek
//const
char *cs, *ct;
char c;
size_t n;

char argumentumS[] = {"Test string per token "};

char token[] = " "; // Elválasztó karakter
char mondat[50];
int returnI, i;
boolean stringComplete = false;  // whether the string is complete
String inputString = "";         // a string to hold incoming data
   
void setup() {
  //Serial.begin(9600);
  Serial.begin(115200); // Soros Monitort Újsor karakter küldésére állitjuk!
  // elsö próba:
  cs = argumentumS; // *cs = argumentumString eleje
  // Az strlen() függvény visszatérési értéke a cs karaktersorozat hossza.
  n = strlen(cs);
  Serial.print("String hossza = ");
  Serial.println(n);
 
  Serial.println("Szavak:");
  for(i = 1; i < 5; i++){
    // Az strtok() függvény megkeresi az cs karaktersorozatban a ct karaktersorozatból vett karakterekkel határolt tokeneket.
    rs[i] =  strtok(cs, token); // tároljuk a szavakat *rs[i] tömbben
    Serial.print(i);
    Serial.print(": ");
    Serial.println(rs[i]);
    cs += strlen(rs[i]) + 1; // *cs = a következö szó eleje
  }
  t = mondat;

}
void loop() {
  // Soros Monitort Újsor karakter küldésére állitjuk!
  // Beolvasunk 1 mondatott és szavakra bontjuk
   // print the string when a newline arrives:
  if (stringComplete) {
    Serial.println(inputString);
    // Az strlen() függvény visszatérési értéke a cs karaktersorozat hossza.
    n = strlen(mondat);
    Serial.print("Mondat hossza = ");
    Serial.println(n);
    cs = mondat;
    ct = cs + n;
    Serial.println("Szavak:");
    for(i = 0; ; i++){
      // Az strtok() függvény megkeresi az cs karaktersorozatban a ct karaktersorozatból vett karakterekkel határolt tokeneket.
      rs[i] =  strtok(cs, token); // tároljuk a szavakat *rs[i] tömbben
      Serial.print(i);
      Serial.print(": ");
      Serial.println(rs[i]);
      cs += strlen(rs[i]) + 1; // *cs = a következö szó eleje
      if(cs > ct) break;  // Ha mondat végére ért kiugrik a ciklusbol
    }
    // EEPROM Write, Read parancs értelmező:
    // Folytatás később!


    // Feldolgozás vége:
    mondat[0] = '\n';
    t = mondat;
    stringComplete = false;
  }
   
 
    /*
    EEPROM.write(addr, c); // ha változik azt elmenti az eepromba
    Serial.print(addr);
    Serial.print("=");
    Serial.println(EEPROM.read(addr)); //eeprom kiíratása
    ++addr;
    //delay(300);
  }
    */
 
 
}

/*
  SerialEvent occurs whenever a new data comes in the
 hardware serial RX.  This routine is run between each
 time loop() runs, so using delay inside loop can delay
 response.  Multiple bytes of data may be available.
 */
void serialEvent() {
 
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    *t = inChar;
    t++;
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n') {

      stringComplete = true;
    }
  }
}



A kapott teszt eredmények:
A belső String:
String hossza = 22
Szavak:
1: Test
2: string
3: per
4: token

Beírt parancs: „cím 100 write 3 adat 200 55 99 „
Mondat hossza = 32
Szavak:
0: cim
1: 100
2: write
3: 3
4: adat
5: 200
6: 55
7: 99
8:

Beírt parancs: „cím 100 read 3”
Mondat hossza = 15
Szavak:
0: cim
1: 100

Ehez hasonló parancsokat képzelek el.
Folytatás következik:
Téma: A parancsok feldolgozása

Ötletek, javaslatok, javítások jöhetnek! :idea:

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

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: Robert » 2017. május 2. kedd, 2:22

Hiányzik a védelem, ami 50 karakter elérésekor a stringet befejezettnek tekinti.
Most simán túlírhatom, és az51. soros adatnál valamit felülírok a változók közt...

Igaz ez a egyes szavakra belül is. Túlírás lehet vagy nem látom a lefoglalt memóriahosszt...
http://www.tavir.hu - a gazda :)

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 2. kedd, 14:09

Köszi, az észrevételt!

Mivel ez még az első munka változat.
A lehetséges felhasználói hibák kivédéséig még nem jutottam el.
A következőben bele rakok tömb határvédelmet.

És tényleg az *rs[10] nem kapott kezdeti értéket!
Sajnos ez a pointeres tömb kezelés még homályos a számomra! (még dolgozok rajta)

Viszont közben megváltozott az elgondolás.
A tokenekre bontás közben folyamatosan fel is dolgozom őket.
Így nem kel újabb memóriát foglalni a teljes mondat számára.

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

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: Robert » 2017. május 3. szerda, 18:49

Ha folyamatosan dolgozpd fel, akkor egy kérdéskupac:
- az utasítás vége jel: ENTER? (Melyik? 0x10 vagy 0x13 vagy (0x10; 0x13)?
- szeparátor: space
- értelmes karakter: ASCII 32...126. Mit teszel a többivel?

Mi van 2 spaceval egymás után?
Felépítés:<utasítás> <param1> <param2> .... <paramx> [ENTER]?
http://www.tavir.hu - a gazda :)

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 3. szerda, 21:03

Itt tart, az elképzelés:

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

// String operátor gyakorlatok.
// Használjuk ezt a tankönyvet: A C programozási nyelv
// http://lidi.uw.hu/krc/index.html
// Próbáljunk mondatot szavakra bontani, használjuk: http://lidi.uw.hu/krc/files/b.html#B3.
// Majd értelmezzük a parancsokat, és végrehajtjuk.

/* Parancsok leirása:
A soros monitort állítjuk 'Újsor' küldésre! '\n' Ez a mondat vége jel!
A parancsokat elválasztó karakter a szóköz: ' '
A jeleket: ' (Nem kell be irni! Csak szemléltetés képen alkalmaztam, hogy érzékelhetők legyenek a parancs határok.)
1. Példa:
cim 123 write 5 adat 1 2 3 4 5
EEPROM kezdő cím megadása:    'cim 123 '      
EEPROM WRITE parancs:              'write 5 '      // A példában 123 cimtöl, 5 char-t irunk
EEPROM ADAT  parancs:              'adat 1 2 3 4 5 '   // Adat értéke 1 Byte lehet (szám: 0 - 255-ig)
2. Példa:
cim 110 read 20
EEPROM kezdő cím megadása:    'cim 110 '   
EEPROM READ  parancs:              'read 20 '      // A példában 110 cimtöl,  20 char-t olvasunk
3. Példa:
cim 200 write 27 str Itt kezdődik a beírt szöveg! Itt a vége!
EEPROM kezdő cím megadása:    'cim 200 '   
EEPROM WRITE parancs:              'write 27 '      // A példában 200 cimtöl, 27 char hosszú szöveget irunk
EEPROM STRING parancs:          'str Itt kezdődik a beírt szöveg! Itt a vége!'    // A String kerül az EEPROM-ba
4. Példa:
cim 200 read 27 str
EEPROM kezdő cím megadása:    'cim 200 '   
EEPROM READ parancs:              'read 27 '      // A példában 200 Cimtöl, 27 char hosszú szöveget olvasunk
EEPROM STRING parancs:          'str '

Az egyben beirható parancs sor hossza max = MAX_MONDAT   500
   
*/



A program még tesztelés állapotban van!

Ha valaki jelentkezik tesztelőnek? Ide rakhatom!

értelmes karakter: ASCII 32...126. Mit teszel a többivel?

Ha nem str parancsban van?: Figyelmen kívül hagyom, eldobom!

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 4. csütörtök, 16:53

Sajnos az Arduino Terminál olyan, amilyen!
Inkább ezt ajánlom használni: Yet Another Terminal
https://sourceforge.net/projects/y-a-terminal/

Text Terminal Seting-ben állítsuk be az: EOL sequence: <LF> -re.
Ebbe be lehet tölteni az előre megírt utasítás sorokat. (Megkímél a sok gépeléstől, és estleges el ütésektől.)

Itt a tesztelendő program változat. (Sajnos még nem volt rá sok időm!):

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

// EEPROMtest02.ino

/**
 *  author: kapu48
 *  date  : 2017. 05. 05
 *  licens: A program szabadon felhasználható!
 */
// String operátor gyakorlatok.
// Használjuk ezt a tankönyvet: A C programozási nyelv
// http://lidi.uw.hu/krc/index.html
// Próbáljunk mondatot szavakra bontani, használjuk: http://lidi.uw.hu/krc/files/b.html#B3.

// A program célja: EEPROM kezelése, Soros terminálról.

/* Használható Parancsok leirása:
A soros monitort állítjuk 'Újsor' küldésre! '\n' Ez a mondat vége jel!
A parncsokat elválasztó karakter a szóköz: ' '
A jeleket: ' (Nem kell beirni! Csak szemléltetés képen alkalmaztam, hogy érzékelhetők legyenek a parancs határok.)

1. A példában 123 cimtöl, 5 char-t irunk
cim 123 write 5 adat 1 2 3 4 5 
EEPROM kezdő cím megadása:    'cim 123 '      
EEPROM WRITE parancs:              'write 5 '      
EEPROM ADAT  parancs:              'adat 1 2 3 4 5 '   // 1 Adat értéke 1 Byte lehet (szám: 0 - 255-ig)

2. A példában 200 cimtöl, 5 char-t törlünk, 225-el (Irunk)
cim 200 clear 5 225
EEPROM kezdő cím megadása:    'cim 200 '   
EEPROM CLEAR  parancs:           'clear 5 225'      


3. A példában 110 cimtöl,  20 char-t olvasunk
cim 110 read 20 adat
EEPROM kezdő cím megadása:    'cim 110 '   
EEPROM READ  parancs:              'read 20 '      
EEPROM ADAT  parancs:              'adat'

4. A példában 200 cimtöl, 40 char hosszú szöveget irunk
cim 200 write 40 str Itt kezdődik a beírt szöveg! Itt a vége!
EEPROM kezdő cím megadása:    'cim 200 '   
EEPROM WRITE parancs:              'write 40 '      
EEPROM STRING parancs:          'str Itt kezdődik a beírt szöveg! Itt a vége!'    // A String + 0,kerül az EEPROM-ba

5 A példában 200 cimtöl, 40 char hosszú szöveget olvasunk
cim 200 read 40 str
EEPROM kezdő cím megadása:    'cim 200 '   
EEPROM READ parancs:              'read 40 '      
EEPROM STRING parancs:          'str'


Az egyben beirható parancs sor hossza max = MAX_MONDAT   500
   
*/

// Karaktersorozat-kezelő függvények:
#include <string.h>
// Kiegészítő rendszerfüggvények:
#include <stdlib.h>

//#include <stdio.h>
#include <EEPROM.h> //EEPROM könyvtár bekérése


#define  MAX_SZO        10   // Tokenek max hossza
#define  MAX_MONDAT   500  //  Mondat Max char száma
#define  TOKEN            ' '  // elválasztó Szóköz
unsigned int addr = 0;  //EEPROM cim
unsigned int bytes = 0;  // Adat bytek száma
unsigned int adat = 0;  // Adat Byte
unsigned int index = 0;  // Tömbb index

char *ps, *pt, *prs; // Pointerek a használt Stringeknek

char *pcs, *pct;
char rs[MAX_SZO];
size_t n;

char token[4];
unsigned int mondatN = 0; // mondat hossz számlálo
char mondat[MAX_MONDAT];
int returnI, i;
boolean stringComplete = false;  // whether the string is complete
boolean w_r = true;  // write/ read kapcsoló

void stringInterpretation(void); // szöveg feldolgozo
   
void setup() {
  //Serial.begin(9600);
  Serial.begin(115200); // Soros Monitort, Újsor karakter küldésére állitjuk!
   token[0] = TOKEN; // Elválasztó karakter
  pt = mondat;

}
void loop() {

  if (stringComplete) {
      // Soros Monitort Újsor karakter küldésére állitjuk!
      // Beolvasunk 1 mondatott és szavakra bontjuk
      // print the string when a newline arrives:   
      stringInterpretation();       
   }
 
 
 
}   // END loop()

// String értelmezés és feldolgozás
void stringInterpretation(void){
   unsigned int szavak = 0;  // Tokenek száma
   
  // Az strlen() függvény visszatérési értéke a cs karaktersorozat hossza.
  n = strlen(mondat);
  Serial.print("Mondat hossza = ");
  Serial.println(n);
  if(n > MAX_MONDAT){  // EROR!
    Serial.println("!Csak az elsö 500 char-t tudom tárolni!");     
  }      
  pcs = mondat;      // Pointer a mondat elejére állitjuk
  pct = pcs + n;   // A mondat vége a memoriában
   prs = rs;            // szó tároló pointer
   szavak = 1;
      
  while(pcs < pct){   // Ciklus amig *pcs a mondat végére nem ér
      // Az strtok() függvény megkeresi az cs karaktersorozatban a ct karaktersorozatból vett karakterekkel határolt tokeneket.
      prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
      Serial.print(szavak);
      Serial.print(": ");
      Serial.println(prs);
      pcs += strlen(prs) + 1; // *pcs = a következö szó elejére mutat
         szavak++;
         // EEPROM Write, Read parancs értelmező:
         // strncmp() Összehasonlítja két string tartalmát, karakterenként.   
      if(strncmp(prs,"cim", 3) == 0) {
        Serial.print("EEP.Cim= ");
            prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
        // Az atoi(s) függvény az s karaktersorozat tartalmát int típusú számmá alakítja.            
        addr = atoi(prs); //  EEPROM kezdö cim
            Serial.println(addr);                  
            pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
            szavak++;         
               
      }else if(strncmp(prs, "write", 5) == 0) {
        Serial.print("EEP.Write: ");
            prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
        bytes = atoi(prs); // EEPROM-ba írandó Bytek száma
            Serial.println(bytes);   
            pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
            szavak++;
        w_r = true;   // write jelzö
               
      }else if(strncmp(prs, "read", 4) == 0) {
        Serial.print("EEP.Read: ");
            prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
        bytes = atoi(prs); // EEPROM-bol olvasandó Bytek száma
            Serial.println(bytes);
            pcs += strlen(prs) + 1; // *pcs = a következö szó elejére
            szavak++;
        w_r = false;   // read jelzö
               
      }else if(strncmp(prs, "adat", 4) == 0) {
        Serial.println("EEP.Adat feldolgzas");       
        for(int ia = 0; ia < bytes; ia++){ 
                  
          if(w_r){  // EEP_WRITE
                  prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
                  adat = atoi(prs); // konvertálás EEPROM-ba irandó Byte
                  pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
                  szavak++;
                  if(adat < 0 || adat > 255){
                     Serial.println("Rossz EEP.Adat Error!");
                     break;
                  } else {
                     EEPROM.write(addr, (uint8_t)adat); // ha változik azt elmenti az eepromba
                     Serial.print(addr);
                     Serial.print("= ");   
                     Serial.println(adat);
                  }
          }else{  // EEP_READ
            adat = EEPROM.read(addr); // EEPROM olvasot Byte
                  // Ide jöhet, hogy mit szeretnénk az adattal csinálni.
            Serial.print(addr);
            Serial.print("= ");       
            Serial.println(adat);
          }
          addr++; // EEPROM cim növelése
        }
      }else if(strncmp(prs, "str", 3) == 0) {   // szöveget akarunk EEPROM-ba irni
            char cdat;
        Serial.print("EEP.String feldolgzas. ");   
            int it = addr + bytes;
        if(w_r){  // EEP_WRITE
               Serial.println(" Write.");
               for(int is = addr; is < it; is++){
                  cdat = *pcs;
                  pcs++;
                  EEPROM.write(is, (uint8_t)cdat); // Elmenti az eepromba
                  Serial.print(is);
                  Serial.print("= ");   
                  Serial.println(cdat);
               }
               EEPROM.write(addr, 0);   // + String lezáró 0
               addr++;
        }else{  // EEP_READ
               Serial.println(" Read.");
               for(int is = addr; is < it; is++){
                     char cdat = EEPROM.read(is); // EEPROM-bol olvasot Byte
                     // Ide jöhet, hogy mit szeretnénk az adattal csinálni.
                     Serial.print(is);
                     Serial.print("= ");       
                     Serial.println(cdat);
               }         
        }         
            
         }else if(strncmp(prs, "clear", 5) == 0) {   //
            Serial.print("EEP.Clear. cim= ");
            Serial.print(addr);
            Serial.print(", adat= ");
        prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
            bytes = atoi(prs); // konvertálás EEPROM-ba irandó Byte
            pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
            szavak++;
            
        prs =  strtok(pcs, token); // tároljuk a szavat rs[] tömbben
            adat = atoi(prs); // konvertálás EEPROM-ba irandó Byte
            Serial.println(adat);
            pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
            szavak++;
            if((adat < 0) || (adat > 255)){
               Serial.println("Rossz EEP.Adat Error!");
               break;
            } else {
               int it = addr + bytes;            
               for(int ia = addr; ia < it; ia++){ 
                  EEPROM.write(ia, adat); //
               }
            }
         }
   }   // END while()
  // Feldolgozás vége:
  Serial.print("Feldolgozott szavak= ");
   Serial.println(szavak);   
   Serial.println();
  mondatN = 0;   // karakrer számlálo = 0
  mondat[0] = '\n'; // tömbb törlése
  pt = mondat;   // Beolvasó pointer a mondat[] elejére
  stringComplete = false;   // Következö mondat beolvasás engedéjezése
   
}   // END String értelmezés és feldolgozás

/*
  SerialEvent occurs whenever a new data comes in the
 hardware serial RX.  This routine is run between each
 time loop() runs, so using delay inside loop can delay
 response.  Multiple bytes of data may be available.
 */
void serialEvent() {
  if(stringComplete == false){
         
      while (Serial.available()) {
         // get the new byte:
         char inChar = (char)Serial.read();
         // add it to the inputString:
         *pt = inChar;
         pt++;
         mondatN++;   // karakrer számlálo++
         // if the incoming character is a newline, set a flag
         // so the main loop can do something about it:
         if ((inChar == '\n') || (mondatN > MAX_MONDAT)) {
            stringComplete = true;
         }
      }
   }else{
      Serial.println();
      Serial.println("Várj! Még dolgozom!");
   }
}

 


Én Megán teszteltem! Nagy részben működőképesnek tűnt!
Viszont még van pár gondolatom, amit bele kel építeni! Főleg felhasználói bakik kivédésére.
A tovább fejlesztésre elképzelés, hogy kész C stílusú tömböket is be tudjon tölteni EEPROM-ba.

Sajnálom, hogy eddig csak Robertet érdekelte a konkrét téma!
Ha valaki próbálná tesztelni. És megírná a tapasztalatait.
Annak nagyon örülnék!

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 4. csütörtök, 20:10

Itt az első javítás! (A rossz címzés, törölte az első karakter!)

A 201, 202 sorokban levő:

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

               EEPROM.write(addr, 0);   // + String lezáró 0
               addr++;


Kel cserélni erre:

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

      EEPROM.write(is, 0);   // + String lezáró 0
            

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 4. csütörtök, 20:21

És így nézki a String irás, olvasás EEPROM-ba.
    cim 200 write 40 str Itt kezdődik a beírt szöveg! Itt a vége!
    Mondat hossza = 62
    0: cim
    EEP.Cim= 200
    2: write
    EEP.Write: 40
    4: str
    EEP.String feldolgzas. Write.
    200= I
    201= t
    202= t
    203=
    204= k
    205= e
    206= z
    207= d
    208= ő
    209= d
    210= i
    211= k
    212=
    213= a
    214=
    215= b
    216= e
    217= í
    218= r
    219= t
    220=
    221= s
    222= z
    223= ö
    224= v
    225= e
    226= g
    227= !
    228=
    229= I
    230= t
    231= t
    232=
    233= a
    234=
    235= v
    236= é
    237= g
    238= e
    239= !
    6:

    Feldolgozott szavak= 7

    cim 200 read 41 str
    Mondat hossza = 20
    0: cim
    EEP.Cim= 200
    2: read
    EEP.Read: 41
    4: str

    EEP.String feldolgzas. Read.
    200= I
    201= t
    202= t
    203=
    204= k
    205= e
    206= z
    207= d
    208= ő
    209= d
    210= i
    211= k
    212=
    213= a
    214=
    215= b
    216= e
    217= í
    218= r
    219= t
    220=
    221= s
    222= z
    223= ö
    224= v
    225= e
    226= g
    227= !
    228=
    229= I
    230= t
    231= t
    232=
    233= a
    234=
    235= v
    236= é
    237= g
    238= e
    239= !
    240=
    241= ˙
    Feldolgozott szavak= 6


Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 5. péntek, 23:40

Uj parancsal bövült a program: token

    6. Elválaszto token megváltoztatása:
    kulcs szo: token
    Paraméter: a token hossza chr, az uj token mostantol: ', '
    token 2 ,
    Ezek után igy nézki a bevitel példa:
    1b. A példában 100 cimtöl, 5 char-t irunk
    cim, 100, write, 5, adat, 10, 20, 30, 40, 50
    Vissza olvasás:
    cim, 100, read, 5, adat

A feldolgozo else if() elágazások végéhez füzzük a következö kiegészítö részt:

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

         }else if(strncmp(prs, "token", 5) == 0) {   //
            char *ptoken;
            ptoken = token;;
            Serial.print("token= ");
            prs =  strtok(pcs, token); // beolvassa a hossz értéket
            bytes = atoi(prs); // konvertálás adat hosssza Bytes
            pcs += strlen(prs) + 1; // *pcs = a következö szó eleje
            szavak++;            
            //char *strncpy(s, ct, n)
            //Az strncpy függvény a ct-ből n karaktert átmásol s-be és visszatér s mutatójával.
            //Az s végét '\0' végjelekkel tölti fel, ha ct n karakternél rövidebb volt.
            ptoken = strncpy(token, pcs, bytes);             
            ptoken += (bytes + 1);
            *ptoken = 0;
            Serial.println(token);
            pcs += strlen(token); // + 1; // *pcs = a következö szó eleje
            szavak++;                        
         }   


Az egész egyben itt tölthető:
EEPROMtest04.ino


A végrehajtás:
    cim, 100, write, 5, adat, 10, 20, 30, 40, 50,
    Mondat hossza = 47
    0: cim,
    EEP.Cim= 100
    2: write,
    EEP.Write: 5
    4: adat,
    EEP.Adat feldolgzas
    100= 10
    101= 20
    102= 30
    103= 40
    104= 50
    10:

    Feldolgozott szavak= 11

    cim, 100, read, 5, adat
    Mondat hossza = 24
    0: cim,
    EEP.Cim= 100
    2: read,
    EEP.Read: 5
    4: adat

    EEP.Adat feldolgzas
    100= 10
    101= 20
    102= 30
    103= 40
    104= 50
    Feldolgozott szavak= 5

Nincs meg a kellő jogosultságod a hozzászóláshoz csatolt állományok megtekintéséhez.

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 5. péntek, 23:53

Kimaradt a lista elejéröl a token megváltoztatás példa:
    token 2 ,
    Mondat hossza = 12
    0: token
    1: 2
    2: ,
    3:

    Feldolgozott szavak= 4

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 6. szombat, 0:06

A következő feladat, a HEXA számok kezelése lessz, EEPROM írás, olvasás közben.


(Robert! 1 órát késik az órád!) :)

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

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: Robert » 2017. május 6. szombat, 2:33

Kimaradt egy fontos tétel:
- az EEPROM 0. címe sérülhet tápingadozás/reset folyamán:
http://www.atmel.com/webdoc/avrlibcrefe ... ption.html


Ha a feltöltés során az adat nem sérülhet, az utasítássor végére egy CRC számítást betennék...
http://www.tavir.hu - a gazda :)

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 6. szombat, 13:55

Köszi, az ide illő linket!
Még hozzátenném, hogy ajánlott mindig páros címről indítani az adatok feltöltését.

Ami még nincs! :
A Hiba ellenőrzések!
A mostani kezdetleges debug kiíratásokat szándékozom lecserélni.
Én bájtonkénti vissza olvasás és összehasonlításra gondoltam, mert úgy pontosan meg tudjuk, hogy melyik címeken van hiba! (Míg a CRC csak a végén mondja meg, hogy valahol hiba van.)
Így eldönthetjük, hogy 1, 2 Byte-t újra írunk, vagy több hiba esetén megismételjük az írást.

Még a mindenkori EEPROM terület határának túllépését is a felhasználónak kell figyelnie!

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 6. szombat, 15:42

Mire gondoltál a CRC-vel?
Mivel a PC. Terminál programot nem én írtam! Oda nem tudok CRC küldést beiktatni.

Csak az EEPROM írást tudom vissza ellenőrizni.
Erre készült a rutin: (Aminek a hívását beiktatom minden Byte írás után.)

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

// EEPROM adat ellenörzés
boolean verify(unsigned int addr_, char adat_){
   boolean verify_ = true;
   char _adat = EEPROM.read(addr_); // EEPROM-bol olvasot Byte
   if(_adat != adat_){   // Ha hibás?
      EEPROM.write(addr_, adat_); // Meg probálja ujra irni
      
      _adat = EEPROM.read(addr_); // EEPROM-bol olvasot Byte
      if(_adat != adat_){   // Ha nem sikerült, javitani?
         Serial.println();
         Serial.print("EEPROM ERROR! Hibas a Cimen:  ");   //   jelezi a hibát
         Serial.print(addr_);   
         Serial.print(", olvasott adat: ");         
         Serial.println(_adat);
         Serial.println("EEPROM Iras megszakitva! ");
         verify_ = false;      //   Mivel nem érdemes folytatni!
      }
   }
   return verify_;
}


false, visszatérés esetén kiugrunk a folytatásból!

Igy megfelelő lessz szerinted?

Avatar
kapu48
Elektronbűvölő
Hozzászólások: 3228
Csatlakozott: 2008. augusztus 29. péntek, 6:00
Tartózkodási hely: Újkígyós

Re: Soros parancs értelmező program készítés!

HozzászólásSzerző: kapu48 » 2017. május 6. szombat, 17:21

Egy kérdés, vagy kérés!

Arduino-ban, hogyan tudom meg, hogy éppen milyen AVR-re fordítják a programomat?
Kellene, hogy meghatározzam az EEPROM méretét.

Vagy esetleg le tudom ezt kérdezni a programban?


Vissza: “Oktatás”

Ki van itt

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