Modifications pour le document Commutateur d' antenne

Modifié par Jean-Yves Dupertuis le 27-08-2014, 11:07
Depuis la version < 11.5 >
modifié par Jean-Yves Dupertuis
sur 18-07-2014, 11:11
À la version < 17.2 >
modifié par Jean-Yves Dupertuis
sur 25-07-2014, 11:16
< >
Commentaire de modification : modification zone txt dans image

Résumé

Détails

Propriétés de la Page
Contenu
... ... @@ -1,3 +1,8 @@
1 +{{box cssClass="floatinginfobox" title="**Contents**"}}
2 +{{toc /}}
3 +{{/box}}
4 +
5 +
1 1  = Commutation d'antenne via raspberry - py =
2 2  
3 3  Ce commutateur va permettre via internet de modifier l' antenne reliée au TX de la station EM.
... ... @@ -8,7 +8,7 @@
8 8  = [[Fabrication>>doc:fabricationSwitch]] =
9 9  
10 10  
11 -== Interface Homme - Machine ==
16 += Interface Homme - Machine =
12 12  
13 13  Pour commuter le TX sur une autre antenne, il suffit de taper la lettre (//canal désiré) au clavier.//
14 14  
... ... @@ -18,14 +18,42 @@
18 18  
19 19  
20 20  
21 -[[image:PremFenetre.jpg]]
26 +(% height="656" width="809" %)
27 +|=|=
28 +|(((
29 +== **__Première fenêtre__** ==
30 +)))|
31 +|(((
32 +Le premier programme que j’ai écrit, commu01.py, est un programme
33 +qui m’a aidé à réaliser des zones dans la fenêtre. Ce programme
34 +dispose de 3 zones. Une zone pour le titre, une pour l’image et la
35 +dernière n’est pas utilisée. J’utilise aussi la zone de l’image pour
36 +dessiner. Actuellement, l’image représente le boîtier du commutateur
37 +avec le fonctionnement interne dessiner dessus. Sur cette image,
38 +j’ai décidé d’afficher la position du commutateur en dessinant une ligne
39 +du point commun au canal actif. Pour quitter le programme, l’utilisateur
40 +utilisera la touche q du clavier.Le code du programme est annexé
41 +à la fin du document.\\
42 +)))|[[image:http://212.74.133.122:81/xwiki/bin/download/Hardware/SwitchAntenna/com_1.jpg?width=1580||alt="com_1.jpg"]]
43 +|(((
44 +== **__Utilisation de la fenêtre__** ==
45 +)))|
46 +|La première modification que j’ai faite dans mon programme est la modification du canal sélectionner sur l’image. J’ai donc choisi, qu’à l’aide du clavier, l’utilisateur pourra faire bouger la sortie. Pour le faire,
47 +il pourra utiliser les touches a, b, c et d du clavier. La fenêtre en elle-même n’a pas changé. Pour faire bouger le commutateur, j’utilise Pygame pour dessiner des lignes. Il demande un point de départ, un point d’arrivée et une épaisseur. J’ai donc noté les coordonnées des points A, B, C et D lors de la création de l’image et j’ai finalement utilisé ces coordonnées dans le programme. Une fois une touche pressée, je
48 +supprime l’ancienne ligne en affichant l’image pardessus et je redessine la nouvelle ligne aux nouvelles coordonnées. Le code du programme (commu02.py) est annexé à la fin du document.| [[image:com_2.jpg]]
49 +|(((
50 +== **__Zone d’aide__** ==
51 +)))|
52 +|Comme le changement de canal fonctionne, j’ai décidé d’ajouter une zone d’aide. Cette zone contiendra les différentes commandes que l’utilisateur peut utilisé. J’ai placé cette zone sur la droite de l’image ce qui m’a fait redéfinir l’emplacement de l’image dans la zone centrale et la position des lignes à afficher. Le code du programme (commu03.py) est annexé à la fin du document.| [[image:com_3.jpg]]
53 +| |
54 +| |
22 22  
23 23  
24 24  
25 -[[image:ZoneAide.jpg]]
26 26  
27 27  
28 28  
61 +
29 29  [[image:BoutonIndication.jpg]]
30 30  
31 31  
... ... @@ -48,7 +48,7 @@
48 48  
49 49  == Câblage du module ==
50 50  
51 -Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transit via des opto - coupleurs.
84 +Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transite via des opto - coupleurs.
52 52  
53 53  Une carte dédiée à cette protection a été développée.
54 54  
... ... @@ -74,10 +74,316 @@
74 74  
75 75  **Ne pas oublier de les relier au 12Vdc !**
76 76  
77 -
78 78  == Câble ==
79 79  
80 80  
81 81  [[image:cableCommAnt.jpg]]
82 82  
115 += Programmation Python =
83 83  
117 +Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
118 +
119 +Si vous ne l'avez pas, vous pouvez le télécharger sur le site Python [[https:~~/~~/www.python.org/downloads/>>url:https://www.python.org/downloads/]].
120 +
121 +Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
122 +
123 +sur votre carte raspberry - py.
124 +
125 +**Important !! **je suis parti du principe que le port **//I2C//** est fonctionnel sur votre raspberry - py.
126 +
127 +**Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !**
128 +
129 +
130 +
131 +== Source : ==
132 +
133 +{{box}}
134 +##{{{# auteur : Gilliand Loris
135 +# date : 02.06.14
136 +# version 0.8
137 +#
138 +# amelioration depuis 0.7 : integre un lcd qui peut commander les changements
139 +
140 +# importation bibilotheques
141 +import pygame, sys, time
142 +from pygame.locals import *
143 +import RPi.GPIO as GPIO
144 +from Adafruit_CharLCDPlate import *
145 +
146 +# initialisation fenetre et gpio
147 +pygame.init()
148 +GPIO.setmode(GPIO.BCM)
149 +
150 +# fonction qui change LA sortie active
151 +def change_sortie(ligne):
152 + BP1.etat = 0
153 + BP2.etat = 0
154 + BP3.etat = 0
155 + BP4.etat = 0
156 + BP1.affiche_etat(inactif)
157 + BP2.affiche_etat(inactif)
158 + BP3.affiche_etat(inactif)
159 + BP4.affiche_etat(inactif)
160 + time.sleep(0.25)
161 + if ligne == 'a':
162 + BP1.etat = 1
163 + BP1.affiche_etat(actif)
164 + elif ligne == 'b':
165 + BP2.etat = 1
166 + BP2.affiche_etat(actif)
167 + elif ligne == 'c':
168 + BP3.etat = 1
169 + BP3.affiche_etat(actif)
170 + elif ligne == 'd':
171 + BP4.etat = 1
172 + BP4.affiche_etat(actif)
173 +
174 +# classe de creation de cases
175 +class Cases:
176 + def init(self,image,pos,port,init):
177 + self.image = pygame.image.load(image).convert()
178 + self.pos = pos
179 + self.port = port
180 + self.etat = init
181 + self.rect = self.image.get_rect().move(self.pos)
182 + GPIO.setup(self.port,GPIO.OUT)
183 + GPIO.output(self.port,GPIO.LOW)
184 +
185 + def affiche_etat(self,indicateur):
186 + indicateur = pygame.image.load(indicateur).convert()
187 + indi_rect = indicateur.get_rect()
188 + indi_rect.centerx = self.rect.centerx - self.pos[0]
189 + indi_rect.centery = self.rect.centery - self.pos[1]
190 + if self.etat == 0:
191 + GPIO.output(self.port,GPIO.LOW)
192 + elif self.etat == 1:
193 + GPIO.output(self.port,GPIO.HIGH)
194 + self.image.blit(indicateur,indi_rect)
195 +
196 +# initialisation de la fenetre
197 +screen = pygame.display.set_mode((600,600))
198 +clock = pygame.time.Clock()
199 +# initialisation des couleurs
200 +rouge = (255,0,0)
201 +noir = (0,0,0)
202 +blanc = (255,255,255)
203 +vert = (0,255,0)
204 +bleu = (0,0,255)
205 +
206 +# initialisation des variables
207 +startline = (183,149)
208 +endline = (293,75)
209 +
210 +flag_canal = 0
211 +
212 +canal = [4,17,18,22,23,24,25,27]
213 +
214 +# definitions des zones
215 +zone1 = pygame.Surface((600,150))
216 +zone1.fill(bleu)
217 +
218 +zone2 = pygame.Surface((400,300))
219 +zone2.fill(bleu)
220 +
221 +zone3 = pygame.Surface((600,150))
222 +zone3.fill(bleu)
223 +
224 +zone4 = pygame.Surface((200,300))
225 +zone4.fill(bleu)
226 +
227 +# definitions des objets a afficher dans les zones
228 +# zone 1
229 +font = pygame.font.Font(None,60)
230 +titre1 = font.render("HB9EM",1,noir)
231 +titre2 = font.render("Commutateur d'antennes",1,noir)
232 +zone1.blit(titre1,(230,30))
233 +zone1.blit(titre2,(50,70))
234 +
235 +# zone 2
236 +commu = pygame.image.load("commu_antenne.bmp").convert()
237 +zone2.blit(commu,(50,50))
238 +
239 +# zone 3
240 +actif = "actif_commu.bmp"
241 +inactif = "inactif_commu.bmp"
242 +
243 +BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
244 +BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
245 +BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
246 +BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
247 +grp_cases = [BP1,BP2,BP3,BP4]
248 +BP1.affiche_etat(actif)
249 +BP2.affiche_etat(inactif)
250 +BP3.affiche_etat(inactif)
251 +BP4.affiche_etat(inactif)
252 +
253 +zone3.blit(BP1.image,BP1.rect)
254 +zone3.blit(BP2.image,BP2.rect)
255 +zone3.blit(BP3.image,BP3.rect)
256 +zone3.blit(BP4.image,BP4.rect)
257 +
258 +font = pygame.font.Font(None,20)
259 +canal_a = font.render("canal A",1,noir)
260 +canal_b = font.render("canal B",1,noir)
261 +canal_c = font.render("canal C",1,noir)
262 +canal_d = font.render("canal D",1,noir)
263 +zone3.blit(canal_a,(125,35))
264 +zone3.blit(canal_b,(225,35))
265 +zone3.blit(canal_c,(325,35))
266 +zone3.blit(canal_d,(425,35))
267 +
268 +# zone 4
269 +commande = font.render("Commandes :",1,noir)
270 +touche_a = font.render("Selection canal A : touche a",1,noir)
271 +touche_b = font.render("Selection canal B : touche b",1,noir)
272 +touche_c = font.render("Selection canal C : touche c",1,noir)
273 +touche_d = font.render("Selection canal D : touche d",1,noir)
274 +quitter = font.render("Quitter : touche q",1,noir)
275 +zone4.blit(commande,(10,20))
276 +zone4.blit(touche_a,(10,60))
277 +zone4.blit(touche_b,(10,80))
278 +zone4.blit(touche_c,(10,100))
279 +zone4.blit(touche_d,(10,120))
280 +zone4.blit(quitter,(10,200))
281 +
282 +# affichage des zones
283 +screen.blit(zone1,(0,0))
284 +screen.blit(zone2,(0,150))
285 +screen.blit(zone3,(0,450))
286 +screen.blit(zone4,(400,150))
287 +
288 +lcd = Adafruit_CharLCDPlate()
289 +lcd.begin(16,2)
290 +btn = ((lcd.SELECT, '', lcd.ON),
291 + (lcd.LEFT , 'Antenne 1' , lcd.ON),
292 + (lcd.UP , 'Antenne 2' , lcd.ON),
293 + (lcd.DOWN , 'Antenne 4' , lcd.ON),
294 + (lcd.RIGHT , 'Antenne 3' , lcd.ON))
295 +prev = -1
296 +temp = ''
297 +active = 'Antenne 1'
298 +act = ' active'
299 +lcd.message((active + act))
300 +while 1:
301 + clock.tick(30)
302 + for b in btn:
303 + if lcd.buttonPressed(lcd.SELECT):
304 + lcd.clear()
305 + lcd.message((active + act))
306 + time.sleep(0.25)
307 + if temp != '':
308 + active = temp
309 + temp = ''
310 + if active == 'Antenne 1':
311 + change_sortie('a')
312 + endline = (293,75)
313 + if active == 'Antenne 2':
314 + change_sortie('b')
315 + endline = (293,125)
316 + if active == 'Antenne 3':
317 + change_sortie('c')
318 + endline = (293,175)
319 + if active == 'Antenne 4':
320 + change_sortie('d')
321 + endline = (293,225)
322 + lcd.setCursor(0,0)
323 + lcd.message((active + act))
324 + lcd.setCursor(0,1)
325 + lcd.message(' ')
326 + if lcd.buttonPressed(lcd.RIGHT):
327 + temp = 'Antenne 3'
328 + lcd.setCursor(0,1)
329 + lcd.message(temp)
330 + if lcd.buttonPressed(lcd.DOWN):
331 + temp = 'Antenne 4'
332 + lcd.setCursor(0,1)
333 + lcd.message(temp)
334 + if lcd.buttonPressed(lcd.UP):
335 + temp = 'Antenne 2'
336 + lcd.setCursor(0,1)
337 + lcd.message(temp)
338 + if lcd.buttonPressed(lcd.LEFT):
339 + temp = 'Antenne 1'
340 + lcd.setCursor(0,1)
341 + lcd.message(temp)
342 +
343 + for event in pygame.event.get():
344 + lcd.setCursor(0,0)
345 + if event.type == pygame.QUIT:
346 + GPIO.cleanup()
347 + sys.exit()
348 + if event.type == pygame.KEYDOWN:
349 + if event.key == pygame.K_q:
350 + GPIO.cleanup()
351 + sys.exit()
352 + if event.key == pygame.K_a:
353 + active = 'Antenne 1'
354 + lcd.message((active + act))
355 + change_sortie('a')
356 + endline = (293,75)
357 + if event.key == pygame.K_b:
358 + active = 'Antenne 2'
359 + lcd.message((active + act))
360 + change_sortie('b')
361 + endline = (293,125)
362 + if event.key == pygame.K_c:
363 + active = 'Antenne 3'
364 + lcd.message((active + act))
365 + change_sortie('c')
366 + endline = (293,175)
367 + if event.key == pygame.K_d:
368 + active = 'Antenne 4'
369 + lcd.message((active + act))
370 + change_sortie('d')
371 + endline = (293,225)
372 +
373 + souris = pygame.mouse.get_pos()
374 + souris_rect = souris[0],souris[1,[5,5]]
375 + souris_rect = pygame.Rect(souris_rect)
376 +
377 + for i in grp_cases:
378 + lcd.setCursor(0,0)
379 + if souris_rect.colliderect(i.rect.move((0,450))):
380 + if pygame.mouse.get_pressed() == (1,0,0):
381 + if i.port == canal[1]:
382 + active = 'Antenne 1'
383 + lcd.message((active + act))
384 + change_sortie('a')
385 + endline = (293,75)
386 + if i.port == canal[2]:
387 + active = 'Antenne 2'
388 + lcd.message((active + act))
389 + change_sortie('b')
390 + endline = (293,125)
391 + if i.port == canal[3]:
392 + active = 'Antenne 3'
393 + lcd.message((active + act))
394 + change_sortie('c')
395 + endline = (293,175)
396 + if i.port == canal[4]:
397 + active = 'Antenne 4'
398 + lcd.message((active + act))
399 + change_sortie('d')
400 + endline = (293,225)
401 +
402 + zone3.blit(BP1.image,BP1.rect)
403 + zone3.blit(BP2.image,BP2.rect)
404 + zone3.blit(BP3.image,BP3.rect)
405 + zone3.blit(BP4.image,BP4.rect)
406 + screen.blit(zone3,(0,450))
407 + zone2.blit(commu,(50,50))
408 + pygame.draw.line(zone2,noir,startline,endline,2)
409 + screen.blit(zone2,(0,150))
410 + pygame.display.update()
411 +}}}##
412 +{{/box}}
413 +
414 +[[Fichier Py>>attach:commu08.py]]
415 +
416 +
417 +=== Distributions 'source' sans et avec LCD ===
418 +
419 +[[Distribution_sans_LCD.rar>>attach:Distribution.rar]]
420 +
421 +
422 +[[Distribution_lcd.rar>>attach:Distribution_lcd.rar]]
Distribution.rar
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +707.0 KB
Contenu
Distribution_lcd.rar
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +10.8 KB
Contenu
com_1.jpg
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +8.9 KB
Contenu
com_2.jpg
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +7.7 KB
Contenu
com_3.jpg
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +10.8 KB
Contenu
commu08.py
Auteur
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Taille
... ... @@ -1,0 +1,1 @@
1 +8.3 KB
Contenu
... ... @@ -1,0 +1,278 @@
1 +# auteur : Gilliand Loris
2 +# date : 02.06.14
3 +# version 0.8
4 +#
5 +# amelioration depuis 0.7 : integre un lcd qui peut commander les changements
6 +
7 +# importation bibilotheques
8 +import pygame, sys, time
9 +from pygame.locals import *
10 +import RPi.GPIO as GPIO
11 +from Adafruit_CharLCDPlate import *
12 +
13 +# initialisation fenetre et gpio
14 +pygame.init()
15 +GPIO.setmode(GPIO.BCM)
16 +
17 +# fonction qui change LA sortie active
18 +def change_sortie(ligne):
19 + BP1.etat = 0
20 + BP2.etat = 0
21 + BP3.etat = 0
22 + BP4.etat = 0
23 + BP1.affiche_etat(inactif)
24 + BP2.affiche_etat(inactif)
25 + BP3.affiche_etat(inactif)
26 + BP4.affiche_etat(inactif)
27 + time.sleep(0.25)
28 + if ligne == 'a':
29 + BP1.etat = 1
30 + BP1.affiche_etat(actif)
31 + elif ligne == 'b':
32 + BP2.etat = 1
33 + BP2.affiche_etat(actif)
34 + elif ligne == 'c':
35 + BP3.etat = 1
36 + BP3.affiche_etat(actif)
37 + elif ligne == 'd':
38 + BP4.etat = 1
39 + BP4.affiche_etat(actif)
40 +
41 +# classe de creation de cases
42 +class Cases:
43 + def __init__(self,image,pos,port,init):
44 + self.image = pygame.image.load(image).convert()
45 + self.pos = pos
46 + self.port = port
47 + self.etat = init
48 + self.rect = self.image.get_rect().move(self.pos)
49 + GPIO.setup(self.port,GPIO.OUT)
50 + GPIO.output(self.port,GPIO.LOW)
51 +
52 + def affiche_etat(self,indicateur):
53 + indicateur = pygame.image.load(indicateur).convert()
54 + indi_rect = indicateur.get_rect()
55 + indi_rect.centerx = self.rect.centerx - self.pos[0]
56 + indi_rect.centery = self.rect.centery - self.pos[1]
57 + if self.etat == 0:
58 + GPIO.output(self.port,GPIO.LOW)
59 + elif self.etat == 1:
60 + GPIO.output(self.port,GPIO.HIGH)
61 + self.image.blit(indicateur,indi_rect)
62 +
63 +# initialisation de la fenetre
64 +screen = pygame.display.set_mode((600,600))
65 +clock = pygame.time.Clock()
66 +# initialisation des couleurs
67 +rouge = (255,0,0)
68 +noir = (0,0,0)
69 +blanc = (255,255,255)
70 +vert = (0,255,0)
71 +bleu = (0,0,255)
72 +
73 +# initialisation des variables
74 +startline = (183,149)
75 +endline = (293,75)
76 +
77 +flag_canal = 0
78 +
79 +canal = [4,17,18,22,23,24,25,27]
80 +
81 +# definitions des zones
82 +zone1 = pygame.Surface((600,150))
83 +zone1.fill(bleu)
84 +
85 +zone2 = pygame.Surface((400,300))
86 +zone2.fill(bleu)
87 +
88 +zone3 = pygame.Surface((600,150))
89 +zone3.fill(bleu)
90 +
91 +zone4 = pygame.Surface((200,300))
92 +zone4.fill(bleu)
93 +
94 +# definitions des objets a afficher dans les zones
95 +# zone 1
96 +font = pygame.font.Font(None,60)
97 +titre1 = font.render("HB9EM",1,noir)
98 +titre2 = font.render("Commutateur d'antennes",1,noir)
99 +zone1.blit(titre1,(230,30))
100 +zone1.blit(titre2,(50,70))
101 +
102 +# zone 2
103 +commu = pygame.image.load("commu_antenne.bmp").convert()
104 +zone2.blit(commu,(50,50))
105 +
106 +# zone 3
107 +actif = "actif_commu.bmp"
108 +inactif = "inactif_commu.bmp"
109 +
110 +BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
111 +BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
112 +BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
113 +BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
114 +grp_cases = [BP1,BP2,BP3,BP4]
115 +BP1.affiche_etat(actif)
116 +BP2.affiche_etat(inactif)
117 +BP3.affiche_etat(inactif)
118 +BP4.affiche_etat(inactif)
119 +
120 +zone3.blit(BP1.image,BP1.rect)
121 +zone3.blit(BP2.image,BP2.rect)
122 +zone3.blit(BP3.image,BP3.rect)
123 +zone3.blit(BP4.image,BP4.rect)
124 +
125 +font = pygame.font.Font(None,20)
126 +canal_a = font.render("canal A",1,noir)
127 +canal_b = font.render("canal B",1,noir)
128 +canal_c = font.render("canal C",1,noir)
129 +canal_d = font.render("canal D",1,noir)
130 +zone3.blit(canal_a,(125,35))
131 +zone3.blit(canal_b,(225,35))
132 +zone3.blit(canal_c,(325,35))
133 +zone3.blit(canal_d,(425,35))
134 +
135 +# zone 4
136 +commande = font.render("Commandes :",1,noir)
137 +touche_a = font.render("Selection canal A : touche a",1,noir)
138 +touche_b = font.render("Selection canal B : touche b",1,noir)
139 +touche_c = font.render("Selection canal C : touche c",1,noir)
140 +touche_d = font.render("Selection canal D : touche d",1,noir)
141 +quitter = font.render("Quitter : touche q",1,noir)
142 +zone4.blit(commande,(10,20))
143 +zone4.blit(touche_a,(10,60))
144 +zone4.blit(touche_b,(10,80))
145 +zone4.blit(touche_c,(10,100))
146 +zone4.blit(touche_d,(10,120))
147 +zone4.blit(quitter,(10,200))
148 +
149 +# affichage des zones
150 +screen.blit(zone1,(0,0))
151 +screen.blit(zone2,(0,150))
152 +screen.blit(zone3,(0,450))
153 +screen.blit(zone4,(400,150))
154 +
155 +lcd = Adafruit_CharLCDPlate()
156 +lcd.begin(16,2)
157 +btn = ((lcd.SELECT, '', lcd.ON),
158 + (lcd.LEFT , 'Antenne 1' , lcd.ON),
159 + (lcd.UP , 'Antenne 2' , lcd.ON),
160 + (lcd.DOWN , 'Antenne 4' , lcd.ON),
161 + (lcd.RIGHT , 'Antenne 3' , lcd.ON))
162 +prev = -1
163 +temp = ''
164 +active = 'Antenne 1'
165 +act = ' active'
166 +lcd.message((active + act))
167 +while 1:
168 + clock.tick(30)
169 + for b in btn:
170 + if lcd.buttonPressed(lcd.SELECT):
171 + lcd.clear()
172 + lcd.message((active + act))
173 + time.sleep(0.25)
174 + if temp != '':
175 + active = temp
176 + temp = ''
177 + if active == 'Antenne 1':
178 + change_sortie('a')
179 + endline = (293,75)
180 + if active == 'Antenne 2':
181 + change_sortie('b')
182 + endline = (293,125)
183 + if active == 'Antenne 3':
184 + change_sortie('c')
185 + endline = (293,175)
186 + if active == 'Antenne 4':
187 + change_sortie('d')
188 + endline = (293,225)
189 + lcd.setCursor(0,0)
190 + lcd.message((active + act))
191 + lcd.setCursor(0,1)
192 + lcd.message(' ')
193 + if lcd.buttonPressed(lcd.RIGHT):
194 + temp = 'Antenne 3'
195 + lcd.setCursor(0,1)
196 + lcd.message(temp)
197 + if lcd.buttonPressed(lcd.DOWN):
198 + temp = 'Antenne 4'
199 + lcd.setCursor(0,1)
200 + lcd.message(temp)
201 + if lcd.buttonPressed(lcd.UP):
202 + temp = 'Antenne 2'
203 + lcd.setCursor(0,1)
204 + lcd.message(temp)
205 + if lcd.buttonPressed(lcd.LEFT):
206 + temp = 'Antenne 1'
207 + lcd.setCursor(0,1)
208 + lcd.message(temp)
209 +
210 + for event in pygame.event.get():
211 + lcd.setCursor(0,0)
212 + if event.type == pygame.QUIT:
213 + GPIO.cleanup()
214 + sys.exit()
215 + if event.type == pygame.KEYDOWN:
216 + if event.key == pygame.K_q:
217 + GPIO.cleanup()
218 + sys.exit()
219 + if event.key == pygame.K_a:
220 + active = 'Antenne 1'
221 + lcd.message((active + act))
222 + change_sortie('a')
223 + endline = (293,75)
224 + if event.key == pygame.K_b:
225 + active = 'Antenne 2'
226 + lcd.message((active + act))
227 + change_sortie('b')
228 + endline = (293,125)
229 + if event.key == pygame.K_c:
230 + active = 'Antenne 3'
231 + lcd.message((active + act))
232 + change_sortie('c')
233 + endline = (293,175)
234 + if event.key == pygame.K_d:
235 + active = 'Antenne 4'
236 + lcd.message((active + act))
237 + change_sortie('d')
238 + endline = (293,225)
239 +
240 + souris = pygame.mouse.get_pos()
241 + souris_rect = [[souris[0],souris[1]],[5,5]]
242 + souris_rect = pygame.Rect(souris_rect)
243 +
244 + for i in grp_cases:
245 + lcd.setCursor(0,0)
246 + if souris_rect.colliderect(i.rect.move((0,450))):
247 + if pygame.mouse.get_pressed() == (1,0,0):
248 + if i.port == canal[1]:
249 + active = 'Antenne 1'
250 + lcd.message((active + act))
251 + change_sortie('a')
252 + endline = (293,75)
253 + if i.port == canal[2]:
254 + active = 'Antenne 2'
255 + lcd.message((active + act))
256 + change_sortie('b')
257 + endline = (293,125)
258 + if i.port == canal[3]:
259 + active = 'Antenne 3'
260 + lcd.message((active + act))
261 + change_sortie('c')
262 + endline = (293,175)
263 + if i.port == canal[4]:
264 + active = 'Antenne 4'
265 + lcd.message((active + act))
266 + change_sortie('d')
267 + endline = (293,225)
268 +
269 + zone3.blit(BP1.image,BP1.rect)
270 + zone3.blit(BP2.image,BP2.rect)
271 + zone3.blit(BP3.image,BP3.rect)
272 + zone3.blit(BP4.image,BP4.rect)
273 + screen.blit(zone3,(0,450))
274 + zone2.blit(commu,(50,50))
275 + pygame.draw.line(zone2,noir,startline,endline,2)
276 + screen.blit(zone2,(0,150))
277 + pygame.display.update()
278 +