Wiki source code of Commutateur d' antenne

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