Changes for page Commutateur d' antenne

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