Code source wiki de Commutateur d' antenne

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