Code source wiki de Commutateur d' antenne

Version 19.3 par Jean-Yves Dupertuis le 25-07-2014, 11:23

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