Arduino, diodi e display LCD

Salve a tutti ragazzi! E’ un po’ che vi seguo ed è un po’ che ero intenzionato ad avvicinarmi ad arduino, finalmente per una serie di motivi vari ho fatto il grande passo.
Ho cominciato con lo starter kit approfondendo poi ciò che mi interessava e rispolverando i vecchi appunti di elettronica di scuola.
Fin qui tutto bene ma ora mi ritrovo in un bel problema:
Ho necessità di collegare 2 arduino uno R3 che accedono allo stesso display LCD (quello della confezione dello starter per intenderci) ovviamente l’LCD viene usato o da uno o da un altro non certo contemporaneamente e questa parte viene gestita dal software, il problema però nasce dal fatto che per evitare correnti inverse sui pin ho adottato i classici diodi, tuttavia se collego il display a valle dei diodi lo schermo non mostra nessun carattere. Per essere più chiaro vi allego sotto lo schema.
Ho provato sia con quei “trattori” degli 1n4001 che con i più normali 1n4148, tuttavia il risultato è sempre quello. Ripeto il display provato collegandolo direttamente ad arduino funziona perfettamente, se invece tra i pin di uscita di arduino e quelli di ingresso del display ci sono i diodi il display non funziona più.
Ho pensato il problema potesse essere il tempo di commutazione dei diodi sulle linee che spediscono i dati al display…in quel caso avrebbe senso usare dei diodi schoktty? e se si quale tipo?
Spero di essere stato sufficientemente chiaro anche se non è molto facile da spiegare
Ringraziandovi anticipatamente vi auguro una buona giornata!
Max

Ti invitiamo a presentarti (dicci quali conoscenze hai di elettronica e di programmazione) qui: Presentazioni e a leggere il regolamento: Regolamento - qui una serie di schede by xxxPighi per i collegamenti elettronici vari: ABC - Arduino Basic Connections - qui le pinout delle varie schede by xxxPighi: Pinout - qui una serie di link [u]generali[/u] utili: Link Utili

max10891: Spero di essere stato sufficientemente chiaro anche se non è molto facile da spiegare

In quel modo non può funzionare perché gli input del display rimangono flottanti quando i pin vanno a zero logico. Non devi mettere dei diodi, devi semplicemente settare come input i pin del Arduino che non deve usare il display, poi li setti come out quando è il suo momento e come input quelli dell'altro Arduino.

ecco questa è una ottima soluzione a cui non avevo pensato! pensavo che le dichiarazioni dei pin come output e come input si potessero solo dichiarare all'inizio e non essere modificate dentro il loop!

Questo risolve parecchi problemi! Provo subito e vi faccio sapere!

Davvero gentili! ;)

ok , ho adattato anche il codice:
-il Master che solitamente svolge la funzione di controllo e di stampa su lcd non è stato modificato.
-lo slave invece ho settato come default le porte come input sia i 3 led che le linee dell’LCD (12,11,5,4,3,2) e successivamente le abilito nel caso in cui per 3 secondi il master non interroga lo slave (simulando volutamente che il master sia spento a causa di un’avaria)

if(CurrentMillis-LastEventM>3000)
  {
    Serial.print("SONO NELLA IF\n");
    
    LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
    lcd.begin(16, 2);
    
    t0_lcd = Temp0_Val;
    tegt_lcd = TempEGT_Val;
    n1_lcd = N1_Val;
  
    lcd.print("T.0  ");
    lcd.print(t0_lcd);
    lcd.print(" N1 ");
    lcd.print(n1_lcd);
    lcd.print("%");
    lcd.setCursor(0, 1);
    lcd.print("T.5 ");
    lcd.print(tegt_lcd);
    
    esegui(Ok,Egt_wrn,Egt_ovrht,N1_ovrs);
    lcd.print(msg);
    myServo.write(angle);
  }

  delay(100);

questa è la parte dello slave dove fa il controllo del check

questa invece è la funzione esegui

void esegui (bool Ok, bool Egt_wrn, bool Egt_ovrht, bool N1_ovrs)
{
    pinMode(EGT_WRN, OUTPUT);
    pinMode(EGT_OVRHT, OUTPUT);
    pinMode(N1_OVRS, OUTPUT);
    
    digitalWrite(STATUS_ON, Ok);
    digitalWrite(EGT_WRN, Egt_wrn);
    digitalWrite(EGT_OVRHT, Egt_ovrht);    
    digitalWrite(N1_OVRS, N1_ovrs);
}

e invece la funzione requestEvent che viene chiamata quando il master richiede dei dati allo slave via I2C

void requestEvent()
{
  //questo evento viene generato quando il master chiede allo slave dei dati
  //spedisco il dato al Master
  //INVIO DATI A MASTER
  
  Temp0_Val_S.f=Temp0_Val;
  TempEGT_Val_S.f=TempEGT_Val;
  N1_Val_S.f=N1_Val;
  
  for(int i=0; i<4;i++)
  {
    Wire.write(Temp0_Val_S.b[i]);
    Wire.write(TempEGT_Val_S.b[i]);
    Wire.write(N1_Val_S.b[i]);
  }
  LastEventM= millis();
  
  //vengono settati come pin di input in modo da non rovinare la scheda
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(5, INPUT);
  pinMode(4, INPUT);
  pinMode(3, INPUT);
  pinMode(2, INPUT);
  pinMode(EGT_WRN, INPUT);
  pinMode(EGT_OVRHT, INPUT);
  pinMode(N1_OVRS, INPUT);
}

in questo modo ogni volta che il master interroga lo slave vengono messi come input i piedini dello slave presupponendo che poichè il master sta facendo richiesta sia anche in grado di gestire il tutto compreso l’LCD…

può avere senso quello che ho combinato?

sono solo spezzoni di codice, il progettino è la simulazione di due fadec che controllano lo stesso motore (ovviamente di molto semplificata), se vi interessa posto tutto il codice :wink:

ragazzi purtroppo non riesco ancora a venirne a capo…così facendo il display funziona ma solo se utilizzo solo lo slave…
altro problema è che alimentando un solo arduino sia con la batteria 9V che con la usb in automatico si accende anche l’altro…
purtroppo non riesco proprio a capire dove sbaglio…vi posto entrambi i codici sia del master che dello slave magari voi riuscite a venirne a capo…

SLAVE

//SLAVE
#include <Servo.h>
#include <LiquidCrystal.h>
#include <Wire.h>

//Label porte
const int Temp0 = A0;
const int TempEGT = A1;
const int N1_sensor = A2;
const int STATUS_ON = 13;
const int EGT_WRN = 8; 
const int EGT_OVRHT = 7;
const int N1_OVRS = 6;  

//Parametri di riferimento
const float EGT_limit = 700;
const float EGT_MIN = 50;  
const float N1_OBJ = 80;
const float N1_TOL = 5;  
const float N1_THRS_up = (N1_OBJ + N1_TOL);
const float N1_THRS_down = (N1_OBJ - N1_TOL);

//Variabili servomotore
int angle;
int angle_min = 5;
int angle_idle = 30;
int angle_open = 90;

//Variabili display
int reply;
int t0_lcd;
int tegt_lcd;
int n1_lcd;

//Variabili controllo Master/Slave
const byte masterAddress = 0x01;
const byte dataCount = 4; // [bytes] (max:32)
byte token;

//variabili di tempo
unsigned long LastEventM = millis();
unsigned long CurrentMillis = millis();

//Typedef per scomposizione in byte di un float per la trasmissione 
typedef union S_float{
  byte b[4];
  float f;
};

//Variabili di scomposizione per invio
S_float Temp0_Val_S;
S_float TempEGT_Val_S;
S_float N1_Val_S;

//Variabili Valori letti
float Temp0_Val;
float TempEGT_Val;
float N1_Val;


void setup() {

   //Inizializzazione Comunicazione seriale, servomotore e LCD
  Serial.begin(9600);
  Wire.begin(0x03); //inizializzazione slave Fadec2 address 0x03
  Wire.onReceive(receiveEvent); // register event
  Wire.onRequest(requestEvent);  // register event

  //Inizializzazione porte
  pinMode(Temp0, INPUT);
  pinMode(TempEGT, INPUT);
  pinMode(N1_sensor, INPUT);
  pinMode(STATUS_ON, OUTPUT);
  
  
  pinMode(EGT_WRN, INPUT);
  pinMode(EGT_OVRHT, INPUT);
  pinMode(N1_OVRS, INPUT);
  pinMode(9, INPUT);
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(5, INPUT);
  pinMode(4, INPUT);
  pinMode(3, INPUT);
  pinMode(2, INPUT);
  
}

void loop() {
  
  bool Ok;
  bool Egt_wrn;
  bool Egt_ovrht;
  bool N1_ovrs;
  String msg;
  
  int Temp0_Digital = analogRead(Temp0); 
  float Temp0_V = (Temp0_Digital / 1024.0) * 5.0;
  Temp0_Val = (Temp0_V - .5) *100;
        
  int TempEGT_Digital = analogRead(TempEGT); 
  float TempEGT_V = (TempEGT_Digital / 1024.0) * 5.0 - .5;
  TempEGT_Val = (TempEGT_V * 234) - 50.0;
        
  int N1_Digital = analogRead(N1_sensor); 
  float N1_V = (N1_Digital / 1024.0) * 5.0 - .49;
  N1_Val = (N1_V / 4.5) * 120.0;
  

  Serial.print("AMB V: ");
  Serial.print(Temp0_V);
      
  Serial.print(" T_0: ");
  Serial.print(Temp0_Val);
      
  Serial.print(" --- EGT V ");
  Serial.print(TempEGT_V);
        
  Serial.print(" T_EGT ");
  Serial.print(TempEGT_Val);
      
  Serial.print(" --- N1 V ");
  Serial.print(N1_V);
  
  Serial.print("\n");
  
  if (TempEGT_Val > EGT_limit && N1_Val > N1_THRS_up){ 
      angle = angle_min;
      
      
      Ok=HIGH;
      Egt_wrn=LOW;
      Egt_ovrht=HIGH;
      N1_ovrs=HIGH;
      msg="SP & HT";
      
    }
    else if (TempEGT_Val > EGT_limit && N1_Val > N1_THRS_down && N1_Val < N1_THRS_up){          
      angle = angle_min;
      
      
      Ok=HIGH;
      Egt_wrn=HIGH;
      Egt_ovrht=HIGH;
      N1_ovrs=LOW;
      msg="OVRHEAT";
      
    }
    
    else if (TempEGT_Val > EGT_limit && N1_Val < N1_THRS_down){
      angle = angle_idle;
      
      
      Ok=LOW;
      Egt_wrn=HIGH;
      Egt_ovrht=HIGH;
      N1_ovrs=HIGH;
      msg="SENSOR";
      
    }
  
    else if (TempEGT_Val < EGT_limit && TempEGT_Val > EGT_MIN && N1_Val > N1_THRS_up){
      angle = angle_min;
      
      
      Ok=HIGH;
      Egt_wrn=LOW;
      Egt_ovrht=LOW;
      N1_ovrs=HIGH;
      msg="OVRSPD";
      
    }
    
    else if (TempEGT_Val < EGT_limit && TempEGT_Val > EGT_MIN && N1_Val < N1_THRS_down){    
      angle = angle_open;
      
      
      Ok=HIGH;
      Egt_wrn=LOW;
      Egt_ovrht=LOW;
      N1_ovrs=LOW;
      msg="OK";
  
    }
  
    else if (TempEGT_Val < EGT_limit && TempEGT_Val > EGT_MIN && N1_Val > N1_THRS_down && N1_Val < N1_THRS_up){           
      angle = angle_idle;
      
      
      Ok=HIGH;
      Egt_wrn=LOW;
      Egt_ovrht=LOW;
      N1_ovrs=LOW;
      msg="OK";
      
    }
  
    else if (TempEGT_Val < EGT_MIN && N1_Val < N1_THRS_down){  
      angle = angle_open;
      
      
      Ok=HIGH;
      Egt_wrn=LOW;
      Egt_ovrht=LOW;
      N1_ovrs=LOW;
      msg="OK";

    }
    
    else if (TempEGT_Val < EGT_MIN && N1_Val > N1_THRS_up){           
      angle = angle_idle;


      Ok=LOW;
      Egt_wrn=HIGH;
      Egt_ovrht=HIGH;
      N1_ovrs=HIGH;
      msg="SENSOR";
  
    }
    
    else if (TempEGT_Val < EGT_MIN && N1_Val > N1_THRS_down && N1_Val < N1_THRS_up){
      angle = angle_idle;
      
      
      Ok=HIGH;
      Egt_wrn=HIGH;
      Egt_ovrht=LOW;
      N1_ovrs=LOW;
      msg="NOZZLE";
      
    }
  
  
  CurrentMillis=millis();
  if(CurrentMillis-LastEventM>3000)
  {
    Serial.print("SONO NELLA IF\n");
    Servo myServo;
    myServo.attach(9);
    LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
    lcd.begin(16, 2);
    
    t0_lcd = Temp0_Val;
    tegt_lcd = TempEGT_Val;
    n1_lcd = N1_Val;
    
    lcd.clear();
    lcd.print("T.0  ");
    lcd.print(t0_lcd);
    lcd.print(" N1 ");
    lcd.print(n1_lcd);
    lcd.print("%");
    lcd.setCursor(0, 1);
    lcd.print("T.5 ");
    lcd.print(tegt_lcd);
    
    esegui(Ok,Egt_wrn,Egt_ovrht,N1_ovrs);
    lcd.print(msg);
    myServo.write(angle);
  } 
  delay(100);
  
}

void esegui (bool Ok, bool Egt_wrn, bool Egt_ovrht, bool N1_ovrs)
{
    pinMode(EGT_WRN, OUTPUT);
    pinMode(EGT_OVRHT, OUTPUT);
    pinMode(N1_OVRS, OUTPUT);
    
    digitalWrite(STATUS_ON, Ok);
    digitalWrite(EGT_WRN, Egt_wrn);
    digitalWrite(EGT_OVRHT, Egt_ovrht);    
    digitalWrite(N1_OVRS, N1_ovrs);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  token = Wire.read();    // receive byte as an integer
  token++;
  Serial.println(token);         // print the integer
  Wire.beginTransmission(masterAddress);
  Wire.write(token);
  Wire.endTransmission();
  LastEventM= millis();
}

void requestEvent()
{
  //questo evento viene generato quando il master chiede allo slave dei dati
  //spedisco il dato al Master
  //INVIO DATI A MASTER
  
  Temp0_Val_S.f=Temp0_Val;
  TempEGT_Val_S.f=TempEGT_Val;
  N1_Val_S.f=N1_Val;
  
  for(int i=0; i<4;i++)
  {
    Wire.write(Temp0_Val_S.b[i]);
    Wire.write(TempEGT_Val_S.b[i]);
    Wire.write(N1_Val_S.b[i]);
  }
  LastEventM= millis();
  
  //vengono settati come pin di input in modo da non rovinare la scheda
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(5, INPUT);
  pinMode(4, INPUT);
  pinMode(3, INPUT);
  pinMode(2, INPUT);
  pinMode(EGT_WRN, INPUT);
  pinMode(EGT_OVRHT, INPUT);
  pinMode(N1_OVRS, INPUT);
}

MASTER

//MASTER
#include <Servo.h>
#include <LiquidCrystal.h>
#include <Wire.h>

//Inizializzazione LCD e Servo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Servo myServo;

//Label porte
const int Temp0 = A0;
const int TempEGT = A1;
const int N1_sensor = A2;
const int STATUS_ON = 13;
const int EGT_WRN = 8; 
const int EGT_OVRHT = 7;
const int N1_OVRS = 6;  

//Parametri di riferimento
const float EGT_limit = 700;
const float EGT_MIN = 50;  
const float N1_OBJ = 80;
const float N1_TOL = 5;  
const float N1_THRS_up = (N1_OBJ + N1_TOL);
const float N1_THRS_down = (N1_OBJ - N1_TOL);

//Variabili servomotore
int angle;
int angle_min = 5;
int angle_idle = 30;
int angle_open = 90;

//Variabili display
int reply;
int t0_lcd;
int tegt_lcd;
int n1_lcd;

//Variabili e costanti controllo Master/Slave
const byte slaveAddress = 0x03;
const byte dataCount = 12; // [bytes] (max:32)
byte token;
byte token2;
bool fadecs; // 0 - fadec slave OFF; 1 - fadec slave ON

//Typedef per scomposizione in byte di un float per la trasmissione 
typedef union S_float{
  byte b[4];
  float f;
};

//Variabili di scomposizione per ricezione dati
S_float Temp0_Val2_S;
S_float TempEGT_Val2_S;
S_float N1_Val2_S;

//Variabili sensori fadec Slave
float Temp0_Val2=0;
float TempEGT_Val2=0;
float N1_Val2=0;

//funzioni
void check();
void richiestaDati();

void setup() {

   //Inizializzazione Comunicazione seriale, servomotore e LDCD
  Serial.begin(9600);    
  myServo.attach(9);
  lcd.begin(16, 2);
  Wire.begin(0x01); //inizializzazione master Fadec1
  Wire.onReceive(receiveEvent); // register event

  //Inizializzazione porte
  pinMode(Temp0, INPUT);
  pinMode(TempEGT, INPUT);
  pinMode(N1_sensor, INPUT);
  pinMode(STATUS_ON, OUTPUT);
  pinMode(EGT_WRN, OUTPUT);
  pinMode(EGT_OVRHT, OUTPUT);
  pinMode(N1_OVRS, OUTPUT);  
}

void loop() {
  
  bool Ok;
  bool Egt_wrn;
  bool Egt_ovrht;
  bool N1_ovrs;
  String msg;
  
  float Temp0_Val_AVG;
  float TempEGT_Val_AVG;
  float N1_Val_AVG;
 
  check();
    
  int Temp0_Digital = analogRead(Temp0); 
  float Temp0_V = (Temp0_Digital / 1024.0) * 5.0;
  float Temp0_Val = (Temp0_V - .5) *100;
        
  int TempEGT_Digital = analogRead(TempEGT); 
  float TempEGT_V = (TempEGT_Digital / 1024.0) * 5.0 - .5;
  float TempEGT_Val = (TempEGT_V * 234) - 50.0;
        
  int N1_Digital = analogRead(N1_sensor); 
  float N1_V = (N1_Digital / 1024.0) * 5.0 - .49;
  float N1_Val = (N1_V / 4.5) * 120.0;
  
  if(fadecs==1)
  {
    richiestaDati();
    if(abs(Temp0_Val-Temp0_Val2)<((15*max(Temp0_Val,Temp0_Val2))/100))      //15% di tolleranza
    {
      Temp0_Val_AVG=(Temp0_Val+Temp0_Val2)/2;
    }
    else
    {
      Temp0_Val_AVG=max(Temp0_Val,Temp0_Val2);
    }
    
    if(abs(TempEGT_Val-TempEGT_Val2)<((15*max(TempEGT_Val,TempEGT_Val2))/100))      //15% di tolleranza
    {
      TempEGT_Val_AVG=(TempEGT_Val+TempEGT_Val2)/2;
    }
    else
    {
      if(TempEGT_Val<EGT_limit && TempEGT_Val>EGT_MIN)
      {
        TempEGT_Val_AVG=TempEGT_Val;
      }
      else
      {
        if(TempEGT_Val2<EGT_limit && TempEGT_Val2>EGT_MIN)
          TempEGT_Val_AVG=TempEGT_Val2;
        else
          TempEGT_Val_AVG=max(TempEGT_Val,TempEGT_Val2);
      }
    }
    
    if(abs(N1_Val-N1_Val2)<((15*max(N1_Val,N1_Val2))/100))      //15%di tolleranza
    {
      N1_Val_AVG=(N1_Val+N1_Val2)/2;
    }
    else
    {
      if(N1_Val<N1_THRS_up && N1_Val>N1_THRS_down)
      {
        N1_Val_AVG=N1_Val;
      }
      else
      {
        if(N1_Val2<N1_THRS_up && N1_Val2>N1_THRS_down)
          N1_Val_AVG=N1_Val2;
        else
          N1_Val_AVG=max(N1_Val,N1_Val2);
      }
    }
  }
  else
  {
    Temp0_Val_AVG = Temp0_Val;
    TempEGT_Val_AVG = TempEGT_Val;
    N1_Val_AVG = N1_Val; 
  }

  Serial.print("AMB V: ");
  Serial.print(Temp0_V);
      
  Serial.print(" T_0: ");
  Serial.print(Temp0_Val);
  Serial.print(" T_0_2: ");
  Serial.print(Temp0_Val2);
  Serial.print(" T_0_AVG: ");
  Serial.print(Temp0_Val_AVG);
      
  Serial.print(" --- EGT V ");
  Serial.print(TempEGT_V);
        
  Serial.print(" T_EGT_Val");
  Serial.print(TempEGT_Val);
  Serial.print(" T_EGT_Val2");
  Serial.print(TempEGT_Val2);
  Serial.print(" T_EGT_AVG ");
  Serial.print(TempEGT_Val_AVG);
      
  Serial.print(" --- N1 V ");
  Serial.print(N1_V);
  
  Serial.print(" --- N1 Val ");
  Serial.print(N1_Val);
  Serial.print(" --- N1 Val2 ");
  Serial.print(N1_Val2);
  Serial.print(" --- N1 V_AVG ");
  Serial.print(N1_Val_AVG);
  Serial.print("\n");
  
  t0_lcd = Temp0_Val_AVG;
  tegt_lcd = TempEGT_Val_AVG;
  n1_lcd = N1_Val_AVG;  
  
  lcd.clear();  
  lcd.print("T.0  ");
  lcd.print(t0_lcd);
  lcd.print(" N1 ");
  lcd.print(n1_lcd);
  lcd.print("%");
  lcd.setCursor(0, 1);
  lcd.print("T.5 ");
  lcd.print(tegt_lcd);

  if (TempEGT_Val_AVG > EGT_limit && N1_Val_AVG > N1_THRS_up){ 
    angle = angle_min;
    
    
    Ok=HIGH;
    Egt_wrn=LOW;
    Egt_ovrht=HIGH;
    N1_ovrs=HIGH;
    msg="SP & HT";
    
  }
  else if (TempEGT_Val_AVG > EGT_limit && N1_Val_AVG > N1_THRS_down && N1_Val_AVG < N1_THRS_up){          
    angle = angle_min;
    
    
    Ok=HIGH;
    Egt_wrn=HIGH;
    Egt_ovrht=HIGH;
    N1_ovrs=LOW;
    msg="OVRHEAT";
    
  }
  
  else if (TempEGT_Val_AVG > EGT_limit && N1_Val_AVG < N1_THRS_down){
      angle = angle_idle;
      
       
      Ok=LOW;
      Egt_wrn=HIGH;
      Egt_ovrht=HIGH;
      N1_ovrs=HIGH;
      msg="SENSOR";
  }

  else if (TempEGT_Val_AVG < EGT_limit && TempEGT_Val_AVG > EGT_MIN && N1_Val_AVG > N1_THRS_up){
    angle = angle_min;
        
        
    Ok=HIGH;
    Egt_wrn=LOW;
    Egt_ovrht=LOW;
    N1_ovrs=HIGH;
    msg="OVRSPD";
  }
  
  else if (TempEGT_Val_AVG < EGT_limit && TempEGT_Val_AVG > EGT_MIN && N1_Val_AVG < N1_THRS_down){    
    angle = angle_open;
    
    
    Ok=HIGH;
    Egt_wrn=LOW;
    Egt_ovrht=LOW;
    N1_ovrs=LOW;
    msg="OK"; 
  }

  else if (TempEGT_Val_AVG < EGT_limit && TempEGT_Val_AVG > EGT_MIN && N1_Val_AVG > N1_THRS_down && N1_Val_AVG < N1_THRS_up){           
    angle = angle_idle;
    
    
    Ok=HIGH;
    Egt_wrn=LOW;
    Egt_ovrht=LOW;
    N1_ovrs=LOW;
    msg="OK";
  }

  else if (TempEGT_Val_AVG < EGT_MIN && N1_Val_AVG < N1_THRS_down){  
    angle = angle_open;
    
    
    Ok=HIGH;
    Egt_wrn=LOW;
    Egt_ovrht=LOW;
    N1_ovrs=LOW;
    msg="OK";
  }
  
  else if (TempEGT_Val_AVG < EGT_MIN && N1_Val_AVG > N1_THRS_up){           
    angle = angle_idle;
    
    
    Ok=LOW;
    Egt_wrn=HIGH;
    Egt_ovrht=HIGH;
    N1_ovrs=HIGH;
    msg="SENSOR"; 
  }
  
  else if (TempEGT_Val_AVG < EGT_MIN && N1_Val_AVG > N1_THRS_down && N1_Val_AVG < N1_THRS_up){
    angle = angle_idle;
    
    
    Ok=HIGH;
    Egt_wrn=HIGH;
    Egt_ovrht=LOW;
    N1_ovrs=LOW;
    msg="NOZZLE"; 
  }
  
  esegui(Ok,Egt_wrn,Egt_ovrht,N1_ovrs);
  lcd.print(msg);
  myServo.write(angle);
  delay(100);

}


void esegui (bool Ok, bool Egt_wrn, bool Egt_ovrht, bool N1_ovrs)
{              
    digitalWrite(STATUS_ON, Ok);
    digitalWrite(EGT_WRN, Egt_wrn);
    digitalWrite(EGT_OVRHT, Egt_ovrht);    
    digitalWrite(N1_OVRS, N1_ovrs);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  Serial.println(howMany); 
  token2 = Wire.read();    // receive byte as an integer
  Serial.println(token2);         // print the integer
  token++;
  if(token==token2)
    fadecs=1;
  else
    fadecs=0;
}

//CONTROLLO DI FUNZIONAMENTO FADECs
void check()
{
  Serial.print("\n\n CHECK \n\n ");
  token=0;
  token2=10;
  Wire.beginTransmission(slaveAddress);
  Wire.write(token);
  Wire.endTransmission();
}

//RICHIAMA LA FUNZIONE PER SAPERE I DATI DELL'ALTRO FADEC
void richiestaDati()
{
  Serial.print("\n\n RICHIESTA DATI \n\n ");
  Wire.requestFrom(slaveAddress, dataCount);    // richiesta di 12bytes (3float);
  for(int i=0; Wire.available() && i<dataCount; i++)    // slave may send less than requested
  { 
    Temp0_Val2_S.b[i] = Wire.read();
    TempEGT_Val2_S.b[i] = Wire.read();
    N1_Val2_S.b[i] = Wire.read(); // receive a byte as memory cell
  }
  
  Temp0_Val2=Temp0_Val2_S.f;
  TempEGT_Val2=TempEGT_Val2_S.f;
  N1_Val2=N1_Val2_S.f;

  delay(75);
}

il circuito è il medesimo di prima, tranne per i diodi…attualmente quando partono tutti e 2 sul display appaiono caratteri strani come se sulle linee dati ci fosse un gran maracanà!

Vi ringrazio nuovamente

P.S. ho dovuto spezzare in due post perchè insieme non me lo faceva inviare spero non sia un problema per i mod :wink:

probabilmente prende l'alimentazione dalle linee in comune del LCD..... capita ! Cedo che i due Arduini sono collegati tramile I2C, perche non colleghi anche l'LCD in I2C

ci sono modulini dedicati come questo

Quindi torniamo al discorso iniziale...devo trovare un modo per "disaccoppiare" i 2 circuiti e i diodi sono la cosa più semplice che mi viene in mente...e quindi mi chiedo gli schottky citati prima dovrebbero funzionare? ma quale tipo?

purtroppo la soluzione del display i2c non è percorribile più che altro per problemi di tempo, sia nel reperire il convertitore sia per riscrivere il codice...se possibile vorrei trovare una soluzione più "immediata"...grazie comunque del suggerimento, ne terrò conto per eventuali progetti futuri ;) :)

EDIT: Cercando un po' con il caro amico Google mi sono imbattuto nella serie di diodi BAD41 e BAT43, 5ns come tempo di commutazione fino a 100mA di corrente diretta... direi che potrebbero fare al mio caso no?

Puoi usare tutti i diodi che vuoi, pure da 2 PicoTetraSecondi, il problema non e’ la velocità dei diodi, ma come già ti aveva detto @Astro, un segnale LOW in uscita da Arduino non passa e ti lascia il piedino di ingresso dell’LCD flottante
E tu dirai… Ah, allora basta aggiungere una resistenza di PullDown dopo il diodo, cosi’ sono a posto.
Nemmeno… perche’ non sai che segnale c’e’ sull’altro diodo.
Guarda il disegnino allegato e supponi di lavorare sull’ingresso A.
Se il B fosse LOW, funzionerebbe, ma se e’ a livello HIGH ?

Per fare quello che vorresti tu, dovresti usare dei Data Selector Multiplexer, dove con l’abilitazione dei rispettivi ingressi di un Flip Flop decidi con quale Arduino lavorare.

E comunque usare l’ I2C non comporta nessuna riscrittura del codice, Basta cambiare il nome della libreria
E anche se lo compri su Ebay, se fanno la consegna con corriere in due gg lo hai

Chiarissimo ed esaustivo al massimo! Grazie mille per la dritta e per l'ottima spiegazione! Vedrò che tipo di soluzione adottare e vi farò sapere...Grazie di nuovo! Max

EDIT: Ho dato un occhio al convertitore i2c che mi avete suggerito, fondamentalmente va inserito collegando gli ingressi del display ai rispettivi pin del convertitore, l'interfaccia con il display "per me" sarà solo i 4 pin VCC GND SDA SCL quindi? penso che a questo punto andrò verso quella soluzione anche perchè mi sembra meno impegnativa del Data Mux

http://www.plexishop.it/it/modulo-lcm1602-lcd-serial-adapter.html

Ho trovato questo con spedizione da corriere, secondo voi è ok?

Grazie