File content as of revision 6:e5f5e56ffc50:

#include <stdarg.h>
#include <ctype.h>
#include "monitor.h"
#include "ConfigFile.h"
#include "SDFileSystem.h"
#include "FATDirHandle.h"
#include "ventiel.h"

extern SDFileSystem sd;                 // definiert in main
extern Serial pc;                       // definiert in main
extern Serial com;                      // definiert in main
extern ventiel magnet;                  // definiert in main             
extern Buffer <char> buf;               // definiert in main
extern ConfigFile cfg;                  // definiert in main
extern char value[BUFSIZ];              // definiert in main
extern float soll_wert;                 // definiert in main
extern bool t_flag;                     // definiert in main
extern bool f_flag;                     // definiert in main
extern int drops;                       // definiert in main
extern int tropfperiode;                // definiert in main

#define COMMAND_MAX    14
#define COMMAND_LEN    7

const char command[COMMAND_MAX][COMMAND_LEN] = {"CYCLE","DATE","DEL","DIR","DROPS","DUMP","FILL","GO","HELP","LIST","SET","SOLL","STOPP","TIME"};

char buffer[100]; 

// globale Variablen

char com_line[COM_LINE_LEN];        // Aktuelle Eingabezeile 
uint8_t ComLinePtr, ComLineTop;     // Cursor Position und Zeilenlänge

uint8_t cr_flag;

// uint16_t status[8];

//-----------------------------------------------------------------------------
// initialisierung

void mon_init(void)
{

      uint8_t i;
      
      for (i = 0; i < COM_LINE_LEN; com_line[i++] = 0);
      ComLinePtr = ComLineTop = 0;
      cr_flag = false;
      
      // 0 Kanal ist daktiv
      // 1 Rohdaten ausgeben
      // 2 Temperaturwert in Float Darstellung
      
      /*
      status[0] = 2;  // Temperaturwerte ausgeben 
      status[1] = 0;
      status[2] = 0;
      status[3] = 0;
      status[4] = 0;
      status[5] = 0;
      status[6] = 0;
      status[7] = 0;
      */
}

//-----------------------------------------------------------------------------
// destructor

void parser (void)
{
  uint8_t i, ch, tch, top, bottom, len;
  int8_t res;

  // Zuerst wird der erste Buchstabe aus dem Eingabestring mit den ersten 
  // Buchstaben aus der Befehlstabelle verglichen                         

  bottom = 0;                                        // untere Suchgrenze 
  top = COMMAND_MAX;                                 // obere Suchgerenze 
  ch = com_line[0];                            // hole erstes Suchzeichen
  
  do 
  {
        i = (top + bottom) >> 1;    // suche in der Mitte des Feldes beginnen
        tch = command [i][0];                     // Vergleichszeichen laden 
        if (tch == ch) break;                             // Zeichen gefunden 
        if (tch > ch) top = i;                           // nach unten suchen 
        else bottom = i;                                  // nach oben suchen 
        if (bottom != 0 && top == bottom + 1) break;   // kein Buchstabe gef.
  
  } while (i > 0 && i < COMMAND_MAX - 1);

  if (tch != ch)
  {
        pc.printf("\nParser Kommando nicht gefunden\n");
        return;                              // Kommando nicht gefunden wurde 
  }
  
  // das erst Wort soll von den Übergabeparametern isoliert werden        
  
  for (i = 0; com_line[i] != ' ' &&  com_line[i] != 0; i++);
  len = i;

  
  if (i == 0) return;

  // die Übergabparameter ermitteln und in als Indexzeiger in            
  // 'ComLinePtr' abspeichern                                            

  for ( ; com_line[i] == ' ' && com_line[i] != 0; i++);
  ComLinePtr = i;
  
  // die binäre Suche nach den restlichen Zeichen wird hier fortgesetzt 

  do
  {
        i = (top + bottom) >> 1;                 // berechnen des Suchplatzes
        //printf_P (PSTR("\n\rVergleich 1 com_line = [%s] und Länge = [%d]"),com_line,len);
        //strcpy_P (temp, &command[i][0]);
        //printf_P (PSTR("\n\rVergleich 2 command[i] = [%s] und Index = [%d]"),temp,i);
        res = strncmp(com_line, &command[i][0], len);
        //printf_P (PSTR("\n\rVergleich 3 res = [%d]"),res);
        if (res == 0) break;                       // Zeichen gefunden 
        if (res > 0) 
            bottom = i;                            // nach unten suchen
        else 
            top = i;                               // nach oben suchen
        if (bottom != 0 && top == bottom + 1) break;
  
  } while (i > 0 && i < COMMAND_MAX - 1);

  
  if (res) 
  {
        pc.printf("\nParser Kommando nicht gefunden.\n");
  }
  else 
  {
        pc.printf("\nAufruf von Funktion %d",i);
        
        switch(i)                       // Programmaufruf
        {
          case  0: cycle();         break;
          case  1: date();          break;
          case  2: del();           break;
          case  3: dir();           break;
          case  4: func_drops();    break;
          case  5: dump();          break;
          case  6: fill();          break;
          case  7: go();            break;
          case  8: help();          break;
          case  9: list();          break;
          case 10: set();           break;
          case 11: soll();          break;
          case 12: stop();          break;
          case 13: time();          break;
        }                                   
  }
}



//-----------------------------------------------------------------------------
// eine Zeile aus dem Eingangsbuffer lesen 
  
void get_line(void)
{
    char ch;
    uint8_t i;
     
    get_ch();
    if (cr_flag)                            // Neue Eingabezeile  
    {
        if (com_line[0] != 0)
        {
            // uart_puts(com_line);         // zum Testen => später wird der parcer aufgerufen
            // Zeichenkette in Großbuchstaben umwandeln

            // printf_P (PSTR("\n monitor "));
            for (i = 0; com_line[i] != 0; i++)
            {
                ch = com_line[i];
                ch = toupper(ch);                          // Nur Großbuchstaben 
                com_line[i] = ch;
                // pc.printf(("\n[%02x] %c"),ch,ch);                
                if (ch == ' ') i = COM_LINE_LEN;
            }
            // pc.printf(("\n"));
            parser();                                   // Parcer wird aufgerufen
        }
 
        for (i=0; i < COM_LINE_LEN; com_line[i++] = 0);
        ComLinePtr = ComLineTop = 0;                         
        cr_flag = 0;
    }     
}

//-----------------------------------------------------------------------------
// eine Zeichen aus dem Eingangsbuffer lesen 

void get_ch (void)
{
    char ch;
  
    if (!buf.available()) return;               // kein Zeichen vorhanden 
     
    ch = buf.get();                             // hole das Zeichen  
    // printf("mon_line: %c %02x\n",ch,ch);     // nur zum Test
  
    switch(ch) 
    {
        case '\r':     // CARRIAGE RETURN  
            cr_flag = true;
            break;

        case '\n':      // LF empfangen
            cr_flag = true;
            break;

        default:                                 // Normales Zeichen  
            if (~iscntrl(ch)) 
            {
                com_line[ComLinePtr] = ch;       // Zeichen einfuegen 
                ComLinePtr++;
            }
            break;

    }   // Ende SWITCH
    
    if (ComLinePtr >= 80) cr_flag = 1;           // Zeilenüberlauf ?  
    
}

//-----------------------------------------------------------------------------
// monitor Aufruf

void date(void)
{
  pc.printf("\nin date");
}

//-----------------------------------------------------------------------------
// monitor Aufruf

void dump(void)
{
  pc.printf("\nin dump");
}

//-----------------------------------------------------------------------------
// monitor Aufruf

void help(void)
{
  pc.printf("\n -- help ------------------------");
  pc.printf("\n go [?,f,F,t,Tl] aktivieren der Heizung oder der Tropfen");
  pc.printf("\n stop [?,f,F,t,Tl] deaktivieren der Heizung oder der Tropfen");
  pc.printf("\n set index [val] Sensor auswaehlen");
  pc.printf("\n soll[val] Sollwertvorgabe fuer den Temperaturfuehler");
  pc.printf("\n cycle [val] Zeiteinheit fuer die Messung der Tropfen");
  pc.printf("\n drops [val] Anzahl der Tropfen pro Zeiteinheit");
  pc.printf("\n");
  pc.printf("\n -- files ------------------------");
  pc.printf("\n dir  >> Dateien anzeigen");  
  pc.printf("\n list name >> den Inhalte einer Datei anzeigen"); 
  pc.printf("\n del name >> eine Datei loeschen"); 
  pc.printf("\n fill name [zeilen] >> eine Datei anlegen und fuellen");        
  pc.printf("\n");
}

//-----------------------------------------------------------------------------
// monitor Aufruf

void set(void)
{
    
    int n;
    char name[20], wert[20];

    n = sscanf(&com_line[ComLinePtr],"%s %s",name,wert);
    
    switch (n)
    {
      case -1: pc.printf("\n list config file");
              
              cfg.read("/sd/input.cfg");
              
              pc.printf("\n Index >> Sonsor 0 bis 7");
              pc.printf("\n wert  >> 0 = inaktiv, 1 = Rohwerte, 2 = errechneter Wert");
              break;
      
      case 1: pc.printf("\n list config value");
              
              cfg.read("/sd/input.cfg");
              
              if (cfg.getValue(name, &value[0], sizeof(value))) 
              {
                pc.printf("\n'%s'='%s'", name, value);
              }
              break;
              
      case 2: pc.printf("\n'%s' = '%s'",name,wert);
               
              cfg.setValue(name, wert);
              cfg.write("/sd/input.cfg");
              
              break;
     } // end switch
    pc.printf("\n");
}

//-----------------------------------------------------------------------------
// monitor Aufruf soll
// mit diesem Befehl wird der Sollwert für den Temperaturfühler vorgegeben

void soll(void)
{
    
    int n;
    char wert[20];

    n = sscanf(&com_line[ComLinePtr],"%s",wert);
    
    switch (n)
    {
      case -1:  pc.printf("\nSollwert = %f",soll_wert);
                break;
        
      case 1:   
               
                cfg.setValue("soll", wert);
                cfg.write("/sd/input.cfg");
                
                soll_wert = atof(wert);
                
                pc.printf("\nneuer Sollwert = %f",soll_wert);
                
                break;
                
     } // end switch
    pc.printf("\n");
}

//-----------------------------------------------------------------------------
// monitor Aufruf cycle
// mit diesem Befehl wird die Zeit in Sekunden vorgegeben, in der die Tropfenzahl
// ausgewertet wird

void cycle(void)
{
    int n;
    char wert[20];

    n = sscanf(&com_line[ComLinePtr],"%s",wert);
    
    switch (n)
    {
      case -1:  pc.printf("\nZeit der Messung = %d Sekunden",tropfperiode);
                break;
        
      case 1:   
               
                cfg.setValue("cycle", wert);
                cfg.write("/sd/input.cfg");
                
                tropfperiode = atoi(wert);
                
                pc.printf("\nneue Zeit der Messung = %d Sekunden",tropfperiode);
                
                break;
                
     } // end switch
     
     pc.printf("\n");
}


//-----------------------------------------------------------------------------
// monitor Aufruf drops
// mit diesem Befehl wird die Anzahl der Tropfen pro Zeiteinheit vorgegeben

void func_drops(void)
{
    
    int n;
    char wert[20];

    n = sscanf(&com_line[ComLinePtr],"%s",wert);
    
    switch (n)
    {
      case -1:  pc.printf("\nAnzahl Tropfen = %d",drops);
                break;
        
      case 1:   
                cfg.setValue("drops", wert);
                cfg.write("/sd/input.cfg");
                
                drops = atoi(wert);
                
                pc.printf("\nneue Anzahl der Tropfen = %d",drops);
                
                break;
                
     } // end switch
    pc.printf("\n");
}
//-----------------------------------------------------------------------------
// monitor Aufruf go
// Wird die Heizung oder der Tropfenspender eingeschaltet.

void go(void)
{
    char ch;

    sscanf(&com_line[ComLinePtr],"%c",&ch);
    
    switch (ch)
    {

      case '1': magnet.set(0); break;
      case '2': magnet.set(1); break;
      case '3': magnet.set(2); break;
      case '4': magnet.set(3); break;
      case '5': magnet.set(4); break;
      case '6': magnet.set(5); break;
      case '7': magnet.set(6); break;
      case '8': magnet.set(7); break;
      case '9': magnet.set(8); break;
          
      case '?':
                if (t_flag) pc.printf("Temperatur aktiv");
                else        pc.printf("Temperatur inaktiv");
                
                if (f_flag) pc.printf("Tropfen freigeschaltet");
                else        pc.printf("Tropfen gesperrt");                
                
                break;  
      case 't':   
      case 'T':         
                cfg.setValue("t_flag", "1");
                cfg.write("/sd/input.cfg");
                
                t_flag = true;
                pc.printf("\nTemperatursteuerung ist aktiv");
                
                break;
 
      case 'f':   
      case 'F':         
                cfg.setValue("f_flag", "1");
                cfg.write("/sd/input.cfg");
                
                f_flag = true;
                //com.putc('1');
                magnet.set(0);
                pc.printf("\nTropfen freigeben");
                
                break;
                      
       default: pc.printf("\nBefehl go kennt nur die Zeichen ?,t,T,f,F");
                break;
                               
     } // end switch
    pc.printf("\n");
}


//-----------------------------------------------------------------------------
// monitor Aufruf stop
// Wird die Heizung oder der Tropfenspender ausgeschaltet.

void stop(void)
{
    char ch;

    sscanf(&com_line[ComLinePtr],"%c",&ch);
    
    switch (ch)
    {

      case '1': magnet.reset(0); break;
      case '2': magnet.reset(1); break;
      case '3': magnet.reset(2); break;
      case '4': magnet.reset(3); break;
      case '5': magnet.reset(4); break;
      case '6': magnet.reset(5); break;
      case '7': magnet.reset(6); break;
      case '8': magnet.reset(7); break;
      case '9': magnet.reset(8); break;
      
      case '?':
                if (t_flag) pc.printf("Temperatur aktiviert");
                else        pc.printf("Temperatur deaktiviert");
                
                if (f_flag) pc.printf("Tropfen freigeschaltet");
                else        pc.printf("Tropfen gesperrt");                
                
                break;  
      case 't':   
      case 'T':         
                cfg.setValue("t_flag", "0");
                cfg.write("/sd/input.cfg");
                
                t_flag = false;
                pc.printf("\nTemperatursteuerung ist deaktiviert");
                
                break;
 
      case 'f':   
      case 'F':         
                cfg.setValue("f_flag", "0");
                cfg.write("/sd/input.cfg");
                
                f_flag = false;
                com.putc('9');
                pc.printf("\nTropfen gesperrt");
                
                break;
                      
       default:  
                pc.printf("\nBefehl stop kennt nur die Zeichen ?,t,T,f,F '%c' %x", ch, ch);
                break;
                               
     } // end switch
     
     pc.printf("\n");
}
//-----------------------------------------------------------------------------
// monitor Aufruf

void time(void)
{
  pc.printf("\nin timer");
}

//-----------------------------------------------------------------------------
// monitor Aufruf dir
//
// weiter Infos siehe auch
// http://elm-chan.org/fsw/ff/00index_e.html
//
void dir(void)
{
    long size;

    DIR *d;
    struct dirent *p;

    d = opendir("/sd");
    if (d != NULL) 
    {
        while ((p = readdir(d)) != NULL) 
        {
            sprintf(buffer,"/sd/%s",p->d_name);
            pc.printf("\n %s", p->d_name);
            FILE * f = fopen(buffer, "r");
            fseek(f, 0, SEEK_END); // seek to end of file
            size = ftell(f);       // get current file pointer
            pc.printf("    %ld bytes ",size);            

            time_t fattime = get_fattime();
            strftime(buffer, 40, "%a,%d %m %Y.%H:%M:%S", localtime(&fattime));
            pc.printf(" %s ", buffer);

            fclose(f);
        }
        
    }
    else 
    {
        pc.printf("\nCould not open directory!\n");
    }
    closedir(d);
    
 
    FATFS* fs;
    DWORD fre_clust;
    f_getfree("0:",&fre_clust,&fs);
    const float frs = float(fs->csize)*float(fs->free_clust)
    #if _MAX_SS != 512
        *(fs->ssize);
    #else
        *512;
    #endif
    pc.printf("\n\nfree space = %f GB",frs/1073741824.0);

    pc.printf("\ndone\n");
}

//-----------------------------------------------------------------------------
// monitor Aufruf list

void list(void)
{
    char dname[25];
    int ch;
      
    sscanf(&com_line[ComLinePtr],"%s",dname);
    sprintf(buffer,"/sd/%s",dname);
    pc.printf("\nlist, file %s \n",buffer);
    FILE * fp = fopen(buffer, "r");
    if(fp == NULL) 
    {
        pc.printf("\nCould not open file for read\n\r");
        return;
    }
    
    // mit fgets werden die Zeile einzeln gelesen, wenn die Länge < 64 Zeichen ist

    while (1)                     // list src to pc  
    {
        ch = fgetc(fp);           // until src EOF read. 
        if (ch == EOF) break;
        pc.putc(ch);  
    }
    
    fclose(fp);
            
    pc.printf("\ndone\n");
}

//-----------------------------------------------------------------------------
// monitor Aufruf del

void del(void)
{
    char dname[25];
    char buffer[40];
    
    sscanf(&com_line[ComLinePtr],"%s",dname);
    sprintf(buffer,"/sd/%s",dname);
    pc.printf("\ndelete file %s",buffer);
    remove(buffer);
    pc.printf("\ndone");
}

//-----------------------------------------------------------------------------
// monitor Aufruf fill

void fill(void)
{
    char dname[25];
    char buffer[40];
    int n = 20;
    
    sscanf(&com_line[ComLinePtr],"%s %d",dname,&n);
    sprintf(buffer,"/sd/%s",dname);
    pc.printf("\nfill file %s \n",buffer);
    FILE *fp = fopen(buffer, "w");
    if(fp == NULL) 
    {
        pc.printf("Could not open file for write\n");
    }
    for (int i = 0; i<n; i++)
    {
        fprintf(fp, "\nschreibe eine Zeile %d ",i);
    }
    fclose(fp); 
    pc.printf("\ndone\n");
}