[Jérémy]

2.png

Bonjour à tous,

Aujourd'hui nous allons parlé de l'écran OLED B click de Mikroelekronika .
Cet écran a 96 pixels de large pour 39 de haut.
Il est piloté par le driver SSD1306 très répandu.
Nous allons voir comment communiquer avec ce driver et dégrossir ses fonctions principales. ( Driver du SSD1306 )

Pour faire ce Tuto je me suis inspiré de l'exemple de MikroE, que vous pouvez retrouver ici
Exemple d'utilisation du module OLED B click
Schéma de connexion du module

1.jpg

Configuration :

- PIC18F45K22
- IDE : MikroC Pro for PIC Version 6.6.2
- Compilateur : Mikro prog suite fo PIC V 2.32
- Plaque Easy PIC V7
- OLED B click en mode SPI







1/ Préliminaire

En tout premier lieu il convient d'attribuer aux codes des différentes fonctions, un nom facilement reconnaissable. On gagnera en compréhension, facilité à debugger et rapidité .

Par exemple d’après la DS ( page 28) , le code 0xAE permet d’éteindre/de mettre en veille l’écran . Nous allons donc définir un nom plus parlant que 0xAE car dans le programme on ne sera pas a quoi correspondra ce code sinon .

1445707623.jpg

Ceci fait parti du travail préliminaire que vous aurez très souvent à faire.
Si vous croyez perdre du temps, détrompez vous, vous verrez que vous en gagnerez énormément par la suite.
Nous utiliserons donc la commande #define: Dans notre exemple cela donnera :

#define SSD1306_DISPLAYOFF 0xAE // Désactive l'écran

Nous allons faire ceci pour toutes les fonctions, et afin d’alléger le code dans le programme principale, nous allons créer un document pour mettre tout ça. Et nous l'appellerons dans notre programme principal en tout début.

2.jpg

Pour créer ce fichier ( avec MikroC, désolé pour les autres) : allez dans Project manager cliquez sur add new file to project, un nouveau document s'ouvre.
Sauvegardez ce fichier en lui donnant un nom, et SURTOUT le type doit être en .h ,le .h signifie Header.
Ensuite dans notre programme principale il nous suffira de l'appeler avec cette commande en tout début de programme:

#include <Votre _nom_de_fichier.h>


Voici le fichier d'exemple customisé par mes soins : les commandes que je n'ai comprises sont marquées avec des points d’interrogations. Si un expert passe par la , il peut compléter avec plaisir, à la suite de ce post.
On remplace donc chaque code d'une commande par un texte clair et compréhensible par tous.


[spoil]

Code : Tout sélectionner

#define SSD1306_LCDWIDTH   96            // Largeur de l’écran
#define SSD1306_LCDHEIGHT  39            // Hauteur de l'écran

#define SSD1306_DISPLAYOFF 0xAE          // Désactive l'écran
#define SSD1306_DISPLAYON 0xAF           // Active l’écran
#define SSD1306_SETCONTRAST 0x81         // Réglage du contraste  (suivis de 1 valeur)
#define SSD1306_NORMALDISPLAY 0xA6       // mode normal d'affichage
#define SSD1306_INVERTDISPLAY 0xA7       // mode Inverse d'affichage
#define SSD1306_MEMORYMODE 0x20          // Choix du mode de mémoire Hori/vert/page (suivis de 1 valeur)
#define SSD1306_COLUMNADDR 0x21          // Config des colonnes début et fin (suivis de 2 valeurs)
#define SSD1306_PAGEADDR   0x22          // Config des pages début et fin    (suivis de 2 valeurs)
#define SSD1306_COMSCANINC 0xC0          // Mode de scan, mode normal de com0 vers com N-1
#define SSD1306_COMSCANDEC 0xC8          // Mode de scan, mode inverse de Com N-12 vers Com0
#define SSD1306_SETSTARTLINE 0x40        // Réglage de la ligne de départ en RAM

#define SSD1306_ACTIVATE_SCROLL 0x2F          // Active le scroll
#define SSD1306_DEACTIVATE_SCROLL 0x2E        // Désactive le scroll
#define SSD1306_SET_VERTICAL_SCROLL_AREA 0xA3 // Sélectionne l'aire du scroll
#define SSD1306_RIGHT_HORIZONTAL_SCROLL 0x26  // scroll horizontal droite
#define SSD1306_LEFT_HORIZONTAL_SCROLL 0x27   // scroll horizontal gauche
#define SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL 0x29 // scroll diagonal droite
#define SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL 0x2A  // scroll diagonal gauche

#define SSD1306_SEGREMAP 0xA0            // Réglage du mappage des segments 0 pour SEG0
#define SSD1306_SETSEGMENTREMAP 0xA1     // Réglage du mappage des segments 127 pour SEG0
#define SSD1306_SETDISPLAYCLOCKDIV 0xD5  // clock division ?? (suivis de 1 valeur)
#define SSD1306_SETPRECHARGE 0xD9        // réglage Pré-charge période ???
#define SSD1306_SETDISPLAYOFFSET 0xD3    // Réglage du shift vertical (suivis de 1 valeur)

#define SSD1306_DISPLAYALLON_RESUME 0xA4 // ??
#define SSD1306_DISPLAYALLON 0xA5        // ??
#define SSD1306_SETLOWCOLUMN 0x00        // ??
#define SSD1306_SETHIGHCOLUMN 0x10       // ??
#define SSD1306_SETVCOMDETECT 0xDB       // ??
#define SSD1306_SETMULTIPLEX 0xA8        // ??
#define SSD1306_CHARGEPUMP 0x8D          // ??
#define SSD1306_SETCOMPINS 0xDA          // ??                                                     

[/spoil]
Voila maintenant on s'y retrouvera plus facilement.

2/ Pilotage du driver avec le SPI

Nous allons piloter notre écran sur le BUS SPI. Sur le bus SPI il n'y a pas d'adressage individuel , l'adressage se fait en hard. C'est à dire en activant le module ou non. Si le module est activé, il prendra en compte tout ce qui transite sur le BUS.

- Ici la broche qui active notre écran s’appelle OLED_CS, elle active notre écran avec un "0". Donc à chaque fois que l'on voudra s'adresser à l'écran il conviendra de mettre cette broche à "0" pour l'activer.

- Une autre broche importante , il s'agit de OLED_DC ( pour Data/Command) , va nous permettre de choisir si on envoie une commande , pour "régler" les paramètres de notre écran ou une donnée " à affichée" sur l’écran.

Pour simplifier le programme nous allons intégrer tout ça dans des fonctions dédiées avec un paramètre d'entrée.

Je prendrais comme exemple l'envoi d'une commande pour activer l'écran .
Voici la fonction OLED_M_command :

Code : Tout sélectionner

void OLED_M_command (unsigned char temp){ //Envoi d'une commande
  OLED_CS=0;            // Chip Select , actif à l'état bas
  OLED_DC=0;            // Data/Command selection: 1=Data; 0=Command
  SPI1_Write(temp);     // Envoi de l'info sur le BUS
  OLED_CS=1;            // on arrête la com en désactivant le chip
}

Cette fonction fais tout en un , pratique non ?

- On lui envoi un argument qui sera notre ordre ou commande comme vous voulez, qu'elle stocke dans la variable temp
- Elle active l'écran sur le BUS SPI(OLED_CS=0;)
- Elle dit que c'est une commande (OLED_DC=0;)
- Ensuite elle envoie l'argument reçu sur le SPI .
- Puis désactive l’écran du BUS SPI pour laisser la place à d'autre si besoin.

C'est pas beau ça ! :D

L’argument à envoyé sera l'activation de l’écran qui d’après la data-sheet correspond au code 0xAF.
Mais grâce à notre fichier de définition on écriera SSD1306_DISPLAYON. Ainsi on comprend tout de suite que l'on active l’écran dans le programme principal.

Avec la fonction cela donnera :
OLED_M_command(SSD1306_DISPLAYON); //0xAF Active l'écran OLED

Grâce à cette fonction nous allons pouvoir paramétrer rapidement notre écran. Voici le code que j'utilise pour le Tuto, Comme le dit un vieux proverbe chinois "Chose inconnue, touche à ton cul " PS: Peut-être que ce n'est pas chinois. J'ai donc laissé les paramètres dont je ne connaissais pas les répercussions tel quels !

[spoil]

Code : Tout sélectionner


void OLED_M_Init(){ // Initialisation de l'écran
    
     OLED_RST=0;         // Reset de l'écran
     Delay_ms(100);      // Pause
     OLED_RST=1;         // Arret du Reset
     Delay_ms(100);      // pause
     
     OLED_M_command(SSD1306_DISPLAYOFF);          //0xAE  Ecran en mode veille (désactivé)
     OLED_M_command(SSD1306_SETDISPLAYCLOCKDIV);  //0xD5  Set Display Clock Divide Ratio/Oscillator Frequency
     OLED_M_command(0x80);
     OLED_M_command(SSD1306_SETMULTIPLEX);        //0xA8  Set Multiplex Ratio
     OLED_M_command(0x27);
     OLED_M_command(SSD1306_SETDISPLAYOFFSET);    //0xD3  Set Display Offset
     OLED_M_command(0x00);
     OLED_M_command(SSD1306_SETSTARTLINE);        //0x40  Set Display Start Line
     OLED_M_command(SSD1306_CHARGEPUMP);          //0x8D  Set Charge Pump
     OLED_M_command(0x14);                        //0x14  Enable Charge Pump
     OLED_M_command(SSD1306_COMSCANDEC);          //0xC8  Set COM Output Scan Direction
     OLED_M_command(SSD1306_SETCOMPINS);          //0xDA  Set COM Pins Hardware Configuration
     OLED_M_command(0x12);
     OLED_M_command(SSD1306_SETCONTRAST);         // 0x81   réglage du contraste
     OLED_M_command(0xAF);                        // Envoi de la valeur du contraste
     OLED_M_command(SSD1306_SETPRECHARGE);        // 0xD9   Set Pre-Charge Period
     OLED_M_command(0x25);
     OLED_M_command(SSD1306_SETVCOMDETECT);       //0xDB   Set VCOMH Deselect Level
     OLED_M_command(0x20);
     OLED_M_command(SSD1306_DISPLAYALLON_RESUME); //0xA4   ??? pas compris - Set Entire Display On/Off
     OLED_M_command(SSD1306_NORMALDISPLAY);       //0xA6   mode normal ou inverse
     OLED_M_command(SSD1306_SETSEGMENTREMAP);     //0xA1   Inverse l'ordre de lecture des colonnes gauche vers droite
     OLED_M_command(SSD1306_MEMORYMODE);          // Selection du mode de defilement
     OLED_M_command(0x00);                        //  Horizontal adressing  mode
     OLED_M_command(SSD1306_COLUMNADDR);
     OLED_M_command(32);
     OLED_M_command(127);
     OLED_M_command(SSD1306_PAGEADDR);
     OLED_M_command(0);
     OLED_M_command(4);
     OLED_M_command(SSD1306_DISPLAYON);           //0xAF   Active l'écran OLED
}

[/spoil]
3/ Mode de fonctionnement

Ce genre de module fonctionne en trois mode bien distincts :
le mode Page, Horizontale et Verticale.
Je vous laisse voir les jolis croquis que vous trouverez en page 34 de la DS.

3.jpg

Dans ce tuto nous utiliserons le mode Horizontal.
cela signifie que chaque fois qu'on lira OU écrira dans le registre du driver, cela incrémentera automatiquement le pointeur de l'adresse de la colonne.
Et à chaque fois que l'on arrivera au bout de la ligne, elle s’incrémentera à son tour automatiquement pour aller à la suivante.

4.jpg

Cette écran est divisé en 5 pages (lignes) de 0 à 4, et de 96 colonnes .
La page 0 est composé de seulement 7 pixels contre 8 pour les autres. Chaque bit d'un octet correspond à pixel sur l'écran verticalement.

Nous avons donc 4 lignes de haut de 8 pixels ( 4 x 8 = 32) , Plus une ligne ( page 0) de 7 pixels de haut . 32+7=39 pixels de haut cela correspond bien à la résolution de la hauteur de notre écran.
Comme nous avons 5 pages de 96 colonnes , pour remplir l'écran il faudra donc 96x5= 480 informations pour remplir notre écran.

4/ Création d'une zone de dessin

Avant d'afficher des données il va falloir créer une zone ou seront affichés nos pixels. Si on ne fait pas ça, nous saurions obligé de remplir de blanc partout, sauf à l'endroit on l'on souhaite voir nos pixels. Vraiment pas pratique, surtout si on veut dessiner quelques choses au milieu de l'écran. On risquerait d'effacer des pixels, sans compter la perte de temps incroyable et d'espace mémoire .

Pour délimité une zone nous allons utilisé la commande SSD1306_COLUMNADDR et SSD1306_PAGEADDR .

Ces commandes définisse la colonne de départ et la colonne de fin de notre zone, et pareil pour les pages. Il faudra donc veiller à faire suivre ces commandes par deux valeurs correspondantes à nos limites . Voici un exemple pour créer une zone qui fait tout l'écran.

Code : Tout sélectionner


     OLED_M_command(SSD1306_COLUMNADDR); // Dit à l’écran qu'on lui envoie les limites de colonnes
     OLED_M_command(32);                 // Valeur 1ere colonne
     OLED_M_command(127);                // Valeur dernière colonne
     OLED_M_command(SSD1306_PAGEADDR);   // Dit à l’écran qu'on lui envoie les limites des pages
     OLED_M_command(0);                  // Valeur de la première page
     OLED_M_command(4);                  // Valeur de la dernière page
 

Attention!! Vous remarquerez que les colonnes vont de 32 à 127 et non de 0 à 96 . En effet le driver est conçu à la base pour des écrans de 128x64 . Nos 96 colonnes se trouvent de l'adresse mémoire 32 à 127. Il font donc utilisé un offset de 32 pour les colonnes . Le problème ne se pose pas pour les pages car elles commencent à 0.

5/ Envoi de DATA

Tout comme les Commandes nous allons créer une fonction qui va automatiser tout cela. Il nous suffira de dire que c'est une DATA plutôt qu'une Commande en changeant le bit qui va bien ! ;) .

Code : Tout sélectionner

void OLED_M_command (unsigned char temp){ //Envoi d'une commande
  OLED_CS=0;            // Chip Select , actif à l'état bas
  OLED_DC=1;            // Data/Command selection: 1=Data; 0=Command
  SPI1_Write(temp);     // Envoi de la donnée sur le BUS
  OLED_CS=1;            // on arrête la com en désactivant le chip
}

Nous voulons créer un carré 8 pixels de coté . Il faudrait donc envoyer , 8 barres verticales à la suite, créant ainsi un carré de 8 pixels de haut sur 8 de large.
et grâce à l'incrémentation automatique, on ferra donc suivre ces valeurs les une à la suite des autres, tout simplement.

Code : Tout sélectionner

void OLED_M_command (unsigned char temp){ //Envoi d'une commande
  OLED_CS=0;            // Chip Select , actif à l'état bas
  OLED_DC=1;            // Data/Command selection: 1=Data; 0=Command
  SPI1_Write(0xFF);     // une barre de 8 pixels de haut . 0xFF=0b11111111 . soit 8 pixels à 1
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  SPI1_Write(0xFF);
  OLED_CS=1;            // on arrête la com en désactivant le chip
}

Vous remarquerez qu'il est plutôt facile de simplifier ce code avec une commande for (i=0;i<=7;i++)


Voici un code exemple pour faire un carré au milieu de l'écran. On remarque que l'on pourrait créer une fonction pour définir notre zone de travail avec 4 paramètres d'entrée . colonne Min, colonne Max, Page Min et page Max . A votre tour de travailler un peu !

[spoil]

Code : Tout sélectionner

//#############################       DECLARATION       ############################
#include <Oled_M.h>

sbit OLED_RST at LATE1_bit; // Definition de la broche RESET
sbit OLED_CS at LATE0_bit;  // Definition de la broche Chip select
sbit OLED_DC at LATC0_bit;  // Definition de la broche Data/command

unsigned int i,j,k;

//############################        FONCTION       ###############################

void OLED_M_command (unsigned char temp){ //Envoi d'une commande
  OLED_CS=0;            // Chip Select , actif à l'état bas
  OLED_DC=0;            // Data/Command selection: 1=Data; 0=Command
  SPI1_Write(temp);     // Envoi de l'info sur le BUS
  OLED_CS=1;            // on arrrete la com en desactivant le chip
}

void OLED_M_data(unsigned char temp){ //Envoi d'une commande
  OLED_CS=0;            // Chip Select , actif à l'état bas
  OLED_DC=1;            // Data/Command selection: 1=Data; 0=Command
  SPI1_Write(temp);     // Envoi de l'info sur le BUS
  OLED_CS=1;            // on arrrete la com en desactivant le chip
}

void OLED_M_Init(){ // Initialisation de l'écran
    
     OLED_RST=0;         // Reset de l'écran
     Delay_ms(100);      // Pause
     OLED_RST=1;         // Arret du Reset
     Delay_ms(100);      // pause
     
     OLED_M_command(SSD1306_DISPLAYOFF);          //0xAE  Ecran en mode veille (désactivé)
     OLED_M_command(SSD1306_SETDISPLAYCLOCKDIV);  //0xD5  Set Display Clock Divide Ratio/Oscillator Frequency
     OLED_M_command(0x80);
     OLED_M_command(SSD1306_SETMULTIPLEX);        //0xA8  Set Multiplex Ratio
     OLED_M_command(0x27);
     OLED_M_command(SSD1306_SETDISPLAYOFFSET);    //0xD3  Set Display Offset
     OLED_M_command(0x00);
     OLED_M_command(SSD1306_SETSTARTLINE);        //0x40  Set Display Start Line
     OLED_M_command(SSD1306_CHARGEPUMP);          //0x8D  Set Charge Pump
     OLED_M_command(0x14);                        //0x14  Enable Charge Pump
     OLED_M_command(SSD1306_COMSCANDEC);          //0xC8  Set COM Output Scan Direction
     OLED_M_command(SSD1306_SETCOMPINS);          //0xDA  Set COM Pins Hardware Configuration
     OLED_M_command(0x12);
     OLED_M_command(SSD1306_SETCONTRAST);         // 0x81   réglage du contraste
     OLED_M_command(0xAF);                        // Envoi de la valeur du contraste
     OLED_M_command(SSD1306_SETPRECHARGE);        // 0xD9   Set Pre-Charge Period
     OLED_M_command(0x25);
     OLED_M_command(SSD1306_SETVCOMDETECT);       //0xDB   Set VCOMH Deselect Level
     OLED_M_command(0x20);
     OLED_M_command(SSD1306_DISPLAYALLON_RESUME); //0xA4   ??? pas compris - Set Entire Display On/Off
     OLED_M_command(SSD1306_NORMALDISPLAY);       //0xA6   mode normal ou inverse
     OLED_M_command(SSD1306_SETSEGMENTREMAP);     //0xA1   Inverse l'ordre de lecture des colonnes gauche vers droite
     OLED_M_command(SSD1306_MEMORYMODE);          // Selection du mode de defilement
     OLED_M_command(0x00);                        //  Horizontal adressing  mode
     OLED_M_command(SSD1306_COLUMNADDR);          // Dit à lécran qu'on lui envoie les limites de colonnes
     OLED_M_command(32);                          // Valeur 1ere colonne
     OLED_M_command(127);                         // Valeur derniére colonne
     OLED_M_command(SSD1306_PAGEADDR);            // Dit à lécran qu'on lui envoie les limites des pages
     OLED_M_command(0);                           // Valeur de la premiere page
     OLED_M_command(4);                           // Valeur de la derniére page

}

//##################################################################################
//######################     PROGRAMME PRINCIPAL     ###############################
//##################################################################################
void main(){

     TRISE0_bit = 0;         // Configure la broche 0 du PORT E en sortie
     TRISE1_bit = 0;         // Configure la broche 1 du PORT E en sortie
     TRISC0_bit = 0;         // Configure la broche 0 du PORT C en sortie

     SPI1_Init();            // Initialisation du SPI
     Delay_ms(500);

     OLED_M_Init();          // Initialisation de l'ecran LCD
     Delay_ms(100);

    for (k=0;k<480;k++){     // On efface l'ecran et la ram
       OLED_M_data(0x00);    // On envoie 480 fois "0" pour tout effacer
    }
     OLED_M_command(SSD1306_DISPLAYON);//0xAF   Active l'écran OLED

//############################     BOUCLE INFINIE     ##############################
  while(1){
     
     OLED_M_command(SSD1306_COLUMNADDR); // Dit à lécran qu'on lui envoie les limites de colonnes
     OLED_M_command(76);                 // Valeur 1ere colonne
     OLED_M_command(84);                // Valeur derniére colonne
     OLED_M_command(SSD1306_PAGEADDR);   // Dit à lécran qu'on lui envoie les limites des pages
     OLED_M_command(2);                  // Valeur de la premiere page
     OLED_M_command(2);                  // Valeur de la derniére page

   for (k=0;k<=7;k++){     // On affiche notre carré
       OLED_M_data(0xFF);
    }

  }
}


[/spoil]


6/ Le SCROLL

le scroll est un déplacement automatique de toutes les valeurs de l'écran. Un sorte de shift ou de décalage à droite, à gauche, en haut, en bas, et en diagonale.
La fonction "scroll" doit être paramétrée avant d'être activée. Comme c'est des paramètres on va donc lui envoyée des commandes, pour lui signaler comment doit se comporter le "scroll".

Voici un exemple pour un scroll horizontal de la gauche vers la droite de la page 2 seulement ( Oui la ou il y notre carré ! ) .
[spoil]

Code : Tout sélectionner

void config_scroll(){
       OLED_M_command(SSD1306_RIGHT_HORIZONTAL_SCROLL);// Configurte le scroll en Horizontal
       OLED_M_command(0X00);                           // Byte factice mettre à 0
       OLED_M_command(2);                              // Definie l'adresse de départ du scroll
       OLED_M_command(0b00000111);                     // regle l'intervalle du temps entre chaque incrementation ( page 28 DS)
       OLED_M_command(2);                              // Définie l'adresse de page de fin
       OLED_M_command(0X00);                          // Byte factice mettre à 0
       OLED_M_command(0XFF);                          // Byte factice mettre à 0
  } 

[/spoil]

Après ce paramétrage , il convient de l'activer pour voir l'effet sur l’écran. Le code d'activation du scroll est 0x2F ( page 29 de la DS) . Mais encore une fois, grace à notre fichier on écriera SSD1306_ACTIVATE_SCROLL. On comprendra tout de suite qu'on active le défilement.

OLED_M_command(SSD1306_ACTIVATE_SCROLL);

Attention!! Bug avec cet écran .
Le scroll met en exergue un probléme que nous avions déjà vu . il s'agit des colonnes de 0 à 31. En effet le driver affiche à l’écran les adresses de 32 à 127 . Nous avons donc créer un offset pour palier a ceci. Mais les adresse 0 à 31existent, elle ne sont pas affichées c'est tout .

Mais lors d'un scroll, l'adresse 31 , va se retrouver à l’adresse 32 puis 33 etc .....
Je ne connais pas de moyen pour empêcher la lecture de la mémoire sur une zone . Nous allons donc devoir rusé !

Lors de l'effacement de l’écran; nous avions écrit 480 colonnes , correspondant aux 5 pages de 96 colonnes . Mais cela n'écrase pas toute la mémoire, mais seulement la mémoire affichée à l’écran . Afin de s'assurer de l'effacer total de la mémoire , je prends comme valeur 128 x 5 = 640. Au lieu d’écrire "0" sur 480 colonnes je l’écris sur 640, en prenant soin de configurer l'ecran de 0 à 127 colonnes .

[spoil]

Code : Tout sélectionner

void efface_ecran(){
     OLED_M_command(SSD1306_COLUMNADDR);          // On configre l'ecran pour effacer toute la RAM
     OLED_M_command(0);
     OLED_M_command(127);
     OLED_M_command(SSD1306_PAGEADDR);
     OLED_M_command(0);
     OLED_M_command(4);

     for (k=0;k<640;k++){     // On efface l'ecran et la ram
         OLED_M_data(0x00);    // On envoie 1024 fois "0" pour tout effacer
      }

     // On reconfigure l'ecran comme il faut
     OLED_M_command(SSD1306_COLUMNADDR);          // Dit à lécran qu'on lui envoie les limites de colonnes
     OLED_M_command(32);                          // Valeur 1ere colonne
     OLED_M_command(127);                         // Valeur derniére colonne
     OLED_M_command(SSD1306_PAGEADDR);            // Dit à lécran qu'on lui envoie les limites des pages
     OLED_M_command(0);                           // Valeur de la premiere page
     OLED_M_command(4);                           // Valeur de la derniére page
  } 

[/spoil]




TO BE CONTINUED.....

[Jérémy]

Je continue sur un nouveau post, car cela devient compliqué de rester sur un seul.

7/ Le contraste

Cet écran permet de faire varier la luminosité/contraste de ses pixels. Le contraste peut etre regler entre 0 à 256 . "0" pour faible contraste et "255" pour un fort contraste.

Pour faire ceci on envoi une Commande suivi de la valeur du contraste que l'on souhaite . Voici un exemple pour mettre la luminosité au plus fort .

Code : Tout sélectionner

     OLED_M_command(SSD1306_SETCONTRAST);
     OLED_M_command(255); 

8/ Les caractères

[paulfjujo]

bonsoir

Bug avec cet écran .
Le scroll met en exergue un probléme que nous avions déjà vu . il s'agit des colonnes de 0 à 32.

je ne peux pas tester ton programme, mais j'ai un soupçon concernant
le nombre de colonnes 0 à 32 => 33 elements
=> un indice de boucle qui deborde ..
je serai plutot enclin à penser que ce pourrait plutot etre 0 à 31
frontiere naturelle modulo 8 ..
encore une histoire d'intervalle et d'espace ( pas) ..

[Temps-x]

Bonsoir Jérémy, et tout le forum,

Je sais je suis pas dans ma section..... mais comme je suis entrain d'écrire un programme en ASM pour cette écran, je me permets de rajouter

Source du message #define SSD1306_CHARGEPUMP 0x8D // ??

Pompe de charge, sa sert à élever la tension, pour avoir la tension nécessaire pour démarrage de l'écran de 7 volts à un maximum de 15 volts.

Je t'en dirais un peux plus quand j'aurais fini d'écrire mon code.

pour ton tutoriel qui est très bien expliqué, de plus en Français, ouf.. on respire.

A+