|
#!/usr/bin/python
|
|
#-*- coding: utf-8 -*-
|
|
import subprocess
|
|
import os #import *
|
|
import sys
|
|
import pipes
|
|
import os.path
|
|
import re
|
|
import time
|
|
import math
|
|
from math import log,sqrt,cosh,tanh
|
|
from ctypes import c_int, c_uint, c_float, Union
|
|
import struct
|
|
from collections import deque
|
|
from struct import unpack
|
|
from struct import pack
|
|
#Union Tab_car_double_int_1
|
|
# { char tampon[928];
|
|
# double x[116];
|
|
# int n[232];
|
|
# byte_buffer -> binary input
|
|
# var_type -> variable type indicator
|
|
# Il faut faire l'équivalent de l'union de C de Gérard en python
|
|
|
|
# unpack_code = ''
|
|
#
|
|
# if var_type == 'INT':
|
|
# unpack_code = 'i'
|
|
# elif var_type == 'DOUBLE':
|
|
# unpack_code = 'd'
|
|
# elif var_type == 'STR':
|
|
# unpack_code = 'b'
|
|
|
|
# var = unpack(unpack_code, byte_buffer)[0]
|
|
#
|
|
# class MyType(Union):
|
|
# _fields_ = [("i", c_int), ("u", c_uint), ("f", c_float)]
|
|
#
|
|
# var = MyType()
|
|
#
|
|
# var.i = unpack("i", byte_buffer)[0]
|
|
|
|
|
|
#Nommer le fichier .info d'Herezh avec lequel on va communiquer:
|
|
# filename = input("Veuillez entrer un nom de fichier : ")
|
|
# try:
|
|
# f = open(filename, "r")
|
|
# except:
|
|
# print("Le fichier", filename, "est introuvable")
|
|
|
|
#Nommer les pipes d'Herezh qui sont toujours les suivants: nom_fonction_nd_envoi_Hz.FIFO et nom_fonction_nd_reception_Hz.FIFO
|
|
#nom_fonction_nD=raw_input("nom de la fonction nD? ")
|
|
# ma_fct_nD_W2_reception_Hz.FIFO
|
|
#nom_fonction_nD=input("nom de la fonction nD? ")
|
|
nom_fonction_nD='ma_fct_nD_W2'
|
|
nomPipeOUT=nom_fonction_nD + '_envoi_Hz.FIFO'
|
|
#print "Le nom du envoi d Herezh est:",'%s'%nomPipeOUT
|
|
print("Le nom du envoi d Herezh est : ",nomPipeOUT)
|
|
nomPipeIN=nom_fonction_nD + '_reception_Hz.FIFO'
|
|
print("Le nom de reception d Herezh est : ",nomPipeIN)
|
|
|
|
#Est-ce que les pipes sont crées par Herezh ?
|
|
if os.path.exists(nomPipeOUT) and os.path.exists(nomPipeIN):
|
|
print("Les pipes ont bien été créés par Herezh: on continue")
|
|
else:
|
|
print("ERROR, le pipe ",nomPipeOUT," ou ",nomPipeOUT," n'a pas été crée par Herezh on arrête la")
|
|
exit()
|
|
|
|
|
|
# On définit un tableau de réception et d'envoi une grandeur qui correspond à notre retour du python
|
|
tab_reception=[]
|
|
#tab_envoi=[] !!! non il ne faut pas declarer le tableau ici !!
|
|
# une grandeur qui correspond à notre retour du python
|
|
precision=0.001
|
|
|
|
# Boucle while avec condition égale 1
|
|
while True:
|
|
# Ouverture du pipe d'envoi d'Herezh en mode lecture : on va lire les infos d'Herezh
|
|
##print("ouverture du pipe en mode lecture pour recevoire les infos d Herezh \n")
|
|
PipeOUT = os.open(nomPipeOUT,os.O_RDONLY) #os.O_RDONLY
|
|
|
|
|
|
# Herezh donne deux entiers (nbr para et nb retour) ce sont des entiers donc 2*4=8bytes
|
|
# J'ai 1 variable de passage dans ma fonction nD externe (1 réelle double=8=8 bytes)
|
|
# total de 16 bytes qui est ensuite définit dans la commande read du pipe
|
|
line = os.read(PipeOUT, 16)
|
|
# On vérifie que la taille est bien de 56 bytes (on peut utiliser cela pour générer des erreurs si on ne retrouve pas le nombre de bytes)
|
|
##print("NBR d'octets à avoir :",len(line))
|
|
#if len(line)=0:
|
|
#print "le calcul est terminé "
|
|
#os.close(PipeIN)
|
|
#os.close(PipeOUT)
|
|
#break
|
|
# J'utilise mon tab de reception dans lequel je traduis les bytes d'Herezh en indiquant le type des grandeurs :
|
|
#i: entier et d: float double
|
|
tab_reception=unpack("@iid",line)
|
|
# je regarde les grandeurs données traduites:
|
|
##print("le nombre d'argument donné par Herezh est :",tab_reception[0])
|
|
##print("le nombre de retour demandé par Herezh est :", tab_reception[1])
|
|
##for i in range(2,tab_reception[0]):
|
|
## print(" argument ",i); print(" valeur ",tab_reception[i])
|
|
# print("Le premier argument est égal à:",tab_reception[2])
|
|
# print("Le deuxième argument est égal à:",tab_reception[3])
|
|
os.close(PipeOUT)
|
|
##print("fermeture du pipe en mode lecture pour recevoir les infos à Herezh \n")
|
|
|
|
# chgt par rapport au prog de Laurent: je garde 1 valeur
|
|
fct1= 6 * tab_reception[2]
|
|
|
|
#
|
|
#
|
|
#
|
|
# Je dois renvoyer les deux entiers à Herezh: nbr para et nb retour donc:
|
|
tab_envoi=[] # il faut le declarer ici, sinon le tableau ne fait que s'agrandir
|
|
# et le retour est toujours le meme !!!!!!!
|
|
tab_envoi.append(tab_reception[0])
|
|
tab_envoi.append(tab_reception[1])
|
|
#Je rajoute le retour de mon fichier python (ici les 1 réel ) dans le tab envoi
|
|
tab_envoi.append(fct1) # 2
|
|
#On traduit en byte pour le pipe
|
|
transformation=pack("@iid",tab_envoi[0],tab_envoi[1],tab_envoi[2])
|
|
#transformation=pack("@iiddddddddd",tab_envoi[0],tab_envoi[1],fct1,fct2,fct3,fct4,fct5,fct6,fct7,fct8,fct9)
|
|
# ici j'indique avec @iiddddddddd exactement le format de retour: 2 entiers et 9 reels
|
|
# On écrit
|
|
# Ouverture du pipe de reception d'Herezh en mode écriture : on va donner les infos du python
|
|
##print("ouverture du pipe en mode écriture pour envoyer les infos à Herezh \n")
|
|
PipeIN = os.open(nomPipeIN,os.O_WRONLY)
|
|
ecriture=os.write(PipeIN,transformation)
|
|
##print "the number of bytes written: "
|
|
##print ecriture
|
|
|
|
os.close(PipeIN)
|
|
##print("fermeture du pipe en mode écriture pour envoyer les infos à Herezh \n")
|
|
|
|
|
|
|
|
|