Arduino cmd

#define MAX_COMMANDS 6
#define MAX_COMMAND_LENGTH 16
#define MAX_STRING_LENGTH 20
#define MAX_ARGUMENTS 2

// A konzolon átvett maximális karakter szám
const uint16_t MAX_INPUT_LENGTH = MAX_COMMAND_LENGTH + MAX_ARGUMENTS * MAX_STRING_LENGTH + MAX_ARGUMENTS + 1;

// argumentumok átadása függvényeknek
typedef char argList[MAX_ARGUMENTS][MAX_STRING_LENGTH];

// void visszatérési érték, string paraméter
typedef void ( *fptr )( byte, argList );


// egy parancs adatait tároló struktúra
typedef struct {
  // max 15 karakter hosszú parancs
  char cmd[MAX_COMMAND_LENGTH];
  // paraméter lista, hogy a súgóban ki tudja írni
  char help_params[MAX_COMMAND_LENGTH];
  // melyik függvényt kell meghívni?
  fptr handler;
} command;

// egy menüben elérhető parancsok listája
typedef struct {
  command commands[MAX_COMMANDS];
  word numberOfCommandsSet;
} menu;

// menü feltöltő segédfüggvények - char[] nem inicializálható
void init( menu* );
// menü hozzáadása
void add( menu*, const char*, const char*, fptr );
// parancs keresése és végrehajtása menüben
bool commandHandler( menu*, char*, const char*, bool );
void list( menu* );
bool list( menu*, char* );

void help( byte, argList );
void port( byte, argList );
void mode( byte, argList );
void pwm ( byte, argList );

menu myMenu;

void setup() {
  Serial.begin( 115200 );
  init( &myMenu );
  add( &myMenu, "help", "", help );
  add( &myMenu, "help", "<command>", help );
  add( &myMenu, "port", "<pin> <state>", port );
  add( &myMenu, "mode", "<pin> <mode>", mode );
  add( &myMenu, "pwm", "<pin> <k>", pwm );
  add( &myMenu, "test", "<pin> <state>", port );
}

char cmd[MAX_INPUT_LENGTH];
byte iCmd = 0;

void loop() {
  if ( Serial.available() ) {
    if ( iCmd < MAX_INPUT_LENGTH ) {
      cmd[iCmd++] = Serial.read();
    }
  }

  if ( iCmd > 0 && cmd[iCmd - 1] == '\n' ) {
    cmd[iCmd - 1] = 0;
    iCmd = 0; // új parancs beolvasása

    if ( !commandHandler( &myMenu, cmd, "Your command: ", true ) ) {
      Serial.println( "Command not found!" );
      Serial.println( "Please use help for see available commands!" );
    }

  } else if ( iCmd == MAX_INPUT_LENGTH ) {
    Serial.println( "Too long command" );
    // várakozás, amíg mindent beolvas, ne maradjon félbe a parancs
    while( Serial.read() != '\n' );
    iCmd = 0; // új parancs beolvasása
  }
}

void init( menu* m ) {
  m->numberOfCommandsSet = 0;
}

/*
 * m:     menu típusú struktúra, amelybe felveszi az adatokat
 * cmd:  a parancs hívóneve
 * type1: 1. help típus
 * type2: 2. help típus
 */
void add( menu* m, const char* cmd, const char* params, fptr h ) {
  if ( m->numberOfCommandsSet < MAX_COMMANDS ) {
    sprintf( m->commands[m->numberOfCommandsSet].cmd, "%s", cmd );
    sprintf( m->commands[m->numberOfCommandsSet].help_params, "%s", params );
    m->commands[m->numberOfCommandsSet].handler = h;
    m->numberOfCommandsSet++;
  }
}

/*
 * m:   menu, amelyikben keressük a parancsot
 * cmd: keresett parancs
 * out: parancs elé írt szöveg
 * output: írja-e vissza a parancsot a képernyőre
 */
bool commandHandler( menu* m,  char* cmd, const char* out, bool output ) {
  char command[MAX_COMMAND_LENGTH];
  char params[MAX_ARGUMENTS][MAX_STRING_LENGTH];
  byte numOfParams = 0;

  // optimalizáló blokk
  {
    // az első token a command
    char *token = strtok( cmd, " " );
    sprintf( command, "%s", token );
    if ( output ) {
      Serial.print( out ); Serial.println( command );
    }
    // a második tokentől jönnek a paraméterek
    do {
      token = strtok( NULL, " " );
      if ( token ) {
        sprintf( params[numOfParams++], "%s", token );
      }
    } while( numOfParams < MAX_ARGUMENTS && token );
  }

  // parancs keresése a parancslistában
  word i = 0;
  while ( i < m->numberOfCommandsSet && strcmp( m->commands[i].cmd, command ) != 0 ) {
    i++;
  }
  // találat
  if ( i < m->numberOfCommandsSet ) {
    m->commands[i].handler( numOfParams, params );
    return true;
  // nincs találat
  } else {
    return false;
  }
}

/*
 * Parancsok listázása m menüből
 */
void list ( menu* m ) {
  for ( int i = 0; i < m->numberOfCommandsSet; i++ ) {
    Serial.print( m->commands[i].cmd );
    Serial.print( "\t" );
    Serial.print( m->commands[i].help_params );
    Serial.println();
  }
}

/*
 * Parancsok listázása m menüből, amelyek megfelelnek cmd kritériumnak
 * azaz cmd-nek megfelelő parancsok paramétereinek listázása
 * ha több van, mindet listázza
 */
bool list ( menu* m, char* cmd ) {
  word numResult = 0;
  for ( word i = 0; i < m->numberOfCommandsSet; i++ ) {
    if ( strcmp( m->commands[i].cmd, cmd ) == 0 ) {
      numResult++;
      Serial.print( m->commands[i].cmd );
      Serial.print( "\t" );
      Serial.print( m->commands[i].help_params );
      Serial.println();
    }
  }

  if ( numResult ) return true;
  else return false;
}

/*
 * argc:  argument counter
 * argv:  argument values
 */
void help( byte argc, argList argv ) {
  if ( argc ) {
    // help <command> lett beírva
    Serial.print( "Looking for: " );
    Serial.println( argv[0] );
    if ( !list( &myMenu, argv[0] ) ) {
      Serial.println( "Command after help not found!" );
    }
  } else {
    // help lett beírva
    list( &myMenu );
  }
}

void port( byte argc, argList argv ) {
  if ( argc == 2 ) {
    // Ez jön be soros porton
    char state_cmd[][10] = {
      "high",
      "low",
    };

    // Erre kell átalakítani
    byte state_def[] = {
      HIGH,
      LOW,
    };

    int port = atoi( argv[0] );
    if ( port > 0 && port <= 13 ) {
      byte i = 0;
      const byte sizeof_state_cmd = sizeof( state_cmd ) / sizeof( state_cmd[0] );
      while( i < sizeof_state_cmd && strcmp( state_cmd[i], argv[1] ) != 0 ) i++;
      if ( i < sizeof_state_cmd ) {
        // találat
        digitalWrite( port, state_def[i] );
        Serial.print( port );
        Serial.print( " set to " );
        Serial.println( state_cmd[i] );
      } else {
        Serial.print( "Wrong state! Available states: " );
        for ( i = 0; i < sizeof_state_cmd; i++ ) {
          Serial.print( state_cmd[i] );
          if ( i < sizeof_state_cmd - 1 )
            Serial.print( "|" );
        }
        Serial.println();
      }
    } else {
      Serial.println( "Wrong port number!" );
    }
  } else {
    Serial.println( "Too few arguments" );
  }
}

void mode( byte argc, argList argv ) {
  if ( argc == 2 ) {
    // Ez jön be soros porton
    char mode_cmd[][10] = {
      "output",
      "input",
    };

    // Erre kell átalakítani
    byte mode_def[] = {
      OUTPUT,
      INPUT,
    };

    int port = atoi( argv[0] );
    if ( port > 0 && port <= 13 ) {
      byte i = 0;
      const byte sizeof_mode_cmd = sizeof( mode_cmd ) / sizeof( mode_cmd[0] );
      while( i < sizeof_mode_cmd && strcmp( mode_cmd[i], argv[1] ) != 0 ) i++;
      if ( i < sizeof_mode_cmd ) {
        // találat
        pinMode( port, mode_def[i] );
        Serial.print( port );
        Serial.print( " set to " );
        Serial.println( mode_cmd[i] );
      } else {
        Serial.print( "Wrong mode! Available modes: " );
        for ( i = 0; i < sizeof_mode_cmd; i++ ) {
          Serial.print( mode_cmd[i] );
          if ( i < sizeof_mode_cmd - 1 )
            Serial.print( "|" );
        }
        Serial.println();
      }
    } else {
      Serial.println( "Wrong port number!" );
    }
  } else {
    Serial.println( "Too few arguments" );
  }
}

void pwm( byte argc, argList argv ) {

}