Code source wiki de Commutateur d' antenne

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