Libreria leggera per utilizzare un display

Buonasera,
Ho un arduino uno che mi deve svolgere dei calcoli molto complessi e deve visualizzarmi i dati su un display.
Al momento dispongo di un display oled da 0.98'' ma quando vado a utilizzarlo arduino fatica ad elaborare e visualizzare i dati.
Se provo a non utilizzare il display e a visualizzare i dati via monitor seriale non si verifica alcun problema, ma dal momento che i dati vengono visualizzati sul display tutto va molto a rilento.
Quale display mi consigliate di utilizzare? Con quale libreria?
grazie in anticipo.

Se non hai bisogno della grafica ma solo caratteri va benissimo un 16x2 oppure un 20x4.
E' normale che lo OLED da 0,98 vada a rilento. perché "ragiona" a pixel e non a carattere...

Una libreria che pilota un OLED deve tenere sia i dati in memoria (RAM) che nella libreria avere la definizione dei caratteri. Non puó essere leggera.

usa come suggerito un display con un controller HD44780 o compatibile.

Ciao Uwe

"Molto a rilento" cosa vuol dire? Se vuoi 50 aggiornamenti al secondo allora usare un OLED la vedo dura, ma se 1 al secondo è sufficiente, non vedo problemi.

Oppure, se proprio vuoi usare l'OLED, vedi se trovi display OLED "intelligenti", dotati di un proprio processore, come Nextion o 4DSystems, come questo

...però decisamente più complicati da gestire :frowning:

buongiorno,
Si, avevo bisogno di anche qualche animazione grafica e sopratutto mi serve un display con un alto contrasto e nitidezza.
In futuro mi servirà un display molto più grosso nella quale verranno visualizzati molti dati.
Secondo voi ha un senso utilizzare un arduino due? Oppure utilizzare un arduino uno o mega che svolge i calcoli e poi collegato ad un altro arduino che ha il compito di visualizzare i dati?

a questo punto appoggio paulus1969... :smiley:

qualche informazione su come si utilizzi questo display e come pilotarlo? gli mando il dato via seriale e lui pensa a ogni pixel?

nocentini:
qualche informazione su come si utilizzi questo display e come pilotarlo? gli mando il dato via seriale e lui pensa a ogni pixel?

Sono diplay intelligenti, dotati di memoria e di MCU propria. Tu con un apposito "editor" disegni le varie maschere, i vari campi, bottoni, ecc. ecc. poi comandi questi "oggetti" via seriale.

Sono prodotti piuttosto complessi che richiedono un certo studio per imparare ad usarli bene.

Guglielmo

okay grazie mille.
Altre opzioni più semplici? Tipo utilizzare un arduino più veloce dell'arduino uno oppure utilizzare un arduino mega per i calcoli e la gestione dei sensori e un arduino uno collegato via seriale con lo scopo di visualizzare?

si... un pc :smiley:
scusa non ho resistito.
comunque da una UNO ad una MEGA la potenza di calcolo non cambia... cambia il numero di I/O, seriali, flash e sram. ma sempre 16 MHz di clock hanno... che poi il problema non è il calcolo di per sé, ma come si ottimizza il codice...

Raspberry PI é un PC.

Comunque non ha ancora risposto alla mia domanda sopra... Se basta qualche aggiornamento al secondo non vedo che problemi ci siano ad usare un OLED?

L'unico problema è che uso un codice già fatto e non saprei come fare a fargli leggere i dati meno volte al secondo.
Se vi linko il codice sapreste come aiutarmi?

Non è tanto la lettura e elaborazione dei dati che devi limitare ma l'aggiornamento dello schermo al solo minimo indispensabile.
Se mett il codice sicuramente qualcuno potrà darti suggerimenti e aiuto

  read_mpu_6050_data();   
 //Subtract the offset values from the raw gyro values
  gyro_x -= gyro_x_cal;                                                
  gyro_y -= gyro_y_cal;                                                
  gyro_z -= gyro_z_cal;                                                
         
  //Gyro angle calculations . Note 0.0000611 = 1 / (250Hz x 65.5)
  angle_pitch += gyro_x * 0.0000611;                                   //Calculate the traveled pitch angle and add this to the angle_pitch variable
  angle_roll += gyro_y * 0.0000611;                                    //Calculate the traveled roll angle and add this to the angle_roll variable
  //0.000001066 = 0.0000611 * (3.142(PI) / 180degr) The Arduino sin function is in radians
  angle_pitch += angle_roll * sin(gyro_z * 0.000001066);               //If the IMU has yawed transfer the roll angle to the pitch angel
  angle_roll -= angle_pitch * sin(gyro_z * 0.000001066);               //If the IMU has yawed transfer the pitch angle to the roll angel
  
  //Accelerometer angle calculations
  acc_total_vector = sqrt((acc_x*acc_x)+(acc_y*acc_y)+(acc_z*acc_z));  //Calculate the total accelerometer vector
  //57.296 = 1 / (3.142 / 180) The Arduino asin function is in radians
  angle_pitch_acc = asin((float)acc_y/acc_total_vector)* 57.296;       //Calculate the pitch angle
  angle_roll_acc = asin((float)acc_x/acc_total_vector)* -57.296;       //Calculate the roll angle
  
  angle_pitch_acc -= 0.0;                                              //Accelerometer calibration value for pitch
  angle_roll_acc -= 0.0;                                               //Accelerometer calibration value for roll

  if(set_gyro_angles){                                                 //If the IMU is already started
    angle_pitch = angle_pitch * 0.9996 + angle_pitch_acc * 0.0004;     //Correct the drift of the gyro pitch angle with the accelerometer pitch angle
    angle_roll = angle_roll * 0.9996 + angle_roll_acc * 0.0004;        //Correct the drift of the gyro roll angle with the accelerometer roll angle
  }
  else{                                                                //At first start
    angle_pitch = angle_pitch_acc;                                     //Set the gyro pitch angle equal to the accelerometer pitch angle 
    angle_roll = angle_roll_acc;                                       //Set the gyro roll angle equal to the accelerometer roll angle 
    set_gyro_angles = true;                                            //Set the IMU started flag
  }
  
  //To dampen the pitch and roll angles a complementary filter is used
  angle_pitch_output = angle_pitch_output * 0.9 + angle_pitch * 0.1;   //Take 90% of the output pitch value and add 10% of the raw pitch value
  angle_roll_output = angle_roll_output * 0.9 + angle_roll * 0.1;      //Take 90% of the output roll value and add 10% of the raw roll value
   Serial.print(" | Angle  = "); Serial.println(angle_pitch_output);

      display.clearDisplay();  // cancello il buffer del display
      display.setFont(&FreeMonoBold9pt7b);  // seleziono il font
      display.setTextSize(1);  // seleziono le dimensioni del testo
      display.setCursor(10, 40);                       // setto il cursore a x=57 e y=27
      display.println(angle_pitch_output);// scrivo nel display l'angolo di incl
      display.display();

 while(micros() - loop_timer < 4000);                                 //Wait until the loop_timer reaches 4000us (250Hz) before starting the next loop
 loop_timer = micros();//Reset the loop timer
}

Non ha senso aggiornare un display ogni 4mS, serve solo a sovraccaricare la cpu.

Usa millis() ed aggiorna il display ogni 100mS, cioe’ 10 aggiornamenti al secondo: bastano e avanzano e la cpu e’ molto piu’ alleggerita.

Ciao
Marco

Scusami ma io e l'istruzione millis() siamo due rette parallele, ho provato a usarlo molte volte ma senza successo..
Potresti farmi un esempio di come poterlo usare nel mio caso? Grazie in anticipo

miky_police:
comunque da una UNO ad una MEGA la potenza di calcolo non cambia...

oltretutto, se devi fare cose come:

angle_pitch += angle_roll * sin(gyro_z * 0.000001066);
angle_roll -= angle_pitch * sin(gyro_z * 0.000001066);  
acc_total_vector = sqrt((acc_x*acc_x)+(acc_y*acc_y)+(acc_z*acc_z));
...
angle_pitch_acc = asin((float)acc_y/acc_total_vector)* 57.296; 
angle_roll_acc = asin((float)acc_x/acc_total_vector)* -57.296;

io andrei su una Teensy 3.6 piuttosto che su una Mega