Wiki source code of Commutateur d' antenne

Version 25.1 by Jean-Yves Dupertuis on 25-07-2014, 11:31
Show last authors
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 == Interface LCD ==
84
85 On a ajouté un LCD fournit par //HB9FOX //qui permet de commuter directement sur le module la bonne Antenne.
86
87 **IMPORTANT !!** Pour ce faire le raspberry - py doit fonctionné et le programme lancé !
88
89
90 Voici le détail :
91
92
93 [[image:lcdVue.jpg]]
94
95
96 [[image:com_9.jpg]]
97
98 L’antenne activée est affichée sur la première ligne de l’écran. Lorsque l’on souhaite changer d’antenne, il faut appuyer sur
99
100 un des 4 boutons. Après avoir pressé le bouton, l’antenne qu’il active sera affichée sur la deuxième ligne. Il ne
101 reste plus qu’à valider le changement en appuyant sur le bouton « Sélection ».Comme vous pouvez le voir sur l’image du titre,
102
103 l’antenne 1 est activée et l’antenne 4 présélectionnée. Si l’utilisateur presse le bouton de sélection, l’antenne 4 sera activée
104
105
106
107
108 == Câblage du module ==
109
110 Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transite via des opto - coupleurs.
111
112 Une carte dédiée à cette protection a été développée.
113
114 Le rasbberry - py est directement relié aux entrée de ces optos et la photo montre comment relié les sorties
115
116 des optos à la carte relais. Une carte relais possède 4 relais de commutation. C'est pourquoi le module
117
118 possède 2 cartes relais.
119
120
121
122 [[image:OptoRelais.jpg]]
123
124
125
126 Depuis les sorties relais on installe le câble de la boite de commutation.
127
128
129 [[image:RelaiCommutateur.jpg]]
130
131
132 Les fils rouge sont l'arrivée du 12 Vdc depuis l'autre côté de la carte relais.
133
134 **Ne pas oublier de les relier au 12Vdc !**
135
136 == Câble ==
137
138
139 [[image:cableCommAnt.jpg]]
140
141 = Programmation Python =
142
143 Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
144
145 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/]].
146
147 Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
148
149 sur votre carte raspberry - py.
150
151 **Important !! **je suis parti du principe que le port **//I2C//** est fonctionnel sur votre raspberry - py.
152
153 **Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !**
154
155
156
157 == Source : ==
158
159 {{box}}
160 ##{{{# auteur : Gilliand Loris
161 # date : 02.06.14
162 # version 0.8
163 #
164 # amelioration depuis 0.7 : integre un lcd qui peut commander les changements
165
166 # importation bibilotheques
167 import pygame, sys, time
168 from pygame.locals import *
169 import RPi.GPIO as GPIO
170 from Adafruit_CharLCDPlate import *
171
172 # initialisation fenetre et gpio
173 pygame.init()
174 GPIO.setmode(GPIO.BCM)
175
176 # fonction qui change LA sortie active
177 def change_sortie(ligne):
178 BP1.etat = 0
179 BP2.etat = 0
180 BP3.etat = 0
181 BP4.etat = 0
182 BP1.affiche_etat(inactif)
183 BP2.affiche_etat(inactif)
184 BP3.affiche_etat(inactif)
185 BP4.affiche_etat(inactif)
186 time.sleep(0.25)
187 if ligne == 'a':
188 BP1.etat = 1
189 BP1.affiche_etat(actif)
190 elif ligne == 'b':
191 BP2.etat = 1
192 BP2.affiche_etat(actif)
193 elif ligne == 'c':
194 BP3.etat = 1
195 BP3.affiche_etat(actif)
196 elif ligne == 'd':
197 BP4.etat = 1
198 BP4.affiche_etat(actif)
199
200 # classe de creation de cases
201 class Cases:
202 def init(self,image,pos,port,init):
203 self.image = pygame.image.load(image).convert()
204 self.pos = pos
205 self.port = port
206 self.etat = init
207 self.rect = self.image.get_rect().move(self.pos)
208 GPIO.setup(self.port,GPIO.OUT)
209 GPIO.output(self.port,GPIO.LOW)
210
211 def affiche_etat(self,indicateur):
212 indicateur = pygame.image.load(indicateur).convert()
213 indi_rect = indicateur.get_rect()
214 indi_rect.centerx = self.rect.centerx - self.pos[0]
215 indi_rect.centery = self.rect.centery - self.pos[1]
216 if self.etat == 0:
217 GPIO.output(self.port,GPIO.LOW)
218 elif self.etat == 1:
219 GPIO.output(self.port,GPIO.HIGH)
220 self.image.blit(indicateur,indi_rect)
221
222 # initialisation de la fenetre
223 screen = pygame.display.set_mode((600,600))
224 clock = pygame.time.Clock()
225 # initialisation des couleurs
226 rouge = (255,0,0)
227 noir = (0,0,0)
228 blanc = (255,255,255)
229 vert = (0,255,0)
230 bleu = (0,0,255)
231
232 # initialisation des variables
233 startline = (183,149)
234 endline = (293,75)
235
236 flag_canal = 0
237
238 canal = [4,17,18,22,23,24,25,27]
239
240 # definitions des zones
241 zone1 = pygame.Surface((600,150))
242 zone1.fill(bleu)
243
244 zone2 = pygame.Surface((400,300))
245 zone2.fill(bleu)
246
247 zone3 = pygame.Surface((600,150))
248 zone3.fill(bleu)
249
250 zone4 = pygame.Surface((200,300))
251 zone4.fill(bleu)
252
253 # definitions des objets a afficher dans les zones
254 # zone 1
255 font = pygame.font.Font(None,60)
256 titre1 = font.render("HB9EM",1,noir)
257 titre2 = font.render("Commutateur d'antennes",1,noir)
258 zone1.blit(titre1,(230,30))
259 zone1.blit(titre2,(50,70))
260
261 # zone 2
262 commu = pygame.image.load("commu_antenne.bmp").convert()
263 zone2.blit(commu,(50,50))
264
265 # zone 3
266 actif = "actif_commu.bmp"
267 inactif = "inactif_commu.bmp"
268
269 BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
270 BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
271 BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
272 BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
273 grp_cases = [BP1,BP2,BP3,BP4]
274 BP1.affiche_etat(actif)
275 BP2.affiche_etat(inactif)
276 BP3.affiche_etat(inactif)
277 BP4.affiche_etat(inactif)
278
279 zone3.blit(BP1.image,BP1.rect)
280 zone3.blit(BP2.image,BP2.rect)
281 zone3.blit(BP3.image,BP3.rect)
282 zone3.blit(BP4.image,BP4.rect)
283
284 font = pygame.font.Font(None,20)
285 canal_a = font.render("canal A",1,noir)
286 canal_b = font.render("canal B",1,noir)
287 canal_c = font.render("canal C",1,noir)
288 canal_d = font.render("canal D",1,noir)
289 zone3.blit(canal_a,(125,35))
290 zone3.blit(canal_b,(225,35))
291 zone3.blit(canal_c,(325,35))
292 zone3.blit(canal_d,(425,35))
293
294 # zone 4
295 commande = font.render("Commandes :",1,noir)
296 touche_a = font.render("Selection canal A : touche a",1,noir)
297 touche_b = font.render("Selection canal B : touche b",1,noir)
298 touche_c = font.render("Selection canal C : touche c",1,noir)
299 touche_d = font.render("Selection canal D : touche d",1,noir)
300 quitter = font.render("Quitter : touche q",1,noir)
301 zone4.blit(commande,(10,20))
302 zone4.blit(touche_a,(10,60))
303 zone4.blit(touche_b,(10,80))
304 zone4.blit(touche_c,(10,100))
305 zone4.blit(touche_d,(10,120))
306 zone4.blit(quitter,(10,200))
307
308 # affichage des zones
309 screen.blit(zone1,(0,0))
310 screen.blit(zone2,(0,150))
311 screen.blit(zone3,(0,450))
312 screen.blit(zone4,(400,150))
313
314 lcd = Adafruit_CharLCDPlate()
315 lcd.begin(16,2)
316 btn = ((lcd.SELECT, '', lcd.ON),
317 (lcd.LEFT , 'Antenne 1' , lcd.ON),
318 (lcd.UP , 'Antenne 2' , lcd.ON),
319 (lcd.DOWN , 'Antenne 4' , lcd.ON),
320 (lcd.RIGHT , 'Antenne 3' , lcd.ON))
321 prev = -1
322 temp = ''
323 active = 'Antenne 1'
324 act = ' active'
325 lcd.message((active + act))
326 while 1:
327 clock.tick(30)
328 for b in btn:
329 if lcd.buttonPressed(lcd.SELECT):
330 lcd.clear()
331 lcd.message((active + act))
332 time.sleep(0.25)
333 if temp != '':
334 active = temp
335 temp = ''
336 if active == 'Antenne 1':
337 change_sortie('a')
338 endline = (293,75)
339 if active == 'Antenne 2':
340 change_sortie('b')
341 endline = (293,125)
342 if active == 'Antenne 3':
343 change_sortie('c')
344 endline = (293,175)
345 if active == 'Antenne 4':
346 change_sortie('d')
347 endline = (293,225)
348 lcd.setCursor(0,0)
349 lcd.message((active + act))
350 lcd.setCursor(0,1)
351 lcd.message(' ')
352 if lcd.buttonPressed(lcd.RIGHT):
353 temp = 'Antenne 3'
354 lcd.setCursor(0,1)
355 lcd.message(temp)
356 if lcd.buttonPressed(lcd.DOWN):
357 temp = 'Antenne 4'
358 lcd.setCursor(0,1)
359 lcd.message(temp)
360 if lcd.buttonPressed(lcd.UP):
361 temp = 'Antenne 2'
362 lcd.setCursor(0,1)
363 lcd.message(temp)
364 if lcd.buttonPressed(lcd.LEFT):
365 temp = 'Antenne 1'
366 lcd.setCursor(0,1)
367 lcd.message(temp)
368
369 for event in pygame.event.get():
370 lcd.setCursor(0,0)
371 if event.type == pygame.QUIT:
372 GPIO.cleanup()
373 sys.exit()
374 if event.type == pygame.KEYDOWN:
375 if event.key == pygame.K_q:
376 GPIO.cleanup()
377 sys.exit()
378 if event.key == pygame.K_a:
379 active = 'Antenne 1'
380 lcd.message((active + act))
381 change_sortie('a')
382 endline = (293,75)
383 if event.key == pygame.K_b:
384 active = 'Antenne 2'
385 lcd.message((active + act))
386 change_sortie('b')
387 endline = (293,125)
388 if event.key == pygame.K_c:
389 active = 'Antenne 3'
390 lcd.message((active + act))
391 change_sortie('c')
392 endline = (293,175)
393 if event.key == pygame.K_d:
394 active = 'Antenne 4'
395 lcd.message((active + act))
396 change_sortie('d')
397 endline = (293,225)
398
399 souris = pygame.mouse.get_pos()
400 souris_rect = souris[0],souris[1,[5,5]]
401 souris_rect = pygame.Rect(souris_rect)
402
403 for i in grp_cases:
404 lcd.setCursor(0,0)
405 if souris_rect.colliderect(i.rect.move((0,450))):
406 if pygame.mouse.get_pressed() == (1,0,0):
407 if i.port == canal[1]:
408 active = 'Antenne 1'
409 lcd.message((active + act))
410 change_sortie('a')
411 endline = (293,75)
412 if i.port == canal[2]:
413 active = 'Antenne 2'
414 lcd.message((active + act))
415 change_sortie('b')
416 endline = (293,125)
417 if i.port == canal[3]:
418 active = 'Antenne 3'
419 lcd.message((active + act))
420 change_sortie('c')
421 endline = (293,175)
422 if i.port == canal[4]:
423 active = 'Antenne 4'
424 lcd.message((active + act))
425 change_sortie('d')
426 endline = (293,225)
427
428 zone3.blit(BP1.image,BP1.rect)
429 zone3.blit(BP2.image,BP2.rect)
430 zone3.blit(BP3.image,BP3.rect)
431 zone3.blit(BP4.image,BP4.rect)
432 screen.blit(zone3,(0,450))
433 zone2.blit(commu,(50,50))
434 pygame.draw.line(zone2,noir,startline,endline,2)
435 screen.blit(zone2,(0,150))
436 pygame.display.update()
437 }}}##
438 {{/box}}
439
440 [[Fichier Py>>attach:commu08.py]]
441
442
443 === Distributions 'source' sans et avec LCD ===
444
445 [[Distribution_sans_LCD.rar>>attach:Distribution.rar]]
446
447
448 [[Distribution_lcd.rar>>attach:Distribution_lcd.rar]]