Wiki source code of Commutateur d' antenne

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