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

[kapu48]

Szerintem most, bővítem az adat fogalmát unsigned int 8, 16, 32 Bytesre, és lecserélem a kulcsszókat!
uint8, uint16, uint32.

[kapu48]

A mintaprogram fejléce nem pontos:

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

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,  <- nem kell a szóköz közé! Végén vesszővel zárom? Vagy elég az ENTER? 
Vissza olvasás:
cim,100,read,5,adat <- nem kell a szóköz közé! Végén vesszővel zárom? Vagy elég az ENTER?

Szerintem a forum motor szedteki a szóközöket! Mert az eredeti kodban még benne volt!

[kapu48]

Az a helyzet, hogy közben rájöttem, az strtok() függvényt másképpen kel használni, mint ahogy én tettem!
http://people.cs.uchicago.edu/~dmfrankl ... strtok.txt

A lényeg ez:

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

char string[] = "This is a sentence, and I want to read only the words from this sentence.\n";

char *tokenPtr;

// initialize the string tokenizer and receive pointer to first token
tokenPtr = strtok(string, " ,.\n");
while(tokenPtr != NULL)
{
	printf("%s\n",tokenPtr);
	tokenPtr = strtok(NULL, " ,.\n");
}

Szóval bocsi! Bár az előző program is működik, de át dolgozom, mert így agyszerűbb lesz!

[SzLacus]

Az eeprom könyvtárnak már nem csak read és write lehetősége van, hanem put és get is. Azok pedig kezelik az adathosszt maguktól. Nem érdemes azt használni?

[kapu48]

Igen igazad van!

De mivel eddig csak Bytet kezelt a programom, elég volt az előbbiek használata!

Később tervbe van véve az adatszélesség kibővítése.

Csak most az eddigiek egyszerűsítésével vagyok elfoglalva. Mert közben tisztázódtak bizonyos fentebb vázolt fogalmak.
Ami által egyszerűbb lesz az elválasztó karakterek kezelése. Mer a többszörös rákérdezésekből kiderült, hogy ez eddig i megoldás nehezen érthető volt.

[SzLacus]

Biztos voltam benne, hogy reszeled a biteket keményen.
Látva, hogy az adatszélesség is benne van a szkópban, gondoltam feldobom a rendszer által kínált megoldást. De nem okvetlenül azért, mert én már belebotlottam, hanem azért, mert arra vagyok kíváncsi hogy az olyanok mint te, akik, asm, meg regiszter szinten ismerik a témát, azok használják a kész megoldást, vagy megírják a maguk verzióját, mert az független a könyvtár adta megoldástól, így hordozhatóbb.

[kapu48]

Én szerényebben fogalmaznák!

Inkább csak tanulgatom a kész C, Cpp rutinok használatát!
(Mivel számomra kiderült, hogy asm-al nem érdemes már szenvedni!)

Még valamikor réges-régen a Z80-as idejében, szinte fejből vágtam!

[kapu48]

Itt a javított elválasztó karaktereket kezelő program változat!

Mostmár az alábbi: ”jelek között” definiált karakterek bármelyikének az első előfordulása, jelenti a szó végét.:

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

#define  TOKEN		" ,;{}\n"    //  elválasztó karakterek

A szavak lehetnek meghatározott parancsszavak, címek az adott EEPROM területre, vagy adatok 0 – 255-ig.
Az write n str szövegíró parancs ’str ’ után csak 1 elválasztó karakter lehet, utána következzen az előzőleg megadott hosszú String. A String végére kel elválasztás, ha utána újabb parancs következik.

További ismertetők a programban.

Javított Forráskód le tölthető:

EEPROMtest05.ino

(A ’token’ parancsot egyelőre kivettem az utasítások közül!)

[kapu48]

Véletlenül rossz programot töltöttem fel!

Ez lesz a Jó:

EEPROMtest051.ino

[vargham]

Miért nem rakod fel GitHub-ra?

[kapu48]

Ez még eszembe sem jutott!
De még nincsen készen!

Még többek között, szeretném a hexa-ban megadott számokat is beolvasni.

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

// EEPROMtest051.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, 255-el (Irunk)
cim 200 clear 5 255
EEPROM kezdő cím megadása:    'cim 200 '	
EEPROM CLEAR  parancs:  			'clear 5 255'		

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' 

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

Az egyben beirható parancs sor hossza max = MAX_MONDAT   500 

Az Uno-ba és más Atmega 328-asokban 1024byte az eeprom nagysága, 
A memória címzés 0-1023-ig
a Megában 4096byte (4kB). A memória címzés 0-4095-ig tart.
    
*/

// 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   //  Szavk max hossza						(Vegyük számitásba a String lezáro 0 -is!)
#define  MAX_MONDAT   500  //  Mondat Max char száma			(Vegyük számitásba a String lezáro 0 -is!)
#define  MAX_TOKEN		10		 //	 Elválasto token max hossza (Vegyük számitásba a String lezáro 0 -is!)
#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 *pt; // Pointer a beolvasott Stringnek
char *pcs, *pct;

size_t n;

char token[MAX_TOKEN+1] = {" ,;.{}\n"};
unsigned int tokenN[2] = {1, 1}; // token hossz számlálo
unsigned int mondatN = 0; // mondat hossz számlálo
char mondat[MAX_MONDAT];	// Tömbb a parancsok beolvasásánk

boolean stringComplete = false;  // whether the string is complete
boolean w_r = true;  // write/ read kapcsoló

uint8_t i8 = 200;
uint16_t i16 = 20000;
uint32_t i32 = 200000;

// Szub rutinok
void stringInterpretation(void); // szöveg feldolgozo
boolean verify(unsigned int addr_, char adat_);	// EEPROM adat ellenörzés
boolean EEPoverflow(void);		// Az adott EEPROM terület túlcsordulás ellenörzése
   
void setup() {
  //Serial.begin(9600);
  Serial.begin(115200); // A Soros Monitort, Újsor karakter küldésére állitjuk!
	//token[0] = TOKEN; // Elválasztó karakter
	//token[1] = 0; // 
  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

	szavak = 0;
/*
http://people.cs.uchicago.edu/~dmfranklin/tutorials/strtok.txt
A lényeg ez:
char string[] = "This is a sentence, and I want to read only the words from this sentence.\n";

char *tokenPtr;

// initialize the string tokenizer and receive pointer to first token
tokenPtr = strtok(string, " ,.\n");
while(tokenPtr != NULL)
{
	printf("%s\n",tokenPtr);
	tokenPtr = strtok(NULL, " ,.\n");
}
*/
	pcs = strtok(mondat, token);	// Megkeresi az elsö szó végét a mondat[] tömbben 
	while(pcs != NULL)
	{
		/*
		char *strtok(s, ct)
		Az strtok függvény megkeresi az s karaktersorozatban a ct karaktersorozatból vett karakterekkel határolt tokeneket.

		Az strtok(s, ct) függvény sorozatos hívásával az s karaktersorozat tokenekre bontható és 
		az egyes tokeneket a ct-ben lévő karakter határolja. 
		A függvény első hívásának s nem NULL értékével kell történnie, és ekkor a függvény megkeresi az s-ben az első, 
		ct-ben nem lévő karakterekből felépített tokent, 
		majd az s következő karakterét a '\0' végjellel felülírva visszatér a tokent címző mutatóval. 
		A további hívásokat az s NULL értéke jelzi, és a függvény ilyenkor a következő token 
		(amelyet az előzőleg talált token végétől kezd keresni) mutatójával tér vissza. 
		Ha az strtok nem talál további tokent, akkor a visszatérési értéke NULL lesz. 
		A ct karaktersorozat hívásról hívásra változhat. */		
      //Serial.print(szavak);
      //Serial.print(": ");
      //Serial.println(pcs);      
			//szavak++;
			
			// EEPROM Write, Read parancs értelmező:
			// strncmp() Összehasonlítja két string tartalmát, karakterenként.	
      if(strncmp(pcs, "cim", 3) == 0) {
        Serial.print("EEP.Cim= ");
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
        // Az atoi(s) függvény az s karaktersorozat tartalmát int típusú számmá alakítja.				
        addr = atoi(pcs); //  EEPROM kezdö cim
				Serial.println(addr);										
				szavak++;			
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben	
				
      }else if(strncmp(pcs, "write", 5) == 0) {
        Serial.print("EEP.Write: ");
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
        bytes = atoi(pcs); // EEPROM-ba írandó Bytek száma
				Serial.println(bytes);	
				if(!EEPoverflow()) goto hiba;				
				szavak++;
        w_r = true;	// write jelzö
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben	
				
      }else if(strncmp(pcs, "read", 4) == 0) {
        Serial.print("EEP.Read: ");
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
        bytes = atoi(pcs); // EEPROM-bol olvasandó Bytek száma
				Serial.println(bytes);
				if(!EEPoverflow()) goto hiba;				
				szavak++;
        w_r = false;	// read jelzö
					
      }else if(strncmp(pcs, "adat", 4) == 0) {
        Serial.println("EEP.Adat feldolgzas");        
        for(int ia = 0; ia < bytes; ia++){  						
          if(w_r){  // EEP_WRITE
						pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
						adat = atoi(pcs); // konvertálás EEPROM-ba irandó Byte
						
						szavak++;
						if(adat < 0 || adat > 255){ 
							Serial.println("Rossz EEP.Adat Error!");
							goto hiba;
						} else {
							EEPROM.write(addr, (uint8_t)adat); // ha változik azt elmenti az eepromba
							if(!verify(addr, adat)) goto hiba;
							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
        }
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
				
      }else if(strncmp(pcs, "str", 3) == 0) {	// szöveget akarunk EEPROM-ba irni
				char cdat;
				int is;
				uint16_t temp;
        Serial.print("EEP.String feldolgzas. ");   
				int it = addr + bytes;
				szavak++;
				pcs += 4;				
        if(w_r){  // EEP_WRITE
					Serial.println(" Write.");
					Serial.print(addr);
					Serial.print(": ");
					for(is = addr; is < it; is++){
						cdat = *pcs;
						EEPROM.write(is, cdat); // Elmenti az eepromba
						if(!verify(is, cdat)) goto hiba;						
						//Serial.print("= ");    
						Serial.print(cdat);
						pcs++;						
					}
					EEPROM.write(is, 0);	// + String lezáró 0
					if(!verify(is, 0)) goto hiba;
					pcs = strtok(pcs, token);	// Megkeresi az elsö szó végét a mondat[] tömbben 
					
        }else{  // EEP_READ
					Serial.println(" Read.");
					Serial.print(addr);
					Serial.print(": ");					
					for(is = addr; is < (it+1); is++){
							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.print(cdat);
					}
          pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
        }			
				Serial.println();
				
			}else if(strncmp(pcs, "clear", 5) == 0) {	// 
				Serial.print("EEP.Clear. cim= ");
				Serial.print(addr);
				Serial.print(", adat= ");
        pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
				bytes = atoi(pcs); // konvertálás EEPROM-ba irandó Byte
				if(!EEPoverflow()) goto hiba;
				
				szavak++;				
        pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben beolvassa az irando értéket
				adat = atoi(pcs); // konvertálás EEPROM-ba irandó Byte
				Serial.println(adat);
				
				szavak++;
				if((adat < 0) || (adat > 255)){ 
					Serial.println("Rossz EEP.Adat Error!");
					goto hiba;
				} else {
					int it = addr + bytes;				
					for(int ia = addr; ia < it; ia++){  
						EEPROM.write(ia, adat); // 
						if(!verify(ia, adat)) goto hiba;
					}
				}
				pcs =  strtok(NULL, token); // Megkeresi a következö szó végét a mondat[] tömbben
			}	
			
		
	}	// END while()
  // Feldolgozás vége:
  //Serial.print("Feldolgozott szavak= ");
	//Serial.println(--szavak);	
	//Serial.println();
hiba:										// Bármilyen hiba esetén itt kiugrunk
  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
	
	Serial.println("END stringInterpretation!");
	
}	// END stringInterpretation()

// 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_); // Megprobálja ujra irni
		Serial.println(" Iras Hiba javitas!");
		_adat = EEPROM.read(addr_); // EEPROM-bol olvasot Byte
		if(_adat != adat_){	// Ha nem sikerült, javitani?			
			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_;
}	// END verify()


 /***
    Advance to the next address, when at the end restart at the beginning.

    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.

    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
		
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.

    ++address &= EEPROM.length() - 1;		
  ***/
boolean EEPoverflow(void){	
  unsigned int address = addr + bytes;
	boolean error = true;
	// debug
	Serial.print(" EEPROM.length: ");
	Serial.println(EEPROM.length());
  if (address >= EEPROM.length()) {
		Serial.print(address);
		Serial.print("! EEPROM cimzes ERROR! Max Cim: ");	//	jelzi a hibát
		Serial.println(EEPROM.length());
		
    error = false;
  }
	return error;
}	


/*
  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++;	// karakter 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("Varj! Meg dolgozom!");
	}
}	// END  serialEvent()

 

[vargham]

Nem akkor kell felrakni, amikor készen van... Hiszen eleve publikusan fejlesztesz. Könnyebb összehasonlítani a verziókat, hozzászólni, kipróbálni, nem kell zip fájlokkal vacakolni.
Ha úgyis használsz verziókezelő rendszert, akkor egyszerű. Ugye használsz? Ha nem, akkor kezdj el! Megkönnyíti az életet.

[kapu48]

Sajnos vannak lényeges hiányosságok a tudásomban!

Az egyik, hogy nem tudok angolul! Ezért Google fordítókat használok legtöbbször.
Amik sajnos nem programozó szakszövegek fordítására lettek kidolgozva.
Ha ezt megpróbálom publikálni, egyből elküldenek melegebb éghajlatra!

Annyit meg nem ér az egész hobbi, hogy fogadjak valakit fordítani.

„Ha úgyis használsz verziókezelő rendszert?”??? Ennek utána kel néznem!
Legszívesebben a szabvány C függvényeket használom, ezek nem verzió függők.

[vargham]

Nem, a verziókezelés mást jelent. A te forráskódod különböző verzióinak kezelését. Minden változást vissza tudsz követni. Nem utolsó sorban biztonsági mentésnek is jó, ha rendszeresen szinkronizálsz egy szerverrel.
Ilyen például a GIT.
Szolgáltatók közül a Bitbucketnek van privát ingyenes szolgáltatása. A GitHub csak a publikus repokat adja ingyen.

Bővebben a verziókezelésről:
https://hu.wikipedia.org/wiki/Verzi%C3%B3kezel%C3%A9s

Én ma már a hobbiprojektekhez és a dokumentumaimhoz is használom.

[kapu48]

Bele olvastam a GIT gyorstalpalóba: http://math.bme.hu/~balazs/git/hasznal.html

Első látásra, roppant bonyolult! Másodikra, nincsen saját nyugdíjas szerverem a padláson!
Harmadikra, amíg ezt megtanulnám kezelni? Nem haladok a programozással.
Negyedszer nem igazán érdekel...