Plusieurs programmes simultanés

**eponge** · 22/07/2018, 17h41

bonjour je tente actuellement de faire d'un raps un mini ordinateur de voyages. cet ordinateur permettrait d'avoir plusieurs informations comme l'heure la localisation, une boussole et divers informations. j'ai un problème car les programmes ensembles pas pouvoir tourner alors que seuls ils marchent. j'ai tenté d'utiliser des threads mais le problème persiste. auriez vous des solutions ?

**Bktero** · 23/07/2018, 08h22

Nom : images.jpeg
Affichages : 1041
Taille : 8,3 Ko

**eponge** · 23/07/2018, 12h05

c'est une pub pour Mme irma ? j'aurais dû mettre un peu de code désolé

Code python :

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
import tkinter as tk,ombre,threading
calendate=[]
 
class Calendrier(threading.Thread):
    def __init__(self,ok=False,jouri=0,date=[1,12,2016]):
        import datetime,calendar
        threading.Thread.__init__(self)
        self.caractere=('Arial',15)
        self.ok=ok
        self.calen=tk.Tk()
        self.calen.title('calendrier')
        self.jsemaines=["lun","mar","mer","jeu","ven","sam","dim"]
        self.listmois=["janvier","février","mars","avril","mai","juin",
                       "juillet","aout","septembre","octobre","novembre","décembre"]
        racjour=datetime.datetime.now()
        self.jour=racjour.day
        self.mois=racjour.month
        self.annee=racjour.year
        self.jsem=racjour.weekday()
        self.nbjour=calendar.mdays      #nombre de jours dans le mois
        self.bisex=calendar.isleap(self.annee)#annee bisextile ou non
        self.jourc=tk.IntVar()
        self.moisc=self.mois
        self.anneec=self.annee
        self.jourper=20     #fêtes personnelles  à lier à la base de données
        self.moisper=2     #fêtes personnelles
        self.jourimp=25     #rendez vous        à lier à la base de données
        self.moisimp=2     #rendez vous
        self.jouri=jouri
        self.date=date
        legende=tk.Frame(self.calen)
        tk.Label(legende,text="aujourd'hui",font=self.caractere,bg="cyan",).grid(row=2,column=0)
        tk.Label(legende,text="rdv",font=self.caractere,bg="magenta").grid(row=3,column=0)
        tk.Label(legende,text="anni,fêtes",font=self.caractere,bg="red").grid(row=4,column=0)
        legende.grid(row=2,column=5,rowspan=3)
        #tk.Button(self.calen,text='voir',font=self.caractere,command=self.montrer).grid(row=0,column=5)
        tk.Button(self.calen,text='validation',font=self.caractere,command=self.valider).grid(row=0,column=5)
        tk.Button(self.calen,text='quitter',font=self.caractere,command=self.calen.destroy).grid(row=1,column=5)
        self.affichage()
 
    #calendrier
    def affichage(self):
        import datetime,calendar
        self.cal=tk.Frame(self.calen)
        #mise en place du premier jour
        self.premsjour=calendar.weekday(self.anneec,self.moisc,1)
        self.jc=1-(self.premsjour)
        for self.ligne in range(6):
            for self.colonne in range(7):
                #mise en place du jour de la semaine
                jourdesemaine=self.jsemaines[self.colonne]
                semainier=tk.Label(self.cal,text=jourdesemaine,font=self.caractere)
                if((jourdesemaine=="sam")or(jourdesemaine=="dim")):
                    semainier.configure(bg="blue")
                    semainier.configure(fg="white")
                semainier.grid(row=0,column=self.colonne+1)    
                #calcul du numéro du jour
                self.jc=7*self.ligne+self.colonne-self.premsjour+1
                if ((self.jc>0)and(self.jc<=self.nbjour[self.moisc])):
                    #calcul du numéro des semaines
                    if(self.jc==1):
                        numsemaine=datetime.date(self.anneec,self.moisc,self.jc).isocalendar()
                        tk.Label(self.cal,text=numsemaine[1],width=2,font=self.caractere).grid(row=self.ligne+1,column=0)
                    #affichage du numéro des semaines
                    if (self.colonne==0) :
                        numsemaine=datetime.date(self.anneec,self.moisc,self.jc).isocalendar()
                        tk.Label(self.cal,text=numsemaine[1],width=2,font=self.caractere).grid(row=self.ligne+1,column=0)
                    #affichage des jours
                    self.nom=tk.Radiobutton(self.cal,text=self.jc,font=self.caractere,variable=self.jourc,value=self.jc,width=2,indicatoron=0,command=self.choixjour)
                    self.nom.grid(row=self.ligne+1,column=self.colonne+1)
                    #affichage du jour actuel
                    if((self.jc==self.jour)and(self.moisc==self.mois)):
                        self.nom.configure(bg="cyan")
                    elif((self.jc==self.jourper)and(self.moisc==self.moisper)):
                        self.nom.configure(bg="red")
                    elif((self.jc==self.jourimp)and(self.moisc==self.moisimp)):
                        self.nom.configure(bg="magenta")
                    else:
                        self.nom.configure(bg="white")
                else:
                    #affichage des cases restantes
                    tk.Label(self.cal,text="  ",font=self.caractere,width=2,bg='grey').grid(row=self.ligne+1,column=self.colonne+1)             
        self.cal.grid(row=4,column=0,columnspan=3)
        self.resuldate=tk.Frame(self.calen,bg="orange")
        #récapitulatif des choix pour la date
        tk.Label(self.resuldate,text=self.jouri,width=2,font=self.caractere,bg="orange").grid(row=1, column=0)
        tk.Label(self.resuldate,text=self.listmois[(self.moisc-1)],width=9,font= self.caractere,bg="orange").grid(row=1,column=1)
        tk.Label(self.resuldate,text=self.anneec,font= self.caractere,bg="orange").grid(row=1,column=2)
        tk.Label(self.resuldate,text="date choisie",font=self.caractere,bg="orange").grid(row=0,column=0,columnspan=3)
        self.resuldate.grid(row=0,column=0,rowspan=2,columnspan=3)
        #print("fin affichage")
        chomois=tk.Frame(self.calen)
        tk.Button(chomois,text="-",font=self.caractere,command=self.boutonmoismoins).grid(row=4,column=0)
        tk.Button(chomois,text='+',font=self.caractere,command=self.boutonmoisplus).grid(row=4,column=3)
        tk.Label(chomois,text=self.listmois[(self.moisc-1)],font=self.caractere,width=9).grid(row=4,column=1)
        tk.Label(chomois,text=self.anneec,font=self.caractere).grid(row=4,column=2)
        chomois.grid(row=3,column=0,columnspan=3)
        self.cal.mainloop()
 
    #calendrier
    def choixjour(self):
       self.jouri=self.jourc.get()
       #self.calen.after(1000,self.choixjour)
       if(self.jouri!=0):
           self.affichage()
           return self.jouri
 
    #calendrier
    def boutonmoisplus(self):
        if(self.moisc>=12):
            self.moisc=1
            self.anneec+=1
            self.affichage()
            return self.moisc,self.anneec
        else:
            self.moisc=self.moisc+1
            self.affichage()
            return self.moisc
 
    #calendrier
    def boutonmoismoins(self):
        if(self.moisc<=1):
            self.moisc=12
            self.anneec-=1
            self.affichage()
            return self.moisc,self.anneec
        else:
            self.moisc=self.moisc-1
            self.affichage()
            return self.moisc
 
    #calendrier
    def valider(self):
        import asyncio
        global calendate
        if self.jouri>0:
            self.ok=True
            self.date=[self.jouri,self.moisc,self.anneec,self.ok]
            calendate=[self.jouri,self.moisc,self.anneec]
            self.quitter()
        else:
            self.ok=True
            self.date=[0,self.moisc,self.anneec,self.ok]
            self.quitter()
        return self.date
 
    #calendrier
    def quitter(self):
        self.calen.destroy()
 
    #calendrier
    def recupdate(self):#retour des choix effectués
        if(self.ok==True):
            return self.date

Code python :

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
class Principal(threading.Thread):    #init comdur
    def __init__(self,angle=0,xn=0,yn=0,xs=0,ys=0,xl=0,yl=0,
                 caractere=('Arial',15),messaginfo="bonjour"):
        import ombre
        threading.Thread.__init__(self)
        self.xn = xn
        self.yn = yn
        self.xs = xs
        self.ys = ys
        self.xl = xl
        self.yl = yl
        self.messaginfo=messaginfo
        verif=ombre.recherche()
        self.comtac =ombre.connection[0]   #verif presence ecran
        self.commes =ombre.connection[1]    #verif module mesure
        self.comdur=ombre.connection[2]    #verif disque dur
        print(ombre.connection)
        self.princ = tk.Tk()
        self.princ.title('principal')
        self.princ.geometry("750x350")
        self.angle=angle
        self.caractere = caractere
        #données exemple a remplacer par la liaison disque dur
        """for i in range(0,8):
            self.reglage1[i]=ombre.stockalarmes[i] #alarme 'une fois'
            self.reglage2[i]=ombre.stockalarmes1[i]#alarme 'un jour par semaine'
            self.reglage3[i]=ombre.stockalarmes2[i]#alarme 'semaine de travail'
            self.reglage4[i]=ombre.stockalarmes3[i]#alarme 'un jour par semaine'
            self.reglage5[i]=ombre.stockalarmes4[i]"""
        self.reglage1=[1,False,8,0,0,0,0,0,0]
        self.reglage2=[2,True,10,30,0,0,0,0,0]
        self.reglage3=[3,False,8,0,0,0,0,0,0]
        self.reglage4=[4,False,8,0,0,0,0,0,0]
        self.reglage5=[5,False,8,0,0,0,0,0,0]
        self.reglage6=[6,True,10,30,0,0,0,0,0]
        self.reglage7=[7,True,12,12,0,0,0,0,0]
        self.reglage8=[8,False,8,0,0,0,0,0,0]
        self.reglage9=[9,False,8,0,0,0,0,0,0]
        self.reglage10=[10,False,8,0,0,0,0,0,0]
        self.aff=tk.Frame(self.princ,bg='black')               
        self.preparationheure()
        tk.Label(self.aff, text=self.horaires, font=("Arial",60), bg= 'black', fg= 'cyan').grid(row=0, rowspan=3, column=2, columnspan=4)
        tk.Label(self.aff, text=self.date, font=("Arial", 20), bg='black', fg='cyan').grid(row=1, column=0, columnspan=2)
        tk.Label(self.aff, text=self.joursem, font=self.caractere, bg='black', fg='cyan').grid(row=2,column=1)
        #tk.Label(self.aff, text=messaginfo,fg='cyan',bg='black',font= ('Arial',12)).grid(row=4, column=1,columnspan=3)
        self.aff.grid(row=0,rowspan=5,column=0,columnspan=4)
        if(self.comdur==True):
            tk.Button(self.princ,text="base",font=self.caractere,bg="orange",state="normal").grid(row=5,column=0,padx=2,pady=2)
            tk.Button(self.princ,text="perso",font=self.caractere,bg="orange",state="normal",command=Perso).grid(row=6,column=0,padx=2,pady=2)
            tk.Button(self.princ,text="divert",font=self.caractere,bg="orange",state="normal").grid(row=7,column=0,padx=2,pady=2)
        else:
            tk.Button(self.princ,text="base",font=self.caractere,bg="orange",state="disabled").grid(row=5,column=0,padx=2,pady=2)
            tk.Button(self.princ,text="perso",font=self.caractere,bg="orange",state="disabled").grid(row=6,column=0,padx=2,pady=2)
            tk.Button(self.princ,text="divert",font=self.caractere,bg="orange",state="disabled").grid(row=7,column=0,padx=2,pady=2)
        #boutons
        tk.Button(self.princ,text="agenda", font=self.caractere,bg='cyan',command=Gestagenda).grid(row=5,column=2)
        tk.Button(self.princ,text="option", font = self.caractere,command=Option,bg="cyan").grid(row=5,column=1)
        tk.Button(self.princ,text='calc.', font=self.caractere,command=Calculatrice).grid(row=5,column=3)
        tk.Button(self.princ,text='alarmes',font=self.caractere,bg='cyan',command=Alarmes).grid(row=6,column=1)
        tk.Button(self.princ,text='exter.',font=self.caractere,bg='cyan',command=Exterieur).grid(row=6,column=2)
        self.misajour()
        tk.Button(self.princ,text="quitter",font= self.caractere,
                  command=self.princ.destroy).grid(row=6,column=3)
        self.princ.mainloop()
 
    #principal
    #preparation de l'heure et jour principaux
    def preparationheure(self):
        import datetime
        self.jsemaines=["lundi","mardi","mercredi","jeudi","vendredi","samedi",
                       "dimanche"]
        racheure = datetime.datetime.now().time()
        self.heure = racheure.hour
        self.minute = racheure.minute
        self.seconde = racheure.second
        racjour = datetime.datetime.now()
        self.jour = racjour.day
        self.mois = racjour.month
        self.annee = racjour.year
        self.jsem = racjour.weekday() #depart lundi
        self.jours = str(self.jour)
        self.moiss = str(self.mois)
        self.annees = str(self.annee)
        self.date = self.jours + "/" + self.moiss + "/" + self.annees
        self.heures = str(self.heure)
        self.minutes = str(self.minute)
        self.secondes = str(self.seconde)
        self.joursem = self.jsemaines[self.jsem]
        if self.heure<10:
            self.heures = " " + self.heures
        if self.minute<10:
            self.minutes = "0" + self.minutes
        if self.seconde<10:
            self.secondes= "0" + self.secondes
        self.horaires = self.heures + ":" + self.minutes + ":" + self.secondes
        self.princ.after(500,self.preparationheure)
        return self.date, self.horaires, self.heure, self.heures, self.minute, self.minutes, self.seconde, self.secondes, self.jour, self.jours, self.mois, self.moiss, self.annee, self.annees, self.jsemaines
 
    #principal
    #bousole pour orientation
    def preparationboussole(self):  #sens de rotation a inverser
        import math
        if self.angle<0:
            self.angle=self.angle+360
        if self.angle>=360:
            self.angle= self.angle-360
        anglef=math.radians(self.angle)*-1
        pi= math.pi
        xn = 100 - 85*math.sin(anglef)
        yn = 100 - 85*math.cos(anglef)
        self.xn=int(xn)
        self.yn=int(yn)
        anglef1 = anglef + (pi/2)
        self.xo = 100 - 85*math.sin(anglef1)
        self.yo = 100 - 85*math.cos(anglef1)
        anglef2 = anglef1 + (pi/2)
        xs = 100 - 60*math.sin(anglef2) #creation d un trait plus court
        ys = 100 - 60*math.cos(anglef2) # pour differencier nord et sud
        self.xs=int(xs)
        self.ys=int(ys)
        anglef3 = anglef2 + (pi/2)
        self.xe = 100 - 85*math.sin(anglef3)
        self.ye = 100 - 85*math.cos(anglef3)
        #placement de la lettre pour le nord
        if((self.angle>=0)and(self.angle<=45)): #bas droite
            self.xl = self.xn + 20
            self.yl = self.yn
        if((self.angle>=45)and(self.angle<=90)):    #haut gauche
            self.xl = self.xn 
            self.yl = self.yn - 20
        if((self.angle>90)and(self.angle<=135)):    #bas gauche
            self.xl = self.xn
            self.yl = self.yn + 20
        if((self.angle>135)and(self.angle<=180)):   #haut droite
            self.xl = self.xn + 20
            self.yl = self.yn
        if((self.angle>180)and(self.angle<=225)):   #haut gauche
            self.xl = self.xn - 20
            self.yl = self.yn
        if((self.angle>225)and(self.angle<=270)):   #bas droite
            self.xl = self.xn
            self.yl = self.yn + 20
        if((self.angle>270)and(self.angle<=315)):   #haut droite
            self.xl = self.xn
            self.yl = self.yn - 20
        if((self.angle>315)and(self.angle<=359)):
            self.xl = self.xn + 20
            self.yl = self.yn
        return self.angle, self.xl, self.yl, self.xn, self.yn, self.xs, self.ys
 
    #principal
    #affichage du niveau d'énergie
    def niveaudenergie(self):
        self.niveaubat=75      #lien vers la batterie a faire
        xn=(self.niveaubat/100)*198
        if(self.niveaubat<=30):
            coul='red'
        elif((self.niveaubat>30)and(self.niveaubat<=60)):
            coul='yellow'
        elif(self.niveaubat>60):
            coul='green'            
        self.niveau=tk.Canvas(self.princ,bg='black',width=200,height=50)
        self.niveau.create_rectangle(2,1,xn,49,fill=coul,width=4)
        self.niveau.create_text(80,25,text="batterie",font=self.caractere,fill='cyan')
        self.niveau.create_text(140,25,text=self.niveaubat,font=self.caractere,fill='cyan')
        self.niveau.grid(row=0,column=5,columnspan=2)
 
    #principal
    def voyants(self):
        voy=tk.LabelFrame(self.princ,text="voyants")
        if(self.commes==False):
            extlampe=False
            extcam=False
        voylampe=tk.Label(voy,text="lampe",font=self.caractere)
        if(extlampe==True):
            voylampe.configure(fg="black",bg="yellow")
        else:
            voylampe.configure(fg="white",bg="black")
        voylampe.grid(row=0,column=0)
        camera=tk.Label(voy,text="caméra",font=self.caractere)
        if(extcam==True):
            camera.configure(fg="black",bg="yellow")
        else:
            camera.configure(fg="white",bg='black')
        camera.grid(row=0,column=1)
        voy.grid(row=1,column=5,columnspan=2)
 
    #principal
    #affiche ce qui marche/marche pas
    def misajour(self):
        #affichage heure
        tk.Label(self.aff, text=self.horaires, font=("Arial",60), bg= 'black', fg= 'cyan').grid(row=0, rowspan=3, column=2, columnspan= 3)
        tk.Label(self.aff, text=self.date, font=("Arial", 20), bg='black', fg='cyan').grid(row=1, column=0,columnspan=2)
        self.voyant=tk.Frame(self.aff,bg='black')
        if self.comtac==True:
            tk.Label(self.voyant,text=' tactile ok', font=('arial',12), fg='#00ff88',bg= 'black').grid(row=3,column=1)
        else:
            tk.Label(self.voyant,text="pas d'écran", font=('arial',12), fg= 'red', bg= 'black').grid(row=3, column=1)
        if self.commes==True:
            tk.Label(self.voyant,text= 'mesure ok', font=('arial',12), fg= '#00ff88', bg= 'black').grid(row=3, column=2)
        else:
            tk.Label(self.voyant, text='pas de mes', font=('arial',12), fg= 'red', bg= 'black').grid(row=3, column=2)
        if self.comdur==True:
            tk.Label(self.voyant, text='dis dur ok', font=('Arial',12), fg='#00ff88', bg= 'black').grid(row=3,column=3)
        else:
            tk.Label(self.voyant, text='dur absent', font=('Arial',12), fg='red', bg= 'black').grid(row=3 ,column=3)
        tk.Label(self.voyant, text=self.messaginfo, font=('Arial',12) ,fg= 'cyan', bg= 'black').grid(row=4,column=1,columnspan=3) 
        self.voyant.grid(row=3,rowspan=2,column=2,columnspan=3)
        self.al=tk.Frame(self.aff)
        if(self.reglage1[1]==True):
            tk.Label(self.al, text=self.reglage1[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=0)
        else:
            tk.Label(self.al, text=self.reglage1[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=0)
        if(self.reglage2[1]==True):
            tk.Label(self.al, text=self.reglage2[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=1)
        else:
            tk.Label(self.al, text=self.reglage2[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=1)
        if(self.reglage3[1]==True):
            tk.Label(self.al, text=self.reglage3[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=2)
        else:
            tk.Label(self.al, text=self.reglage3[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=2)
        if(self.reglage4[1]==True):
            tk.Label(self.al, text=self.reglage4[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=3)
        else:
            tk.Label(self.al, text=self.reglage4[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=3)
        if(self.reglage5[1]==True):
            tk.Label(self.al, text=self.reglage5[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=4)
        else:
            tk.Label(self.al, text=self.reglage5[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=5)
        if(self.reglage6[1]==True):
            tk.Label(self.al, text=self.reglage6[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=5)
        else:
            tk.Label(self.al, text=self.reglage6[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=6)
        if(self.reglage5[1]==True):
            tk.Label(self.al, text=self.reglage7[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=6)
        else:
            tk.Label(self.al, text=self.reglage7[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=7)
        if(self.reglage5[1]==True):
            tk.Label(self.al, text=self.reglage8[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=8)
        else:
            tk.Label(self.al, text=self.reglage8[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=8)
        if(self.reglage5[1]==True):
            tk.Label(self.al, text=self.reglage9[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=9)
        else:
            tk.Label(self.al, text=self.reglage9[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=9)
        if(self.reglage5[1]==True):
            tk.Label(self.al, text=self.reglage10[0],font=self.caractere,bg='#00ff88',fg="black").grid(row=5,column=10)
        else:
            tk.Label(self.al, text=self.reglage10[0],font=self.caractere,bg="red",fg="black").grid(row=5,column=10)
 
        self.al.grid(row=5,column=0,columnspan=3)
        self.bous=tk.Canvas(self.princ,bg='black',height=200,width=200)
        self.bous.create_oval(40,40,160,160,outline='cyan',width=4)
        self.bous.create_line(self.xn,self.yn,self.xs,self.ys,fill='cyan',width=2,arrow="first")
        self.bous.create_text(self.xl,self.yl,text="N",fill='cyan')
        self.bous.create_text(100,190,text=self.angle,fill='cyan',font=self.caractere)
        self.bous.grid(row=3,column=5,rowspan=5,columnspan=2)
        self.preparationboussole()
        self.niveaudenergie()
        self.voyants()
        self.princ.after(500,self.misajour)

voici deux parties du code le premier sert à créer un calendrier l'autre sert d'affichage principal je n'ai pas mis la gestion des communications et similaires. si certains veulent m'aider pour ce projet je serais ravi d'en discuter

**LittleWhite** · 23/07/2018, 17h30

Bonjour,

Si vous lancez chaque programme dans un terminal différent, cela devrait fonctionner ? Ou alors, j'ai mal saisi le problème.

**eponge** · 24/07/2018, 07h40

un terminal différent ? sur un raps différent ou lancer un puis l'autre de manière indépendante ?

quand j'ai commencé le projet j'avais l'intention de faire une interface principale qui permettait de lancer les fonctions secondaires (comme le calendrier) suivant les informations désirées. pour le programme chaque fonction à moins de nécessiter des informations comme les frappes d'un clavier, les données d'un capteur ou d'un autre programme est totalement autonome (d'où l'utilisation des classes). le lien avec les capteurs, clavier est fait par un ensemble de programmes ou chaque fonction est faite par une classe. cet ensemble gère aussi les threads mais j'avoue avoir quelques doutes sur l'efficacité de ceux-ci. de plus je n'ai qu'un raps en stock entouré d'arduino pour les rôle de plateforme de mesure, de clavier, et autres fonctions ne nécessitant pas ou peu de puissance de calcul. le raps sert de 'cerveau' à l'ensemble

**LittleWhite** · 24/07/2018, 10h37

Non, juste lancer l'un puis l'autre de manière indépendante.
Après, vous pouvez intégrer ce mécanisme dans un script Python "maître" avec popen ou similaire.

**eponge** · 24/07/2018, 17h51

je ne connais pas la commande popen je vais regarder ce que ça donne merci. il y a une commande qui puisse fermer une application aussi ? je pensais justement faire un programme maître comme tu me le conseil mais j'avoue avoir du mal rapport au manque de connaissances. par exemple j'avais vu des commandes pour mettre en pause mais rien de bien concluant (leur utilisation par exemple manquait). il y a des adresses où je pourrais trouver des renseignements ?

**LittleWhite** · 30/07/2018, 17h05

Avec kill, on peut fermer un programme avec son PID. J'imagine que Python offre une solution similaire. De même, en linux, on peut mettre un programme en pause (avec un signal (envoyé par kill encore), SIGSTOP et on continue avec SIGCONT).

**chrtophe** · 06/08/2018, 17h13

Tu peux gérer des threads avec Python.

tu pourras alors les créer, les suspendre, les détruire.
https://python.developpez.com/faq/?page=Thread

**eponge** · 07/08/2018, 11h15

justement j'ai tenté avec des threads et le résultat ne me semble pas très différent. je pense aussi que je n'ai pas dû faire les choses comme il fallait

**eponge** · 26/08/2018, 10h18

je teste actuellement la solution popen sauf que comme mes programmes ne sont pas des applications comment puis je les utiliser ? pour les thread j'ai passé plusieurs jours à tenter une énième fois de les intégrer dans les programmes et aucun résultat. rien ne marche

**LittleWhite** · 27/08/2018, 10h58

Vous pouvez les transformer en programme en ajoutant un main() et en lançant avec une commande du style python ./programme.py.

**eponge** · 28/08/2018, 10h00

merci la méthode fonctionne, je sais que j'abuse, mais pour récupérer une donnée venant du programme utilisé comment faire ? parce que je pense que le programme fermé tout doit se réinitialiser ?

**LittleWhite** · 28/08/2018, 10h11

Avec popen, vous pouvez passer par un fichier sur le disque, ou une communication à travers un socket. Avec thread, cela aurait été un peu plus facile (variable partagée/valeur de retour disponibles).

Plusieurs programmes simultanés

Raspberry Pi

Discussions similaires

Partager

Partager