Code source wiki de Commutateur d' antenne

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