Paramètre de type I2C à passer à une fonction dans une bibliothèque.

Bonjour à tous,

J'écris en micropython une bibliothèque pour afficher un message sur un écran lcd connecté en i2c à un microcontroleur esp8266.
Je n'arrive pas à faire passer en paramètre un objet i2c qui représente le brochage de mon écran lcd sur le microcontrôleur.

Ma question est d'ordre général en python. Je saurais faire passer des paramètres string, entiers ou réels, mais je n'arrive pas à le faire avec cet objet i2c.

Je cherche depuis plusieurs semaines sans succès. Merci de votre aide.

Voici mon code :

-------------------------------- programme principal, laid mais qui fonctionne --------------------------------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
test ecran LCD Grove en Micropython sur Esp8266 / ESP32
"""
import time
from machine import Pin, I2C
from Grove_LCD import Grove_lcd
 
i2c = I2C(scl=Pin(2), sda=Pin(14), freq=20000) # création d'un objet i2c là où il devrait être, pour indiquer le brochage sur l'ESP8266
 
 
lcd = Grove_lcd() # Crée un objet lcd pour pouvoir utiliser ses méthodes
 
# lcd = Grove_lcd(i2c) # voici mon objectif => faire passer l'objet i2c avec le brochage en paramètre. Je ne trouve pas la syntaxe appropriée. global i2c ???  
 
lcd.write("Bonjour le monde ! ")       # méthode pour écrire sur l'écran

-------------------- bibliothèque (avec le brochge i2c écrit en dur dedans, que je voudrais éviter) ---------------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
from machine import Pin, I2C
import time
 
i2c = I2C(scl=Pin(2), sda=Pin(14), freq=20000) # création d'un objet i2c au mauvais endroit
# Comment éviter de coder en dur le brochage dans la bibliothèque ?
# Cette ligne devrait être dans le programme principal, passée en paramètre comme suit :
# afficheur = Grove_lcd(i2c)
 
 
class Grove_lcd():
    # global i2c ne fonctionne pas, et ce n'est pas le meilleur moyen.
    """
    Pour gerer l'afficheur 1602 Grove
    """
    def __init__(self):
 
        # initialisation
        self.set_register(0x00, 0)
        self.set_register(0x01, 0)
 
        # toutes les Leds controllées par PWM
        self.set_register(0x08, 0xAA)
 
        # attente initialisation après mise sous tension
        time.sleep_ms(50)
 
        # envoi configuration afficheur 2 lignes
        self.cmd(0x20 | 0x04 | 0x08)
        time.sleep_us(4500)
        self.cmd(0x20 | 0x04 | 0x08)
        time.sleep_us(150)
        self.cmd(0x20 | 0x04 | 0x08)
        self.cmd(0x20 | 0x04 | 0x08)
 
        # allumage afficheur
        self.disp_ctrl = 0x04 | 0x00 | 0x00
        self.display1(True)
        self.clear()
        self.disp_mode = 0x02 | 0x00
        self.cmd(0x04 | self.disp_mode)
 
    def set_register(self, reg, val):
        val = bytes((reg, val))
        i2c.writeto(0x62, val) # adresse i2c de l'afficheur pour le fond
 
    def color(self, R, G, B):
        self.set_register(0x04, R)
        self.set_register(0x03, G)
        self.set_register(0x02, B)
 
    def cmd(self, command):
        assert command >= 0 and command < 256
        val = bytes((0x80, command))
        i2c.writeto(0x3e, val) # adresse i2c de l'afficheur pour le texte
 
    def write_char(self, c):
        assert c >= 0 and c < 256
        val = bytes((0x40, c))
        i2c.writeto(0x3e, val)
 
    def write(self, text):
        text = str(text)
        for char in text:
            self.write_char(ord(char))
 
    def setCursor(self, col, row):
        col = (col | 0x80) if row == 0 else (col | 0xc0)
        self.cmd(col)
 
    def display1(self, state):
        if state:
            self.disp_ctrl |= 0x04
            self.cmd(0x08 | self.disp_ctrl)
        else:
            self.disp_ctrl &= ~0x04
            self.cmd(0x08 | self.disp_ctrl)
 
    def clear(self):
        self.cmd(0x01)
        time.sleep_ms(2)

global ne permet pas de "franchir" des modules, ils sont dans un namespace différent.
1) Ou alors,

Code:

from script_principal import i2c

mais cela conduirait à une boucle des imports (script 1 importe depuis script 2, qui importe depuis script 1...), bref, python n'aime pas ça (personne n'aime ça)

2) Pour un cas comme celui-ci, je définirais un troisième fichier dédié aux configurations, plus facilement maintenable et modifiable.

3) Sinon, la meilleure solution est de définir un attribut "i2c" pour la classe Grove_lcd
Soit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class Grove_lcd(): # global i2c ne fonctionne pas, et ce n'est pas le meilleur moyen. """ Pour gerer l'afficheur 1602 Grove """ def __init__(self, i2c): self.i2c = i2c .... def set_register(self, ...): ... self.i2c.writeto(0x62, val)
Code:

1 2 3 4 from Grove_LCD import Grove_lcd i2c = I2C(scl=Pin(2), sda=Pin(14), freq=20000) lcd = Grove_lcd(i2c)
Soit:
Code:

1 2 3 4 class Grove_lcd(): def __init__(self, scl, sda, freq): self.i2c = I2C(scl=Pin(2), sda=Pin(14), freq=20000)
Code:

1 2 3 from Grove_LCD import Grove_lcd lcd = Grove_lcd(Pin(2), Pin(14), 20000)

Super !

Précis et rapide. (bien plus que ma réponse, mais internet était cassé ici, désolé)

Un très grand merci.
Jean-François.