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!
