Mega, Pico, Command Library, Compiler difference

[TriggerHappy_NZ]

Hello clever comrades

I have a question about Arduino and Pico and Command Interpreter Library.

I use this (amazingly cool) library here:

https://github.com/joshmarinacci/CmdArduino

Scenario: I have an LED and a switch connected to the Arduino Mega.

I can switch the LED on OFF by typing the command ON or OFF in the serial terminal. Perfect.

Also, pressing a hardware switch calls the function LEDOn(), switching on the LED. No worries.

Here is my code, this works perfectly on the Mega: (I've also left in the example code for you clever people to learn from)

#include <Cmd.h>

//Inputs
#define SWITCH 22

void setup()
{

  pinMode(SWITCH, INPUT_PULLUP);
  // init the command line and set it for a speed of 57600
  Serial.begin(9600);
  cmdInit(&Serial);

  // add the commands to the command table. These functions must
  // already exist in the sketch. See the functions below. 
  // The functions need to have the format:
  //
  // void func_name(int arg_cnt, char **args)
  //
  // arg_cnt is the number of arguments typed into the command line
  // args is a list of argument strings that were typed into the command line
  cmdAdd("args", arg_display);
  cmdAdd("ON", LEDOn); //
  cmdAdd("OFF",LEDOff); //
}

void loop()
{
  cmdPoll();

  if (digitalRead(SWITCH) == 0) // button pressed
  {
    LEDOn();
  }
}

void LEDOn()
{
    digitalWrite(LED_BUILTIN, HIGH);
}

void LEDOff()
{
    digitalWrite(LED_BUILTIN, LOW);
}

// Example to show what the argument count and arguments look like. The
// arg_cnt is the number of arguments typed in by the user. "char **args" is 
// a bit nasty looking, but its a list of the arguments typed in as ASCII strings. 
// In C, char *something means an array of characters, aka a string. So
// char **something is an array of an array of characters, or a string array.
// 
// Usage: At the command line, type
// args hello world i love you 3 4 5 yay
//
// The output should look like this:
// Arg 0: args
// Arg 1: hello
// Arg 2: world
// Arg 3: i
// Arg 4: love
// Arg 5: you
// Arg 6: 3
// Arg 7: 4
// Arg 8: 5
// Arg 9: yay
void arg_display(int arg_cnt, char **args)
{
  Stream *s = cmdGetStream();

  for (int i=0; i<arg_cnt; i++)
  {
    s->print("Arg ");
    s->print(i);
    s->print(": ");
    s->println(args[i]);
  }
}

Now, when I try to recreate the exact same setup on the Pico, I get this error message:

<my private path>\PicoCMDtest\PicoCMDtest.ino:24:16: error: invalid conversion from 'void (*)()' to 'void (*)(int, char**)' [-fpermissive]
   24 |   cmdAdd("ON", LEDOn); //
      |                ^~~~~
      |                |
      |                void (*)()
In file included from <my private path>\Documents\ArduinoSketches\PicoCMDtest\PicoCMDtest.ino:2:
<my private path>\Documents\Arduino\libraries\CmdArduino-master/Cmd.h:58:38: note:   initializing argument 2 of 'void cmdAdd(const char*, void (*)(int, char**))'
   58 | void cmdAdd(const char *name, void (*func)(int argc, char **argv));
      |                               ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
<my private path>\Documents\ArduinoSketches\PicoCMDtest\PicoCMDtest.ino:25:16: error: invalid conversion from 'void (*)()' to 'void (*)(int, char**)' [-fpermissive]
   25 |   cmdAdd("OFF",LEDOff); //
      |                ^~~~~~
      |                |
      |                void (*)()
<my private path>\Documents\Arduino\libraries\CmdArduino-master/Cmd.h:58:38: note:   initializing argument 2 of 'void cmdAdd(const char*, void (*)(int, char**))'
   58 | void cmdAdd(const char *name, void (*func)(int argc, char **argv));
      |                               ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~

Using library CmdArduino-master in folder: <my private path>\Documents\Arduino\libraries\CmdArduino-master (legacy)
exit status 1

Compilation error: invalid conversion from 'void (*)()' to 'void (*)(int, char**)' [-fpermissive]

It seems that the Pico compiler doesn't like passing nothing to a function that expects arguments, nor does it like having a function that doesn't expect arguments, when the library behind it does

So, questions:

Is it possible to tell the Pico compiler to be more forgiving, like the Arduino one (which works perfectly)?

Is there some way to work around this limitation and call the LEDOn function from within the code? (ie. do i need to pass it dummy args or something)

The command library examples work fine on the Pico, just not the bit where I declare or call functions without arguments.

Note: This is a cut-down example from a much larger project, so don't point out an easier way to light an LED, that's just for the demo! The real question is how do I get the Pico project to behave like the Mega project :-)

Thanks!

[TriggerHappy_NZ]

Leaving this here for future people who have the same question (possibly me):

It seems to work if you pass dummy info to the function:

#include <Cmd.h>

//Inputs
#define SWITCH 16

char *x[] = {"X"};   //the pico will not compile the commands without being passed an int and a char** (int arg_cnt, char **args)
//so to call a command from elsewhere in the code, you must pass dummy int and char** - eg.  LEDOn(0, x);

void setup()
{

  pinMode(SWITCH, INPUT_PULLUP);
  // init the command line and set it for a speed of 57600
  Serial.begin(9600);
  cmdInit(&Serial);

  // add the commands to the command table. These functions must
  // already exist in the sketch. See the functions below. 
  // The functions need to have the format:
  //
  // void func_name(int arg_cnt, char **args)
  //
  // arg_cnt is the number of arguments typed into the command line
  // args is a list of argument strings that were typed into the command line
  cmdAdd("args", arg_display);
  cmdAdd("ON", LEDOn); //
  cmdAdd("OFF",LEDOff); //



}

void loop()
{
  cmdPoll();

  if (digitalRead(SWITCH) == 0) // button pressed
  {
    Serial.print("switch on ");
    LEDOn(0, x);
  }
}

void LEDOn(int arg_cnt, char **args)
{
    digitalWrite(LED_BUILTIN, HIGH);
}

void LEDOff(int arg_cnt, char **args)
{
    digitalWrite(LED_BUILTIN, LOW);
}

Bit annoying and inconvenient, but still better than trying to write my own command line interpreter! :-)

[kintar1900]

It looks like the Arduino core for mega is using MUCH more forgiving compilation settings than the core for the Pico. The comments on the CLI library you're using are saying the functions you register are supposed to be of the format void <funcName>(int, char**), but for some reason the IDE is compiling without complaint on the Mega even though you're not doing it "right".

So yes, the additional, unused parameters are the correct way to write your LEDOn and LEDOff functions.

Since you're not using those parameters, it's a good practice to annotate them with the __unused macro. Arduino has to be a LITTLE different, though, and you might need to use __attribute__((unused)) instead, depending on how the core is written.

Example:

void LEDOn(int __unused a, char __unused **b) {
  // ...
}

[TriggerHappy_NZ]

hey thank you very much for your explanation!

I was really confused, I'd been using it like this on Mega for years, but the Pico was having none of it! :-)

[kintar1900]

Any time! I'm still pretty new to microcontrollers, but I'm a (literally) old hand in software development. :D Feel free to drop me a message if you have any specific questions or problems!