Problema de compatibiliad Oled I2C display con comunicacion Serie

International Español Software
1

Hola amigos, estoy trabajando en un proyecto en el cual estoy usando un arduino UNO como controlador principal de una lampara, una maquina de humo, y master de un NodeMCU. Este arduino UNO tiene conectado un display OLED con protocolo I2C, y debe recibir por puerto Serie mensajes provenientes de otro arduino para ejecutar distintas acciones. en el diseno inicial del proyecto estuve usando un display de 128x 32 pixeles, pero ahora he tenido q migrar para uno de 128x64. Me esta sucediendo que con el display de 128x64 no me esta mostrando ningun tipo de texto que deberia mostrar todo el tiempo, haciendo revision del codigo, a prueba y error descubri que si comento el metodo de recibir los mensajes por el puerto serie del arduino, el display funciona con normalidad. Alguna ide de que pudiera estar pasandome? Muchas gracias de antemano
Adjunto el codigo

#include <Arduino.h>
#include <SoftwareSerial.h>
// #include <EEPROM.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH110X.h>

// ////////////////PARAMETROS SINCRONIZACION DEVICES/////////////////

// int delay_Mostrar_Pantalla = 3000;

// int Sync_Ip_Retry_Max = 3; // cant maxima de reintentos cuando intenta conectar devices x Ip

/// parametros de mensajes en pantalla////
bool isDebug = true;
int delay_ShowMsg = 100;
int delay_ShowMsg_Debug = 500;

// ///////////////PARAMETROS SMOKE MACHINE/////////////////////////
int SM_StrikeTime = 3;
bool need_power_off_machine = true;
///////////////////////
/////parametros SL
int SL_strikeTime = 5;

/////// entradas/////////////////////
int in_connected_SM = A0;
int in_low_fuel_SM = A1;
int in_connected_SS = A2;
int in_connected_interfaz = A3;
int in_SL_DMX = 9;
///////////////////////////////
///////salidas///////////////
int power_sm = 2;
int shoot_sm = 3;
int fan_sm = 4;
int sl = 6;
int sound = 8;
SoftwareSerial com_Smart_screen(10, 5); // RX,TX

 
int lect_ss_anterior = 0;
int lect_ss;

// //para indicar si en Stand By se deja la SM primaria encendida. De esa forma estaria ready cuando se abra un juego y no demoraria calentando.
bool SM_StandBy_On = false;

// // true indica que se usan las SM, false indica que aunque se tenga Lane Plus, no se deberian usar las SM (para evitar problemas de sobreconsumo de corriente)
bool Use_SM = false;



unsigned long currentMillis = 0;
unsigned long prevMillis = 0;

bool waitingForTurnOnSM = false;      // cuando se apaga un SM para evitar sobreconsumo, se debe esperar 10 segundos hasta que se vuelva a intentar conectar de nuevo
int waitingForTurnOnSM_Delay = 10000; // tiempo de espera desde que se mandaron a apagar las SM hasta que se vuelven a encender (10 seg)

bool IsOpen_Game = false;
 
bool useLanePlus = true;
bool UseLanePlusOnSpare = true;

 
#define i2c_Address 0x3C // initialize with the I2C addr 0x3C Typically eBay OLED's

#define SCREEN_WIDTH 128 // Ancho de display en pixeles
#define SCREEN_HEIGHT 64 // Altura de display en pixeles
#define OLED_RESET -1    // Pin reset -1 ya que no tiene

Adafruit_SH1106G display = Adafruit_SH1106G(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
bool LOW_FUEL_SM = false;

bool CONNECTED_SM = false;

bool CONNECTED_SS = false;

bool CONNECTED_INTERFAZ = false;
bool CONNECTED_SL = false;

void displayFuncion(int tamano, int columna, int fila, String textDisplay, String textDisplay2)
{
  if (columna == 0 and fila == 0)
  {
    display.clearDisplay();
    }
  display.setTextSize(tamano);        // Tamaño del texto
  display.setTextColor(SH110X_WHITE); // Color de texto blanco
  display.setCursor(columna, fila);   // Empezamos en la columna 0,
  display.print(textDisplay);
  // display.setCursor(0, 16);
  // display.println(textDisplay2);
  display.display();
}
void ShowMsg_Debug2(String msg1, String msg2)
{
  if (isDebug)
  {
    displayFuncion(2, 0, 0, msg1, msg2);
    delay(delay_ShowMsg_Debug);
  }
}
 void ShowMsg_Debug(String msg)
{
  if (isDebug)
  {
    displayFuncion(2, 0, 0, msg, "");
    delay(delay_ShowMsg_Debug);
  }
}

 
void ShowMsg2(String msg, String msg2)
{
  displayFuncion(2, 0, 0, msg, msg2);
  delay(delay_ShowMsg);
}

 
// /********** SM VALIDATIONS ****************************************************************/

void Smoke_Machine_Power_OFF()
{
  digitalWrite(power_sm, LOW);
}
void Smoke_Machine_Power_ON()
{
  digitalWrite(power_sm, HIGH);
}

void TurnOn_SM()
{
  Smoke_Machine_Power_ON();
  ShowMsg2("Turn ON SM", "");
}
void TurnOff_SM()
{
  Smoke_Machine_Power_OFF();
  ShowMsg2("Turn OFF SM", "");
}

 
void shoot_smoke()
{
  digitalWrite(shoot_sm, HIGH);
  delay(SM_StrikeTime * 1000);
  digitalWrite(shoot_sm, LOW);
}


void Todo_onStrike_SM()
{
  shoot_smoke();
  if (need_power_off_machine)
    TurnOff_SM();
}
void CheckTurnOn_SM()
{
  // si hay alguna SM apagada
  if (waitingForTurnOnSM == true)
  {
    currentMillis = millis();

    if (useLanePlus == true && Use_SM == true && currentMillis - prevMillis >= waitingForTurnOnSM_Delay)
    {
      ShowMsg2("RECONNECT", "SM ...");

      if (CONNECTED_SM == false)
      {
        TurnOn_SM();
        waitingForTurnOnSM = false;
      }
    }
  }
}

void Send_Info_To_SS(String msg)
{
  com_Smart_screen.println(msg);
  delay(10);
}
void Todo_OnStrike_SS(int strikes_Count)
{
  Send_Info_To_SS("strike" + String(strikes_Count));
}

void turn_on_SL()
{
  digitalWrite(sl, HIGH);
  delay(SL_strikeTime * 1000);
}
void turn_off_SL()
{
  digitalWrite(sl, LOW);
}

void Todo_OnStrike_SL()
{
  turn_on_SL();
  turn_off_SL();
}
void ShowMsg(String msg)
{
  displayFuncion(2, 0, 0, msg, "");
  delay(delay_ShowMsg);
}
// ////////////////////////FUNCION PARA Q CUANDO SE ACTIVE LA ORDEN DE STRIKE SE MANDE A LOS DiSPOSITIVOS///////////////////
void Todo_OnStrike(int strikes_Count)
{

  Todo_OnStrike_SS(strikes_Count);


  if (useLanePlus == true)
  {
    // solo se mandan a echar humo si las SM estan activas
    if (Use_SM == true)
      Todo_onStrike_SM();

    // ShowMsg("sent strike FM");
    Todo_OnStrike_SL();
  }
}

 
void OpenGame()
{
  IsOpen_Game = true;

  // send Open Game to Smart Screen
  Send_Info_To_SS("O1");

  if (useLanePlus)
  {
    TurnOn_SM();
  }
}


void Activate_Lane_Plus()
{
  useLanePlus = true;
}
void EndGame()
{
  IsOpen_Game = false;

   
  Send_Info_To_SS("E");

  // se manda a apagar 1 o las 2 smoke machines
  if (useLanePlus)
  {
    TurnOff_SM();
  }

  Activate_Lane_Plus();
}

void Gutter()
{
  // se manda el Gutter para el SS solo si esta el LanePlus activado
  if (useLanePlus)
  {
    Send_Info_To_SS("G");
  }
}

// // busca si se recibio respuesta de SmartScreen
bool ReceiveAnswerFromSmartScreen()
{
  CONNECTED_SS = true;
  return true;
}

 void Check_For_SM_Sensors_Info()
{

  if (digitalRead(in_connected_SM) == LOW)
  {
    CONNECTED_SM = true;
  }
  else
  {
    CONNECTED_SM = false;
    LOW_FUEL_SM = false;
    // RDY_SM1 = false;
  }
    if (CONNECTED_SM == true)
     {
    if (digitalRead(in_low_fuel_SM) == LOW)
    {
      LOW_FUEL_SM = true;
    }
 

}
}

 

void ConfigPins()
{
  displayFuncion(2, 16, 0, " KASTLE", "STARTING");

 
  pinMode(in_connected_SM, INPUT);
  pinMode(in_low_fuel_SM, INPUT);
  pinMode(in_connected_SS, INPUT);
  pinMode(in_connected_interfaz, INPUT);
  pinMode(in_SL_DMX, INPUT);

  pinMode(power_sm, OUTPUT);
  pinMode(shoot_sm, OUTPUT);
  pinMode(fan_sm, OUTPUT);
  pinMode(sl, OUTPUT);
  pinMode(sound, OUTPUT);
}

void InitializeDisplay()
{
  //  Serial.begin(9600);
  // delay(250);
  display.begin(i2c_Address, true);
  // display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  //  display.begin(SH1106_SWITCHCAPVCC, 0x3C);

  // display.display();
  //  delay(2000);
  display.clearDisplay();

  delay(10);
}

void Todo_OnSpare(String lec)
{
  // enviar Spare to SS
  Send_Info_To_SS(lec);

  if (UseLanePlusOnSpare == true)
  {
    Todo_onStrike_SM();
    ShowMsg_Debug("sent FM");
    Todo_OnStrike_SL();
  }
}

void Update_UseLanePlusOnSpare(String lec)
{
  if (lec.substring(2).toInt() == 1)
  {
    UseLanePlusOnSpare = true;
    useLanePlus = true;
    ShowMsg2("Lane Plus", "Spare ON");
  }
  else
  {
    UseLanePlusOnSpare = false;
    ShowMsg2("Lane Plus", "Spare OFF");
  }
}

void Cancel_Game()
{
  IsOpen_Game = false;
  ShowMsg_Debug("Cancel Game");
  Activate_Lane_Plus();
}

void Todo_OnWinner_SS(String msg)
{
  Send_Info_To_SS(msg);
}
void Winner(String msg)
{
  Todo_OnWinner_SS(msg);
}

void Todo_OnSuperWinner_SS(String msg)
{
  Send_Info_To_SS(msg);
}
void SuperWinner(String msg)
{
  Todo_OnSuperWinner_SS(msg);

  if (useLanePlus == true)
  {
    Todo_onStrike_SM();
    Todo_OnStrike_SL();
  }
}

 

void Update_SM_Time(String msg)
{
  SM_StrikeTime = (msg.substring(3)).toInt();
 
}

 

void Update_SM_Use(String msg)
{
  if ((msg.substring(3)).toInt() == 1)
  {
    Use_SM = true;
  }
  else
  {
    Use_SM = false;
    TurnOff_SM();
  }
}

 
void Update_SM_StandBy(String msg)
{
  if ((msg.substring(3)).toInt() == 1)
  {
    SM_StandBy_On = true;
  }
  else
  {
    SM_StandBy_On = false;
  }
}
 

// //se usan o no las SM
void Update_UseSM(bool value)
{
  Use_SM = value;
}

void Receive_Interface_Data()
{
  ////// leo un paquete q viene de la interfaz
  if (Serial.available())
  {
    String lec = Serial.readStringUntil('\n');
    // ShowMsg_Debug2(lec, String(lec.length()));

    if (lec.substring(0, 1) == "K")
    {
      IsOpen_Game = true;
      int strikes_coming = (lec.substring(1)).toInt();

      Todo_OnStrike(strikes_coming);
    }
    else if (lec.substring(0, 2) == "LP")
    { 
      if (lec.substring(2).toInt() == 1)
      {
        useLanePlus = true;
        ShowMsg("Lane Plus ON");
      }
      else
      {
        useLanePlus = false;
        ShowMsg("Lane Plus OFF");
      }
 
    }
    else
    {
      if (lec.substring(0, 1) == "E")
      {
        EndGame();
      }
      else
      {
        if (lec.substring(0, 2) == "O1")
        {
          OpenGame();
        }
        else
        {
          if (lec.substring(0, 3) == "FMB")
          {
            Update_SM_StandBy(lec);
          }
          else
          {
            if (lec.substring(0, 3) == "FMO")
            {
              // Update_SM_Balance(lec);
            }
            else
            {
              if (lec.substring(0, 3) == "FMM")
              {
                //  Update_SM_Primary(lec);
              }
              else
              {
                if (lec.substring(0, 3) == "FT1")
                {
                  Update_SM_Time(lec);
                }
                else
                {
                  if (lec.substring(0, 3) == "FT2")
                  {
                    // Update_SM_Secondary_Time(lec);
                  }
                  else
                  {
                    if (lec.substring(0, 2) == "LE")
                    {
                      //                    Save_LanePlus_Params();
                    }
                    else
                    {
                      if (lec.substring(0, 3) == "SWN")
                      {
                        SuperWinner(lec);
                      }
                      else
                      {
                        if (lec.substring(0, 2) == "WN")
                        {
                          Winner(lec);
                        }
                        else
                        {
                          if (lec.substring(0, 2) == "O0")
                          {
                            Cancel_Game();
                            Send_Info_To_SS("O0");
                          }
                          else
                          {
                            if (lec.substring(0, 2) == "PR")
                            {
                              Update_UseLanePlusOnSpare(lec);
                            }
                            else
                            {
                              if (lec.substring(0, 2) == "SP")
                              {
                                Todo_OnSpare(lec);
                              }
                              else
                              {
                                if (lec.substring(0, 3) == "FMA") // para saber si se usa o no los SM
                                {
                                  Update_SM_Use(lec);
                                }
                                else
                                {
                                  if (lec.substring(0, 1) == "G")
                                  {
                                    Gutter();
                                  }
                                  else
                                  {
                                    Send_Info_To_SS(lec); // llego algo que debe reenviarse al Smart Screen
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
void Smart_Screen_connected()
{
  lect_ss = digitalRead(in_connected_SS); // necesidad de anadir resistencia de pull down en el pin 2 (cambio de hardware)

  if (lect_ss == HIGH)
  {
    CONNECTED_SS = true;
  }
  else
  {
    CONNECTED_SS = false;
  }
  if (lect_ss != lect_ss_anterior)
  {
    if (lect_ss == HIGH)
    {
      ShowMsg_Debug("SS connected");
    }
    else
    {
      ShowMsg_Debug("SS disconnected");
    }
  }
  lect_ss_anterior = lect_ss;
}


void iniciar_coms()
{

 
  Serial.begin(9600);
  com_Smart_screen.begin(9600);
}
void check_interface_connected()
{
  int lect_interface = digitalRead(in_connected_interfaz);
 
  if (lect_interface == HIGH)
  {
    CONNECTED_INTERFAZ = true;
  }
  else
  {
    CONNECTED_INTERFAZ = false;
  }
}
void check_SL_connected()
{
  int lect_sl = digitalRead(in_SL_DMX);
  if (lect_sl == HIGH)
  {
    CONNECTED_SL = true;
  }
  else
  {
    CONNECTED_SL = false;
  }
}

void Check_devices_info()
{
  Smart_Screen_connected();
  Check_For_SM_Sensors_Info();
  check_interface_connected();
  check_SL_connected();
}
void show_param()
{
  String mostrar = "KASTLE ";
  if (useLanePlus == true)
  {
    mostrar = mostrar + "LP";
  }
  if (UseLanePlusOnSpare == true)
  {
    mostrar = mostrar + " SP";
  }
 

  displayFuncion(2, 0, 0, mostrar, "");
  delay(1000);
}
void setup()
{
  iniciar_coms();
 
  InitializeDisplay();
 

  ConfigPins();

 
  displayFuncion(1, 0, 0, "STARTING LP", "");
  delay(3000);

 
}

void loop()
{
  

 
if(CONNECTED_INTERFAZ==true)
{
  Receive_Interface_Data();/// este es el metodo q si comento el display empieza funcionar
}
  Check_devices_info();
  show_param();

  
}
2

tu código depende de esto

 int lect_interface = digitalRead(in_connected_interfaz);

Si no recibe nada en el pin A3 (in_connected_interfaz) o sea un 1, no hace ni procesa nada

void check_interface_connected()
{
  int lect_interface = digitalRead(in_connected_interfaz);

  if (lect_interface == HIGH)   {
    connected_interfaz = true;
  }
  else   {
    connected_interfaz = false;
  }
}