Use 2D chars table with colomns and row names

Projects Programming
1

Hi,
For a 3-axis stepper motor Arduino Mega project, I wish to set up a 2D table holding the various motor and switches pin numbers.
I want to address the table pin values by names rather that by numbers, example:
byte Pinnumber = [Motor1][direction];
After building a test program I noticed that I can not make it work: Addressing the items by names does no bring the expected result, as can be seen in the attached code example.
The main problem seems to be passing a row name to select a raw.
Can any one suggest a remedy or a better way?
(To test run the attached, just serial send one byte of X,Y or Z ASCII (88,89, 90 dec, or 0x58, 0x59, 0x5A at 115200).
Thanks

// Test program to designate Arduino Mega pin numbers for 3-axis stepper motors and end-switches.    
    
    enum axis {X, Y, Z};
    enum function { dir, enable, steps, home, out, gnd };
    byte pin[3][6];         //Define 2D 3X6 "pin" array 

void setup(void)
{
    Serial.begin(115200);
   // Set XYZ motors pin numbers for Arduino Mega
    pin[X][gnd] =   23;
    pin[X][enable] =25;
    pin[X][dir] =   27;
    pin[X][steps] = 29;
    pin[X][home] =  14;
    pin[X][out] =   15;
    
    pin[Y][gnd] =   31;
    pin[Y][enable] =33;
    pin[Y][dir] =   35;
    pin[Y][steps] = 37;
    pin[Y][home] =  16;
    pin[Y][out] =   17;

    pin[Z][gnd] =   39;
    pin[Z][enable] =41;
    pin[Z][dir] =   43;
    pin[Z][steps] = 45;
    pin[Z][home] =  18;
    pin[Z][out] =   19;
 }
void loop()
{
 if (Serial.available())           // Send HEX ASCII of X,Y or Z  =  0x58, 0x59, 0x5A 
  {
    byte val = Serial.read();
    Serial.print(" val="); Serial.println(val);
    RunTest(val);        //88 dec = char X. 
  }
}

void RunTest(byte motor)    //ASCII of X,Y,Z 
{
  char ax = char(motor);
  Serial.print(" ax="); Serial.println(ax);                     // OK. Disp X
  Serial.print(" pin X="); Serial.println(pin[X][steps]);       // OK. Disp correct pin number
  Serial.print(" pin num="); Serial.println(pin[ax][steps]);    // Expect correct pin number ???
  digitalWrite(pin[ax][steps], ! digitalRead(pin[ax][steps]));  // Negate X steps
  Serial.print(" ax dir="); Serial.println(digitalRead(pin[ax][steps]));    // Expect 1,0,1,0
}
2

Hello

Character 'X' is not the same as the X of your axis enum, which is just a named constant with a value of 0 ( Y is 1 and Z is 2 )

What you could do however in this particular case, is to substract 'X' from the character received from Serial, so, 'X' - 'X' is 0, 'Y' - 'X' is 1 and 'Z' - 'X' is 2 .

Of course, this won't work with names from the function enum

3

you could define a STRUCTURE

struct Stepper
{
  byte gnd; // ???
  byte enable;
  byte dir;
  byte steps;
  byte home;
  byte out;
};
Stepper pin[3];


void initPin() // for usual you would initilize your variables when you create your structure
{
  pin[X].gnd =   23;
  pin[X].enable = 25;
  pin[X].dir =   27;
  pin[X].steps = 29;
  pin[X].home  =  14;
  pin[X].out  =   15;

  pin[Y].gnd  =   31;
  pin[Y].enable = 33;
  pin[Y].dir  =   35;
  pin[Y].steps  = 37;
  pin[Y].home  =  16;
  pin[Y].out  =   17;

  pin[Z].gnd =   39;
  pin[Z].enable  = 41;
  pin[Z].dir  =   43;
  pin[Z].steps  = 45;
  pin[Z].home  =  18;
  pin[Z].out =   19;
}

as I assume pins should not change during runtime I propose to make the variables const and initialize the values on global level.

I hope this makes sense for you:

enum axis {X, Y, Z};

struct Stepper
{
  const byte gnd; // ???
  const byte enable;
  const byte dir;
  const byte steps;
  const byte home;
  const byte out;
};
Stepper pin[] {
  {23, 25, 27, 29, 14, 15},
  {31, 33, 35, 37, 16, 17},
  {39, 41, 43, 45, 18, 19}
};

void setup() {
  Serial.begin(115200);
  Serial.println("started");
  Serial.flush();
}

void loop() {
  if (Serial.available() > 0)
  {
    byte c = Serial.read();
    if (c >= 'X') 
    {
      Serial.print("in "), Serial.println(c);
      runTest(c);
    }
  }
}

void runTest(byte actual)
{
  byte ax = actual - 'X'; //edited... 

  Serial.print(" ax="); Serial.println(ax);                     
  Serial.print(" pin num="); Serial.println(pin[ax].steps );    
  digitalWrite(pin[ax].steps, ! digitalRead(pin[ax].steps));
  Serial.print(" ax dir="); Serial.println(digitalRead(pin[ax].steps ));    // Expect 1,0,1,0
}

just enter X Y Z in Serial.

4

Thanks guix.
Yes, I realized the 'X' was anew one, not the one I receoved in the function, but I thought there is a way to get the original 'X'. Your suggestion is nice and I can use it. In the meantime I simply used pure numbers (0,1,2 for XYZ, similar to your suggestion).
As for the columns' names, there is no problem as they do not change in the program and I use them as they are and it runs nicely.

5

Thanks for nice reply. Same idea as guix.
As for your edit: I simply replaced the X with Z and it solves the problem.
byte ax = 'Z' - actual gives the same as your edit byte ax = actual - 'X'; //edited.