Me quedo sin I/O en un mega 2560 R3 y varias cuestiones mas (1/2)

Buenas tardes, llevo poco tiempo con Arduino y hay varias dudas que me asaltan.He intentado buscar algo por internet y en los foros pero no he visto nada, posiblemente porque no he planteado la pregunta correcta y me gustaría a ver si alguien puede orientarme.
Empecemos, la idea general es controlar 36 finales de carrera como entradas independientes y utilizar 2 señales de salida para unas alarmas asociadas a cada entrada mas 1 salida asociada a todas las entradas como testigo del pulso recibido.
Hasta ahí tengo el código resuelto:

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DECLARACION DE CONSTANTES 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
#define linein01  54                                                 // ASIGNACION PIN ENTRADA LINEA 01
#define lineout01  4                                                 // ASIGNACION PIN TESTIGO SENSOR LINEA 01
#define bajoprod01 5                                                 // ASIGNACION PIN BAJO PRODUCTO LINEA 01
#define needprod01 6                                                 // ASIGNACION PIN PRODUCTO NECESITADO LINEA 01
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DECLARACION DE VARIABLES
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int sensorcounter01 = 30;                                            // CONTADOR DEL NUMERO DE PULSACIONES DEL SENSOR DE LA LINEA 01(UNIDADES A CONTAR SEGUN sensorcounter01)
int sensorState01 = 0;                                               // ESTADO ACTUAL DEL SENSOR DE LA LINEA 01
int lastsensorState01 = 0;                                           // ESTADO ANTERIOR DEL SENSOR DE LA LINEA 01
int totalcountersensor01 = 0;                                        // TOTALIZADOR DE PULSOS DE LA LINEA 01
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() 
// DECLARACION DE PINES DE SALIDA
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
                                                              
  pinMode(linein01,INPUT);                                           // DECLARACION DEL SENSOR DE ENTRADA DE LA LINEA 01                                                                                       
  pinMode(lineout01,OUTPUT);                                         // DECLARACION DE LA SEÑALIZACION DE SALIDA DE LA LINEA 01
  pinMode(bajoprod01,OUTPUT);                                        // DECLARACION DE LA SEÑALIZACION DE BAJO PRODUCTO DE LA LINEA 01                                                                           
  pinMode(needprod01,OUTPUT);                                        // DECLARACION DE LA SEÑALIZACION DE PRODUCTO NECESITADO LINEA 01
  
  Serial.begin(9600);                                                // INICIALIZACION DE COMUNICACION SERIE 
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{
                                                                                        
  sensorState01 = digitalRead(linein01);                             // LECTURA DEL PULSADOR DE ENTRADA

                                                                                        
  if (sensorState01 != lastsensorState01)                            // COMPARA EL ESTADO ACTUAL DEL PULSADOR CON EL ESTADO ANTERIOR DEL MISMO
  {                         
                                                                     
    if (sensorState01 == HIGH)                                       // SI EL ESTADO DEL SENSOR DE LINEA 01 ES ALTO ENTONCES VAMOS DE PRINCIPIO A FIN
    {
                                                                    
      sensorcounter01--;                                             // SI EL ESTADO HA CAMBIADO,DECREMETA EL CONTADOR
      
      Serial.println("on");
      Serial.print("Pulsos hasta llegar a 0 en Linea01:  ");
      Serial.println(sensorcounter01);
      
      totalcountersensor01++;                                        // AUMENTA EL TOTALIZADOR DE PULSOS
      
      Serial.println(" ");
      Serial.print("Totalizador de pulsos Linea01:  ");
      Serial.println(totalcountersensor01);
   
    } 
    else {
                                                                     // SI EL ESTADO DEL SENSOR DE LINEA 01 ES BAJO CORTAMOS LA COMUNICACION SERIE
      Serial.println("off");
      delay(50); 
    }
  
   lastsensorState01 = sensorState01;                                // GUARDA EL ESTADO ACTUAL COMO ULTIMO ESTADO PARA LA PROXIMA VEZ ATRACES DEL BUCLE
                                                                     // ESTA LINEA ES EL MOTIVO DEL DOBLE PARPADEO SEÑALIZACION SALIDA 01
  
   if (sensorcounter01 == 0)sensorcounter01 ;                        // CON ESTA LINEA SE RESETEA EL CONTADOR DE PULSACIONES DE LA LINEA 01 PASANDO A LA ESPERA 
                                                                     // DE REACTIVAR LA VARIABLE SENSORCOUNTER01 DE MANERA MANUAL                                                                                                               
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                                                        

   if (digitalRead(sensorState01)==LOW)                              // MONITORIZACION DE SENSOR LINEA 01 
   
   {    digitalWrite(lineout01,LOW);                                      

   }
   else
   {    digitalWrite(lineout01,HIGH);
        delay(200);
        digitalWrite(lineout01,LOW);
        delay(50);
        
   }
  }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
   if (sensorcounter01 >=8)                                           // SEÑALIZACION ALARMA BAJO PRODUCTO LINEA 01
   
  {     digitalWrite(bajoprod01,LOW);                                 // EL PUNTO DE ALARMA SE FIJA SEGUN EL NUMERO ENTERO TRAS EL COMPRADOR " >= "
}
   else
{     
        digitalWrite(bajoprod01,HIGH);       
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
   if (sensorcounter01 <=0)                                            // SEÑALIZACION ALARMA PRODUCTO NECESITADO LINEA 01
{       digitalWrite(bajoprod01,HIGH);                                 // DISPARA LA ALARMA AL LLEGAR A 0
        digitalWrite(needprod01,HIGH);
}
   else
{       digitalWrite(bajoprod01,LOW);
        digitalWrite(needprod01,LOW);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Fin de la primera parte ya que el mensaje es demasiado largo

A partir de aquí es cuando vienen las dudas, lógicamente con un solo Arduino no puedo controlar tantas entradas y salidas por lo que necesitaría 2 como mínimo, pero la cosa se complica "un poco" mas.

Necesito realizar una interacción con una táctil de 2,4" para introducir unas "predeterminaciones" en las líneas de entrada (por defecto la he colocado en 30) pero me gustaría que se pueda seleccionar mediante un teclado numérico desde la TFT (estoy en como hacerlo). Y para liarlo un poco mas me gustaría montar un servidor web donde monitorizar todo el proceso.

Me queda grande ..... NO .... grandisimo ... pero soy cabezoncete. En este par de semanas de búsquedas y empollos ya he conseguido hacer el código de la primera parte del proyecto. Se que no es mucho porque no es muy complicado visto lo que hay por aquí pero bueno, por algún sitio hay que empezar.

Y ya que os habéis hecho una idea del proyecto os explico las dudas ........

¿Necesitare como mínimo 2 megas para controlar todas las entradas y salidas necesarias pero como los interconecto para hacer correr el programa en los dos megas? O tengo que dividir el programa en 2 para que corra la mitad en cada uno.

¿Necesitaría otro Arduino para controlar la táctil y el servidor web o podría ir integrado en los dos necesarios para el control I / O?

¿Cómo relacionar el tacto para realizar su función de predeterminación en ambos Arduino?

Hay alguna mas por ahí pero de momento ..... para ir abriendo boca creo que hay bastante ya, mientras voy liándome con la TFT.

Muchísimas gracias por adelantado y si no es aquí donde debo publicar perdón y muévanlo por favor.

Gracias.

Para empezar, regañarte. Tienes una duda y has creado dos post diferentes. Tendrias que haber seguido en el mismo hilo, ahora obligas al moderador a tener que unirlos.

Analizamos: 36 entradas, 2 salidas, una tactil supongo SPI asi que 4 pins, un keypad 8 total 50 pines del Mega.

Ahora bien, enfoquemos las 36 entradas, ¿son finales de carrera? No se si conectándole un simple diodo te valdrá. Es decir, la misma carrera sirve para como entrada del arduino y para alimentar un led.

Si no te vale, la siguiente opción puede ser usar un expansor de E/S via I2C o SPI. Por ejemplo, el MCP23017 que son 16 entradas/salidas, que colocando varios en cascada puedes poner 8, dandote un total de 128 entradas/salidas.

La otra opción como bien dices es usar otro mega, comunicándolos por ejemplo por I2C, pero no creo que sea necesario llegar a tales extremos.

Buenas tardes,ante todo agradecerte la atención prestada.Lo del regaño... te lo permito " ;p " porque no sabia como hacerlo ya que el mensaje original excedía de los 9000 caracteres y no me dejaba publicar. Daré otro re repaso a las normas del foro a ver si veo como hacerlo.
En cuanto a los pines necesarios... no son exactamente los que has contado.
Serian : 36 entradas ,72 salidas mas otra común , en total 73 salidas. Los finales de carrera o sensores de paso...serian mecánicos para el conteo de piezas que pasan por las lineas (las 36 entradas) . El esquema que me has proporcionado es el que he empleado yo para realizar las pruebas, por lo tanto me sirve perfectamente solo que sin el led asociado ( monitorizaba las salidas con el monitor serie del IDE ) .La salida común es para chequear el correcto funcionamiento de las entradas ( led de señalizacion ). Realizado así ya que son imposibles dos pulsos simultáneos en las entradas
Las 72 salidas son utilizadas para activar 2 alarmas referentes a cada una de las entradas.
En cuanto a la táctil haría las veces de keypad mediante un pequeño menú y un teclado numérico para seleccionar cuantas piezas se van a contar en cada una de las lineas.
Y aun quedaría el servidor web que no me he puesto con el ya que aun falta camino por recorrer hasta llegar ahí.
Con todo esto,podría utilizar simultáneamente los MCP 23017 y la táctil en un solo Arduino?
Gracias por tu tiempo

Buenas tardes,ante todo agradecerte la atención prestada.Lo del regaño... te lo admito " ;p " porque no sabia como hacerlo ya que el mensaje original excedía de los 9000 caracteres y no me dejaba publicar. Daré otro re repaso a las normas del foro a ver si veo como hacerlo.
En cuanto a los pines necesarios... no son exactamente los que has contado.
Serian : 36 entradas ,72 salidas mas otra común , en total 73 salidas. Los finales de carrera o sensores de paso...serian mecánicos para el conteo de piezas que pasan por las lineas (las 36 entradas) . El esquema que me has proporcionado es el que he empleado yo para realizar las pruebas, por lo tanto me sirve perfectamente solo que sin el led asociado ( monitorizaba las salidas con el monitor serie del IDE ) .La salida común es para chequear el correcto funcionamiento de las entradas ( led de señalizacion ). Realizado así ya que son imposibles dos pulsos simultáneos en las entradas
Las 72 salidas son utilizadas para activar 2 alarmas referentes a cada una de las entradas.
En cuanto a la táctil haría las veces de keypad mediante un pequeño menú y un teclado numérico para seleccionar cuantas piezas se van a contar en cada una de las lineas.
Y aun quedaría el servidor web que no me he puesto con el ya que aun falta camino por recorrer hasta llegar ahí.
Con todo esto,podría utilizar simultáneamente los MCP 23017 y la táctil en un solo Arduino?
Gracias por tu tiempo

Como te comenté, con el mpc23017 puedes tener hasta un total de 128 pines adicionales, restandóle solo los pines I2C al Mega, pero el resto te queda libre. El único pero que le veo es que te quedes sin RAM sal usar una TFT y gráficos; pero puedes controlar el consumo de RAM.

Ok , entendido Me pillare los MPC necesarios y probaremos.

Otra cuestión . Ayer recibí la pantalla, es una shield de 2,4". Bueno , realmente no se si colocar aquí el post,supongo que como es referente al mismo proyecto no me tiraran muy fuerte de las orejas.
Resulta que monta el Spfd5408 he instalado las librerias correspondientes y en ejemplo para un boton en pantalla he sustituido las originales de adafruit por las del 5408 . Aparece el boton pero el tactil esta invertido,es decir, el boton esta en el lado corto superior y se acciona desde el lado corto inferior.Desde ayer llevo instalando diferentes librerías,rotando pantalla con " tft.setRotation();" para ver si coincide pero no hay manera,He buscado por internet y hay algo
con la libreria MCUFRIEND_kbv editandola pero compila solo para Arduino UNO .Alguna sugerencia??
Muchas gracias

Probaste esta librería? Ojo que esta discontinuada pero es específica para el 5408 y dice que soluciona el problema de las coordenadas invertidas, entre otros.

Saludos

Pues si,la había probado gatul,y no me funcionaba, y gracias a ti me he dado cuenta que solo había incluido esta librería (SPFD5408_Adafruit_TFTLCD.h) y no la del touch así que muchas gracias ahora si funciona correctamente.
bueno...a ver como me las apañao con lo de los menú. ya os iré dando la brasa nuevamente.
Muchas gracias de nuevo por perder vuestro tiempo conmigo.

Suele pasar...
Los otros días me volví loco con una función y resultó que me había olvidado un return.
Suele pasar... :grin: