Discussion :

[Florian BERTOSSI]

Bonjour à tous,

Je travaille actuellement sur le Raspberry Pi en Python et j'utilise TKinter pour l'IHM et WiringPi pour les I/O. Mon programme permet d'envoyer différentes valeurs numériques sur un port 10001 à l'aide d'un Scale (curseur).
J'aimerai maintenant inclure une courbe qui affiche en temps réel les variations du Scale mais je ne sais pas vraiment comment faire (je débute en Python). Dans mon code, j'utilise Canvas pour afficher les axes du graphique.

Est-il plus simple d'utiliser Matplotlib en sachant que la courbe doit être affiché dans ma fenêtre TKinter ?

Pourriez-vous m'aider ?
Merci d'avance

Voici mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# -*- coding: cp1252 -*-
import os # Declaration des librairies
import wiringpi2 as WR
from time import sleep
from Tkinter import *
from random import randrange
 
CLOCK = 27 # Pin 27 GPIO
DATA = 18 # Pin 18 GPIO
LATCH = 24 # Pin 24 GPIO
 
WR.wiringPiSetupGpio() # Configuration des pins
WR.pinMode(LATCH,1) # La pin 24 GPIO du Latch est en sortie
WR.pinMode(DATA,1) # La pin 18 GPIO de data est en sortie 
WR.pinMode(CLOCK,1) # La pin 27 GPIO de clock est en sortie
 
 
def send_att(attn): # Fonction de calcul et de transmission des donnees
    if 0 <= attn < 31:
        WR.shiftOut(DATA,CLOCK,1,(int(attn)*2)) # Le 1 ou le 0 permet d'inverser l'ordre des bits         
 
    elif attn < 63:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-31)+32)*2)) # int(attn) evite l'erreur " unsuported operand type for -: 'str' and 'int' "
 
    elif attn < 93:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-62)+96)*2))
 
    elif attn >= 93:
        attn = 93
 
    # end if
# end def
 
 
def Cursor(attn): # Fonction pour recuperer la valeur du curseur
    voie1 = Slider1.get() # Voie 1 = Position du curseur
    send_att(voie1) # Appel de fonction avec attn = voie1
    WR.digitalWrite(LATCH,1) # LATCH ON
    WR.digitalWrite(LATCH,0) # LATCH OFF
    print voie1
 
# end def
 
 
# Creation de l'IHM
fenetre = Tk()
fenetre.title("Ways Command")
 
voie1 = IntVar() # Declaration des variables pour Scale apres Tk(). Evite l'erreur " 'NoneType' object has no attribute 'tk' "
attn = IntVar()
 
Slider1 = Scale(fenetre,orient=HORIZONTAL,length=600,width=20,sliderlength=10,from_=0,to=93.5,tickinterval=10,resolution=5,variable=voie1,command=Cursor) # Choisir la valeur de la voie 1 avec le Slade
Slider1.pack()
 
bouton_quitter = Button(fenetre,text="Quittter",bg='red',command=fenetre.destroy) # Boutton quitter
bouton_quitter.pack(side=LEFT,anchor="sw")
 
graphique = Canvas(fenetre,bg='white',height=150,width=200) # Ajouter un graphique qui affiche les variations du Scale
graphique.pack()
graphique.create_line(10,75,200,75,arrow=LAST) # Axe des abscisses
graphique.create_line(10,145,10,5,arrow=LAST) # Axe des ordonnées
pas = (175/8)
for t in range(1,9): # Graduations
    stx = 10 + t*pas
    graphique.create_line(stx,71,stx,79)
 
fenetre.mainloop()# Boucle principale

[Invité]

Bonjour à tous,

Je travaille actuellement sur le Raspberry Pi en Python et j'utilise TKinter pour l'IHM et WiringPi pour les I/O. Mon programme permet d'envoyer différentes valeurs numériques sur un port 10001 à l'aide d'un Scale (curseur).
J'aimerai maintenant inclure une courbe qui affiche en temps réel les variations du Scale mais je ne sais pas vraiment comment faire (je débute en Python). Dans mon code, j'utilise Canvas pour afficher les axes du graphique.

Est-il plus simple d'utiliser Matplotlib en sachant que la courbe doit être affiché dans ma fenêtre TKinter ?

Pourriez-vous m'aider ?
Merci d'avance

Bonjour,

Je me suis amusé à bidouiller ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
# Declaration des librairies
import os
import wiringpi2 as WR
from time import sleep
from random import randrange
from Tkinter import *
 
CLOCK = 27 # Pin 27 GPIO
DATA = 18 # Pin 18 GPIO
LATCH = 24 # Pin 24 GPIO
 
WR.wiringPiSetupGpio() # Configuration des pins
WR.pinMode(LATCH,1) # La pin 24 GPIO du Latch est en sortie
WR.pinMode(DATA,1) # La pin 18 GPIO de data est en sortie
WR.pinMode(CLOCK,1) # La pin 27 GPIO de clock est en sortie
 
 
def send_att(attn): # Fonction de calcul et de transmission des donnees
    if 0 <= attn < 31:
        WR.shiftOut(DATA,CLOCK,1,(int(attn)*2)) # Le 1 ou le 0 permet d'inverser l'ordre des bits
 
    elif attn < 63:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-31)+32)*2)) # int(attn) evite l'erreur " unsuported operand type for -: 'str' and 'int' "
 
    elif attn < 93:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-62)+96)*2))
 
    elif attn >= 93:
        attn = 93
    # end if
 
# end def
 
 
def Cursor(attn): # Fonction pour recuperer la valeur du curseur
    voie1 = slider1.get() # Voie 1 = Position du curseur
    send_att(voie1) # Appel de fonction avec attn = voie1
    WR.digitalWrite(LATCH,1) # LATCH ON
    WR.digitalWrite(LATCH,0) # LATCH OFF
    #~ print voie1
    # init taille carré
    size = 5
    # init hauteur de référence graphique
    h = graphique.winfo_reqheight() - 7 - size
    # init ordonnée y
    y = h * (1 - voie1 / slider1["to"])
    # init abscisse x
    x = graphique.winfo_reqwidth() - 2 - size
    # on représente la valeur par un carré
    graphique.create_rectangle(
        x, y, x+size, y+size,
        fill="red", outline="black", width=1, tag="dots",
    )
    # scrolling relatif
    graphique.move("dots", -size, 0)
 
# end def
 
 
# Creation de l'IHM
fenetre = Tk()
fenetre.title("Ways Command")
 
voie1 = IntVar() # Declaration des variables pour Scale apres Tk(). Evite l'erreur " 'NoneType' object has no attribute 'tk' "
attn = IntVar()
 
slider1 = Scale(
    fenetre,
    orient=HORIZONTAL,
    length=600,
    width=20,
    sliderlength=10,
    from_=0,
    to=93.5,
    tickinterval=10,
    resolution=5,
    variable=voie1,
    command=Cursor,
) # Choisir la valeur de la voie 1 avec le Scale
 
slider1.pack()
 
bouton_quitter = Button(fenetre,text="Quitter",bg='red',command=fenetre.destroy) # Boutton quitter
bouton_quitter.pack(side=LEFT,anchor="sw")
 
graphique = Canvas(fenetre,bg='white',height=150,width=200) # Ajouter un graphique qui affiche les variations du Scale
graphique.pack()
graphique.create_line(10,145,200,145,arrow=LAST) # Axe des abscisses
graphique.create_line(10,145,10,5,arrow=LAST) # Axe des ordonnées
pas = (175/8)
for t in range(1,9): # Graduations
    stx = 10 + t*pas
    graphique.create_line(stx,141,stx,149)
 
fenetre.mainloop()# Boucle principale

juste une petite question : est-ce que LATCH ON / LATCH OFF ne devrait pas plutôt figurer dans la fonction send_att() ?

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def send_att(attn): # Fonction de calcul et de transmission des donnees
    if 0 <= attn < 31:
        WR.shiftOut(DATA,CLOCK,1,(int(attn)*2)) # Le 1 ou le 0 permet d'inverser l'ordre des bits
 
    elif attn < 63:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-31)+32)*2)) # int(attn) evite l'erreur " unsuported operand type for -: 'str' and 'int' "
 
    elif attn < 93:
        WR.shiftOut(DATA,CLOCK,1,(((int(attn)-62)+96)*2))
 
    elif attn >= 93:
        attn = 93 # késako ??????
    # end if
 
    WR.digitalWrite(LATCH,1) # LATCH ON
    WR.digitalWrite(LATCH,0) # LATCH OFF
 
# end def

@+.

[Florian BERTOSSI]

Bonjour,

Super ça fonctionne !
Merci beaucoup pour votre aide !

juste une petite question : est-ce que LATCH ON / LATCH OFF ne devrait pas plutôt figurer dans la fonction send_att() ?

En effet, les instructions LATCH ON et LATCH OFF doivent figurer dans la fonction send_att(attn).

@+

[Kurodiam]

C'est pas possible , ce code vient de la planète Mars , il défie toutes les lois logiques . Ce qui est étonnant , c'est que tu n'utilises pas du tout l'argument event ....

D'où viennent toutes ses librairies ? Est-ce qu'il faut les installer ?

En quoi consiste les instructions LATCH ON et LATCH OFF ?

[Invité]

C'est pas possible , ce code vient de la planète Mars , il défie toutes les lois logiques .

Bonjour,

si vous voulez quelque chose de plus Terrien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import wiringpi2 as WR
 
from Tkinter import *
 
CLOCK = 27  # Pin 27 GPIO
LATCH = 24  # Pin 24 GPIO
DATA = 18   # Pin 18 GPIO
 
WR.wiringPiSetupGpio()  # Configuration des pins
WR.pinMode(CLOCK, 1)     # La pin 27 GPIO de clock est en sortie
WR.pinMode(LATCH, 1)     # La pin 24 GPIO du Latch est en sortie
WR.pinMode(DATA, 1)      # La pin 18 GPIO de data est en sortie
 
 
def send_att(attn):
    """
        envoi d'un bytechar sur la carte électronique
    """
    attn = abs(int(attn)) & 0xFF # bytechar only
 
    if 31 <= attn < 63:
        attn += 1
    elif 63 <= attn < 93:
        attn += 34
    # end if
 
    if attn < 93:
        # écriture du bytechar sur le port
        # de la carte électronique
        WR.shiftOut(DATA, CLOCK, 1, attn * 2)
        # on libère le bytechar retenu
        # par le latch sur la carte électronique
        WR.digitalWrite(LATCH, 1) # LATCH ON
        WR.digitalWrite(LATCH, 0) # LATCH OFF
    # end if
 
# end def
 
 
def value_changed(attn):
    """
        transmission et affichage nouvelle valeur
    """
    # init valeur
    voie1 = slider1.get()
    # transmission valeur
    send_att(voie1)
    # init taille carré
    size = 5
    # init hauteur de référence canvas
    h = canvas.winfo_reqheight() - 7 - size
    # init ordonnée y
    y = h * (1 - voie1 / slider1["to"])
    # init abscisse x
    x = canvas.winfo_reqwidth() - 2 - size
    # on représente la valeur par un carré
    canvas.create_rectangle(
        x, y, x+size, y+size,
        fill="red", outline="black", width=1, tag="dots",
    )
    # scrolling relatif
    canvas.move("dots", -size, 0)
# end def
 
# création de l'IHM
fenetre = Tk()
fenetre.title("Ways Command")
 
voie1 = IntVar()
 
slider1 = Scale(
    fenetre,
    orient=HORIZONTAL,
    length=600,
    width=20,
    sliderlength=10,
    from_=0,
    to=93.5,
    tickinterval=10,
    resolution=5,
    variable=voie1,
    command=value_changed,
)
 
slider1.pack()
 
canvas = Canvas(
    fenetre,
    bg='white',
    height=150,
    width=200
)
canvas.pack()
 
# dessin du repère graphique
canvas.create_line(10, 145, 200, 145, arrow=LAST) # Axe des abscisses
canvas.create_line(10, 145, 10, 5, arrow=LAST) # Axe des ordonnées
pas = 175 / 8
 
for t in range(1, 9): # Graduations
    stx = 10 + t * pas
    canvas.create_line(stx, 141, stx, 149)
# end for
 
Button(
    fenetre, text="Quitter", bg='red', command=fenetre.destroy
).pack(side=RIGHT, anchor=SW)
 
fenetre.mainloop()

Ce qui est étonnant , c'est que tu n'utilises pas du tout l'argument event ....

ah non, pas pour un objet Tkinter.Scale : http://infohost.nmt.edu/tcc/help/pub...web/scale.html (voir explications option command=callback)

En quoi consiste les instructions LATCH ON et LATCH OFF ?

le LATCH est un mécanisme de rétention qui mémorise une valeur sur la carte électronique puis qui la délivre sur le port adéquat au moment voulu par l'opérateur ou le programme.

on appelle ça aussi un FLIP-FLOP en électronique.

@+.