Go Down

Topic: Ecran oled 128x64 i2c et bibliothèque u8g2 (Read 722 times) previous topic - next topic

ArduinoFree

Bonjour

Suite au post précédent sur "Ecran oled 128x64 i2c et bibliothèque u8x8, j'essaie la bibliothèque u8g2
qui me permet de changer la taille de la police.

J'ai 2 pb.
1 Je ne sais pas quel écran choisir dans la rubriqueSSD1306 128X64_NONAME
Et comment le paramétrer
https://github.com/olikraus/u8g2/wiki/u8g2setupc

2 Je ne comprends pas le choix des fontes.
Certaines sont notées en fin u8g2, d'autres x11.
Je pense que c'est directX11, mais laquelle je dois prendre ?
 
https://github.com/olikraus/u8g2/wiki/fntlistall

Je joints le code qui fonctionne en u8x8
Code: [Select]
/*
  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.
  Please UNCOMMENT one of the contructor lines below

  U8x8 Contructor List: https://github.com/olikraus/u8g2/wiki/u8x8setupcpp
  Update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
*/

/* utilisation de  A0 pour le voltage                avec resistance en //
             pin 4 pour l'AIR DS18b20EAU
             des A4 et A5 pour l'écran
             du  pin 2 pour l'eau DS18b20EAU

  AO   récupère l'information du voltage avec GND fil direct à la batterie mais avec resistance en parallèle !!
  pin 4 AIR récupère l'information de la température de la sonde étanche 1m  DS18B20
  pin 2 EAU récupère l'information de la température de la sonde étanche 1m  DS18B20
  A4 et A5 affichage de l'écran

    "5 Volt c'est la tension de la référence de tension de l'ADC.
    J'espère que tu n'as pas raccordé directement le 12V à A0 ?
    Il faut placer un pont diviseur à deux résistances pour que la tension sur A0 soit inférieure à 12V".
*/


/* Essai affichage voltage, température air et eau
  // http://www.instructables.com/id/Arduino-OLED-Voltage-Meter/  le voltmètre
  //              A0 et GND entre les deux mettre resistance ( voir le lien)ici A0 pour le voltage
  //              A0 est lié à la batterie et GND à l'autre  pôle de la batterie

  // http://edu.mrpigg.ca/termo.html     thermo resistor  Keyes KY-013  pour l'air
  // https://letmeknow.fr/blog/2016/08/10/le-capteur-de-temperature-ds18b20/

  //les librairies de l'écran
  //https://github.com/adafruit/Adafruit_SSD1306
  //https://github.com/adafruit/Adafruit-GFX-Library


  //les librairies de la sonde étanche DS18B20
  //https://github.com/PaulStoffregen/OneWire
*/


// Pour l'écran
#include <Arduino.h>
#include <U8x8lib.h>
//Pour les sondes
#include <DallasTemperature.h>     //DS18B20 pour température de l'eau et de l'air
#include <Wire.h>



// Déclaratipon de l'écran 128x64
U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(A5, A4, U8X8_PIN_NONE); // OLEDs without Reset of the Display
// Déclaratipon de l'écran 128x128 à venir
// U8X8_SH1107_128X128_HW_I2C u8x8(/* reset=*/ 8);

// les 2 sondes DS18B20
#define ONE_WIRE_BUS_1 2               // sonde pour l'eau pin 2
#define ONE_WIRE_BUS_2 4               // sonde pour l'air pin 4
OneWire oneWire_in(ONE_WIRE_BUS_1);    // sonde pour l'eau
OneWire oneWire_out(ONE_WIRE_BUS_2);   // sonde pour l'air
DallasTemperature sensor_eau(&oneWire_in);     // sonde pour l'eau
DallasTemperature sensor_air(&oneWire_out);    // sonde pour l'air



void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8x8.begin();
  u8x8.setPowerSave(0);


  // start serial port
  Serial.begin(115200);
  Serial.println("Dallas Temperature Control Library Demo - TwoPin_DS18B20");

  // Start up the library
  sensor_eau.begin();    // sonde pour l'eau
  sensor_air.begin();    // sonde pour l'air

  // déclaration de la pin 2 et 4
  pinMode(2, INPUT);
  pinMode(4, INPUT);

  int readValEau = analogRead(2);// met à zéro la sonde EAU
  int readValAir = analogRead(4);// met à zéro la sonde AIR


}

void loop(void)
{
  // AFFICHAGE SUR SERIAL
  Serial.print("Recherche des temperatures...");
  sensor_eau.requestTemperatures();
  sensor_air.requestTemperatures();
  Serial.println(" done");

  // sonde EAU
  Serial.print("Température eau: ");
  Serial.println(sensor_eau.getTempCByIndex(0));

  // sonde AIR
  Serial.print("Température air: ");
  Serial.println(sensor_air.getTempCByIndex(0));
  delay ( 5000);

  /*/modele d'écriture
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 18);
    u8x8.print("Hello World");
  */

  // Affichage Niveau batterie
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 0);
  u8x8.println("NIVEAU BATTERIE");
  //delay ( 1000);

  // pour le voltage de la batterie
  // Conversion du signal (which goes from 0 - 1023) to a voltage (0 - (V):
  int sensorValue = analogRead(A0);//*******************************************************  A3 pour la voiture bateau
  // écrit la valeur lue
  float voltage = sensorValue * (5.0 / 1023.0);
  u8x8.setCursor(0, 1);// position 0, sur la 1 ere ligne,
  u8x8.print("        ");
  u8x8.print(voltage);
  u8x8.print("V");

  //Affichage  températures Air
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 3);
  u8x8.println("TEMP. AIR ");
  u8x8.print("       ");
  u8x8.print(sensor_air.getTempCByIndex(0));
  u8x8.print(" ");
  u8x8.print("C");

  // Affichage  températures Eau
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 6);
  u8x8.println("TEMP. EAU ");
  u8x8.print("       ");
  u8x8.print(sensor_eau.getTempCByIndex(0));
  u8x8.print(" ");
  u8x8.print("C");


}



Code de test dans lequel j'ai remplacé les u8x8 par u8g2 ( si j'ai bien compris la différence entre les 2 bibliothèque)
Code: [Select]

// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
U8G2_SSD1306_128X64_NONAME_SW_I2C U8G2(A5, A4, U8G2_PIN_NONE); // OLEDs without Reset of the Display
// Déclaratipon de l'écran 128x128 à venir
// U8G2_SH1107_128X128_HW_I2C U8G2(/* reset=*/ 8);





void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);
}

void loop(void)
{
  //modele d'écriture
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 15);
  u8g2.print("Hello World!");

}

lesept

Je n'au jamais testé u8g2, mais dans ton second lien on voit l'explication des noms des polices.
Code: [Select]
<prefix> '_' <name> '_' <purpose> <char set>

Purpose :
  • t   Transparent font, Do not use a background color.
  • h   All glyphs have common height.
  • m   All glyphs have common height and width (monospace).
  • 8   All glyphs fit into a 8x8 pixel box.


Char set :
  • f   The font includes up to 256 glyphs.
  • r   Only glyphs on the range of the ASCII codes 32 to 127 are included in the font.
  • u   Only glyphs on the range of the ASCII codes 32 to 95 (uppercase chars) are included in the font.
  • n   Only numbers and extra glyphs for writing date and time strings are included in the font.
  • ...   Other custom character list.

Là on voit que celles qui finissent par 'u' prennent moins de place : que des majuscules, plus les chiffres et la ponctuation (voir une table ASCII pour les codes de 32 à 95). Celles qui finissent par 't' ajoutent les minuscules.
Après, le choix de la police dépend de toi...

Pour la configuration, ton premier lien donne ceci :
Code: [Select]
u8g2_t u8g2; // a structure which will contain all the data for one display
...
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_lpc11u3x);  // init u8g2 structure
u8g2_InitDisplay(&u8g2); // send init sequence to the display, display is in sleep mode after this,
u8g2_SetPowerSave(&u8g2, 0); // wake up display

Il y a 3 arguments :
  • U8G2_R0 : définit la rotation de l'écran (5 cas possibles, voir sur le lien), tu testes jusqu'à trouver celui qui te convient
  • u8x8_byte_sw_i2c : c'est bon pour toi si tu es en I2C
  • u8x8_gpio_and_delay_lpc11u3x : là c'est assez complexe, je ne sais pas trop... Tu peux essayer de mettre U8X8_MSG_DELAY_I2C
Ca donnerait :
Code: [Select]
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

ArduinoFree

#2
Jun 25, 2018, 10:19 am Last Edit: Jun 25, 2018, 10:36 am by ArduinoFree
Merci

J'ai essayé de voir sur le site

Je ne pourrais tester que ce soir.

J'ai pris cet écran 128x128
https://www.banggood.com/fr/1_5-Inch-128x128-OLED-Shield-Screen-Module-For-Raspberry-Pi-STM32-Arduino-p-1305186.html?rmmds=myorder&cur_warehouse=CN

Je ne sais pas lequel prendre , il y a des MIDAS, des EA ...
je prendrai celui-ci
Code: [Select]
u8g2_Setup_ssd1327_i2c_midas_128x128_1(u8g2, rotation, u8x8_byte_sw_i2c, uC specific)


Je suis aller sur leur wiki , mais je n'ai rien compris

lesept

C'est vrai qu'il y a 2 types d'écrans 128x128 en I2C, je suppose que ce sont des fabricants différents.

Pour U8x8, tu peux les tester avec ce code :
Code: [Select]
#include <Arduino.h>
#include <SPI.h>
#include <U8x8lib.h>

/* Constructor */
U8X8_SSD1327_EA_W128128_SW_I2C(A5, A4);
// ou, si ça ne marche pas :
//  U8X8_SSD1327_MIDAS_128X128_SW_I2C(A5, A4);

/* u8x8.begin() is required and will sent the setup/init sequence to the display */
void setup(void)
{
  u8x8.begin();
}

void loop(void)
{
  u8x8.setFont(u8x8_font_chroma48medium8_r);  // <-- Choisir la bonne police ici
  u8x8.drawString(0,0,"Hello World!");
  delay(1000);
}


Pour U8g2 :
Code: [Select]
#include <Arduino.h>
#include <SPI.h>
#include <U8g2lib.h>

/* Constructor */
U8G2_SSD1327_EA_W128128_1_SW_I2C(U8G2_R0, A5, A4);
// si ne marche pas :
//U8G2_SSD1327_MIDAS_128X128_1_SW_I2C(U8G2_R0, A5, A4);

/* u8g2.begin() is required and will sent the setup/init sequence to the display */
void setup(void) {
  u8g2.begin();
}

/* draw something on the display with the `firstPage()`/`nextPage()` loop*/
void loop(void) {
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_ncenB14_tr);  // <-- Choisir la bonne police ici
    u8g2.drawStr(0,20,"Hello World!");
  } while ( u8g2.nextPage() );
  delay(1000);
}
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

ArduinoFree


ArduinoFree

Salut

Voici pour le test en 128x64 avec u8g2
Retour des erreurs

Code: [Select]
Arduino : 1.8.5 (Windows 10), Carte : "Arduino/Genuino Uno"

Ecran_u8G2_128x64_128x128:11: error: expected constructor, destructor, or type conversion before '(' token

 u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

                                       ^

D:\ACER-Patrick\CLARISSE\Code bateau\000_fonctionnent\Ecran_u8G2_128x64_128x128\Ecran_u8G2_128x64_128x128.ino: In function 'void setup()':

Ecran_u8G2_128x64_128x128:23: error: 'u8g2' was not declared in this scope

   u8g2.begin();

   ^

D:\ACER-Patrick\CLARISSE\Code bateau\000_fonctionnent\Ecran_u8G2_128x64_128x128\Ecran_u8G2_128x64_128x128.ino: In function 'void loop()':

Ecran_u8G2_128x64_128x128:36: error: 'u8g2' was not declared in this scope

   u8g2.setFont(u8g2_font_ncenB14_tr);

   ^

exit status 1
expected constructor, destructor, or type conversion before '(' token

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.


Code complet 

Code: [Select]
// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

// Déclaratipon de l'écran 128x128 à venir
/* Constructor */
//U8G2_SSD1327_EA_W128128_1_SW_I2C(U8G2_R0, A5, A4);
// si ne marche pas :
//U8G2_SSD1327_MIDAS_128X128_1_SW_I2C(U8G2_R0, A5, A4);
void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);




}

void loop(void)
{


 // modele d'écriture
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 15);
  u8g2.print("Hello World!");



}

lesept

#6
Jun 26, 2018, 09:08 am Last Edit: Jun 26, 2018, 09:09 am by lesept
C'est la déclaration de l'écran qui n'est pas bonne :
Code: [Select]
// Déclaration de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

Tu as un peu tout mélangé. Essaye ça :
Code: [Select]

// Déclaration de l'écran 128x128
U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, A5, A4);
J'avais oublié le nom de l'instanciation de l'écran, "u8g2" que tu utilises pour les fonctions ensuite.

Comme dit plus haut, si ça ne marche pas, essaye le MIDAS :
Code: [Select]
U8G2_SSD1327_MIDAS_128X128_1_SW_I2C u8g2(U8G2_R0, A5, A4);

J'avance "à vue" car je n'ai jamais utilisé cette bibli... et ça n'a pas l'air simple (au moins au début, ça sera plus facile après)
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

ArduinoFree

#7
Jun 26, 2018, 09:21 am Last Edit: Jun 26, 2018, 09:24 am by ArduinoFree
Bonjour


NB : tu as répondu avant moi , j'écrivais ceci
      "Il ne manquerait pas la rotation ?
Code: [Select]
U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])
"

Comme je vais dans plusieurs voies en même temps je me noie un peu.

Pour tout mettre à plat.
Actuellement je n'ai que les écrans 128x64 sous la main.
J'attends les 128x128.

Je teste le code pour le 128x64 et en avance je prévoie pour le 128x128 ( que je ne peux tester actuellement)

Donc pour le 128x64, c'est ce code

Code: [Select]
// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

/*U8G2_SSD1306_128X64_NONAME_2_SW_I2C(rotation, clock, data [, reset])
                                    // U8G2_R0,SCL  A5, SDA  A4
U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])
*/
void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);




}

void loop(void)
{


  /*/modele d'écriture
    u8g2.setFont(u8g2_font_ncenB14_tr);
    u8g2.setCursor(0, 15);
    u8g2.print("Hello World!");
  */

  // Affichage Niveau batterie
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 0);
  u8g2.println("NIVEAU BATTERIE");
  
}



Pour la taille de la police, c'est son choix qui défini la taille, c'est bon ?


les lignes suivantes sont ce que je pensais bon
Code: [Select]
/*U8G2_SSD1306_128X64_NONAME_2_SW_I2C(rotation, clock, data [, reset])
                                    // U8G2_R0,SCL  A5, SDA  A4
U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])
*/

lesept

Quote
Comme je vais dans plusieurs voies en même temps je me noie un peu.
C'est pas bon de se noyer pour un capitaine de bateau... même dans une piscine ! :)

Quand tu déclares l'écran, avec ce qu'ils appellent le constructeur, tu dois lui donner un nom. Ce nom, le nom de l'instance, tu l'utilises à chaque fois que tu appelles une fonction d'affichage dans la suite de ton programme.
Ça sert par exemple si tu as plusieurs écrans : tu peux les distinguer par des noms différents et afficher sur l'un et sur l'autre des choses différentes.

Donc au niveau du constructeur, tu déclares ainsi :
Code: [Select]
Constructor_name Display_name (arguments)
Pour toi :
Code: [Select]
U8G2_SSD1306_128X64_NONAME_2_SW_I2C u8g2 (U8G2_R0, A5, A4)
  • Constructor_name : U8G2_SSD1306_128X64_NONAME_2_SW_I2C
  • Display_name : u8g2
  • arguments : U8G2_R0, A5, A4 (les [ et ] ne doivent pas être utilisés dans ton code, ils servent juste dans le manuel d'utilisation à préciser les arguments optionnels.
Ensuite dans ton code, tu affiches sur l'écran appelé u8g2 (mais tu peux décider dès le début de l'appeler Marcel, il faut juste conserver cette convention dans tout le programme) en appelant les fonctions référencées par ce nom, comme par exemple u8g2.begin();
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

ArduinoFree


ArduinoFree


lesept

#11
Jun 26, 2018, 07:36 pm Last Edit: Jun 26, 2018, 07:37 pm by lesept
Il te propose d'utiliser un constructeur qui utilise le I2C hardware. Je suis loin de maîtriser le sujet, mais j'ai vu que le SPI et l'I2C existent en version hardware (je suppose que ça veut dire que ça oblige à utiliser les broches spécifiques A4, A5 pour I2C et les broches SCK, MOSI, CS pour le SPI) et en version software. Dans ce dernier cas, on peut utiliser d'autres broches, elles émulent les broches spécifiques. La différence c'est la vitesse : le HW est plus rapide que le SW.

A mon avis, pour toi, ça ne changera rien. Mais tu peux essayer la version HW :
Code: [Select]
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2 (U8G2_R0, A5, A4);
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

ArduinoFree

#12
Jun 26, 2018, 08:07 pm Last Edit: Jun 26, 2018, 08:11 pm by ArduinoFree
Tu as raison
Même résultat
Rien sur l 'écran :smiley-confuse:

Je suis pret a tester toutes tes propositions.
Je ne pense pas arriver a la fumée blanche  :)

ArduinoFree

J ai eu une autre reponse sur l autre post.

ArduinoFree

#14
Jun 27, 2018, 09:18 am Last Edit: Jun 27, 2018, 09:27 am by ArduinoFree
J'ai trouvé ceci
https://github.com/olikraus/u8g2/issues/397


https://github.com/olikraus/U8g2_Arduino/archive/master.zip


Cela parle du 128x128 mais peut-être pour le 128x64 ?

Il y a deux exemples page buffer / Print Helle word
                               full buffer / Helo word   

Lequel je dois prendre comme base ?

Go Up