Code source wiki de Commutateur d' antenne

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