Gestione display OLED

[Saverio15]

Grazie per la precisazione.
Della cosa mi ero accorto.
Avendo collegato alla scheda di prova , sia un display SSD1306 che un SH1106 ottengo contemporaneamente la stessa visualizzazione.

[lelerelele]

Avevo provato anche la u8glib, ma era troppo pesante ed occupava un sacco di spazio (non parliamo poi del "mattone" Adafruit, che da solo, includendolo, mi portava via quasi il 90% dello spazio di memoria)

Ecco perché mi sono sempre scritto le librerie che servivano, ma mi chiedo cosa ci sarà di interessante ad usare cose già fatte, e non capirci dentro niente?

Non sarebbe più bello ed utile, capire come farle e farsele specifiche per l'uso che se ne vuol fare? Certo non si può partire da progetto megagalattico.

Io ho scritto dentro un display grafico con un pic12!

Saluti

[Saverio15]

Complimenti. Questa è una cosa che non riuscirò mai a fare.
Per il momento copio molto dalla rete e aggiungo solo le cose più semplici.
Ecco l'ultimo mio lavoro di cui vorrei sostituire il display a LCD con uno a OLED ma per il momento ho grosse difficoltà.

[WALTERmwp]

(...) Ecco perché mi sono sempre scritto le librerie che servivano, ma mi chiedo cosa ci sarà di interessante ad usare cose già fatte, e non capirci dentro niente? (...)

di interessante forse poco ma, a mio parere, certamente diverse altre ragioni per ricorrervici.

Saluti

p.s.
bell'oggettino Saverio15!

[Etemenanki]

Esistono degli OLED 20x4, ma sono troppo costosi (dai 45 ai 60 Euro per poterci scrivere solo 4 righe di testo, e' una follia chiedere un prezzo simile) ... dovresti andare su un grafico, magari gia I2C, ma per farci stare la stessa quantita' di testo, e grande abbastanza da essere leggibile senza occhiali, o vai su un 2.4 (2.42 per alcuni venditori, sempre 128x64), che li trovi sulla ventina di Euro, oppure tocca usare LCD TFT, perche' gli OLED piu grandi li fanno pagare due spropositi e tre quarti, per ora (alcuni venditori, perfino tre spropositi chiedono).

Un TFT con il suo retroilluminatore consumera' sicuramente di piu, rispetto ad un'OLED, ma almeno hai un display a colori con risoluzione maggiore (ad esempio, trovi questi o simili https://it.aliexpress.com/item/1005003936535877.html , 2.8 pollici, 240x320, oppure dei 3.5 o 4.3, ma pagandoli di piu)

[stefanopc]

Bello il tuo prototipo Saverio15.

Quando hai tempo prova la libreria che ti ho segnalato.
Secondo me ti eviti una buona parte di problemi.

Ecco perché mi sono sempre scritto le librerie che servivano, ma mi chiedo cosa ci sarà di interessante ad usare cose già fatte, e non capirci dentro niente?

Riguardo il farsi da se le librerie può essere interessante farlo se non esistono o se quelle esistenti non funzionano correttamente.

Con i PIC 16f88 comandavo i display lcd 4x20 con tre pin e un convertitore seriale parallelo e le librerie non sapevo nemmeno cosa fossero.

Se invece le librerie ci sono e funzionano perfettamente e gente preparata ci ha speso svariate ore di lavoro perché non usarle?

Anche io ho dovuto creare una libreria per utilizzare un chip della Linear nel mio BMS.
Diversi mesi di lavoro che mi sarei evitato volentieri con in più il rischio di ottenere qualcosa di non esattamente affidabile quanto una libreria ufficiale.

A questo punto bisognerebbe farsi ognuno un sistema operativo (al posto di Windows, Linux e Android ) e tutti gli applicativi (editor grafici e testo fogli di calcolo montaggio video, disegno vettoriale ecc) e i driver per tutte le periferiche naturalmente.

Probabilmente saremmo ancora quasi tutti (la maggior parte) alla macchina da scrivere con la carta carbone.
Ciao

[lelerelele]

Riguardo il farsi da se le librerie può essere interessante farlo se non esistono o se quelle esistenti non funzionano correttamente.

Si. Non dico di no.

Se la trovi, e funziona bene, l'unico motivo sarebbe un prodotto custom potrebbe avere meno codice non necessario e quindi caricare meno il sistema, da valutare però se ne vale la pena.

poi io scordo sempre che nel mio piccolo ho fatto tutto come hobby, quindi il tempo perso non viene considerato, che in altro ambito lavorativo assume un forte peso.

Nel caso si tratti di studio, che trovo molto simile al lavoro da hobbysta, ritengo la priorità debba essere data ad imparare, interesse secondario al tempo perso, (farsele è tutto lavoro, e tempo perso, che servirà molto in futuro), quindi credo che in questo ambito sia importante.

Ovvio che questo intervento, ed il precedente, spero siano interessanti come mio punto di vista per Saverio15, da prendere come un parere disinteressato.

A questo punto bisognerebbe farsi ognuno un sistema operativo (al posto di Windows, Linux e Android ) e tutti gli applicativi (editor grafici e testo fogli di calcolo montaggio video, disegno vettoriale ecc) e i driver

per ora non mi sono ancora fatto il sistema operativo del PC, (purtoppo non lo farò mai), anche se ho speso molto tempo alla ricerca di sistemi leggeri con cui usare il PC senza imbottirlo di cazzate e non va piu per il software che serve. Comunque nei miei PC, (pure al lavoro), uso tuti i giorni una serie di programmi, per vario uso, che non sono in commercio, home made, vanno anche bene.


saluti.

[Saverio15]

Ciao Ragazzi. Malgrado la mia buona volontà e le molte ore perse, non riesco a trovare l'inghippo. Mi mancano le competenze.
Tra di voi, c'è qualcuno della zona di Trieste che mi può aiutare?
Grazie.

[Saverio15]

Se può essere utile alla comprensione del mal funzionamento del display, inserisco il listato del programma.

Codice: Seleziona tutto

//     2 - Strumento con OLED SSD1306  del 02.05.2024

//     Nel programma sono usati:
//     Arduino Nano
//     Display OLED SSD1306
//     Metro: HY-SRF05  –  Inclinometro: GY-521  –  Bussola: GY-271  - Temperatura: DHT22

// *************************************************************
//                             Inizializzazione Display OLED
  #include <Adafruit_GFX.h>
  #include <SPI.h>
  #include <Wire.h>
  #include <Adafruit_SSD1306.h>
  #define OLED_ADDR   0x3C
  #define SCREEN_WIDTH 128
  #define SCREEN_HEIGHT 32

//  Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT);

  Adafruit_SSD1306 display(128, 32);

// *************************************************************
//      Inizializzazione DHT22 Umidità e Temperatura del 13.03.2024
  #include <DHT.h>
  #define dataPin 2
  #define DHTType DHT22
  DHT dht = DHT(dataPin, DHTType);

// **************************************************************
//                    Tensione batteria
  int PinBatt = A0;
  int ValPinBatt;
  float Vbatt;
// **************************************************************
//                          Metro
  int t, d; // t=tempo, d=distanza

// **************************************************************
//                     Inclinometro
  #include <SPI.h>
  #include <Wire.h>
  #define MPU 0x68  // I2C address of the MPU-6050 Inclinometro
  #define addr 0x68 //  Address for The QMC5883L  Bussola

  double AcX, AcY, AcZ;
  int Pitch, Roll;

//****************************************************************
//                        Bussola
  #define HMC5883L_Address 0x0D // oppure 0x1E   L'indirizzo del modulo bussola1
  #define X 3 // Registra l'indirizzo per i dati X Y e Z
  #define Y 7
  #define Z 5
  double angle;

//*****************************************************************
  void setup()
  {
// ****************************************************************
  //                   Display OLED
  // initializza e pulisce display
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  display.clearDisplay();
  display.display();

// ****************************************************************
  Serial.begin(9600);

// ****************************************************************
  //                   Tensione batteria
  pinMode (PinBatt, INPUT);

// ****************************************************************
  //            Sensore di temperatura e umidità
  dht.begin();

// ****************************************************************
  //                    Presentazione per display OLED
  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text
  display.setCursor(42, 0);
  display.println(" Ciao");
  display.display();

  display.setTextSize(2);

  display.setCursor(0, 13);
  display.println(" Saverio");
  display.display();

  delay(2000);

  display.clearDisplay();
  display.display();

// ******************************************************************
  //                             Metro
  pinMode (5, INPUT); // pin echo
  pinMode (6, OUTPUT); // pin trigger
  pinMode (7, OUTPUT); // pin buzzer

// ****************************************************************
  //                         Bussola
  Wire.begin(); // Inizializza la libreria Wire
  Init_HMC5883L(); // Inizializza il modulo HMC5883L

//*****************************************************************
  //                              Bussola
  Wire.beginTransmission(addr); //start talking
  Wire.write(0x0B); // Tell the QMC5883L to Continuously Measure
  Wire.write(0x01); // Set the Register
  Wire.endTransmission();
  Wire.beginTransmission(addr); //start talking
  Wire.write(0x09); // Tell the QMC5883L to Continuously Measure
  Wire.write(0x1D); // Set the Register
  Wire.endTransmission();
  }
// *****************************************************************
  void loop ()
  {
// ****************************************************************+

  //                       Tensione batteria

  ValPinBatt = analogRead(PinBatt);

  //  Serial.print("Tensione batteria:");
  ValPinBatt * 2 / 100;
  Vbatt = ValPinBatt;
  //  Serial.println(Vbatt*2/100,1); // visualizza un decimale
  delay(200);

  //               ----------------------------
  //                  Display OLED

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

  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text
  display.setCursor(90, 0);
  display.print(Vbatt * 2 / 100, 1);
  display.println(" V");
  display.display();
  delay(200);

// ***************************************************************
  //                   controllo sensore DHT22
  delay(200);
  float h = dht.readHumidity();
  float t = dht.readTemperature();

// ************************************************************
  //                     Sensore temperatura display OLED
  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text

  display.setCursor(0, 0);
  display.print(t * 0.99, 1);
  display.setCursor(27, 0);
  display.print("g");
  display.display();

// ************************************************************
  //                        Sensore umidità display OLED

  display.setCursor(40, 0);
  display.print(h, 1);
  display.setCursor(68, 0);
  display.print("PC");
  display.display();

  delay(2000);

// ***********************************************************
  //                   Tensione batteria display OLED
  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text
  display.setCursor(90, 0);
  display.print(Vbatt * 2 / 100, 1);
  display.println(" V");
  display.display();
  delay(200);

// ************************************************************
  //                      Programma metro
  digitalWrite(6, LOW); // livello basso sul pin trigger
  delayMicroseconds(2); // per 2 ms
  digitalWrite(6, HIGH); // livello alto sul pin trigger
  delayMicroseconds(10); // per 2 ms
  digitalWrite(6, LOW); // livello basso sul pin trigger
  t = pulseIn(5, HIGH); // comando per la misura del tempo
  d = t / 58; // calcolo della distanza

  //      visualizzazione dei dati sul monitor seriale

  //                     display OLED

  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text
  display.setCursor(0, 8);

  display.print("   Metro = cm ");
  display.setCursor(100, 8);
  display.print("        ");

  display.setCursor(90, 8);
  display.println(d); // distanza in cm
  display.display();
  delay(200);


//************************************************************
  //                        Programma Inclinometro
  FunctionsMPU(); // Acquisisco assi AcX, AcY, AcZ.

  Roll = FunctionsPitchRoll(AcX, AcY, AcZ);   //Calcolo angolo Roll
  Pitch = FunctionsPitchRoll(AcY, AcX, AcZ);  //Calcolo angolo Pitch

  }
void init_MPU()
  {

  Wire.beginTransmission(MPU);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0);     // set to zero (wakes up the MPU-6050)
  Wire.endTransmission(true);
  delay(200);
  }

//         Funzione per il calcolo degli angoli Pitch e Roll

  double FunctionsPitchRoll(double A, double B, double C) {
  double DatoA, DatoB, Value;
  DatoA = A;
  DatoB = (B * B) + (C * C);
  DatoB = sqrt(DatoB);

  Value = atan2(DatoA, DatoB);
  Value = Value * 180 / 3.14;

  return (int)Value;
  }

//       Funzione per l'acquisizione degli assi X,Y,Z del MPU6050

  void FunctionsMPU()
  {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // request a total of 14 registers
  AcX = Wire.read() << 8 | Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
  AcY = Wire.read() << 8 | Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
  AcZ = Wire.read() << 8 | Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L


  //                     display OLED

  display.setTextSize(1);
  display.setTextColor(WHITE); // Draw white text

  display.setCursor(0, 16);
  display.print(" Incl. X= ");
  display.setCursor(50, 16);
  display.print("     ");

  display.setCursor(58, 16);
  display.println(Pitch); // Asse X
  display.display();
  delay(200);

  display.setCursor(80, 16);
  display.print(" Y= ");
  display.setCursor(80, 16);
  display.print("     ");

  display.setCursor(100, 16);
  display.println(Roll); // Asse Y
  display.display();
  delay(200);

//  *************************************************************
  //                     Programma Bussola
  angle = (atan2((double)HMC5883L_Read(X), (double)HMC5883L_Read(Y)) * (180 /
           3.14159265)) + 180; /* Angolo in gradi */

  display.setTextSize(1);  // Testo display OLED
  display.setTextColor(WHITE); // Colore testo display OLED
  if ((angle <= 22.1) || (angle >= 337.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("   Nord");
    display.display();
  }
  if ((angle >= 22) && (angle <= 67.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print(" Nord-Est");
    display.display();
  }
  if ((angle >= 67) && (angle <= 112.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("   Est");
    display.display();
  }
  if ((angle >= 112) && (angle <= 157.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("Sud-Est");
    display.display();
  }
  if ((angle >= 157) && (angle <= 202.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("   Sud");
    display.display();
  }
  if ((angle >= 202) && (angle <= 247.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("Sud-Ovest");
    display.display();
  }
  if ((angle >= 247) && (angle <= 292.1 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("  Ovest");
    display.display();
  }
  if ((angle >= 292) && (angle <= 337 ))
  {
    display.setCursor(10, 24); // Posizione testo display OLED
    display.print("Nord-Ovest");
    display.display();
  }

  //                     Angolo display OLED

  display.setCursor(80, 24); // Posizione testo display OLED
  display.print("     ");   // cancellazione valori precedenti
  display.setCursor(80, 24); // Posizione testo display OLED
  display.print(angle, 0);
  display.print(" gr");
  //  display.print((char)223);

  display.display();

// ***************************************************************

  delay(100); // Aspetta un po' prima di leggere di nuovo

  }
 
//  Questa funzione inizializzerà il modulo e dovrà essere eseguito solo una volta
//  dopo che il modulo è stato acceso o resettato per la prima volta

  void Init_HMC5883L(void)
  {
  // Impostare il modulo su media 8x e frequenza 15Hz
  Wire.beginTransmission(HMC5883L_Address);
  Wire.write(0x00);
  Wire.write(0x70);

  // Imposta un guadagno di 5
  Wire.write(0x01);
  Wire.write(0xA0);
  Wire.endTransmission();
  }
//  Questa funzione verrà letta una sola volta da uno dei registri a 3 assi
//  e restituire il risultato firmato a 16 bit

  int HMC5883L_Read(byte Axis)
  {
  int Result;

  // Iniziare una singola misurazione
  Wire.beginTransmission(HMC5883L_Address);
  Wire.write(0x02);
  Wire.write(0x01);
  Wire.endTransmission();
  delay(6);

  Wire.beginTransmission(HMC5883L_Address);
  Wire.write(Axis);
  Wire.endTransmission();

  // Leggi i dati dai registri
  Wire.requestFrom(HMC5883L_Address, 2);
  Result = Wire.read() << 8;
  Result |= Wire.read();
  return Result;

  // delay(8000);

}

[Saverio15]

Visto che il problema dei caratteri puntiformi sembra più ostico, c'è qualcuno che possa risolvere il problema della sovrascrittura delle misure rendendo la lettura impossibile?
Grazie.