Code source wiki de Commutateur d' antenne

Version 19.1 par Jean-Yves Dupertuis le 25-07-2014, 11:19

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