Need help in doing multiple operations with multiple inputs simultaneously

hi I am working on a project where I send data input from my Raspberry Pi to Arduino via Serial communication. I want to control different solenoid at different type based on the user input simultaneously I have managed to get the input from Raspberry Pi and now I am stuck in Arduino code please help me with it. here is the Arduino code.

#include <textparser.h>

TextParser parser(",");  // Delimiter is a comma followed by a space.
int pul, From_Solenoid, To_Solenoid, Delay;

#undef MyHW
#ifdef MyHW
int pulse  = 9;
int step   = 10;
int direct = 11;
int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
unsigned long interval=0;
#else
int pulse  = 9;
int step   = 10;
int direct = 11;
int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
unsigned long interval=0;
#endif


char inc;

enum { Off = LOW, On = HIGH };

unsigned long msecPump;
unsigned long msec;

// -----------------------------------------------------------------------------
void setup () {
    Serial.begin (9600);

    analogWrite (pulse,  0);
    digitalWrite (step,   Off);
    digitalWrite (direct, Off);
    digitalWrite (s1,    Off);
    digitalWrite (s2,    Off);
    digitalWrite (s3,    Off);
    digitalWrite (s4,    Off);
    digitalWrite (s5,    Off);
    digitalWrite (s6,    Off);
    digitalWrite (s7,    Off);
    digitalWrite (s8,    Off);

    digitalWrite (c1,    Off);
    digitalWrite (c2,    Off);
    digitalWrite (c3,    Off);
    digitalWrite (c4,    Off);
    digitalWrite (c5,    Off);
    digitalWrite (c6,    Off);

    pinMode (pulse,  OUTPUT);
    pinMode (step,   OUTPUT);
    pinMode (direct, OUTPUT);
    pinMode (s1,    OUTPUT);
    pinMode (s2,    OUTPUT);
    pinMode (s3,    OUTPUT);
    pinMode (s4,    OUTPUT);
    pinMode (s5,    OUTPUT);
    pinMode (s6,    OUTPUT);
    pinMode (s7,    OUTPUT);
    pinMode (s8,    OUTPUT);

    pinMode (c1,    OUTPUT);
    pinMode (c2,    OUTPUT);
    pinMode (c3,    OUTPUT);
    pinMode (c4,    OUTPUT);
    pinMode (c5,    OUTPUT);
    pinMode (c6,    OUTPUT);
}
// -------------------------PUMP-Functions-----------------------------pul----------------------
void pump1 ()
{
    if (On == digitalRead (direct) && (msec - msecPump) >= interval)  {
        digitalWrite (step,   Off);
        digitalWrite (direct, Off);
        analogWrite  (pulse,  0);
    }
}
// -------------------------SOLENOID-line-1-Functions-------------------From-Solenoid--------------------------------
void solenoid1 ()
{
    if (On == digitalRead (s1) && (msec - msecPump) >= interval)  {
        digitalWrite (s1, Off);
    }
}
void solenoid2 ()
{
    if (On == digitalRead (s2) && (msec - msecPump) >= interval)  {
        digitalWrite (s2, Off);
    }
}
void solenoid3 ()
{
    if (On == digitalRead (s3) && (msec - msecPump) >= interval)  {
        digitalWrite (s3, Off);
    }
}
void solenoid4 ()
{
    if (On == digitalRead (s4) && (msec - msecPump) >= interval)  {
        digitalWrite (s4, Off);
    }
}
void solenoid5 ()
{
    if (On == digitalRead (s5) && (msec - msecPump) >= interval)  {
        digitalWrite (s5, Off);
    }
}
void solenoid6 ()
{
    if (On == digitalRead (s6) && (msec - msecPump) >= interval)  {
        digitalWrite (s6, Off);
    }
}
void solenoid7 ()
{
    if (On == digitalRead (s7) && (msec - msecPump) >= interval)  {
        digitalWrite (s7, Off);
    }
}
void solenoid8 ()
{
    if (On == digitalRead (s8) && (msec - msecPump) >= interval)  {
        digitalWrite (s8, Off);
    }
}
// ------------------------C-SOLENOID--Functions-----------------To-Solenoid----------------------------------
void solenoidc1 ()
{
    if (On == digitalRead (c1) && (msec - msecPump) >= interval)  {
        digitalWrite (c1, Off);
    }
}
void solenoidc2 ()
{
    if (On == digitalRead (c2) && (msec - msecPump) >= interval)  {
        digitalWrite (c2, Off);
    }
}
void solenoidc3 ()
{
    if (On == digitalRead (c3) && (msec - msecPump) >= interval)  {
        digitalWrite (c3, Off);
    }
}
void solenoidc4 ()
{
    if (On == digitalRead (c4) && (msec - msecPump) >= interval)  {
        digitalWrite (c4, Off);
    }
}
void solenoidc5 ()
{
    if (On == digitalRead (c5) && (msec - msecPump) >= interval)  {
        digitalWrite (c5, Off);
    }
}
void solenoidc6 ()
{
    if (On == digitalRead (c6) && (msec - msecPump) >= interval)  {
        digitalWrite (c6, Off);
    }
}
// --------------------------------MAIN LOOP---------------------------------------------
void loop () {
   msec = millis ();

    pump1 ();
     
    solenoid1 ();
    solenoid2 ();
    solenoid3 ();
    solenoid4 ();
    solenoid5 ();
    solenoid6 ();
    solenoid7 ();
    solenoid8 ();

    solenoidc1 ();
    solenoidc2 ();
    solenoidc3 ();
    solenoidc4 ();
    solenoidc5 ();
    solenoidc6 ();


   if(Serial.available()>0){
    char line[80];
    //Assume `line` is of the form "255,2,3,1(in min)\n".
   Serial.readBytesUntil('\n', line, sizeof(line));
   parser.parseLine(line, pul, From_Solenoid, To_Solenoid, Delay); // pul=pwm value, 
        
    interval=Delay;
    
        switch (inc){
        case 'a':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s1, On);
            digitalWrite (c1, On);
            msecPump = msec;
            break;
        case 'b':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s2, On);
            digitalWrite (c2, On);
            msecPump = msec;
            break;
        case 'c':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s3, On);
            digitalWrite (c3, On);
            msecPump = msec;
            break;
        case 'd':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s4, On);
            digitalWrite (c4, On);
            msecPump = msec;
            break;
        case 'e':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s5, On);
            digitalWrite (c5, On);
            msecPump = msec;
            break;
        case 'f':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s6, On);
            digitalWrite (c6, On);
            msecPump = msec;
            break;
        case 'g':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s7, On);
            msecPump = msec;
            break;
        case 'h':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s8, On);
            msecPump = msec;
            break;
        }}}

Please study this...

after reading about arrays:

F1: Please describe exactly what you receive from the Raspberry as "telegram" is it just one character like 'a' for one solenoid ?

F2: under which condition will you change the value of

analogWrite  (pulse,  255);

?

Actually that switch case is just a random program I was just checking whether serial communication is working perfectly or not by giving some random inputs like a,b,c... PWM value should change every time considering users input

Besides arrays, I don't suggest you to use this approach to read from serial:

   if(Serial.available()>0){
    char line[80];
    //Assume `line` is of the form "255,2,3,1(in min)\n".
   Serial.readBytesUntil('\n', line, sizeof(line));

because readBytesUntil() stops executing until the terminator is read (and discarded from the resultimg buffer), the maximum number of bytes have been recevied (even if without receiving the terminator), or a timeout.
EDIT: I mean the program stops executing any other task while waiting for the terminator char, and it isn't usually a good thing.

You better store received characters one by one, and parse the result at the end (i.e. the terminator has been received):

// Put this as global
char line[80];
// Pointer to next buffer position
byte ptr = 0;
...
   if(Serial.available()){
     char c = Serial.read();
     if (c == '\n') { 
       // Process the line
       //Assume `line` is of the form "255,2,3,1(in min)\n".
       parser.parseLine(line, pul, From_Solenoid, To_Solenoid, Delay); // pul=pwm value
       ptr = 0; // Reset pointer
       line[0] = '\0'; // Clear string
       ... process the data...
     }
     else {
       // Store the new char into line buffer
       line[ptr++] = c;
       line[ptr] = '\0'; // String terminator
     }

And where are you stuck with this code?
Is it works as expected or not?
If not - what is works wrong?

This is the working code which display's the user's input. I want to use that data and run my solenoids and pump

#include <textparser.h>

TextParser parser(", ");  // Delimiter is a comma followed by a space.
int pulse, From_Solenoid, To_Solenoid, Delay;

void loop() {
  char line[80];

  // Assume `line` is of the form "1, 2, 3, 4\n".
  Serial.readBytesUntil('\n', line, sizeof(line));
  parser.parseLine(line, pulse, From_Solenoid, To_Solenoid, Delay);
  Serial.println(pulse);
  Serial.println(From_Solenoid);
  Serial.println(To_Solenoid);
  Serial.println(Delay); 
}

This is the second program which runs pump and solenoid without delay I am trying to combine both the programs and control the solenoid, delay , pwm speed etc on the user's given input.
Here is the second program

little bit more that arrays

consider
added logic to turn pump off when all solenoids closeds

struct Pump {
    byte            pinS;
    byte            pinC;
    char            cmd;
    const char     *desc;
    byte            on;
    unsigned long   msecLst;
    unsigned long   interval;
};

#undef MyHW
#ifdef MyHW
int pulse  = 2;
int step   = 3;
int direct = 13;

Pump pumps [] = {
    { 10, 11, 'a', "pump1" },
    { 12,  0, 'b', "pump2" },
};

enum { Off = HIGH, On = LOW };

#else
#include <textparser.h>
TextParser parser(",");  // Delimiter is a comma followed by a space.

int pulse  = 9;
int step   = 10;
int direct = 11;

Pump pumps [] = {
    { 22, 31, 'a', "pump1" },
    { 23, 32, 'b', "pump2" },
    { 24, 33, 'c', "pump3" },
    { 25, 34, 'd', "pump4" },
    { 26, 35, 'e', "pump5" },
    { 27,  0, 'f', "pump6" },
    { 28,  0, 'g', "pump7" },
    { 19,  0, 'h', "pump8" },
};

int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;

enum { Off = LOW, On = HIGH };
#endif

const unsigned N_PUMP = sizeof(pumps) / sizeof(Pump);
Pump *p;

int pul, From_Solenoid, To_Solenoid, Delay;

unsigned long msecPump;
unsigned long msec;

// -----------------------------------------------------------------------------
void setup () {
    Serial.begin (9600);

    analogWrite  (pulse,  0);

    digitalWrite (step,   Off);
    pinMode      (step,   OUTPUT);

    digitalWrite (direct, Off);
    pinMode      (direct, OUTPUT);

    p = pumps;
    for (unsigned n = 0; n < N_PUMP; n++, p++)  {
        digitalWrite (p->pinS, Off);
        pinMode      (p->pinS, OUTPUT);

        digitalWrite (p->pinC, Off);
        pinMode      (p->pinC, OUTPUT);
    }
}

// -----------------------------------------------------------------------------
void
pumpOff (
    Pump *p )
{
    if (p->pinS)
        digitalWrite (p->pinS, Off);
    if (p->pinC)
        digitalWrite (p->pinC, Off);
    p->on      = false;

    Serial.print   (p->desc);
    Serial.println (" off");

    bool allOff = true;
    p = pumps;
    for (unsigned n = 0; n < N_PUMP; n++, p++)  {
        if (p->on)
            allOff = false;
    }

    if (allOff)  {
        digitalWrite (step,   Off);
        digitalWrite (direct, Off);
        analogWrite  (pulse,  0);
    }
}

// -----------------------------------------------------------------------------
void
pumpOn (
    Pump *p,
    int   msecTime )
{
    p->interval = msecTime;
    p->on       = true;

    digitalWrite (direct, On);
    analogWrite  (pulse,  255);
    digitalWrite (step,   On);

    if (p->pinS)
        digitalWrite (p->pinS, On);
    if (p->pinC)
        digitalWrite (p->pinC, On);

    p->on      = true;
    p->msecLst = msec;

    Serial.print   (p->desc);
    Serial.println (" on");
}

// --------------------------------MAIN LOOP------------------------------------
void loop ()
{
    msec = millis ();

    p = pumps;
    for (unsigned n = 0; n < N_PUMP; n++, p++)  {
        if (p->on)  {
            if ( (msec - p->msecLst) >= p->interval)
                pumpOff (p);
        }
    }

    if (Serial.available()) {
#ifdef MyHW
        char inc = Serial.read ();
        Delay    = 1000;
#else
        char line[80];
        //Assume `line` is of the form "255,2,3,1(in min)\n".
        Serial.readBytesUntil('\n', line, sizeof(line));
        parser.parseLine(line, pul, From_Solenoid, To_Solenoid, Delay);
#endif

        p = pumps;
        for (unsigned n = 0; n < N_PUMP; n++, p++)  {
            if (p->cmd == inc)  {
                pumpOn (p, Delay);
            }
        }
    }
}

Haha, understatement of the day.

a7

Sorry for the late reply, the code is not working even after giving the input ex: 255,2,3,1
I also want to manipulate pulse. :grimacing:

from raspberry pi I will be receiving (pulse value , from solenoid number (from 1-8), to solenoid number(1-6), delay(in min). pulse value will change every time based on the input.

the code works good when ever given any input ex: a,b,c... it executes every commands. But now I want to manipulate pulse and solenoid numbers too. from raspberry pi I will be sending (pulse value , from solenoid number (from 1-8), to solenoid number(1-6), delay(in min). I want to change pulse value every time based on the input. Also I want to add one more pump and it should be running simultaneously.

I tried running 2 pumps with the previous code and it works.

#undef MyHW
#ifdef MyHW
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;
int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
unsigned long intervalSol1  = 3000;
unsigned long intervalPump = 6000;
unsigned long intervalSol2  = 3000;
unsigned long intervalPump1 = 6000;

#else
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;
int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
unsigned long intervalSol1  = 3000;
unsigned long intervalPump = 6000;
unsigned long intervalSol2  = 3000;
unsigned long intervalPump1 = 6000;
#endif


char inc;

enum { Off = LOW, On = HIGH };

unsigned long msecSol1;
unsigned long msecSol2;
unsigned long msecPump;
unsigned long msecPump1;
unsigned long msec;
unsigned long msec1;

// -----------------------------------------------------------------------------
void setup () {
    Serial.begin (9600);

    analogWrite (pulse,  0);
    digitalWrite (step,   Off);
    digitalWrite (direct, Off);
    analogWrite (pulse1,  0);
    digitalWrite (step1,   Off);
    digitalWrite (direct1, Off);
    digitalWrite (s1,    Off);
    digitalWrite (s2,    Off);
    digitalWrite (s3,    Off);
    digitalWrite (s4,    Off);
    digitalWrite (s5,    Off);
    digitalWrite (s6,    Off);
    digitalWrite (s7,    Off);
    digitalWrite (s8,    Off);

    digitalWrite (c1,    Off);
    digitalWrite (c2,    Off);
    digitalWrite (c3,    Off);
    digitalWrite (c4,    Off);
    digitalWrite (c5,    Off);
    digitalWrite (c6,    Off);

    digitalWrite (s11,    Off);
    digitalWrite (s22,    Off);
    digitalWrite (s33,    Off);
    digitalWrite (s44,    Off);
    digitalWrite (s55,    Off);
    digitalWrite (s66,    Off);
    digitalWrite (s77,    Off);
    digitalWrite (s88,    Off);

    digitalWrite (c11,    Off);
    digitalWrite (c22,    Off);
    digitalWrite (c33,    Off);
    digitalWrite (c44,    Off);
    digitalWrite (c55,    Off);
    digitalWrite (c66,    Off);

    pinMode (pulse,  OUTPUT);
    pinMode (step,   OUTPUT);
    pinMode (direct, OUTPUT);
    pinMode (pulse1,  OUTPUT);
    pinMode (step1,   OUTPUT);
    pinMode (direct1, OUTPUT);
    pinMode (s1,    OUTPUT);
    pinMode (s2,    OUTPUT);
    pinMode (s3,    OUTPUT);
    pinMode (s4,    OUTPUT);
    pinMode (s5,    OUTPUT);
    pinMode (s6,    OUTPUT);
    pinMode (s7,    OUTPUT);
    pinMode (s8,    OUTPUT);

    pinMode (c1,    OUTPUT);
    pinMode (c2,    OUTPUT);
    pinMode (c3,    OUTPUT);
    pinMode (c4,    OUTPUT);
    pinMode (c5,    OUTPUT);
    pinMode (c6,    OUTPUT);

    pinMode (s11,    OUTPUT);
    pinMode (s22,    OUTPUT);
    pinMode (s33,    OUTPUT);
    pinMode (s44,    OUTPUT);
    pinMode (s55,    OUTPUT);
    pinMode (s66,    OUTPUT);
    pinMode (s77,    OUTPUT);
    pinMode (s88,    OUTPUT);

    pinMode (c11,    OUTPUT);
    pinMode (c22,    OUTPUT);
    pinMode (c33,    OUTPUT);
    pinMode (c44,    OUTPUT);
    pinMode (c55,    OUTPUT);
    pinMode (c66,    OUTPUT);
}

// -------------------------PUMP-Functions---------------------------------------------------
void pump1 ()
{
    if (On == digitalRead (direct) && (msec - msecPump) >= intervalPump)  {
        digitalWrite (step,   Off);
        digitalWrite (direct, Off);
        analogWrite  (pulse,  0);
    }
}

void pump2 ()
{
    if (On == digitalRead (direct1) && (msec1 - msecPump1) >= intervalPump1)  {
        digitalWrite (step1,   Off);
        digitalWrite (direct1, Off);
        analogWrite  (pulse1,  0);
    }
}
// -------------------------SOLENOID-line-1-Functions---------------------------------------------------
void solenoid1 ()
{
    if (On == digitalRead (s1) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s1, Off);
    }
}
void solenoid2 ()
{
    if (On == digitalRead (s2) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s2, Off);
    }
}
void solenoid3 ()
{
    if (On == digitalRead (s3) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s3, Off);
    }
}
void solenoid4 ()
{
    if (On == digitalRead (s4) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s4, Off);
    }
}
void solenoid5 ()
{
    if (On == digitalRead (s5) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s5, Off);
    }
}
void solenoid6 ()
{
    if (On == digitalRead (s6) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s6, Off);
    }
}
void solenoid7 ()
{
    if (On == digitalRead (s7) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s7, Off);
    }
}
void solenoid8 ()
{
    if (On == digitalRead (s8) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (s8, Off);
    }
}
// ------------------------C-SOLENOID-line-1-Functions---------------------------------------------------
void solenoidc1 ()
{
    if (On == digitalRead (c1) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c1, Off);
    }
}
void solenoidc2 ()
{
    if (On == digitalRead (c2) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c2, Off);
    }
}
void solenoidc3 ()
{
    if (On == digitalRead (c3) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c3, Off);
    }
}
void solenoidc4 ()
{
    if (On == digitalRead (c4) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c4, Off);
    }
}
void solenoidc5 ()
{
    if (On == digitalRead (c5) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c5, Off);
    }
}
void solenoidc6 ()
{
    if (On == digitalRead (c6) && (msec - msecSol1) >= intervalSol1)  {
        digitalWrite (c6, Off);
    }
}

// -------------------------SOLENOID-line-2-Functions---------------------------------------------------
void solenoid11 ()
{
    if (On == digitalRead (s11) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s11, Off);
    }
}
void solenoid22 ()
{
    if (On == digitalRead (s22) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s22, Off);
    }
}
void solenoid33 ()
{
    if (On == digitalRead (s33) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s33, Off);
    }
}
void solenoid44 ()
{
    if (On == digitalRead (s44) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s44, Off);
    }
}
void solenoid55 ()
{
    if (On == digitalRead (s55) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s55, Off);
    }
}
void solenoid66 ()
{
    if (On == digitalRead (s66) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s66, Off);
    }
}
void solenoid77 ()
{
    if (On == digitalRead (s77) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s77, Off);
    }
}
void solenoid88 ()
{
    if (On == digitalRead (s88) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (s88, Off);
    }
}
// ------------------------C-SOLENOID-line-2-Functions---------------------------------------------------
void solenoidc11 ()
{
    if (On == digitalRead (c11) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c11, Off);
    }
}
void solenoidc22 ()
{
    if (On == digitalRead (c22) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c22, Off);
    }
}
void solenoidc33 ()
{
    if (On == digitalRead (c33) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c33, Off);
    }
}
void solenoidc44 ()
{
    if (On == digitalRead (c44) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c44, Off);
    }
}
void solenoidc55 ()
{
    if (On == digitalRead (c55) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c55, Off);
    }
}
void solenoidc66 ()
{
    if (On == digitalRead (c66) && (msec1 - msecSol2) >= intervalSol2)  {
        digitalWrite (c66, Off);
    }
}

// --------------------------------MAIN LOOP---------------------------------------------
void loop () {
    msec1 = msec = millis ();

    pump1 ();
    pump2 ();
    
    solenoid1 ();
    solenoid2 ();
    solenoid3 ();
    solenoid4 ();
    solenoid5 ();
    solenoid6 ();
    solenoid7 ();
    solenoid8 ();

    solenoidc1 ();
    solenoidc2 ();
    solenoidc3 ();
    solenoidc4 ();
    solenoidc5 ();
    solenoidc6 ();

    solenoid11 ();
    solenoid22 ();
    solenoid33 ();
    solenoid44 ();
    solenoid55 ();
    solenoid66 ();
    solenoid77 ();
    solenoid88 ();

    solenoidc11 ();
    solenoidc22 ();
    solenoidc33 ();
    solenoidc44 ();
    solenoidc55 ();
    solenoidc66 ();

    if (Serial.available ())  {
        inc = Serial.read ();
        Serial.println (inc);

        switch (inc){
        case 'a':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s1, On);
            digitalWrite (c1, On);
            msecPump = msecSol1 = msec;
            break;
        case 'b':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s2, On);
            digitalWrite (c2, On);
            msecPump = msecSol1 = msec;
            break;
        case 'c':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s3, On);
            digitalWrite (c3, On);
            msecPump = msecSol1 = msec;
            break;
        case 'd':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s4, On);
            digitalWrite (c4, On);
            msecPump = msecSol1 = msec;
            break;
        case 'e':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s5, On);
            digitalWrite (c5, On);
            msecPump = msecSol1 = msec;
            break;
        case 'f':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s6, On);
            digitalWrite (c6, On);
            msecPump = msecSol1 = msec;
            break;
        case 'g':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s7, On);
            msecPump = msecSol1 = msec;
            break;
        case 'h':
            digitalWrite (direct, On);
            analogWrite  (pulse,  255);
            digitalWrite (step,   On);
            digitalWrite (s8, On);
            msecPump = msecSol1 = msec;
            break;
        case 'i':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s11, On);
            digitalWrite (c11, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'j':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s22, On);
            digitalWrite (c22, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'k':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s33, On);
            digitalWrite (c33, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'l':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s44, On);
            digitalWrite (c44, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'm':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s55, On);
            digitalWrite (c55, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'n':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s66, On);
            digitalWrite (c66, On);
            msecPump1 = msecSol2 = msec1;
            break;
        case 'o':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s77, On);
            msecPump1 = msecSol2 = msec1;
            break;  
        case 'p':
            digitalWrite (direct1, On);
            analogWrite  (pulse1,  255);
            digitalWrite (step1,   On);
            digitalWrite (s88, On);
            msecPump1 = msecSol2 = msec1;
            break; 
        case 'x':
            analogWrite (pulse,  0);
            digitalWrite (step,   Off);
            digitalWrite (direct, Off);

            digitalWrite (s1,    Off);
            digitalWrite (s2,    Off);
            digitalWrite (s3,    Off);
            digitalWrite (s4,    Off);
            digitalWrite (s5,    Off);
            digitalWrite (s6,    Off);
            digitalWrite (s7,    Off);
            digitalWrite (s8,    Off);

            digitalWrite (c1,    Off);
            digitalWrite (c2,    Off);
            digitalWrite (c3,    Off);
            digitalWrite (c4,    Off);
            digitalWrite (c5,    Off);
            digitalWrite (c6,    Off);
            break; 
        case 'y':
            analogWrite (pulse1,  0);
            digitalWrite (step1,   Off);
            digitalWrite (direct1, Off);

            digitalWrite (s11,    Off);
            digitalWrite (s22,    Off);
            digitalWrite (s33,    Off);
            digitalWrite (s44,    Off);
            digitalWrite (s55,    Off);
            digitalWrite (s66,    Off);
            digitalWrite (s77,    Off);
            digitalWrite (s88,    Off);
          
            digitalWrite (c11,    Off);
            digitalWrite (c22,    Off);
            digitalWrite (c33,    Off);
            digitalWrite (c44,    Off);
            digitalWrite (c55,    Off);
            digitalWrite (c66,    Off);
            break; 
        case 'z':
            analogWrite (pulse1,  0);
            digitalWrite (step1,   Off);
            digitalWrite (direct1, Off);
            analogWrite (pulse,  0);
            digitalWrite (step,   Off);
            digitalWrite (direct, Off);

            digitalWrite (s1,    Off);
            digitalWrite (s2,    Off);
            digitalWrite (s3,    Off);
            digitalWrite (s4,    Off);
            digitalWrite (s5,    Off);
            digitalWrite (s6,    Off);
            digitalWrite (s7,    Off);
            digitalWrite (s8,    Off);

            digitalWrite (c1,    Off);
            digitalWrite (c2,    Off);
            digitalWrite (c3,    Off);
            digitalWrite (c4,    Off);
            digitalWrite (c5,    Off);
            digitalWrite (c6,    Off);

            digitalWrite (s11,    Off);
            digitalWrite (s22,    Off);
            digitalWrite (s33,    Off);
            digitalWrite (s44,    Off);
            digitalWrite (s55,    Off);
            digitalWrite (s66,    Off);
            digitalWrite (s77,    Off);
            digitalWrite (s88,    Off);
          
            digitalWrite (c11,    Off);
            digitalWrite (c22,    Off);
            digitalWrite (c33,    Off);
            digitalWrite (c44,    Off);
            digitalWrite (c55,    Off);
            digitalWrite (c66,    Off);
            break; 
            
        }
    }
}

I want to run the same code but with the user provided pwm and solenoid numbers.

i don't see where "inc" is set using your parser function

hey,
I have used your logic to stop pump and solenoid and it worked both the pumps are working simultaneously but there is an issue when I give inputs to pump 1 and 2 pump 1 stops at the given delay but pump 2 doesn't. please look into this code. I have also attached few inputs screenshots.


#include <textparser.h>
TextParser parser(",");  // Delimiter is a comma.

#undef MyHW
#ifdef MyHW
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;

int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
#else
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;

int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
#endif

int pumpnum, pul, From_Solenoid, To_Solenoid, Delay;

byte            pinS;
byte            pinC;
byte            pinS1;
byte            pinC1;
byte            on;
byte            on1;
unsigned long   msecLst;
unsigned long   interval;
unsigned long   msecLst1;
unsigned long   interval1;
unsigned long msecPump;
unsigned long msec;

enum { Off = LOW, On = HIGH };

// -----------------------------------------------------------------------------
void setup () {
    Serial.begin (9600);

    analogWrite (pulse,  0);
    digitalWrite (step,   Off);
    digitalWrite (direct, Off);
    analogWrite (pulse1,  0);
    digitalWrite (step1,   Off);
    digitalWrite (direct1, Off);
    digitalWrite (s1,    Off);
    digitalWrite (s2,    Off);
    digitalWrite (s3,    Off);
    digitalWrite (s4,    Off);
    digitalWrite (s5,    Off);
    digitalWrite (s6,    Off);
    digitalWrite (s7,    Off);
    digitalWrite (s8,    Off);

    digitalWrite (c1,    Off);
    digitalWrite (c2,    Off);
    digitalWrite (c3,    Off);
    digitalWrite (c4,    Off);
    digitalWrite (c5,    Off);
    digitalWrite (c6,    Off);

    digitalWrite (s11,    Off);
    digitalWrite (s22,    Off);
    digitalWrite (s33,    Off);
    digitalWrite (s44,    Off);
    digitalWrite (s55,    Off);
    digitalWrite (s66,    Off);
    digitalWrite (s77,    Off);
    digitalWrite (s88,    Off);

    digitalWrite (c11,    Off);
    digitalWrite (c22,    Off);
    digitalWrite (c33,    Off);
    digitalWrite (c44,    Off);
    digitalWrite (c55,    Off);
    digitalWrite (c66,    Off);
    
    pinMode (pulse,  OUTPUT);
    pinMode (step,   OUTPUT);
    pinMode (direct, OUTPUT);
    pinMode (pulse1,  OUTPUT);
    pinMode (step1,   OUTPUT);
    pinMode (direct1, OUTPUT);
    pinMode (s1,    OUTPUT);
    pinMode (s2,    OUTPUT);
    pinMode (s3,    OUTPUT);
    pinMode (s4,    OUTPUT);
    pinMode (s5,    OUTPUT);
    pinMode (s6,    OUTPUT);
    pinMode (s7,    OUTPUT);
    pinMode (s8,    OUTPUT);

    pinMode (c1,    OUTPUT);
    pinMode (c2,    OUTPUT);
    pinMode (c3,    OUTPUT);
    pinMode (c4,    OUTPUT);
    pinMode (c5,    OUTPUT);
    pinMode (c6,    OUTPUT);

    pinMode (s11,    OUTPUT);
    pinMode (s22,    OUTPUT);
    pinMode (s33,    OUTPUT);
    pinMode (s44,    OUTPUT);
    pinMode (s55,    OUTPUT);
    pinMode (s66,    OUTPUT);
    pinMode (s77,    OUTPUT);
    pinMode (s88,    OUTPUT);

    pinMode (c11,    OUTPUT);
    pinMode (c22,    OUTPUT);
    pinMode (c33,    OUTPUT);
    pinMode (c44,    OUTPUT);
    pinMode (c55,    OUTPUT);
    pinMode (c66,    OUTPUT);
}

// -----------------------------------------------------------------------------
void pumpOff ()
{
    if (pinS)
        digitalWrite (pinS, Off);
    if (pinC)
        digitalWrite (pinC, Off);
    on = false;

        digitalWrite (step,   Off);
        digitalWrite (direct, Off);
        analogWrite  (pulse,  0);
}

void pumpOff1 ()
{
    if (pinS1)
        digitalWrite (pinS1, Off);
    if (pinC1)
        digitalWrite (pinC1, Off);
    on1 = false;

        digitalWrite (step1,   Off);
        digitalWrite (direct1, Off);
        analogWrite  (pulse1,  0);
}

// -----------------------------------------------------------------------------
void pumpOn (int   msecTime, int value)
{
    interval = msecTime;
    on       = true;
    digitalWrite (direct, On);
    analogWrite  (pulse,  value);
    digitalWrite (step,   On);
    if (pinS)
        digitalWrite (pinS, On);
    if (pinC)
        digitalWrite (pinC, On);

    on      = true;
    msecLst = msec;
}

void pumpOn1 (int   msecTime1, int value1)
{
    interval1 = msecTime1;
    on1       = true;
    digitalWrite (direct1, On);
    analogWrite  (pulse1,  value1);
    digitalWrite (step1,   On);
    if (pinS1)
        digitalWrite (pinS1, On);
    if (pinC1)
        digitalWrite (pinC1, On);

    on1      = true;
    msecLst1 = msec;
}
// -----------------------------------------------------------------------------
void solenoid(int sval){
  if(sval == 1){
    pinS = s1;
  }
  else if(sval == 2){
    pinS = s2;
  }
  else if(sval == 3){
    pinS = s3;
  }
  else if(sval == 4){
    pinS = s4;
  }
  else if(sval == 5){
    pinS = s5;
  }
  else if(sval == 6){
    pinS = s6;
  }
  else if(sval == 7){
    pinS = s7;
  }
  else if(sval == 8){
    pinS = s8;
  }
}

void solenoidc(int cval){
  if(cval == 1){
    pinC = c1;
  }
  else if(cval == 2){
    pinC = c2;
  }
  else if(cval == 3){
    pinC = c3;
  }
  else if(cval == 4){
    pinC = c4;
  }
  else if(cval == 5){
    pinC = c5;
  }
  else if(cval == 6){
    pinC = c6;
  }
}
// --------------------------------------------------------------------------------------
void solenoidone(int svalone){
  if(svalone == 1){
    pinS = s11;
  }
  else if(svalone == 2){
    pinS = s22;
  }
  else if(svalone == 3){
    pinS = s33;
  }
  else if(svalone == 4){
    pinS = s44;
  }
  else if(svalone == 5){
    pinS = s55;
  }
  else if(svalone == 6){
    pinS = s66;
  }
  else if(svalone == 7){
    pinS = s77;
  }
  else if(svalone == 8){
    pinS = s88;
  }
}
void solenoidcone(int cvalone){
  if(cvalone == 1){
    pinC = c11;
  }
  else if(cvalone == 2){
    pinC = c22;
  }
  else if(cvalone == 3){
    pinC = c33;
  }
  else if(cvalone == 4){
    pinC = c44;
  }
  else if(cvalone == 5){
    pinC = c55;
  }
  else if(cvalone == 6){
    pinC = c66;
  }
}
// --------------------------------MAIN LOOP---------------------------------------------
void loop ()
{
    msec = millis ();
    
        if (on)  {
            if ( (msec - msecLst) >= interval)
                pumpOff ();
        }

        else if (on1) {
          if ((msec-msecLst1) >= interval1)
              pumpOff1 ();
        }
    

    if (Serial.available()) {
        char line[80];
        //Assume `line` is of the form "(1or2),255,2,3,1(in sec)\n".
        Serial.readBytesUntil('\n', line, sizeof(line));
        parser.parseLine(line, pumpnum, pul, From_Solenoid, To_Solenoid, Delay);
        if(pumpnum == 1){
            solenoid(From_Solenoid);//for pump 1
            solenoidc(To_Solenoid);//for pump 1
            pumpOn(Delay,pul);
        }
        else if(pumpnum == 2){
            solenoidone(From_Solenoid);//for pump 2
            solenoidcone(To_Solenoid);//for pump 2
            pumpOn1(Delay,pul);
        }
    }
}

I solved the problem, the condition for stop should be in the function not in the main loop.
Thank you everyone for helping me out. :v: . Here is the final working code. Also, I am trying to reduce the line of code in my project, I have seen tutorials on YouTube and tried following them but I'm still not able to figure out.
I would be grateful if any one could give me a hand with this, I am not sure what else to do.

#include <textparser.h>
TextParser parser(",");  // Delimiter is a comma.

#undef MyHW
#ifdef MyHW
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;

int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
#else
int pulse  = 9;
int step   = 10;
int direct = 11;
int pulse1  = 8;
int step1   = 12;
int direct1 = 13;

int s1    = 22;
int s2    = 23;
int s3    = 24;
int s4    = 25;
int s5    = 26;
int s6    = 27;
int s7    = 28;
int s8    = 29;
int c1    = 30;
int c2    = 31;
int c3    = 32;
int c4    = 33;
int c5    = 34;
int c6    = 35;
int s11    = 36;
int s22    = 37;
int s33    = 38;
int s44    = 39;
int s55    = 40;
int s66    = 41;
int s77    = 42;
int s88    = 43;
int c11    = 44;
int c22    = 45;
int c33    = 46;
int c44    = 47;
int c55    = 48;
int c66    = 49;
#endif

int pumpnum, pul, From_Solenoid, To_Solenoid, Delay;

byte            pinS;
byte            pinC;
byte            pinS1;
byte            pinC1;
byte            on;
byte            on1;
unsigned long   msecLst;
unsigned long   interval;
unsigned long   msecLst1;
unsigned long   interval1;
unsigned long msecPump;
unsigned long msec;

enum { Off = LOW, On = HIGH };

// -----------------------------------------------------------------------------
void setup () {
    Serial.begin (9600);

    analogWrite (pulse,  0);
    digitalWrite (step,   Off);
    digitalWrite (direct, Off);
    analogWrite (pulse1,  0);
    digitalWrite (step1,   Off);
    digitalWrite (direct1, Off);
    digitalWrite (s1,    Off);
    digitalWrite (s2,    Off);
    digitalWrite (s3,    Off);
    digitalWrite (s4,    Off);
    digitalWrite (s5,    Off);
    digitalWrite (s6,    Off);
    digitalWrite (s7,    Off);
    digitalWrite (s8,    Off);

    digitalWrite (c1,    Off);
    digitalWrite (c2,    Off);
    digitalWrite (c3,    Off);
    digitalWrite (c4,    Off);
    digitalWrite (c5,    Off);
    digitalWrite (c6,    Off);

    digitalWrite (s11,    Off);
    digitalWrite (s22,    Off);
    digitalWrite (s33,    Off);
    digitalWrite (s44,    Off);
    digitalWrite (s55,    Off);
    digitalWrite (s66,    Off);
    digitalWrite (s77,    Off);
    digitalWrite (s88,    Off);

    digitalWrite (c11,    Off);
    digitalWrite (c22,    Off);
    digitalWrite (c33,    Off);
    digitalWrite (c44,    Off);
    digitalWrite (c55,    Off);
    digitalWrite (c66,    Off);
    
    pinMode (pulse,  OUTPUT);
    pinMode (step,   OUTPUT);
    pinMode (direct, OUTPUT);
    pinMode (pulse1,  OUTPUT);
    pinMode (step1,   OUTPUT);
    pinMode (direct1, OUTPUT);
    pinMode (s1,    OUTPUT);
    pinMode (s2,    OUTPUT);
    pinMode (s3,    OUTPUT);
    pinMode (s4,    OUTPUT);
    pinMode (s5,    OUTPUT);
    pinMode (s6,    OUTPUT);
    pinMode (s7,    OUTPUT);
    pinMode (s8,    OUTPUT);

    pinMode (c1,    OUTPUT);
    pinMode (c2,    OUTPUT);
    pinMode (c3,    OUTPUT);
    pinMode (c4,    OUTPUT);
    pinMode (c5,    OUTPUT);
    pinMode (c6,    OUTPUT);

    pinMode (s11,    OUTPUT);
    pinMode (s22,    OUTPUT);
    pinMode (s33,    OUTPUT);
    pinMode (s44,    OUTPUT);
    pinMode (s55,    OUTPUT);
    pinMode (s66,    OUTPUT);
    pinMode (s77,    OUTPUT);
    pinMode (s88,    OUTPUT);

    pinMode (c11,    OUTPUT);
    pinMode (c22,    OUTPUT);
    pinMode (c33,    OUTPUT);
    pinMode (c44,    OUTPUT);
    pinMode (c55,    OUTPUT);
    pinMode (c66,    OUTPUT);
}

// -----------------------------------------------------------------------------
void pumpOff ()
{
  if (on)  {
   if ( (msec - msecLst) >= interval){
    if (pinS)
        digitalWrite (pinS, Off);
    if (pinC)
        digitalWrite (pinC, Off);
    on = false;

        digitalWrite (step,   Off);
        digitalWrite (direct, Off);
        analogWrite  (pulse,  0);
}
  }
}

void pumpOff1 ()
{
  if (on1) {
   if ((msec-msecLst1) >= interval1){
    if (pinS1)
        digitalWrite (pinS1, Off);
    if (pinC1)
        digitalWrite (pinC1, Off);
    on1 = false;

        digitalWrite (step1,   Off);
        digitalWrite (direct1, Off);
        analogWrite  (pulse1,  0);
}
  }
}

// -----------------------------------------------------------------------------
void pumpOn (int   msecTime, int value)
{
    interval = msecTime;
    on       = true;
    digitalWrite (direct, On);
    analogWrite  (pulse,  value);
    digitalWrite (step,   On);
    if (pinS)
        digitalWrite (pinS, On);
    if (pinC)
        digitalWrite (pinC, On);

    on      = true;
    msecLst = msec;
}

void pumpOn1 (int   msecTime1, int value1)
{
    interval1 = msecTime1;
    on1       = true;
    digitalWrite (direct1, On);
    analogWrite  (pulse1,  value1);
    digitalWrite (step1,   On);
    if (pinS1)
        digitalWrite (pinS1, On);
    if (pinC1)
        digitalWrite (pinC1, On);

    on1      = true;
    msecLst1 = msec;
}
// -----------------------------------------------------------------------------
void solenoid(int sval){
  if(sval == 1){
    pinS = s1;
  }
  else if(sval == 2){
    pinS = s2;
  }
  else if(sval == 3){
    pinS = s3;
  }
  else if(sval == 4){
    pinS = s4;
  }
  else if(sval == 5){
    pinS = s5;
  }
  else if(sval == 6){
    pinS = s6;
  }
  else if(sval == 7){
    pinS = s7;
  }
  else if(sval == 8){
    pinS = s8;
  }
}

void solenoidc(int cval){
  if(cval == 1){
    pinC = c1;
  }
  else if(cval == 2){
    pinC = c2;
  }
  else if(cval == 3){
    pinC = c3;
  }
  else if(cval == 4){
    pinC = c4;
  }
  else if(cval == 5){
    pinC = c5;
  }
  else if(cval == 6){
    pinC = c6;
  }
}
// --------------------------------------------------------------------------------------
void solenoidone(int svalone){
  if(svalone == 1){
    pinS = s11;
  }
  else if(svalone == 2){
    pinS = s22;
  }
  else if(svalone == 3){
    pinS = s33;
  }
  else if(svalone == 4){
    pinS = s44;
  }
  else if(svalone == 5){
    pinS = s55;
  }
  else if(svalone == 6){
    pinS = s66;
  }
  else if(svalone == 7){
    pinS = s77;
  }
  else if(svalone == 8){
    pinS = s88;
  }
}
void solenoidcone(int cvalone){
  if(cvalone == 1){
    pinC = c11;
  }
  else if(cvalone == 2){
    pinC = c22;
  }
  else if(cvalone == 3){
    pinC = c33;
  }
  else if(cvalone == 4){
    pinC = c44;
  }
  else if(cvalone == 5){
    pinC = c55;
  }
  else if(cvalone == 6){
    pinC = c66;
  }
}
// --------------------------------MAIN LOOP---------------------------------------------
void loop ()
{
    msec = millis ();

      pumpOff ();
      pumpOff1 ();   

    if (Serial.available()) {
        char line[80];
        //Assume `line` is of the form "(1or2),255,2,3,1(in sec)\n".
        Serial.readBytesUntil('\n', line, sizeof(line));
        parser.parseLine(line, pumpnum, pul, From_Solenoid, To_Solenoid, Delay);
        if(pumpnum == 1){
            solenoid(From_Solenoid);//for pump 1
            solenoidc(To_Solenoid);//for pump 1
            pumpOn(Delay,pul);
        }
        else if(pumpnum == 2){
            solenoidone(From_Solenoid);//for pump 2
            solenoidcone(To_Solenoid);//for pump 2
            pumpOn1(Delay,pul);
        }
    }
}

When you have lots of variables whose names are of the form name + number it is a clue that you could be using array variables.

When you have lines of code repeated with just a small change, you could be using a for loop to do the one line of code over and over and use the loop index to make the line a bit different every iteration.

When you have functions that are almost identical, it is probable that one function could serve several rolls, with some extra function arguments directing the exact process in the function.

And when you have global variables that are set in one function to be used in another function to tailor its activities, that is a sign that perhaps those variables would be better as function parameters.

So I do never argue with success, but as you may see, adding a third something the way you are going would get old fast. And fixing an error would mean fixing it in all the places you managed to copy/paste/edit it.

Take some time off making direct progress with your project and start in on arrays, loops and functions. Recognizing and exploiting patterns is key to writing the least code. Less code, fewer errors.

Usually by now one or two ppl would have tripped over themselves to re-write your sketch from a step or two (or three!) beyond where you are. Give it a shot yourself, ask questions here and show us why what you thought would work did not, if indeed it doesn't.

a7

what will be the value of N_PUMP here??

the size of the pumps array: 2 under MyHW and 8 for your values

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.