Union de entradas digitales con interrupciones

Saludos estimados, estoy empezando con arduino y tengo una duda, he conectado en arduino uno dos sensores de caudal FS400A, y me va muy bien pero deseo cionectar 6 mas y las entradas que permiten interrupciones son solo el pin2 y el pin3 ... que podria hacer para conectar los otros caudalimetros..?? por favor ayudenme...

Buenas noches por favor deseo que alguien me ayude orientando porque no puedo imprimir mas de 15 lineas por medio del monitor serial con un arduino DUE...
Tengo este codigo:, cuando deseo imprimir otro bloque de lineas me sale en el monitor serial una letra C.

//variable para la cantidad de pulsos recibidos
volatile int NumPulsos1;
volatile int NumPulsos2;
volatile int NumPulsos3;
volatile int NumPulsos4;
volatile int NumPulsos5;
volatile int NumPulsos6;
volatile int NumPulsos7;
volatile int NumPulsos8;
const int retardo = 50;

//Sensores y pines de conexion
int PinSensor1 = 2;
int PinSensor2 = 3;
int PinSensor3 = 4;
int PinSensor4 = 5;
int PinSensor5 = 6;
int PinSensor6 = 7;
int PinSensor7 = 8;
int PinSensor8 = 9;

//para convertir de frecuencia a caudal
float factor_conversion1=3.5;
float factor_conversion2=5.5;
float factor_conversion3=7.5;

//VARIABLES PARA MEDIR EL VOLUMEN
float volumen1=0;
float volumen2=0;
float volumen3=0;
float volumen4=0;
float volumen5=0;
float volumen6=0;
float volumen7=0;
float volumen8=0;

long dt=0; //variación de tiempo por cada bucle
long t0=0; //millis() del bucle anterior

//---Funciónes que se ejecutan en interrupción---------------
void ContarPulsos1 ()
{
NumPulsos1++; //incrementamos la variable de pulsos
}

void ContarPulsos2 ()
{
NumPulsos2++; //incrementamos la variable de pulsos
}

void ContarPulsos3 ()
{
NumPulsos3++; //incrementamos la variable de pulsos
}

void ContarPulsos4 ()
{
NumPulsos4++; //incrementamos la variable de pulsos
}

/*
void ContarPulsos5 ()
{
NumPulsos5++; //incrementamos la variable de pulsos
}

void ContarPulsos6 ()
{
NumPulsos6++; //incrementamos la variable de pulsos
}

void ContarPulsos7 ()
{
NumPulsos7++; //incrementamos la variable de pulsos
}

void ContarPulsos8 ()
{
NumPulsos8++; //incrementamos la variable de pulsos
}
*/
//---Funciónes para obtener frecuencias de los pulsos--------
int ObtenerFrecuecia1()
{
int frecuencia1;
NumPulsos1 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia1=NumPulsos1; //Hz(pulsos por segundo)
return frecuencia1;
}

int ObtenerFrecuecia2()
{
int frecuencia2;
NumPulsos2 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia2=NumPulsos2; //Hz(pulsos por segundo)
return frecuencia2;
}

int ObtenerFrecuecia3()
{
int frecuencia3;
NumPulsos3 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia3=NumPulsos3; //Hz(pulsos por segundo)
return frecuencia3;
}

int ObtenerFrecuecia4()
{
int frecuencia4;
NumPulsos4 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia4=NumPulsos4; //Hz(pulsos por segundo)
return frecuencia4;
}
/*
int ObtenerFrecuecia5()
{
int frecuencia5;
NumPulsos5 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia5=NumPulsos5; //Hz(pulsos por segundo)
return frecuencia5;
}

int ObtenerFrecuecia6()
{
int frecuencia6;
NumPulsos6 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia6=NumPulsos6; //Hz(pulsos por segundo)
return frecuencia6;
}

int ObtenerFrecuecia7()
{
int frecuencia7;
NumPulsos7 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia7=NumPulsos7; //Hz(pulsos por segundo)
return frecuencia7;
}

int ObtenerFrecuecia8()
{
int frecuencia8;
NumPulsos8 = 0; //Ponemos a 0 el número de pulsos
interrupts(); //Habilitamos las interrupciones
delay(retardo); //muestra de 1 segundo
noInterrupts(); //Deshabilitamos las interrupciones
frecuencia8=NumPulsos8; //Hz(pulsos por segundo)
return frecuencia8;
}
*/

void setup()
{

Serial.begin(9600);
pinMode(PinSensor1, INPUT);
pinMode(PinSensor2, INPUT);
pinMode(PinSensor3, INPUT);
pinMode(PinSensor4, INPUT);
pinMode(PinSensor5, INPUT);
pinMode(PinSensor6, INPUT);
pinMode(PinSensor7, INPUT);
pinMode(PinSensor8, INPUT);

attachInterrupt(2,ContarPulsos1,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(3,ContarPulsos2,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(4,ContarPulsos3,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(5,ContarPulsos4,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
/*attachInterrupt(6,ContarPulsos5,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(7,ContarPulsos6,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(8,ContarPulsos7,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
attachInterrupt(9,ContarPulsos8,RISING);//(Interrupción 0(Pin2),función,Flanco de subida)
//Serial1.println ("Envie 'r' para restablecer el volumen a 0 Litros");
*/
t0=millis();
}

void loop ()
{

float frecuencia1=ObtenerFrecuecia1(); //obtenemos la frecuencia de los pulsos en Hz
float frecuencia2=ObtenerFrecuecia2();
float frecuencia3=ObtenerFrecuecia3();
float frecuencia4=ObtenerFrecuecia4();
/*float frecuencia5=ObtenerFrecuecia5();
float frecuencia6=ObtenerFrecuecia6();
float frecuencia7=ObtenerFrecuecia7();
float frecuencia8=ObtenerFrecuecia8();
/
float caudal_L_m1=frecuencia1/factor_conversion1; //calculamos el caudal en L/m
float caudal_L_m2=frecuencia2/factor_conversion2;
float caudal_L_m3=frecuencia3/factor_conversion2;
float caudal_L_m4=frecuencia4/factor_conversion2;
/

float caudal_L_m5=frecuencia5/factor_conversion2;
float caudal_L_m6=frecuencia6/factor_conversion2;
float caudal_L_m7=frecuencia7/factor_conversion2;
float caudal_L_m8=frecuencia8/factor_conversion2;
*/
dt=millis()-t0; //calculamos la variación de tiempo
t0=millis();

// volumen(L)=caudal(L/s)tiempo(s)
volumen1=volumen1+(caudal_L_m1/60)
(dt/1000);
volumen2=volumen2+(caudal_L_m2/60)(dt/1000);
volumen3=volumen3+(caudal_L_m3/60)
(dt/1000);
volumen4=volumen4+(caudal_L_m4/60)(dt/1000);
/volumen5=volumen5+(caudal_L_m5/60)(dt/1000);
volumen6=volumen6+(caudal_L_m6/60)
(dt/1000);
volumen7=volumen7+(caudal_L_m7/60)(dt/1000);
volumen8=volumen8+(caudal_L_m8/60)
(dt/1000);
*/
//-----Enviamos por el puerto serie---------------
Serial.print ("Caudal 1: ");
Serial.print (caudal_L_m1,3);
Serial.print ("L/min\tVolumen 1: ");
Serial.print (volumen1,3);
Serial.println ("L");

Serial.print ("Caudal 2: ");
Serial.print (caudal_L_m2,3);
Serial.print ("L/min\tVolumen 2: ");
Serial.print (volumen2,3);
Serial.println ("L");

Serial.print ("Caudal 3: ");
Serial.print (caudal_L_m3,3);
Serial.print ("L/min\tVolumen 3: ");
Serial.print (volumen3,3);
Serial.println ("L");
/*
Serial.print ("Caudal 4: ");
Serial.print (caudal_L_m4,3);
Serial.print ("L/min\tVolumen 4: ");
Serial.print (volumen4,3);
Serial.println (" L");
/*
//Serial.println ("");
Serial.print ("Caudal 5: ");
Serial.print (caudal_L_m5,3);
Serial.print ("L/min\tVolumen 5: ");
Serial.print (volumen5,3);
Serial.println (" L");

//Serial.println ("");
Serial.print ("Caudal 6: ");
Serial.print (caudal_L_m6,3);
Serial.print ("L/min\tVolumen 6: ");
Serial.print (volumen6,3);
Serial.println (" L");

//Serial.println ("");
Serial.print ("Caudal 7: ");
Serial.print (caudal_L_m7,3);
Serial.print ("L/min\tVolumen 7: ");
Serial.print (volumen7,3);
Serial.println (" L");

//Serial.println ("");
Serial.print ("Caudal 8: ");
Serial.print (caudal_L_m8,3);
Serial.print ("L/min\tVolumen 8: ");
Serial.print (volumen8,3);
Serial.println (" L");
*/
}

Moderador
Por favor edita tu post usando etiquetas de código.
Lee las Normas del foro

Por favor, edita.
Normalmente no respondo pero en este caso te diré.
Interrupción es algo que debe realizarse con rapidez.
Jamás en una interrupción puedes poner esto

delay(retardo);   //muestra de 1 segundo

es el contrasentido mas grande del mundo a nivel programación.
Si usas interrupciones no usas delay().
Usa flags que avisen al código en el loop y usa millis() para que el código fluya naturalmente.

quita cada uno de los delay() en tus interrupciones.
Estan muy mal empleadas.

No puedes y menos debes continuar por esa vía.

Posible sugerencia el MEGA o un DUE.
Mega 2 3 21 20 19 18
Due todos los pines.
Tiene exactamente 6 interrupciones x hardware.

Tambien puedes usar un ESP8266 tipo nodemcu o un ESP32
Hay otros arduinos capaces de manejar tantas interrupciones.

NOTA: alguien esta preguntando lo mismo con un DUE, espero que no seas tu porque entonces sería un doble posteo.

Editado:
Confirmado: eras tu.
Bueno, tienes una primer advertencia por doble posteo.
Mi recomendación es que leas atentamente las normas del foro para no repetir mas faltas.