ApelPro

Arduino cmd

Feb 19th, 2021
532
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #define MAX_COMMANDS 6
  2. #define MAX_COMMAND_LENGTH 16
  3. #define MAX_STRING_LENGTH 20
  4. #define MAX_ARGUMENTS 2
  5.  
  6. // A konzolon átvett maximális karakter szám
  7. const uint16_t MAX_INPUT_LENGTH = MAX_COMMAND_LENGTH + MAX_ARGUMENTS * MAX_STRING_LENGTH + MAX_ARGUMENTS + 1;
  8.  
  9. // argumentumok átadása függvényeknek
  10. typedef char argList[MAX_ARGUMENTS][MAX_STRING_LENGTH];
  11.  
  12. // void visszatérési érték, string paraméter
  13. typedef void ( *fptr )( byte, argList );
  14.  
  15.  
  16. // egy parancs adatait tároló struktúra
  17. typedef struct {
  18.   // max 15 karakter hosszú parancs
  19.   char cmd[MAX_COMMAND_LENGTH];
  20.   // paraméter lista, hogy a súgóban ki tudja írni
  21.   char help_params[MAX_COMMAND_LENGTH];
  22.   // melyik függvényt kell meghívni?
  23.   fptr handler;
  24. } command;
  25.  
  26. // egy menüben elérhető parancsok listája
  27. typedef struct {
  28.   command commands[MAX_COMMANDS];
  29.   word numberOfCommandsSet;
  30. } menu;
  31.  
  32. // menü feltöltő segédfüggvények - char[] nem inicializálható
  33. void init( menu* );
  34. // menü hozzáadása
  35. void add( menu*, const char*, const char*, fptr );
  36. // parancs keresése és végrehajtása menüben
  37. bool commandHandler( menu*, char*, const char*, bool );
  38. void list( menu* );
  39. bool list( menu*, char* );
  40.  
  41. void help( byte, argList );
  42. void port( byte, argList );
  43. void mode( byte, argList );
  44. void pwm ( byte, argList );
  45.  
  46. menu myMenu;
  47.  
  48. void setup() {
  49.   Serial.begin( 115200 );
  50.   init( &myMenu );
  51.   add( &myMenu, "help", "", help );
  52.   add( &myMenu, "help", "<command>", help );
  53.   add( &myMenu, "port", "<pin> <state>", port );
  54.   add( &myMenu, "mode", "<pin> <mode>", mode );
  55.   add( &myMenu, "pwm", "<pin> <k>", pwm );
  56.   add( &myMenu, "test", "<pin> <state>", port );
  57. }
  58.  
  59. char cmd[MAX_INPUT_LENGTH];
  60. byte iCmd = 0;
  61.  
  62. void loop() {
  63.   if ( Serial.available() ) {
  64.     if ( iCmd < MAX_INPUT_LENGTH ) {
  65.       cmd[iCmd++] = Serial.read();
  66.     }
  67.   }
  68.  
  69.   if ( iCmd > 0 && cmd[iCmd - 1] == '\n' ) {
  70.     cmd[iCmd - 1] = 0;
  71.     iCmd = 0; // új parancs beolvasása
  72.    
  73.     if ( !commandHandler( &myMenu, cmd, "Your command: ", true ) ) {
  74.       Serial.println( "Command not found!" );
  75.       Serial.println( "Please use help for see available commands!" );
  76.     }
  77.        
  78.   } else if ( iCmd == MAX_INPUT_LENGTH ) {
  79.     Serial.println( "Too long command" );
  80.     // várakozás, amíg mindent beolvas, ne maradjon félbe a parancs
  81.     while( Serial.read() != '\n' );
  82.     iCmd = 0; // új parancs beolvasása
  83.   }
  84. }
  85.  
  86. void init( menu* m ) {
  87.   m->numberOfCommandsSet = 0;
  88. }
  89.  
  90. /*
  91.  * m:     menu típusú struktúra, amelybe felveszi az adatokat
  92.  * cmd:  a parancs hívóneve
  93.  * type1: 1. help típus
  94.  * type2: 2. help típus
  95.  */
  96. void add( menu* m, const char* cmd, const char* params, fptr h ) {
  97.   if ( m->numberOfCommandsSet < MAX_COMMANDS ) {
  98.     sprintf( m->commands[m->numberOfCommandsSet].cmd, "%s", cmd );
  99.     sprintf( m->commands[m->numberOfCommandsSet].help_params, "%s", params );
  100.     m->commands[m->numberOfCommandsSet].handler = h;
  101.     m->numberOfCommandsSet++;
  102.   }
  103. }
  104.  
  105. /*
  106.  * m:   menu, amelyikben keressük a parancsot
  107.  * cmd: keresett parancs
  108.  * out: parancs elé írt szöveg
  109.  * output: írja-e vissza a parancsot a képernyőre
  110.  */
  111. bool commandHandler( menu* m,  char* cmd, const char* out, bool output ) {
  112.   char command[MAX_COMMAND_LENGTH];
  113.   char params[MAX_ARGUMENTS][MAX_STRING_LENGTH];
  114.   byte numOfParams = 0;
  115.  
  116.   // optimalizáló blokk
  117.   {
  118.     // az első token a command
  119.     char *token = strtok( cmd, " " );
  120.     sprintf( command, "%s", token );
  121.     if ( output ) {
  122.       Serial.print( out ); Serial.println( command );
  123.     }
  124.     // a második tokentől jönnek a paraméterek
  125.     do {  
  126.       token = strtok( NULL, " " );
  127.       if ( token ) {
  128.         sprintf( params[numOfParams++], "%s", token );
  129.       }
  130.     } while( numOfParams < MAX_ARGUMENTS && token );
  131.   }
  132.  
  133.   // parancs keresése a parancslistában
  134.   word i = 0;
  135.   while ( i < m->numberOfCommandsSet && strcmp( m->commands[i].cmd, command ) != 0 ) {
  136.     i++;
  137.   }
  138.   // találat
  139.   if ( i < m->numberOfCommandsSet ) {
  140.     m->commands[i].handler( numOfParams, params );
  141.     return true;
  142.   // nincs találat
  143.   } else {
  144.     return false;
  145.   }
  146. }
  147.  
  148. /*
  149.  * Parancsok listázása m menüből
  150.  */
  151. void list ( menu* m ) {
  152.   for ( int i = 0; i < m->numberOfCommandsSet; i++ ) {
  153.     Serial.print( m->commands[i].cmd );
  154.     Serial.print( "\t" );
  155.     Serial.print( m->commands[i].help_params );
  156.     Serial.println();
  157.   }
  158. }
  159.  
  160. /*
  161.  * Parancsok listázása m menüből, amelyek megfelelnek cmd kritériumnak
  162.  * azaz cmd-nek megfelelő parancsok paramétereinek listázása
  163.  * ha több van, mindet listázza
  164.  */
  165. bool list ( menu* m, char* cmd ) {
  166.   word numResult = 0;
  167.   for ( word i = 0; i < m->numberOfCommandsSet; i++ ) {
  168.     if ( strcmp( m->commands[i].cmd, cmd ) == 0 ) {
  169.       numResult++;
  170.       Serial.print( m->commands[i].cmd );
  171.       Serial.print( "\t" );
  172.       Serial.print( m->commands[i].help_params );
  173.       Serial.println();
  174.     }  
  175.   }
  176.  
  177.   if ( numResult ) return true;
  178.   else return false;
  179. }
  180.  
  181. /*
  182.  * argc:  argument counter
  183.  * argv:  argument values
  184.  */
  185. void help( byte argc, argList argv ) {
  186.   if ( argc ) {
  187.     // help <command> lett beírva
  188.     Serial.print( "Looking for: " );
  189.     Serial.println( argv[0] );
  190.     if ( !list( &myMenu, argv[0] ) ) {
  191.       Serial.println( "Command after help not found!" );
  192.     }
  193.   } else {
  194.     // help lett beírva
  195.     list( &myMenu );
  196.   }
  197. }
  198.  
  199. void port( byte argc, argList argv ) {
  200.   if ( argc == 2 ) {
  201.     // Ez jön be soros porton
  202.     char state_cmd[][10] = {
  203.       "high",
  204.       "low",
  205.     };
  206.  
  207.     // Erre kell átalakítani
  208.     byte state_def[] = {
  209.       HIGH,
  210.       LOW,
  211.     };
  212.  
  213.     int port = atoi( argv[0] );
  214.     if ( port > 0 && port <= 13 ) {
  215.       byte i = 0;
  216.       const byte sizeof_state_cmd = sizeof( state_cmd ) / sizeof( state_cmd[0] );
  217.       while( i < sizeof_state_cmd && strcmp( state_cmd[i], argv[1] ) != 0 ) i++;
  218.       if ( i < sizeof_state_cmd ) {
  219.         // találat
  220.         digitalWrite( port, state_def[i] );
  221.         Serial.print( port );
  222.         Serial.print( " set to " );
  223.         Serial.println( state_cmd[i] );
  224.       } else {
  225.         Serial.print( "Wrong state! Available states: " );
  226.         for ( i = 0; i < sizeof_state_cmd; i++ ) {
  227.           Serial.print( state_cmd[i] );
  228.           if ( i < sizeof_state_cmd - 1 )
  229.             Serial.print( "|" );
  230.         }
  231.         Serial.println();
  232.       }
  233.     } else {
  234.       Serial.println( "Wrong port number!" );
  235.     }    
  236.   } else {
  237.     Serial.println( "Too few arguments" );
  238.   }
  239. }
  240.  
  241. void mode( byte argc, argList argv ) {
  242.   if ( argc == 2 ) {
  243.     // Ez jön be soros porton
  244.     char mode_cmd[][10] = {
  245.       "output",
  246.       "input",
  247.     };
  248.    
  249.     // Erre kell átalakítani
  250.     byte mode_def[] = {
  251.       OUTPUT,
  252.       INPUT,
  253.     };
  254.  
  255.     int port = atoi( argv[0] );
  256.     if ( port > 0 && port <= 13 ) {
  257.       byte i = 0;
  258.       const byte sizeof_mode_cmd = sizeof( mode_cmd ) / sizeof( mode_cmd[0] );
  259.       while( i < sizeof_mode_cmd && strcmp( mode_cmd[i], argv[1] ) != 0 ) i++;
  260.       if ( i < sizeof_mode_cmd ) {
  261.         // találat
  262.         pinMode( port, mode_def[i] );
  263.         Serial.print( port );
  264.         Serial.print( " set to " );
  265.         Serial.println( mode_cmd[i] );
  266.       } else {
  267.         Serial.print( "Wrong mode! Available modes: " );
  268.         for ( i = 0; i < sizeof_mode_cmd; i++ ) {
  269.           Serial.print( mode_cmd[i] );
  270.           if ( i < sizeof_mode_cmd - 1 )
  271.             Serial.print( "|" );
  272.         }
  273.         Serial.println();
  274.       }
  275.     } else {
  276.       Serial.println( "Wrong port number!" );
  277.     }    
  278.   } else {
  279.     Serial.println( "Too few arguments" );
  280.   }
  281. }
  282.  
  283. void pwm( byte argc, argList argv ) {
  284.  
  285. }
  286.  
RAW Paste Data