Changes for page Commutateur d' antenne

Last modified by Jean-Yves Dupertuis on 27-08-2014, 11:07
From version < 11.4 >
edited by Jean-Yves Dupertuis
on 18-07-2014, 11:06
To version < 17.1 >
edited by Jean-Yves Dupertuis
on 25-07-2014, 11:11
< >
Change comment: Ajout de l'image com_3.jpg

Summary

Details

Page properties
Content
... ... @@ -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.
... ... @@ -5,10 +5,10 @@
5 5  Ce travail a été confié à un apprenant de 4ème année (M// Loris Gilliand//) .
6 6  
7 7  
8 -= Fabrication =
13 += [[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,10 +18,26 @@
18 18  
19 19  
20 20  
21 -[[image:PremFenetre.jpg]]
26 +(% height="656" width="809" %)
27 +|=|=
28 +|Le premier programme que j’ai écrit, commu01.py, est un programme
29 +qui m’a aidé à réaliser des zones dans la fenêtre. Ce programme
30 +dispose de 3 zones. Une zone pour le titre, une pour l’image et la
31 +dernière n’est pas utilisée. J’utilise aussi la zone de l’image pour
32 +dessiner. Actuellement, l’image représente le boîtier du commutateur
33 +avec le fonctionnement interne dessiner dessus. Sur cette image,
34 +j’ai décidé d’afficher la position du commutateur en dessinant une ligne
35 +du point commun au canal actif. Pour quitter le programme, l’utilisateur
36 +utilisera la touche q du clavier.Le code du programme est annexé
37 +à la fin du document.\\|[[image:http://212.74.133.122:81/xwiki/bin/download/Hardware/SwitchAntenna/com_1.jpg?width=1580||alt="com_1.jpg"]]
38 +|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,
39 +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
40 +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]]
41 +|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.|
22 22  
23 23  
24 24  
45 +
25 25  [[image:ZoneAide.jpg]]
26 26  
27 27  
... ... @@ -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.
72 +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,11 +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  
103 += Programmation Python =
83 83  
105 +Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
84 84  
107 +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/]].
108 +
109 +Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
110 +
111 +sur votre carte raspberry - py.
112 +
113 +**Important !! **je suis parti du principe que le port **//I2C//** est fonctionnel sur votre raspberry - py.
114 +
115 +**Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !**
116 +
117 +
118 +
119 +== Source : ==
120 +
121 +{{box}}
122 +##{{{# auteur : Gilliand Loris
123 +# date : 02.06.14
124 +# version 0.8
125 +#
126 +# amelioration depuis 0.7 : integre un lcd qui peut commander les changements
127 +
128 +# importation bibilotheques
129 +import pygame, sys, time
130 +from pygame.locals import *
131 +import RPi.GPIO as GPIO
132 +from Adafruit_CharLCDPlate import *
133 +
134 +# initialisation fenetre et gpio
135 +pygame.init()
136 +GPIO.setmode(GPIO.BCM)
137 +
138 +# fonction qui change LA sortie active
139 +def change_sortie(ligne):
140 + BP1.etat = 0
141 + BP2.etat = 0
142 + BP3.etat = 0
143 + BP4.etat = 0
144 + BP1.affiche_etat(inactif)
145 + BP2.affiche_etat(inactif)
146 + BP3.affiche_etat(inactif)
147 + BP4.affiche_etat(inactif)
148 + time.sleep(0.25)
149 + if ligne == 'a':
150 + BP1.etat = 1
151 + BP1.affiche_etat(actif)
152 + elif ligne == 'b':
153 + BP2.etat = 1
154 + BP2.affiche_etat(actif)
155 + elif ligne == 'c':
156 + BP3.etat = 1
157 + BP3.affiche_etat(actif)
158 + elif ligne == 'd':
159 + BP4.etat = 1
160 + BP4.affiche_etat(actif)
161 +
162 +# classe de creation de cases
163 +class Cases:
164 + def init(self,image,pos,port,init):
165 + self.image = pygame.image.load(image).convert()
166 + self.pos = pos
167 + self.port = port
168 + self.etat = init
169 + self.rect = self.image.get_rect().move(self.pos)
170 + GPIO.setup(self.port,GPIO.OUT)
171 + GPIO.output(self.port,GPIO.LOW)
172 +
173 + def affiche_etat(self,indicateur):
174 + indicateur = pygame.image.load(indicateur).convert()
175 + indi_rect = indicateur.get_rect()
176 + indi_rect.centerx = self.rect.centerx - self.pos[0]
177 + indi_rect.centery = self.rect.centery - self.pos[1]
178 + if self.etat == 0:
179 + GPIO.output(self.port,GPIO.LOW)
180 + elif self.etat == 1:
181 + GPIO.output(self.port,GPIO.HIGH)
182 + self.image.blit(indicateur,indi_rect)
183 +
184 +# initialisation de la fenetre
185 +screen = pygame.display.set_mode((600,600))
186 +clock = pygame.time.Clock()
187 +# initialisation des couleurs
188 +rouge = (255,0,0)
189 +noir = (0,0,0)
190 +blanc = (255,255,255)
191 +vert = (0,255,0)
192 +bleu = (0,0,255)
193 +
194 +# initialisation des variables
195 +startline = (183,149)
196 +endline = (293,75)
197 +
198 +flag_canal = 0
199 +
200 +canal = [4,17,18,22,23,24,25,27]
201 +
202 +# definitions des zones
203 +zone1 = pygame.Surface((600,150))
204 +zone1.fill(bleu)
205 +
206 +zone2 = pygame.Surface((400,300))
207 +zone2.fill(bleu)
208 +
209 +zone3 = pygame.Surface((600,150))
210 +zone3.fill(bleu)
211 +
212 +zone4 = pygame.Surface((200,300))
213 +zone4.fill(bleu)
214 +
215 +# definitions des objets a afficher dans les zones
216 +# zone 1
217 +font = pygame.font.Font(None,60)
218 +titre1 = font.render("HB9EM",1,noir)
219 +titre2 = font.render("Commutateur d'antennes",1,noir)
220 +zone1.blit(titre1,(230,30))
221 +zone1.blit(titre2,(50,70))
222 +
223 +# zone 2
224 +commu = pygame.image.load("commu_antenne.bmp").convert()
225 +zone2.blit(commu,(50,50))
226 +
227 +# zone 3
228 +actif = "actif_commu.bmp"
229 +inactif = "inactif_commu.bmp"
230 +
231 +BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
232 +BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
233 +BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
234 +BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
235 +grp_cases = [BP1,BP2,BP3,BP4]
236 +BP1.affiche_etat(actif)
237 +BP2.affiche_etat(inactif)
238 +BP3.affiche_etat(inactif)
239 +BP4.affiche_etat(inactif)
240 +
241 +zone3.blit(BP1.image,BP1.rect)
242 +zone3.blit(BP2.image,BP2.rect)
243 +zone3.blit(BP3.image,BP3.rect)
244 +zone3.blit(BP4.image,BP4.rect)
245 +
246 +font = pygame.font.Font(None,20)
247 +canal_a = font.render("canal A",1,noir)
248 +canal_b = font.render("canal B",1,noir)
249 +canal_c = font.render("canal C",1,noir)
250 +canal_d = font.render("canal D",1,noir)
251 +zone3.blit(canal_a,(125,35))
252 +zone3.blit(canal_b,(225,35))
253 +zone3.blit(canal_c,(325,35))
254 +zone3.blit(canal_d,(425,35))
255 +
256 +# zone 4
257 +commande = font.render("Commandes :",1,noir)
258 +touche_a = font.render("Selection canal A : touche a",1,noir)
259 +touche_b = font.render("Selection canal B : touche b",1,noir)
260 +touche_c = font.render("Selection canal C : touche c",1,noir)
261 +touche_d = font.render("Selection canal D : touche d",1,noir)
262 +quitter = font.render("Quitter : touche q",1,noir)
263 +zone4.blit(commande,(10,20))
264 +zone4.blit(touche_a,(10,60))
265 +zone4.blit(touche_b,(10,80))
266 +zone4.blit(touche_c,(10,100))
267 +zone4.blit(touche_d,(10,120))
268 +zone4.blit(quitter,(10,200))
269 +
270 +# affichage des zones
271 +screen.blit(zone1,(0,0))
272 +screen.blit(zone2,(0,150))
273 +screen.blit(zone3,(0,450))
274 +screen.blit(zone4,(400,150))
275 +
276 +lcd = Adafruit_CharLCDPlate()
277 +lcd.begin(16,2)
278 +btn = ((lcd.SELECT, '', lcd.ON),
279 + (lcd.LEFT , 'Antenne 1' , lcd.ON),
280 + (lcd.UP , 'Antenne 2' , lcd.ON),
281 + (lcd.DOWN , 'Antenne 4' , lcd.ON),
282 + (lcd.RIGHT , 'Antenne 3' , lcd.ON))
283 +prev = -1
284 +temp = ''
285 +active = 'Antenne 1'
286 +act = ' active'
287 +lcd.message((active + act))
288 +while 1:
289 + clock.tick(30)
290 + for b in btn:
291 + if lcd.buttonPressed(lcd.SELECT):
292 + lcd.clear()
293 + lcd.message((active + act))
294 + time.sleep(0.25)
295 + if temp != '':
296 + active = temp
297 + temp = ''
298 + if active == 'Antenne 1':
299 + change_sortie('a')
300 + endline = (293,75)
301 + if active == 'Antenne 2':
302 + change_sortie('b')
303 + endline = (293,125)
304 + if active == 'Antenne 3':
305 + change_sortie('c')
306 + endline = (293,175)
307 + if active == 'Antenne 4':
308 + change_sortie('d')
309 + endline = (293,225)
310 + lcd.setCursor(0,0)
311 + lcd.message((active + act))
312 + lcd.setCursor(0,1)
313 + lcd.message(' ')
314 + if lcd.buttonPressed(lcd.RIGHT):
315 + temp = 'Antenne 3'
316 + lcd.setCursor(0,1)
317 + lcd.message(temp)
318 + if lcd.buttonPressed(lcd.DOWN):
319 + temp = 'Antenne 4'
320 + lcd.setCursor(0,1)
321 + lcd.message(temp)
322 + if lcd.buttonPressed(lcd.UP):
323 + temp = 'Antenne 2'
324 + lcd.setCursor(0,1)
325 + lcd.message(temp)
326 + if lcd.buttonPressed(lcd.LEFT):
327 + temp = 'Antenne 1'
328 + lcd.setCursor(0,1)
329 + lcd.message(temp)
330 +
331 + for event in pygame.event.get():
332 + lcd.setCursor(0,0)
333 + if event.type == pygame.QUIT:
334 + GPIO.cleanup()
335 + sys.exit()
336 + if event.type == pygame.KEYDOWN:
337 + if event.key == pygame.K_q:
338 + GPIO.cleanup()
339 + sys.exit()
340 + if event.key == pygame.K_a:
341 + active = 'Antenne 1'
342 + lcd.message((active + act))
343 + change_sortie('a')
344 + endline = (293,75)
345 + if event.key == pygame.K_b:
346 + active = 'Antenne 2'
347 + lcd.message((active + act))
348 + change_sortie('b')
349 + endline = (293,125)
350 + if event.key == pygame.K_c:
351 + active = 'Antenne 3'
352 + lcd.message((active + act))
353 + change_sortie('c')
354 + endline = (293,175)
355 + if event.key == pygame.K_d:
356 + active = 'Antenne 4'
357 + lcd.message((active + act))
358 + change_sortie('d')
359 + endline = (293,225)
360 +
361 + souris = pygame.mouse.get_pos()
362 + souris_rect = souris[0],souris[1,[5,5]]
363 + souris_rect = pygame.Rect(souris_rect)
364 +
365 + for i in grp_cases:
366 + lcd.setCursor(0,0)
367 + if souris_rect.colliderect(i.rect.move((0,450))):
368 + if pygame.mouse.get_pressed() == (1,0,0):
369 + if i.port == canal[1]:
370 + active = 'Antenne 1'
371 + lcd.message((active + act))
372 + change_sortie('a')
373 + endline = (293,75)
374 + if i.port == canal[2]:
375 + active = 'Antenne 2'
376 + lcd.message((active + act))
377 + change_sortie('b')
378 + endline = (293,125)
379 + if i.port == canal[3]:
380 + active = 'Antenne 3'
381 + lcd.message((active + act))
382 + change_sortie('c')
383 + endline = (293,175)
384 + if i.port == canal[4]:
385 + active = 'Antenne 4'
386 + lcd.message((active + act))
387 + change_sortie('d')
388 + endline = (293,225)
389 +
390 + zone3.blit(BP1.image,BP1.rect)
391 + zone3.blit(BP2.image,BP2.rect)
392 + zone3.blit(BP3.image,BP3.rect)
393 + zone3.blit(BP4.image,BP4.rect)
394 + screen.blit(zone3,(0,450))
395 + zone2.blit(commu,(50,50))
396 + pygame.draw.line(zone2,noir,startline,endline,2)
397 + screen.blit(zone2,(0,150))
398 + pygame.display.update()
399 +}}}##
400 +{{/box}}
401 +
402 +[[Fichier Py>>attach:commu08.py]]
403 +
404 +
405 +=== Distributions 'source' sans et avec LCD ===
406 +
407 +[[Distribution_sans_LCD.rar>>attach:Distribution.rar]]
408 +
409 +
410 +[[Distribution_lcd.rar>>attach:Distribution_lcd.rar]]
Distribution.rar
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +707.0 KB
Content
Distribution_lcd.rar
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +10.8 KB
Content
com_1.jpg
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +8.9 KB
Content
com_2.jpg
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +7.7 KB
Content
com_3.jpg
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +10.8 KB
Content
commu08.py
Author
... ... @@ -1,0 +1,1 @@
1 +XWiki.Dupertuis
Size
... ... @@ -1,0 +1,1 @@
1 +8.3 KB
Content
... ... @@ -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 +