Commutateur d' antenne
Version 14.5 par Jean-Yves Dupertuis le 18-07-2014, 14:52
Commutation d'antenne via raspberry - py
Ce commutateur va permettre via internet de modifier l' antenne reliée au TX de la station EM.
Ce travail a été confié à un apprenant de 4ème année (M Loris Gilliand) .
Fabrication
Interface Homme - Machine
Pour commuter le TX sur une autre antenne, il suffit de taper la lettre (canal désiré) au clavier.
L'image se modifie selon votre choix pour valider sa commutation.
Vous pouvez via la "souris" obtenir le même résultat !
On a ajouté un LCD fournit par HB9FOX qui permet de commuter directement sur le module la bonne Antenne.
IMPORTANT !! Pour ce faire le raspberry - py doit fonctionné et le programme lancé !
Voici le détail :
Câblage du module
Le raspberry - py travaille avec 8 GPIO qui pour des raisons de protection transite via des opto - coupleurs.
Une carte dédiée à cette protection a été développée.
Le rasbberry - py est directement relié aux entrée de ces optos et la photo montre comment relié les sorties
des optos à la carte relais. Une carte relais possède 4 relais de commutation. C'est pourquoi le module
possède 2 cartes relais.
Depuis les sorties relais on installe le câble de la boite de commutation.
Les fils rouge sont l'arrivée du 12 Vdc depuis l'autre côté de la carte relais.
Ne pas oublier de les relier au 12Vdc !
Câble
Programmation Python
Voici le code source, vous pouvez le copier directement dans un IDLE Python 2.7.
Si vous ne l'avez pas, vous pouvez le télécharger sur le site Python https://www.python.org/downloads/.
Pour linux c'est plus simple il suffit d' ouvrir l'IDLE 2.7 déjà présent
sur votre carte raspberry - py.
Important !! je suis parti du principe que le port I2C est fonctionnel sur votre raspberry - py.
Si ce n'est pas le cas, seul la distribution sans le LCD fonctionnera !
Source :
# auteur : Gilliand Loris
# date : 02.06.14
# version 0.8
#
# amelioration depuis 0.7 : integre un lcd qui peut commander les changements
# importation bibilotheques
import pygame, sys, time
from pygame.locals import *
import RPi.GPIO as GPIO
from Adafruit_CharLCDPlate import *
# initialisation fenetre et gpio
pygame.init()
GPIO.setmode(GPIO.BCM)
# fonction qui change LA sortie active
def change_sortie(ligne):
BP1.etat = 0
BP2.etat = 0
BP3.etat = 0
BP4.etat = 0
BP1.affiche_etat(inactif)
BP2.affiche_etat(inactif)
BP3.affiche_etat(inactif)
BP4.affiche_etat(inactif)
time.sleep(0.25)
if ligne == 'a':
BP1.etat = 1
BP1.affiche_etat(actif)
elif ligne == 'b':
BP2.etat = 1
BP2.affiche_etat(actif)
elif ligne == 'c':
BP3.etat = 1
BP3.affiche_etat(actif)
elif ligne == 'd':
BP4.etat = 1
BP4.affiche_etat(actif)
# classe de creation de cases
class Cases:
def init(self,image,pos,port,init):
self.image = pygame.image.load(image).convert()
self.pos = pos
self.port = port
self.etat = init
self.rect = self.image.get_rect().move(self.pos)
GPIO.setup(self.port,GPIO.OUT)
GPIO.output(self.port,GPIO.LOW)
def affiche_etat(self,indicateur):
indicateur = pygame.image.load(indicateur).convert()
indi_rect = indicateur.get_rect()
indi_rect.centerx = self.rect.centerx - self.pos[0]
indi_rect.centery = self.rect.centery - self.pos[1]
if self.etat == 0:
GPIO.output(self.port,GPIO.LOW)
elif self.etat == 1:
GPIO.output(self.port,GPIO.HIGH)
self.image.blit(indicateur,indi_rect)
# initialisation de la fenetre
screen = pygame.display.set_mode((600,600))
clock = pygame.time.Clock()
# initialisation des couleurs
rouge = (255,0,0)
noir = (0,0,0)
blanc = (255,255,255)
vert = (0,255,0)
bleu = (0,0,255)
# initialisation des variables
startline = (183,149)
endline = (293,75)
flag_canal = 0
canal = [4,17,18,22,23,24,25,27]
# definitions des zones
zone1 = pygame.Surface((600,150))
zone1.fill(bleu)
zone2 = pygame.Surface((400,300))
zone2.fill(bleu)
zone3 = pygame.Surface((600,150))
zone3.fill(bleu)
zone4 = pygame.Surface((200,300))
zone4.fill(bleu)
# definitions des objets a afficher dans les zones
# zone 1
font = pygame.font.Font(None,60)
titre1 = font.render("HB9EM",1,noir)
titre2 = font.render("Commutateur d'antennes",1,noir)
zone1.blit(titre1,(230,30))
zone1.blit(titre2,(50,70))
# zone 2
commu = pygame.image.load("commu_antenne.bmp").convert()
zone2.blit(commu,(50,50))
# zone 3
actif = "actif_commu.bmp"
inactif = "inactif_commu.bmp"
BP1 = Cases("bouton_commu.bmp",(125,50),canal[1],1)
BP2 = Cases("bouton_commu.bmp",(225,50),canal[2],0)
BP3 = Cases("bouton_commu.bmp",(325,50),canal[3],0)
BP4 = Cases("bouton_commu.bmp",(425,50),canal[4],0)
grp_cases = [BP1,BP2,BP3,BP4]
BP1.affiche_etat(actif)
BP2.affiche_etat(inactif)
BP3.affiche_etat(inactif)
BP4.affiche_etat(inactif)
zone3.blit(BP1.image,BP1.rect)
zone3.blit(BP2.image,BP2.rect)
zone3.blit(BP3.image,BP3.rect)
zone3.blit(BP4.image,BP4.rect)
font = pygame.font.Font(None,20)
canal_a = font.render("canal A",1,noir)
canal_b = font.render("canal B",1,noir)
canal_c = font.render("canal C",1,noir)
canal_d = font.render("canal D",1,noir)
zone3.blit(canal_a,(125,35))
zone3.blit(canal_b,(225,35))
zone3.blit(canal_c,(325,35))
zone3.blit(canal_d,(425,35))
# zone 4
commande = font.render("Commandes :",1,noir)
touche_a = font.render("Selection canal A : touche a",1,noir)
touche_b = font.render("Selection canal B : touche b",1,noir)
touche_c = font.render("Selection canal C : touche c",1,noir)
touche_d = font.render("Selection canal D : touche d",1,noir)
quitter = font.render("Quitter : touche q",1,noir)
zone4.blit(commande,(10,20))
zone4.blit(touche_a,(10,60))
zone4.blit(touche_b,(10,80))
zone4.blit(touche_c,(10,100))
zone4.blit(touche_d,(10,120))
zone4.blit(quitter,(10,200))
# affichage des zones
screen.blit(zone1,(0,0))
screen.blit(zone2,(0,150))
screen.blit(zone3,(0,450))
screen.blit(zone4,(400,150))
lcd = Adafruit_CharLCDPlate()
lcd.begin(16,2)
btn = ((lcd.SELECT, '', lcd.ON),
(lcd.LEFT , 'Antenne 1' , lcd.ON),
(lcd.UP , 'Antenne 2' , lcd.ON),
(lcd.DOWN , 'Antenne 4' , lcd.ON),
(lcd.RIGHT , 'Antenne 3' , lcd.ON))
prev = -1
temp = ''
active = 'Antenne 1'
act = ' active'
lcd.message((active + act))
while 1:
clock.tick(30)
for b in btn:
if lcd.buttonPressed(lcd.SELECT):
lcd.clear()
lcd.message((active + act))
time.sleep(0.25)
if temp != '':
active = temp
temp = ''
if active == 'Antenne 1':
change_sortie('a')
endline = (293,75)
if active == 'Antenne 2':
change_sortie('b')
endline = (293,125)
if active == 'Antenne 3':
change_sortie('c')
endline = (293,175)
if active == 'Antenne 4':
change_sortie('d')
endline = (293,225)
lcd.setCursor(0,0)
lcd.message((active + act))
lcd.setCursor(0,1)
lcd.message(' ')
if lcd.buttonPressed(lcd.RIGHT):
temp = 'Antenne 3'
lcd.setCursor(0,1)
lcd.message(temp)
if lcd.buttonPressed(lcd.DOWN):
temp = 'Antenne 4'
lcd.setCursor(0,1)
lcd.message(temp)
if lcd.buttonPressed(lcd.UP):
temp = 'Antenne 2'
lcd.setCursor(0,1)
lcd.message(temp)
if lcd.buttonPressed(lcd.LEFT):
temp = 'Antenne 1'
lcd.setCursor(0,1)
lcd.message(temp)
for event in pygame.event.get():
lcd.setCursor(0,0)
if event.type == pygame.QUIT:
GPIO.cleanup()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
GPIO.cleanup()
sys.exit()
if event.key == pygame.K_a:
active = 'Antenne 1'
lcd.message((active + act))
change_sortie('a')
endline = (293,75)
if event.key == pygame.K_b:
active = 'Antenne 2'
lcd.message((active + act))
change_sortie('b')
endline = (293,125)
if event.key == pygame.K_c:
active = 'Antenne 3'
lcd.message((active + act))
change_sortie('c')
endline = (293,175)
if event.key == pygame.K_d:
active = 'Antenne 4'
lcd.message((active + act))
change_sortie('d')
endline = (293,225)
souris = pygame.mouse.get_pos()
souris_rect = souris[0],souris[1,[5,5]]
souris_rect = pygame.Rect(souris_rect)
for i in grp_cases:
lcd.setCursor(0,0)
if souris_rect.colliderect(i.rect.move((0,450))):
if pygame.mouse.get_pressed() == (1,0,0):
if i.port == canal[1]:
active = 'Antenne 1'
lcd.message((active + act))
change_sortie('a')
endline = (293,75)
if i.port == canal[2]:
active = 'Antenne 2'
lcd.message((active + act))
change_sortie('b')
endline = (293,125)
if i.port == canal[3]:
active = 'Antenne 3'
lcd.message((active + act))
change_sortie('c')
endline = (293,175)
if i.port == canal[4]:
active = 'Antenne 4'
lcd.message((active + act))
change_sortie('d')
endline = (293,225)
zone3.blit(BP1.image,BP1.rect)
zone3.blit(BP2.image,BP2.rect)
zone3.blit(BP3.image,BP3.rect)
zone3.blit(BP4.image,BP4.rect)
screen.blit(zone3,(0,450))
zone2.blit(commu,(50,50))
pygame.draw.line(zone2,noir,startline,endline,2)
screen.blit(zone2,(0,150))
pygame.display.update()
Distributions 'source' sans et avec LCD