====== SSD1306 =======

Étude réalisée avec afficheur OLED SSD1306

{{ :raspberry_pi_pico:micropython:ssd1306_i2c.png |}}


===== Branchement : =====

   * GND > 0V
   * VDD > 3.3V
   * SCK > GP9 
   * SDA > GP8

Attention à ne pas se fier aux numéros des broches (ici 11 et 12).



===== Initialisation : =====

<code python>
# import
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C

#initialisation i2c
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000)	# la fréquence n'est pas obligatoire

# initialisation oled
oled = SSD1306_I2C(128, 64, i2c, 0x3C)	# taille de l'écran 128x64 pix, addresse de l'afficheur 0x3C
</code>



===== Identification de l'adresse I2C de l'afficheur : =====

Dans l'inconnu, on peut utiliser **i2c.scan** pour identifier l'adresse.

<code python>
print(i2c.scan())
</code>

Dans notre exemple la commande **print** retourne la valeur **[60, 119]** => l'adresse est **60** en décimal, soit **3C** en hexadécimal.

===== Fonctions : =====

==== show : ====

rafraîchît l'affichage

<code python>
oled.show()
</code>

==== invert : ====

Inverse l'affichage : noir sur fond blanc (0) ou (True), blanc sur fond noir (1) ou (False)

<code python>
oled.invert(True)
oled.invert(0)
</code>

===== Module framebuf : =====

==== Fonctions : ====

  * **blit** : dessine un autre Framebuffer sur le framebuffer courant 
  * **fill :** rempli l'écran entier
  * **text :** affiche un texte. Mono-police en 8x8 pixels
  * **pixel :** affiche un pixel
  * **line :**  affiche une ligne
  * **hline :** affiche une ligne horizontale
  * **vline :** trace une ligne verticale
  * **rect :** affiche un rectangle vide
  * **fill_rect :**  affiche un rectangle rempli
  * **scroll :** défile le tableau de pixel

==== Initialisation : ====

<code python>
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import framebuf
</code>

=== fill : ===

oled.fill(1) permet d'afficher un écran tout blanc
oled.fill(0) permet d'afficher un écran tout noir

=== text : ===

Affichage d'une chaîne de caractères avec la position x, y.

<code python>
oled.fill(0)
oled.text("Helllo !", 0, 0)
oled. show()
</code>

=== pixel : ===

<code python>
oled.pixel(20,20,1)		# pos x (de 0 à 127), pos y (de 0 à 63) , blanc (1) 
oled.show()
</code>

Sur fond blanc on donne une couleur noir (0)

<code python>
oled.fill(1)
oled.pixel(20,20,0)		# pos x, pos y, noir (0)
oled.show()
</code>

=== line : ===

<code python>
oled.line(0, 0, 127, 63, 1)		# segment (A,B) : xA, yB, XB, yB en blanc (1)
oled.show()
</code>

=== hline : vline : ===

<code python>
oled.hline(10, 35, 50, 1)	# xA, yA, longueur vers la droite en blanc
oled.vline(35, 10, 50, 1)	# xA, yA, longueur vers le bas en blanc
oled.show()
</code>

=== rect / fill_rect : ===

<code python>
oled.rect(10, 10, 50, 50, 1)	# pos x, pos y, largeur, hauteur, blanc (1)
oled.show()
</code>

Sur fond blanc on donne une couleur noir (0)

<code python>
oled.fill(1)
oled.rect(10, 10, 50, 50, 0)	# 0 = noir (0)
oled.show()
</code>

=== scroll : ===

<code python>
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import framebuf
import time

#initialisation i2c
i2c = I2C(0, scl=Pin(9), sda=Pin(8))

# initialisation oled
oled = SSD1306_I2C(128, 64, i2c, 0x3C)

# Affichage d'un rectangle et scrolling
oled.fill(0)
oled.rect(10, 10, 50, 50, 1)
oled.show()
for x in range (64):
    oled.scroll(x, 0)	# scrolling vers la droite
    time.sleep(0.01)	# fréquence du scrolling
    oled.show()
</code>

=== Affichage d'un icone avec des pixels : ===

<code python>
ICON = [
    [ 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [ 0, 1, 1, 0, 0, 0, 1, 1, 0],
    [ 1, 1, 1, 1, 0, 1, 1, 1, 1],
    [ 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [ 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [ 0, 1, 1, 1, 1, 1, 1, 1, 0],
    [ 0, 0, 1, 1, 1, 1, 1, 0, 0],
    [ 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [ 0, 0, 0, 0, 1, 0, 0, 0, 0],
]
for y, row in enumerate(ICON):
    for x, c in enumerate(row):
        oled.pixel(x+5, y+5, c)
        oled.show()
</code>

=== Affiche un logo en utilisant le buffer : ===

<code python>
# Affiche un logo sous forme d un tableau d'octets de 32x32
buffer = None
buffer = bytearray(
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\xfc'
b'\x00\x00\x1f\xfe\x00\x00\x01\xfe\x3f\xff\xfd\xfe\x60\x00\x05\x0e\x4f\xfe\x05\x0e\x5f\xf8\x05\xfe\x5f\x80\x05\xfe\x5e\x00\x05\x06'
b'\x5c\x00\x05\xfe\x58\x00\x05\xfe\x50\x00\x05\xfe\x40\x00\x05\xfe\x40\x00\x05\xfe\x7f\xff\xfd\xfe\x7f\xff\xfd\xfe\x00\x18\x01\x3e'
b'\x00\x18\x1f\x9e\x00\x18\x1f\x3e\x00\xfe\x1f\xfe\x03\xff\x9f\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
)

# Charge le logo de 32 x 32 pixels dans le framebuffer avec Format de couleur monochrome
fb = framebuf.FrameBuffer(buffer, 32, 32, framebuf.MONO_HLSB)

# Envoie l'image du framebuffer vers l ecran à la position x = 50 et y = 24
oled.blit(fb, 48, 16)	# affichage au centre de l'écran

oled.show()
</code>