First working pipe implementation.

Author: dani007200964

examples/Commander_simple_stream_pipe/Commander_simple_stream_pipe.ino

@@ -0,0 +1,255 @@
+/*
+ * Created on Oct. 2 2020
+ *
+ * Copyright (c) 2020 - Daniel Hajnal
+ * [email protected]
+ * This file is part of the Shellminator project.
+ * Modified 2022.10.02
+ *
+*/
+
+#include <WiFi.h>
+#include "esp_wifi.h"
+
+#include "Shellminator.hpp"
+#include "Shellminator-IO.hpp"
+
+// Necessary includes
+#include "Commander-API.hpp"
+#include "Commander-IO.hpp"
+
+#define SERVER_PORT 23
+
+// WiFi credentials.
+const char* ssid     = "WIFI_SSID";
+const char* password = "WIFI_PASS";
+
+// Create an instance of the server.
+// It will be available on port 23.
+WiFiServer server( SERVER_PORT );
+
+// Create a Shellminator object, and initialize it to use WiFiServer
+Shellminator shell( &server );
+
+const char logo[] =
+
+"   _____ __         ____          _             __            \r\n"
+"  / ___// /_  ___  / / /___ ___  (_)___  ____ _/ /_____  _____\r\n"
+"  \\__ \\/ __ \\/ _ \\/ / / __ `__ \\/ / __ \\/ __ `/ __/ __ \\/ ___/\r\n"
+" ___/ / / / /  __/ / / / / / / / / / / / /_/ / /_/ /_/ / /    \r\n"
+"/____/_/ /_/\\___/_/_/_/ /_/ /_/_/_/ /_/\\__,_/\\__/\\____/_/     \r\n"
+"                                                              \r\n"
+;
+
+// We have to create an object from Commander class.
+Commander commander;
+
+// We have to create the prototype functions for our commands.
+// The arguments has to be the same for all command functions.
+void cat_func( char *args, Stream *response );
+void dog_func( char *args, Stream *response );
+void sum_func( char *args, Stream *response );
+void led_func( char *args, Stream *response );
+void ledPWM_func( char *args, Stream *response );
+void random_func( char *args, Stream *response );
+
+// Commander API-tree
+Commander::API_t API_tree[] = {
+    apiElement( "cat", "Description for cat command.", cat_func ),
+    apiElement( "dog", "Description for dog command.", dog_func ),
+    apiElement( "led", "Toggle the buit-in LED.", led_func ),
+    apiElement( "sum", "This function sums two number from the argument list.", sum_func ),
+    apiElement( "ledPWM", "Set the brightness of the LED", ledPWM_func ),
+    apiElement( "random", "Generate a random number between the arguments.", random_func )
+};
+
+void setup() {
+
+  // Initialize Serial with 115200 baudrate.
+  Serial.begin( 115200 );
+
+  // If you using Atmega32U4, the code will wait, until
+  // you open the serial port.
+  while( !Serial );
+
+  // Clear the terminal
+  shell.clear();
+
+  // Attach the logo.
+  shell.attachLogo( logo );
+
+  // Print start message
+  Serial.println( "Program begin..." );
+
+  // WiFi configuration section
+  Serial.print( "Connect to  WiFi: " );
+  Serial.print( ssid );
+
+  WiFi.mode( WIFI_STA );
+  WiFi.setSleep(WIFI_PS_NONE);
+  WiFi.begin( ssid, password );
+
+  while( WiFi.status() != WL_CONNECTED ){
+
+    delay( 1000 );
+    Serial.print( "." );
+
+  }
+
+  shell.beginServer();
+
+  Serial.println( " [ OK ]" );
+
+  Serial.println( "Connected!" );
+  Serial.print( "Device IP: " );
+  Serial.print( WiFi.localIP() );
+  Serial.print( " at port: " );
+  Serial.println( SERVER_PORT );
+
+
+  // There is an option to attach a debug channel to Commander.
+  // It can be handy to find any problems during the initialization
+  // phase. In this example we will use Serial for this.
+  commander.attachDebugChannel( &Serial );
+
+  // At start, Commander does not know anything about our commands.
+  // We have to attach the API_tree array from the previous steps
+  // to Commander to work properly.
+  commander.attachTree( API_tree );
+
+  // Initialize Commander.
+  commander.init();
+
+  shell.attachCommander( &commander );
+
+  // initialize shell object.
+  shell.begin( "arnold" );
+
+}
+
+void loop() {
+
+  shell.update();
+
+}
+
+/// This is an example function for the cat command
+void cat_func(char *args, Stream *response )
+{
+
+  response -> print("Hello from cat function!\r\n");
+
+}
+
+/// This is an example function for the dog command
+void dog_func(char *args, Stream *response )
+{
+
+  response -> print("Hello from dog function!\r\n");
+
+}
+
+/// This is an example function for the led command
+void led_func(char *args, Stream *response )
+{
+
+  // Toggle your LED pin here, if you have on your board
+  // digitalWrite( LED_PIN, !digitalRead( LED_PIN ) );
+  response -> print("LED toggle!\r\n");
+
+}
+
+/// This is an example function for the sum command
+void sum_func(char *args, Stream *response )
+{
+
+  // These variables will hold the value of the
+  // two numbers, that has to be summed.
+  int a = 0;
+  int b = 0;
+
+  // This variable will hold the result of the
+  // argument parser.
+  int argResult;
+
+  // This variable will hold the sum result.
+  int sum = 0;
+
+  argResult = sscanf( args, "%d %d", &a, &b );
+
+  // We have to check that we parsed successfully  the two
+  // numbers from the argument string.
+  if( argResult != 2 ){
+
+    // If we could not parse two numbers, we have an argument problem.
+    // We print out the problem to the response channel.
+    response -> print( "Argument error! Two numbers required, separated with a blank space.\r\n" );
+
+    // Sadly we have to stop the command execution and return.
+    return;
+
+  }
+
+  // Calculate the sum.
+  sum = a + b;
+
+  // Print out the result.
+  response -> print( a );
+  response -> print( " + " );
+  response -> print( b );
+  response -> print( " = " );
+  response -> println( sum );
+
+}
+
+void ledPWM_func(char *args, Stream *response ){
+
+  int pwm = 0;
+
+  int argResult;
+
+  argResult = sscanf( args, "%d", &pwm );
+
+  if( argResult != 1 ){
+
+    response -> print( "Argument error!" );
+
+    // Sadly we have to stop the command execution and return.
+    return;
+
+  }
+
+  if( pwm > 100 ){
+    pwm = 100;
+  }
+
+  if( pwm < 0 ){
+    pwm = 0;
+  }
+
+  response -> print( "New PWM value: " );
+  response -> print( pwm );
+
+}
+
+void random_func(char *args, Stream *response ){
+
+  int minVal;
+  int maxVal;
+
+  int argResult;
+
+  argResult = sscanf( args, "%d %d", &minVal, &maxVal );
+
+  if( argResult != 2 ){
+
+    response -> print( "Argument error!" );
+
+    // Sadly we have to stop the command execution and return.
+    return;
+
+  }
+
+  response -> print( random( minVal, maxVal ) );
+
+}

src/Commander-API.cpp

@@ -299,6 +299,8 @@ void Commander::executeCommand( char *cmd ){
 
 	int32_t pipePos;
 
+	uint32_t i;
+
 	// Copy the command data to the internal buffer.
 	// It is necessary because we have to modify the content
 	// of it. If it is points to a const char array we will
@@ -307,6 +309,13 @@ void Commander::executeCommand( char *cmd ){
 
 	pipePos = hasChar( tempBuff, '|' );
 
+	if( pipePos >= 0 ){
+
+		// Terminate where pip is found.
+		tempBuff[ pipePos ] = '\0';
+
+	}
+
 	// tempBuff is the address of the first character of the incoming command.
 	// If we give arg variable the value stored in tempBuff means arg will point to
 	// the first character of the command as well.
@@ -344,13 +353,6 @@ void Commander::executeCommand( char *cmd ){
 
 	}
 
-	else if( *arg == '|' ){
-
-		*arg = '\0';
-		arg++;
-
-	}
-
 	// Try to find the command datata.
 	commandData_ptr = (*this)[ tempBuff ];
 
@@ -392,16 +394,66 @@ void Commander::executeCommand( char *cmd ){
 		// If show_description flag is not set, than we have to execute the commands function.
 		else{
 
+			// TODO if the pipe buffer has data, the arg has to be replaced with that.
+			if( pipeChannel.available() > 0 ){
+
+				// pipeChannel.readBytesUntil( '\0', pipeArgBuffer, COMMANDER_MAX_COMMAND_SIZE );
+
+				i = 0;
+
+				while( pipeChannel.available() ){
+
+					if( i < COMMANDER_MAX_COMMAND_SIZE ){
+
+						pipeArgBuffer[ i ] = pipeChannel.read();
+
+					}
+
+					else{
+
+						pipeChannel.read();
+
+					}
+
+					i++;
+
+				}
+
+				if( i < COMMANDER_MAX_COMMAND_SIZE ){
+
+					pipeArgBuffer[ i ] = '\0';
+
+				}
+
+				pipeArgBuffer[ COMMANDER_MAX_COMMAND_SIZE - 1 ] = '\0';
+
+				arg = pipeArgBuffer;
+
+			}
+
 			if( pipePos > 0 ){
 
-				// TODO Switch response to internal buffer.
+				// Execute commands function and redirect the output to pipe.
+				(commandData_ptr -> func)( arg, &pipeChannel );
+
+			}
+
+			else{
+
+				(commandData_ptr -> func)( arg, response );
 
 			}
 
-			// TODO if the internal buffer has data, the arg has to be replaced to that.
+			if( pipePos > 0 ){
+
+				// To remowe whitespace from the new command begin.
+				while( tempBuff[ pipePos + 1 ] == ' ' ){
+					pipePos++;
+				}
+
+				executeCommand( &tempBuff[ pipePos + 1 ] );
 
-			// Execute commands function.
-			(commandData_ptr -> func)( arg, response );
+			}
 
 		}
 
@@ -444,6 +496,13 @@ void Commander::executeCommand( char *cmd ){
 
 		#endif
 
+		// Clear the pipe at error.
+		while( pipeChannel.available() ){
+
+			pipeChannel.read();
+
+		}
+
 	}
 
 }

src/Commander-API.hpp

@@ -310,7 +310,8 @@ class Commander{
 
 	int32_t hasChar( char* str, char c );
 
-	char pipeBuffer[COMMANDER_MAX_COMMAND_SIZE];
+	commanderPipeChannel pipeChannel;
+	char pipeArgBuffer[ COMMANDER_MAX_COMMAND_SIZE ];
 
 };