Code source wiki de Commutateur d' antenne

Version 15.1 par Jean-Yves Dupertuis le 25-07-2014, 11:04

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
14.7	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
6.1	40	[[image:PremFenetre.jpg]]
	41
	42
	43
	44	[[image:ZoneAide.jpg]]
	45
	46
	47
	48	[[image:BoutonIndication.jpg]]
	49
	50
	51	[[image:ClassGpio.jpg]]
8.2	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
10.2	68	== Câblage du module ==
8.2	69
14.4	70	Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transite via des opto - coupleurs.
10.2	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 !
11.2	95
	96	== Câble ==
	97
	98
	99	[[image:cableCommAnt.jpg]]
	100
11.6	101	= Programmation Python =
	102
	103	Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
	104
12.2	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/]].
11.6	106
12.2	107	Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
	108
11.6	109	sur votre carte raspberry - py.
	110
14.3	111	Important !! je suis parti du principe que le port //I2C// est fonctionnel sur votre raspberry - py.
12.2	112
14.3	113	Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !
	114
	115
	116
12.3	117	== Source : ==
12.2	118
14.6	119	{{box}}
	120	##{{{# auteur : Gilliand Loris
11.6	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:
11.7	162	def init(self,image,pos,port,init):
11.6	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()
11.7	360	souris_rect = souris[0],souris[1,[5,5]]
11.6	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()
14.6	397	}}}##
	398	{{/box}}
11.6	399
12.2	400	[[Fichier Py>>attach:commu08.py]]
	401
14.2	402
14.5	403	=== Distributions 'source' sans et avec LCD ===
14.2	404
	405	[[Distribution_sans_LCD.rar>>attach:Distribution.rar]]
	406
	407
	408	[[Distribution_lcd.rar>>attach:Distribution_lcd.rar]]