Changes for page Commutateur d' antenne

Last modified by Jean-Yves Dupertuis on 27-08-2014, 11:07
From version < 15.1 >
edited by Jean-Yves Dupertuis
on 25-07-2014, 11:04
To version < 11.3 >
edited by Jean-Yves Dupertuis
on 18-07-2014, 11:04
< >
Change comment: cable relais - commutateur

Summary

Details

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