Code source wiki de Commutateur d' antenne

Version 24.1 par Jean-Yves Dupertuis le 25-07-2014, 11:30
Afficher les derniers auteurs
1 {{box cssClass="floatinginfobox" title="**Contents**"}}
2 {{toc /}}
3 {{/box}}
4
5
6 = Commutation d'antenne via raspberry - py =
7
8 Ce commutateur va permettre via internet de modifier l' antenne reliée au TX de la station EM.
9
10 Ce travail a été confié à un apprenant de 4ème année (M// Loris Gilliand//) .
11
12
13 = [[Fabrication>>doc:fabricationSwitch]] =
14
15
16 = Interface Homme - Machine =
17
18 Pour commuter le TX sur une autre antenne, il suffit de taper la lettre (//canal désiré) au clavier.//
19
20 L'image se modifie selon votre choix pour valider sa commutation.
21
22 Vous pouvez via la "souris" obtenir le même résultat !
23
24
25
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 == Boutons d’indication ==
55 )))|
56 | L’étape suivante dans l’amélioration de mon programme est d’afficher sur des « boutons » l’état de chaque sorties. Ces « boutons » sont représentés par des carrés noirs. Une sortie active a un vu vert dans son carré alors qu’une sortie inactive a une croix rouge.J’appel ces indicateurs « boutons » car, prochainement, l’utilisateur pourra utiliser la souris pour activer une sortie. Pour le moment, les commandes se font encore au clavier. Le code du programme (commu04.py) est annexé à la fin du document.
57 \\\\Après avoir utiliser les boutons comme indicateurs, j’ai décidé de rendre possible le changement d’état à la souris. Maintenant, il est donc possible de cliquer sur une case pour l’activer. Le code du programme (commu05.py) est annexé à la fin du document.|[[image:com_4.jpg]]
58 | |
59
60 == Finalisation [[image:com_5.jpg]] [[image:com_7.jpg]] [[image:com_8.jpg]] ==
61
62 La finalisation du projet c’est fait par la création d’une classe pour les boutons de commande. Cette classe crée une case vide avec
63
64 les attributs image, pos, port, etat et rect. L’attribut pos représente les coordonnées du coin supérieur gauche de la case.
65
66 L’attribut port représente le n° du GPIO qui sera attribué à cette case. Les numéros des GPIO sont stockés dans le tableau appelé canal.
67
68 Il faut donc créer la case avec l’argument canal[...] pour le port. Le tableau contient 8 infos donc il est possible de créer jusqu'à 8 cases.
69 Vous trouverez ci-dessous l’organisation du tableau.
70
71
72 [[image:com_6.jpg]]
73
74 Par exemple, en créant une case à l’aide de la classe avec l’argument canal[0] pour le port, le GPIO 4 (pin 7) sera assigné à l’objet.
75 La classe dispose d’une seule méthode. Cette méthode est utilisée pour changer l’état du port. En changeant l’état, la méthode se
76
77 charge aussi d’afficher une indication dans la case. Cette image d’indication est à envoyer en argument. Pour mon cas, j’utilise un
78
79 vu vert pour une sortie active et une croix rouge pour une sortie inactive.Ce programme, commu06.py, est annexé en fin de document.\\
80
81
82
83
84
85
86 On a ajouté un LCD fournit par //HB9FOX //qui permet de commuter directement sur le module la bonne Antenne.
87
88 **IMPORTANT !!** Pour ce faire le raspberry - py doit fonctionné et le programme lancé !
89
90
91 Voici le détail :
92
93
94 [[image:lcdVue.jpg]]
95
96
97 [[image:lcdCommande.jpg]]
98
99
100 == Câblage du module ==
101
102 Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transite via des opto - coupleurs.
103
104 Une carte dédiée à cette protection a été développée.
105
106 Le rasbberry - py est directement relié aux entrée de ces optos et la photo montre comment relié les sorties
107
108 des optos à la carte relais. Une carte relais possède 4 relais de commutation. C'est pourquoi le module
109
110 possède 2 cartes relais.
111
112
113
114 [[image:OptoRelais.jpg]]
115
116
117
118 Depuis les sorties relais on installe le câble de la boite de commutation.
119
120
121 [[image:RelaiCommutateur.jpg]]
122
123
124 Les fils rouge sont l'arrivée du 12 Vdc depuis l'autre côté de la carte relais.
125
126 **Ne pas oublier de les relier au 12Vdc !**
127
128 == Câble ==
129
130
131 [[image:cableCommAnt.jpg]]
132
133 = Programmation Python =
134
135 Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
136
137 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/]].
138
139 Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
140
141 sur votre carte raspberry - py.
142
143 **Important !! **je suis parti du principe que le port **//I2C//** est fonctionnel sur votre raspberry - py.
144
145 **Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !**
146
147
148
149 == Source : ==
150
151 {{box}}
152 ##{{{# auteur : Gilliand Loris
153 # date : 02.06.14
154 # version 0.8
155 #
156 # amelioration depuis 0.7 : integre un lcd qui peut commander les changements
157
158 # importation bibilotheques
159 import pygame, sys, time
160 from pygame.locals import *
161 import RPi.GPIO as GPIO
162 from Adafruit_CharLCDPlate import *
163
164 # initialisation fenetre et gpio
165 pygame.init()
166 GPIO.setmode(GPIO.BCM)
167
168 # fonction qui change LA sortie active
169 def change_sortie(ligne):
170 BP1.etat = 0
171 BP2.etat = 0
172 BP3.etat = 0
173 BP4.etat = 0
174 BP1.affiche_etat(inactif)
175 BP2.affiche_etat(inactif)
176 BP3.affiche_etat(inactif)
177 BP4.affiche_etat(inactif)
178 time.sleep(0.25)
179 if ligne == 'a':
180 BP1.etat = 1
181 BP1.affiche_etat(actif)
182 elif ligne == 'b':
183 BP2.etat = 1
184 BP2.affiche_etat(actif)
185 elif ligne == 'c':
186 BP3.etat = 1
187 BP3.affiche_etat(actif)
188 elif ligne == 'd':
189 BP4.etat = 1
190 BP4.affiche_etat(actif)
191
192 # classe de creation de cases
193 class Cases:
194 def init(self,image,pos,port,init):
195 self.image = pygame.image.load(image).convert()
196 self.pos = pos
197 self.port = port
198 self.etat = init
199 self.rect = self.image.get_rect().move(self.pos)
200 GPIO.setup(self.port,GPIO.OUT)
201 GPIO.output(self.port,GPIO.LOW)
202
203 def affiche_etat(self,indicateur):
204 indicateur = pygame.image.load(indicateur).convert()
205 indi_rect = indicateur.get_rect()
206 indi_rect.centerx = self.rect.centerx - self.pos[0]
207 indi_rect.centery = self.rect.centery - self.pos[1]
208 if self.etat == 0:
209 GPIO.output(self.port,GPIO.LOW)
210 elif self.etat == 1:
211 GPIO.output(self.port,GPIO.HIGH)
212 self.image.blit(indicateur,indi_rect)
213
214 # initialisation de la fenetre
215 screen = pygame.display.set_mode((600,600))
216 clock = pygame.time.Clock()
217 # initialisation des couleurs
218 rouge = (255,0,0)
219 noir = (0,0,0)
220 blanc = (255,255,255)
221 vert = (0,255,0)
222 bleu = (0,0,255)
223
224 # initialisation des variables
225 startline = (183,149)
226 endline = (293,75)
227
228 flag_canal = 0
229
230 canal = [4,17,18,22,23,24,25,27]
231
232 # definitions des zones
233 zone1 = pygame.Surface((600,150))
234 zone1.fill(bleu)
235
236 zone2 = pygame.Surface((400,300))
237 zone2.fill(bleu)
238
239 zone3 = pygame.Surface((600,150))
240 zone3.fill(bleu)
241
242 zone4 = pygame.Surface((200,300))
243 zone4.fill(bleu)
244
245 # definitions des objets a afficher dans les zones
246 # zone 1
247 font = pygame.font.Font(None,60)
248 titre1 = font.render("HB9EM",1,noir)
249 titre2 = font.render("Commutateur d'antennes",1,noir)
250 zone1.blit(titre1,(230,30))
251 zone1.blit(titre2,(50,70))
252
253 # zone 2
254 commu = pygame.image.load("commu_antenne.bmp").convert()
255 zone2.blit(commu,(50,50))
256
257 # zone 3
258 actif = "actif_commu.bmp"
259 inactif = "inactif_commu.bmp"
260
261 BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
262 BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
263 BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
264 BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
265 grp_cases = [BP1,BP2,BP3,BP4]
266 BP1.affiche_etat(actif)
267 BP2.affiche_etat(inactif)
268 BP3.affiche_etat(inactif)
269 BP4.affiche_etat(inactif)
270
271 zone3.blit(BP1.image,BP1.rect)
272 zone3.blit(BP2.image,BP2.rect)
273 zone3.blit(BP3.image,BP3.rect)
274 zone3.blit(BP4.image,BP4.rect)
275
276 font = pygame.font.Font(None,20)
277 canal_a = font.render("canal A",1,noir)
278 canal_b = font.render("canal B",1,noir)
279 canal_c = font.render("canal C",1,noir)
280 canal_d = font.render("canal D",1,noir)
281 zone3.blit(canal_a,(125,35))
282 zone3.blit(canal_b,(225,35))
283 zone3.blit(canal_c,(325,35))
284 zone3.blit(canal_d,(425,35))
285
286 # zone 4
287 commande = font.render("Commandes :",1,noir)
288 touche_a = font.render("Selection canal A : touche a",1,noir)
289 touche_b = font.render("Selection canal B : touche b",1,noir)
290 touche_c = font.render("Selection canal C : touche c",1,noir)
291 touche_d = font.render("Selection canal D : touche d",1,noir)
292 quitter = font.render("Quitter : touche q",1,noir)
293 zone4.blit(commande,(10,20))
294 zone4.blit(touche_a,(10,60))
295 zone4.blit(touche_b,(10,80))
296 zone4.blit(touche_c,(10,100))
297 zone4.blit(touche_d,(10,120))
298 zone4.blit(quitter,(10,200))
299
300 # affichage des zones
301 screen.blit(zone1,(0,0))
302 screen.blit(zone2,(0,150))
303 screen.blit(zone3,(0,450))
304 screen.blit(zone4,(400,150))
305
306 lcd = Adafruit_CharLCDPlate()
307 lcd.begin(16,2)
308 btn = ((lcd.SELECT, '', lcd.ON),
309 (lcd.LEFT , 'Antenne 1' , lcd.ON),
310 (lcd.UP , 'Antenne 2' , lcd.ON),
311 (lcd.DOWN , 'Antenne 4' , lcd.ON),
312 (lcd.RIGHT , 'Antenne 3' , lcd.ON))
313 prev = -1
314 temp = ''
315 active = 'Antenne 1'
316 act = ' active'
317 lcd.message((active + act))
318 while 1:
319 clock.tick(30)
320 for b in btn:
321 if lcd.buttonPressed(lcd.SELECT):
322 lcd.clear()
323 lcd.message((active + act))
324 time.sleep(0.25)
325 if temp != '':
326 active = temp
327 temp = ''
328 if active == 'Antenne 1':
329 change_sortie('a')
330 endline = (293,75)
331 if active == 'Antenne 2':
332 change_sortie('b')
333 endline = (293,125)
334 if active == 'Antenne 3':
335 change_sortie('c')
336 endline = (293,175)
337 if active == 'Antenne 4':
338 change_sortie('d')
339 endline = (293,225)
340 lcd.setCursor(0,0)
341 lcd.message((active + act))
342 lcd.setCursor(0,1)
343 lcd.message(' ')
344 if lcd.buttonPressed(lcd.RIGHT):
345 temp = 'Antenne 3'
346 lcd.setCursor(0,1)
347 lcd.message(temp)
348 if lcd.buttonPressed(lcd.DOWN):
349 temp = 'Antenne 4'
350 lcd.setCursor(0,1)
351 lcd.message(temp)
352 if lcd.buttonPressed(lcd.UP):
353 temp = 'Antenne 2'
354 lcd.setCursor(0,1)
355 lcd.message(temp)
356 if lcd.buttonPressed(lcd.LEFT):
357 temp = 'Antenne 1'
358 lcd.setCursor(0,1)
359 lcd.message(temp)
360
361 for event in pygame.event.get():
362 lcd.setCursor(0,0)
363 if event.type == pygame.QUIT:
364 GPIO.cleanup()
365 sys.exit()
366 if event.type == pygame.KEYDOWN:
367 if event.key == pygame.K_q:
368 GPIO.cleanup()
369 sys.exit()
370 if event.key == pygame.K_a:
371 active = 'Antenne 1'
372 lcd.message((active + act))
373 change_sortie('a')
374 endline = (293,75)
375 if event.key == pygame.K_b:
376 active = 'Antenne 2'
377 lcd.message((active + act))
378 change_sortie('b')
379 endline = (293,125)
380 if event.key == pygame.K_c:
381 active = 'Antenne 3'
382 lcd.message((active + act))
383 change_sortie('c')
384 endline = (293,175)
385 if event.key == pygame.K_d:
386 active = 'Antenne 4'
387 lcd.message((active + act))
388 change_sortie('d')
389 endline = (293,225)
390
391 souris = pygame.mouse.get_pos()
392 souris_rect = souris[0],souris[1,[5,5]]
393 souris_rect = pygame.Rect(souris_rect)
394
395 for i in grp_cases:
396 lcd.setCursor(0,0)
397 if souris_rect.colliderect(i.rect.move((0,450))):
398 if pygame.mouse.get_pressed() == (1,0,0):
399 if i.port == canal[1]:
400 active = 'Antenne 1'
401 lcd.message((active + act))
402 change_sortie('a')
403 endline = (293,75)
404 if i.port == canal[2]:
405 active = 'Antenne 2'
406 lcd.message((active + act))
407 change_sortie('b')
408 endline = (293,125)
409 if i.port == canal[3]:
410 active = 'Antenne 3'
411 lcd.message((active + act))
412 change_sortie('c')
413 endline = (293,175)
414 if i.port == canal[4]:
415 active = 'Antenne 4'
416 lcd.message((active + act))
417 change_sortie('d')
418 endline = (293,225)
419
420 zone3.blit(BP1.image,BP1.rect)
421 zone3.blit(BP2.image,BP2.rect)
422 zone3.blit(BP3.image,BP3.rect)
423 zone3.blit(BP4.image,BP4.rect)
424 screen.blit(zone3,(0,450))
425 zone2.blit(commu,(50,50))
426 pygame.draw.line(zone2,noir,startline,endline,2)
427 screen.blit(zone2,(0,150))
428 pygame.display.update()
429 }}}##
430 {{/box}}
431
432 [[Fichier Py>>attach:commu08.py]]
433
434
435 === Distributions 'source' sans et avec LCD ===
436
437 [[Distribution_sans_LCD.rar>>attach:Distribution.rar]]
438
439
440 [[Distribution_lcd.rar>>attach:Distribution_lcd.rar]]