File content as of revision 45:58713cc78010:

// istanze di funzioni per metterle poi dove si vuole
bool funcfromMenu(int);
int contaMenuFunc();
//-------------------------------------------------

void choiceVideoSettings()
{
    string prefix;
    bool bbold;
    //stampo menu
    for (int i =  0; i<10 ; i++) {
        if (i==menuidx) {
            bbold=1;
            prefix="*";
        } else {
            bbold=0;
            prefix=" ";
        }
        term.formatPrintf(fnzAdd.string2char(prefix+menu_main[i]),1,4+i,19,bbold);
    }
    //info terminale
    term.formatPrintf("Menu Add \n",61,p52,19,1); //p52

    funcfromMenu(menuidx);
}

void writeLogInput(string strIn)
{
    // stampa i splitta i parametri in ingesso
    string func;
    string funcnum;
    string param;
    func=strIn.substr(0,1);
    funcnum=strIn.substr(1,1);
    param=strIn.substr(2,3);
    term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS(func)),11,p01,10,1);       //p01
    term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS(funcnum)),39,p02,10,1);    //p02
    term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS(param)),61,p03,10,1);      //p03
    //write input string
    term.formatPrintf(fnzAdd.string2char(strIn.substr(0,17)),21,p51,10,1); //p51
//---------------------------------------------------------------------------------------------
}

int trovaIndiceFunzione(string strIn)
{
    //data la stringa di menu e funzione, restituisce l'indice
    int idx=0;
    bool trovato=false;
    //cerca valore. Per ora facciamo cosi, poi si vede se indicizzarlo
    while ((trovato==false) && (idx<50)) {
        if ((strIn.substr(0,1)==fnzAdd.i2s(function_val[idx][0])) && (strIn.substr(2,1)==fnzAdd.i2s(function_val[idx][1]))) trovato=true;
        else idx++;
    }
    return idx;
}


void writeFunctionVal(string strIn, int fullstampa=1)
{
    //scrivi a video i valori funzione
    int idx=trovaIndiceFunzione(strIn);
    //stampo
    if (idx<50) { //non dovrebbe servire
        if (fullstampa==1) {
            term.formatPrintf(fnzAdd.string2char(fnzAdd.i2s(function_val[idx][2])),50,16,10); //min
            term.formatPrintf(fnzAdd.string2char(fnzAdd.i2s(function_val[idx][5])),60,16,10); //start
            term.formatPrintf(fnzAdd.string2char(fnzAdd.i2s(function_val[idx][3])),70,16,10); //max
        }
        term.formatPrintf(fnzAdd.string2char(fnzAdd.i2s(function_val[idx][6])),70,4+funcidx,10); //valore attuale di fianco alla riga
    }
}


//********************* Led
bool Lfunc(string func, string funcnum, string param)
{
    bool errp=1;

    if (funcnum=="1") {
        if (param=="on ") {
            term.formatPrintf("Led ACCESO \n",61,p52,99,1); //p52
            ardser.printf("\nLed ACCESO \n\r");
            printDisp(dispType,"Led ACCESO \n\r");
            led.onOff(1); //Accende il led
            errp=0;
        }
        if (param=="off") {
            term.formatPrintf("Led SPENTO! \n",61,p52,99,1); //p52
            ardser.printf("\nLed SPENTO! \n\r");
            printDisp(dispType,"Led SPENTO \n\r");
            led.onOff(0); //Spegne il led
            errp=0;
        }
    }
    return errp;
}


//********************** cambio menu
bool funcfromMenu(int funcnum)
{
// funzione di load funzioni da menu scelto
    bool errp=1;
    int tempm;
    int ccmenu=0; //indice vettore funzioni selezionate
    int ccfun=0; //indice vettore funzione principale
    int contoldfun, contonewfun; //conta le voci di menu prima di sostituirlo
    string funzionen;
    string prefix; //prefisso asterisco per voci selezionate
    bool bbold=0; //postfisso bold per righe selezionate
    contoldfun=contaMenuFunc();
    //filtro vettore funzioni in base la menu
    funzionen=menu_function[ccmenu];
    while ((funzionen.substr(0,1)!="Z") && (ccmenu<=99)) {
        // confronto il primo carattere dell vettore funzioni col primo carattere del menu
        tempm=atoi(fnzAdd.string2char(funzionen.substr(0,1)));
        // se = metto il valore del vettore funzioni nel vettore funzioni scelte
        if (menuidx==tempm) {
            menu_funcChoice[ccfun]=menu_function[ccmenu];
            ccfun++;
        }
        ccmenu++;
        funzionen=menu_function[ccmenu];  //assegna la stringa del menu
    }
    menu_funcChoice[ccfun]="Z.Z"; //setto lo stop
    contonewfun=contaMenuFunc();
    // menu fatti, ora funzioni
    if (ccfun>0) { //non dovrebbe avvenire diversamente perche' 1 ci deve esere ma e' da trappare
        //azzero da dove sono in giu'
        for (int i =  contonewfun+1; i <=contoldfun ; i++) {
            term.formatPrintf(fnzAdd.string2char(fnzAdd.padstr(" ",38,' ')),41,4+i);
        }
        //scrivo dalla prima allo scelto
        funcidx=0;
        for (int i =  0; i <ccfun ; i++) {
            if (i==funcidx) {
                bbold=1;
                prefix="*";
            } else {
                bbold=0;
                prefix=" ";
            }
            term.formatPrintf(fnzAdd.string2char(prefix+menu_funcChoice[i]),41,4+i,38,bbold); //stampo funzione in bold
        }
        writeFunctionVal(menu_funcChoice[funcidx].substr(0,3)); //scrivo valore
    }

    // errp=0; //per ora non fa nulla, vedere se tenere a uso futuro
    return errp;
}

bool funcOut(string func, string sstr)
{
    //setta la funzione in uso
    bool errp=1;
    string funcc;
    int contoldfun=0; //conta le voci di menu prima di sostituirlo
    contoldfun=contaMenuFunc();
    funcc=sstr.substr(1,1);
    if ((funcc>="0") && (funcc<="9")) {
        contoldfun=fnzAdd.min(contoldfun,atoi(fnzAdd.string2char(funcc))); //assegno il minimo
        //azzero
        term.resetattrib();
        term.formatPrintf(fnzAdd.string2char(" "+menu_funcChoice[funcidx]),41,4+funcidx,38);
        // scrivo in console
        term.bold();
        funcidx=contoldfun;
        term.formatPrintf(fnzAdd.string2char("*"+menu_funcChoice[funcidx]),41,4+funcidx,38);
        term.resetattrib();
        //invio ad arduino
        //ardser.printf(fnzAdd.string2char("f"+fnzAdd.padstr(fnzAdd.i2s(trovaIndiceFunzione(menu_funcChoice[funcidx])),2,' ')+"\r")); // no, questa passa il valore dell'indice
        ardser.printf(fnzAdd.string2char("f"+funcc+"\r"));
        // scrivo valori della funzione a video
        writeFunctionVal(menu_funcChoice[funcidx].substr(0,3));
        //display
        term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("Set Funzione "+funcc+"\n")),61,p52,99,1); //p52
        printDisp(dispType,fnzAdd.string2char(fnzAdd.addEOS("Set Funzione "+funcc+"\r")));
        errp=0;
    }
    return errp;
}

bool menuOut(string func, string sstr)
{
    //setta il menu in uso
    bool errp=1;
    string funcc;
    funcc=sstr.substr(1,1);
    if ((funcc>="0") && (funcc<="9")) {
        //azzero
        term.resetattrib();
        term.formatPrintf(fnzAdd.string2char(" "+menu_main[menuidx]),1,4+menuidx,19);
        // scrivo
        term.bold();
        menuidx=atoi(fnzAdd.string2char(funcc));
        term.formatPrintf(fnzAdd.string2char("*"+menu_main[menuidx]),1,4+menuidx,19);
        term.resetattrib();
        //invio ad arduino
        ardser.printf(fnzAdd.string2char("m"+funcc+"\r"));
        //setto funzioni
        funcfromMenu(menuidx);
        //display
        term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("Set Menu "+funcc+"\n")),61,p52,99,1); //p52
        printDisp(dispType,fnzAdd.string2char(fnzAdd.addEOS("Set Menu "+funcc+"\r")));
        errp=0;
    }
    return errp;
}


//************************ Random Out
bool RfuncOut(string func,string sstr)
{
    bool errp=1;
    string funcc;
    funcc=sstr.substr(1,3);

    if (funcc=="on ") {
        term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("On")),39,p17,10,1);
        ardser.printf(fnzAdd.string2char(fnzAdd.addEOS("ron\r")));
        printDisp(dispType,"Random On \n\r");
        randomActivate=true;
    } else {
        term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("Off")),39,p17,10,1);
        ardser.printf(fnzAdd.string2char(fnzAdd.addEOS("roff\r")));
        printDisp(dispType,"Random OFF\n\r");
        randomActivate=false;
     }
    errp=0;
      return errp;
}

//************************ Sensori Out
bool sensorOut(string func,string sstr)
{
    bool errp=1;
    string funcc;
    funcc=sstr.substr(1,3);

    if (funcc=="on ") {
      //  term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("On")),39,p17,10,1); ///mettere a video!!!1
        ardser.printf(fnzAdd.string2char(fnzAdd.addEOS("son\r")));
        printDisp(dispType,"Sensor On \n\r");
        randomActivate=true;
    } else {
     //   term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("Off")),39,p17,10,1); ///mettere a video!!!1
        ardser.printf(fnzAdd.string2char(fnzAdd.addEOS("soff\r")));
        printDisp(dispType,"Sensor OFF\n\r");
        randomActivate=false;
     }
    errp=0;
      return errp;
}

//********************* Start
bool StartfuncOut()
{
    status=true;
    term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("On")),11,p16,10,1);
    term.formatPrintf("Start\n",21,p51,8,1); //p51
    term.formatPrintf("Start H-Ard\n",61,p52,99,1);   //p52
    ardser.printf("start\r");
    printDisp(dispType,"Start H-Ard\n\r");
    return 0;
}

//********************* Stop
bool StopfuncOut()
{
    status=false;
    term.formatPrintf(fnzAdd.string2char(fnzAdd.addEOS("Off")),11,p16,10,1);
    term.formatPrintf("Stop\n",21,p51,8,1); //p51
    term.formatPrintf("Stop H-Ard\n",61,p52,99,1);   //p52
    ardser.printf("stop\r");
    printDisp(dispType,"Stop H-Ard\n\r");
    return 0;
}

//********************* Plus
bool plusOut(string func, string sstr)
{
    //aumenta la funzione
    bool errp=1;
    string funcc;
    funcc=sstr.substr(1,1);

    term.formatPrintf("+\n",21,p51,8,1); //p51
    term.formatPrintf("+\n",61,p52,99,1);   //p52
    ardser.printf("+\r");
    printDisp(dispType,"Add Value\n\r");

    errp=0;
    return errp;
}

//********************* Minus
bool minusOut(string func, string sstr)
{
    //aumenta la funzione
    bool errp=1;
    string funcc;
    funcc=sstr.substr(1,1);

    term.formatPrintf("-\n",21,p51,8,1); //p51
    term.formatPrintf("-\n",61,p52,99,1);   //p52
    ardser.printf("-\r");
    printDisp(dispType,"Sub Value\n\r");

    errp=0;
    return errp;
}

/************************ IN Function *****************************/
/******************************************************************/
/******************************************************************/


//********************* Menu In
bool menuIn(string func, string sstr)
{
    bool errp=1;
    int funcn=0;
    string funcc;
    funcc=sstr.substr(3,1);

    if ((funcc>="0") && (funcc<="9")) {
        //trasformo in intero
        funcn=atoi(fnzAdd.string2char(funcc));
        menuidx=funcn;
        //assegno menu al vettore
        menu_main[funcn]=fnzAdd.addEOS(sstr.substr(3,20));
        //*** tolti in attesa di regolare la sincronizzazione
        //stampo in posizione
        ///term.formatPrintf(fnzAdd.string2char(menu_main[funcn]),2,4+funcn,38);
        //info terminale
        ///term.formatPrintf("Menu Add \n",61,p52,99,1); //p52
        //******
        //display
        printDisp(dispType,"Menu Add \n\r");
        printDisp(dispType,fnzAdd.string2char(fnzAdd.addEOS("  "+sstr.substr(0,3)+"\r")));

    }
    if (funcc=="9") {
        errp=0;
        // writeLogInput( sstr); //solo al 9 stampo il log. Ha poi senso?
    }
    return errp;
}

//********************* Function In
bool functionIn(string func, string sstr)
{
    bool errp=1;
    string funcc;
    funcc=sstr.substr(3,1);
    if (funcc!="Z") {
        //assegno menu al vettore
        menu_function[funccontidx]=fnzAdd.addEOS(sstr.substr(1,20));
        //info terminale
        term.formatPrintf("Function In \n",61,p52,99,1); //p52
        //display
        printDisp(dispType,"Function In \n\r");
        printDisp(dispType,fnzAdd.string2char(fnzAdd.addEOS("  "+sstr.substr(0,3)+"\r")));
        funccontidx++; //incremento il contatore generale delle funzioni
    } else {
        menu_function[funccontidx]="Z.Z"; //carico lo stop
        funccontidx=0; //azzero il contatore generale delle funzioni
        writeLogInput(sstr); //solo allo z stampo il log. Ha poi senso?
        //set default video
        choiceVideoSettings();
        errp=0;
    }
    return errp;
}

//********************** Parametri in ingresso
bool getParamIn(string func, string sstr)
{
    //Sintassi: gpx
    //G:costante
    //P:0-menu 1-funzione 2-onoff 3-random
    //X:valore
    bool errp=1;
    int ttype=atoi(fnzAdd.string2char(sstr.substr(1,1)));
    switch (ttype) {
        case 0: //menu
            menuOut("m", "m"+sstr.substr(2,1));
            break;
        case 1: //function
            funcOut("f", "f"+sstr.substr(2,1));
            break;
        case 2: //onoff
            if (sstr.substr(2,1)=="1") StartfuncOut();
            else  StopfuncOut();
            break;
        case 3:
            //////////// fare random!!!!
            break;
    }
    errp=0;
    return errp;
}

//********************* Start //!!!!!!!!!!da fare
bool StartfuncIn()
{
    term.formatPrintf("*\n",26,p51,8,1); //p51
    // term.formatPrintf("Start H-Ard\n",61,p52,99,1);   //p52
    // printDisp(dispType,"InStart H-Ard\n\r");
    return 1;
}

//********************* Start //!!!!!!!!!!!!!!!!da fare
bool StopfuncIn()
{
    term.formatPrintf("*\n",26,p51,8,1); //p51
    // term.formatPrintf("Start H-Ard\n",61,p52,99,1);   //p52
//  printDisp(dispType,"InStop H-Ard\n\r");
    return 1;
}

//********************* Value Functions In
bool valueIn(string sstr)
{
    /* valore funzioni in ingresso
    Formato: viimftxxxx
    v-prefisso sempre v
    ii-indice
    m-menu
    f-funzione
    t-tipo n:min, x:max, s:step, v:valstart, a:valore attuale
    xxxx-valore
    */
    bool errp=1;
    int vval=atoi(fnzAdd.string2char(sstr.substr(6,4)));
    int idx=atoi(fnzAdd.string2char(sstr.substr(1,2)));
    if (sstr.substr(0,1)=="v") {
        if (idx!=99) { //se l'indice passato e' ignoto perche' e' un update, cercalo, se un primo giro crealo
            function_val[idx][0]=atoi(fnzAdd.string2char(sstr.substr(3,1))); //MENU
            function_val[idx][1]=atoi(fnzAdd.string2char(sstr.substr(4,1))); //FUNZIONE
        } else {
            //cerca valore. Per ora facciamo cosi, poi si vede se indicizzarlo
            idx=trovaIndiceFunzione(sstr.substr(3,1)+"."+sstr.substr(4,1));
        }
        function_val[idx][2+atoi(fnzAdd.string2char(sstr.substr(5,1)))] =vval; //tipo
        if ((sstr.substr(5,1)=="4") || (status==true)) writeFunctionVal(sstr.substr(3,1)+"."+sstr.substr(4,1),0); //stampa solo il 4. da rivedere
        //errp=0;
    }
    return errp;
}

//**************************************** altre
int contaMenuFunc()
{
    //funzione che conta le voci di menu in essere
    int ret=0;
    //conta gli elemnti del vecchio menu per la cancellazione. Si potrebbe usare una variabile globale ricordando il conteggio precedente ma cosi' non dovrebbe perdere troppo tempo
    while (menu_funcChoice[ret].substr(0,1)!="Z") {
        ret++;
    }
    if (ret>0) ret--; //per rirportare indietro il contatore
    return ret;
}