def consultation(pidC,numEnreg):
try:
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file
#print("FSC: Creation/Ouverture de la file de message serveur to client")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande
global contenu
find=False
Sconsul.acquire() #P(S) on bloque l'acces au fichier pour les autres threads
rep = u"/"
fichier = u"fichier.txt"
chemin = cherchefichier(fichier,rep)
b=chemin [0:-1]
if b != '/':
chemin =chemin +'/'
cheminObs = chemin + nomFichier
try: #on essaye d'ouvrir le fichier
with open(cheminObs, "r") as fichier: #with permet d'ouvrir le fichier puis le ferme automatiquement, ici on ouvre le fichier en lecture
for enregistrement in fichier.readlines(): #on parcourt tout les enregistrement du fichier
if enregistrement.startswith(numEnreg + ": "): #On cherche l'enregistrement qui correpond au numero rechercher
find = True
contenu = enregistrement.strip('\n')
if find == False:
contenu = "l'enregistrement que vous cherchez n'existe pas"
except: #si il y a echec, on le notifi
contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible."
Sconsul.release() #V(S) on libère le fichier
FSC.send(contenu,None,int(pidC)) #On met dans la file FSC le contenu rechercher pour le client
def modification(pidC,numEnreg,newEnreg):
try:
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file
#print("FSC: Creation/Ouverture de la file de message serveur to client")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande
#On bloque les autres actions possibles
Smodif.acquire()
Sconsul.acquire()
Sadd.acquire()
Svisu.acquire()
Ssupp.acquire()
try:
with open(nomFichier, "r") as fichier: #on lis entierement le fichier pour le récuperer
listEnregistrements = fichier.readlines()
try:
with open(nomFichier, "w") as fichier: #puis on le récrit a partir de ce que l'on a recuperer en modifiant ce que l'on cherche
for enregistrement in listEnregistrements:
if enregistrement.startswith(numEnreg + ": "): #lorsque on a trouvé le bon enregistrement, on le change
enregistrement = numEnreg + ": " + newEnreg + "\n"
fichier.write(enregistrement)
notif = "Modification effectue sur l'enregistrement numero " + numEnreg + "."
except:
notif = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible."
except:
notif = "Le fichier " + nomFichier + " est introuvable ou nest pas accessible."
#on libere les autres actions
Smodif.release()
Ssupp.release() #V(S)
Sconsul.release() #V(S)
Sadd.release() #V(S)
Svisu.release() #V(S)
FSC.send(notif,None,int(pidC))
def adjonction(pidC, newEnreg):
try:
FSC = pos.MessageQueue("/queueFSC" + str(pidC),
pos.O_CREAT) #création ou ouverture de la file
print(
"FSC: Creation/Ouverture de la file de message serveur to client")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFSC" +
str(pidC)) #destruction de la file
FSC = pos.MessageQueue("/queueFSC" + str(pidC),
pos.O_CREAT) #puis redemande
newNum = 1
Sadd.acquire() #P(S)
try: #on essaye d'ouvrir le fichier
with open(
nomFichier, "r"
) as fichier: #with permet d'ouvrir le fichier puis le ferme automatiquement, ici on ouvre le fichier en lecture
for enregistrement in fichier.readlines(
): #on parcourt tout les enregistrement du fichier
newNum = newNum + 1
except: #si il y a echec, on le notifi
contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible."
try:
with open(nomFichier, "a") as fichier: #On ouvre le fichier en ajout
fichier.write(
str(newNum) + ": " + newEnreg + "\n"
) #On ajoute le nouvel enregistrement au fichier,newNum permet de classer nos enregistrement et "\n" permet de séparé les enregistrements
notif = "Enregistrement numero " + str(newNum) + " effectue."
except:
notif = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible."
Sadd.release() #V(S)
FSC.send(notif, None, int(pidC))
def run():
while True:
print "gobatch: En attente d'une commande"
# Le processus est bloqué tant qu'aucune commande pgcycl n'est arrivée
S.acquire()
# gobatch attend de reçevoir un message de pgcycl :
try:
filmess = pos.MessageQueue("/queue", pos.O_CREAT) # ouvre la file
except pos.ExistentialError:
pos.unlink_message_queue("/queue") # détruit la file
filmess = pos.MessageQueue(
"/queue", pos.O_CREAT) # puis redemande la création
(message,
priorite) = filmess.receive() # retire le message en tête de file
print "gobatch : Le message reçu est : {}, de priorité {}".format(
message, priorite)
# Type d'action en fonction de la priorité (type) du message
if priorite == 1:
# Action : lecture du fichier fbatch
lectureFichier()
elif priorite == 2:
# Action : suppression de la commande spécifiée
supprimerThread(message)
elif priorite == 3:
# Action : écriture dans le fichier fbatch
creationThread()
def __init__(self):
txq_name, rxq_name = self.load_config()
self.rxq = ipc.MessageQueue('/' + rxq_name, ipc.O_CREAT)
self.txq = ipc.MessageQueue('/' + txq_name, ipc.O_CREAT,
max_messages=10, max_message_size=2048)
self.txq.block = False
self.rxq.block = False
def __init__(self):
self.status = False
self.shutdown = False
self.rx_mq = posix_ipc.MessageQueue(AGENT_TO_JUPYTER,
posix_ipc.O_CREAT)
self.tx_mq = posix_ipc.MessageQueue(JUPYTER_TO_AGENT,
posix_ipc.O_CREAT)
def start_to_capture(self):
if self.lineEdit_sensor1_location.text() == "":
result = QtGui.QMessageBox.warning(
self, "warning", "please input sensor1's location first")
return
if self.lineEdit_sensor2_location.text() == "":
result = QtGui.QMessageBox.warning(
self, "warning", "please input sensor2's location first")
return
if self.lineEdit_source_location.text() == "":
result = QtGui.QMessageBox.warning(
self, "warning", "please input source's location first")
return
self.sensor1_loc = float(self.lineEdit_sensor1_location.text())
self.sensor2_loc = float(self.lineEdit_sensor2_location.text())
self.source_loc = float(self.lineEdit_source_location.text())
self.lineEdit_sensor1_location.setEnabled(False)
self.lineEdit_sensor2_location.setEnabled(False)
self.lineEdit_source_location.setEnabled(False)
self.running = threading.Event()
self.flag = threading.Event()
self.running.set()
self.flag.clear()
self.receive_thread = threading.Thread(
name="datareceiver", target=self.receive_message_queue)
self.receive_thread.start()
self.pushButton_start_to_capture.setEnabled(False)
self.pushButton_stop_to_capture.setEnabled(True)
self.mqd = posix.MessageQueue("/mqd", flags=posix.O_CREAT, mode=0o644)
self.mqf = posix.MessageQueue("/mqf", flags=posix.O_CREAT, mode=0o644)
self.start_capture()
def __init__(self):
self.mq_recv = posix_ipc.MessageQueue('/simu_IPC_reply',
posix_ipc.O_CREAT)
self.mq_recv.block = False # non-blocking recv , send
self.mq_send = posix_ipc.MessageQueue('/simu_IPC_cmd',
posix_ipc.O_CREAT)
self.mq_send.block = False # non-blocking recv , send
def __init__(self, callback):
self.thread = None
self.isStop = False
self.rx_mq = posix_ipc.MessageQueue(JUPYTER_TO_AGENT,
posix_ipc.O_CREAT)
self.tx_mq = posix_ipc.MessageQueue(AGENT_TO_JUPYTER,
posix_ipc.O_CREAT)
self.callback = callback
def main():
#--- programme serveur: gère les accès concurents entre les modifications et les suppressions.
signal.signal(
signal.SIGINT, fermer_serveur
) # SIGINT au Handler fermer_serveur : prévient le SE qu’à l’arrivée du signal ^C il faudra exécuter fermer_programme
#Initialisation des deux files FCS et FSC
#!!! problème potentiel initialisation, si erreur ça detruit puis ça recreer (perte msg?)? quel erreur ?
# a voir avec le tp ConsMessage, la partie except fait surement n'importe quoi !!!
#FCS
try:
FCS = pos.MessageQueue("/queueFCS",
pos.O_CREAT) #création ou ouverture de la file
print(
"FCS: Creation/Ouverture de la file de message client to serveur")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFCS") #destruction de la file
FCS = pos.MessageQueue("/queueFCS", pos.O_CREAT) #puis redemande
ouvertureServ = True
#La partie qui boucle du serveur
while ouvertureServ:
try:
messageClient = FCS.receive(
) # 0 car on prend en FIFO, voir "TP UNIX-Python SEANCE 2016v2 tout à la fin"
#!! receive retourne, selon ce même pdf, un tuple de (message,type), comment récupérer juste le msg ? j'ai mis [0] dans le doute, à tester
listInfo = messageClient[0].split(
"/"
) #ici on split les informations reçu pour les stockés et les utiliser plus tard
action = listInfo[0]
pidClient = listInfo[1]
nomFichier = listInfo[3]
numEnregistrement = listInfo[4] #numEnreg peut être "-" parfois
nouvelEnreg = listInfo[5] #nouvelEnreg peut être "-" parfois
#New thread(split(3), (split 1 et 2)) /*split 1 et 2 correspondent aux autres infos envoyées comme par exemple le pid ou le numéro d’enregistrement*/
#On determine la fonction à exécuter en selon l'action demandé par le client
if action == 'consultation':
thread.start_new_thread(consultation,
(pidClient, numEnregistrement))
elif action == 'modification':
thread.start_new_thread(
modification, (pidClient, numEnregistrement, nouvelEnreg))
elif action == 'suppression':
thread.start_new_thread(suppression,
(pidClient, numEnregistrement))
elif action == 'adjonction':
thread.start_new_thread(adjonction, (pidClient, nouvelEnreg))
elif action == 'visualisation':
thread.start_new_thread(visualisation, (pidClient, ))
elif action == 'tempsAttente':
tempsAttente()
except pos.SignalError:
ouvertureServ = False
def make_queues(task_name, instance_id, is_clear=False):
q_name_b2t = '/broker_to_' + task_name + ':' + str(instance_id)
q_name_t2b = '/' + task_name + ':' + str(instance_id) + '_to_broker'
q_b2t = posix_ipc.MessageQueue(q_name_b2t, posix_ipc.O_CREAT)
q_t2b = posix_ipc.MessageQueue(q_name_t2b, posix_ipc.O_CREAT)
if is_clear:
clear(q_b2t)
clear(q_t2b)
return (q_b2t, q_t2b)
def __init__(self, config, index):
import posix_ipc
prefix = f'nsh_{index}'
max_message_size = config.getint('nsh', 'max_message_size')
self.sender = posix_ipc.MessageQueue(f'/{prefix}.g2e',
flags=posix_ipc.O_CREAT,
max_message_size=max_message_size)
self.receiver = posix_ipc.MessageQueue(
f'/{prefix}.e2g',
flags=posix_ipc.O_CREAT,
max_message_size=max_message_size)
def main():
#--- programme serveur: gère les accès concurents entre les modifications et les suppressions.
signal.signal(
signal.SIGINT, fermer_serveur
) # SIGINT au Handler fermer_serveur : prévient le SE qu’à l’arrivée du signal ^C il faudra exécuter fermer_programme
#FCS
try:
FCS = pos.MessageQueue("/queueFCS" + str(nomFichier),
pos.O_CREAT) #création ou ouverture de la file
print(
"FCS: Creation/Ouverture de la file de message client to serveur")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFCS" +
str(nomFichier)) #destruction de la file
FCS = pos.MessageQueue("/queueFCS" + str(nomFichier),
pos.O_CREAT) #puis redemande
ouvertureServ = True
#La partie qui boucle du serveur
while ouvertureServ:
try:
messageClient = FCS.receive()
listInfo = messageClient[0].split(
"/"
) #ici on split les informations reçu pour les stockés et les utiliser plus tard
action = listInfo[0]
pidClient = listInfo[1]
nomFichier = listInfo[2]
numEnregistrement = listInfo[3] #numEnreg peut être "-" parfois
nouvelEnreg = listInfo[4] #nouvelEnreg peut être "-" parfois
#New thread(split(3), (split 1 et 2)) /*split 1 et 2 correspondent aux autres infos envoyées comme par exemple le pid ou le numéro d’enregistrement*/
#On determine la fonction à exécuter en selon l'action demandé par le client
if action == 'consultation':
thread.start_new_thread(consultation,
(pidClient, numEnregistrement))
elif action == 'modification':
thread.start_new_thread(
modification, (pidClient, numEnregistrement, nouvelEnreg))
elif action == 'suppression':
thread.start_new_thread(suppression,
(pidClient, numEnregistrement))
elif action == 'adjonction':
thread.start_new_thread(adjonction, (pidClient, nouvelEnreg))
elif action == 'visualisation':
thread.start_new_thread(visualisation, (pidClient, ))
elif action == 'tempsAttente':
tempsAttente(pidClient)
except pos.SignalError:
ouvertureServ = False
def demander_modifier(idEnr):
'''
Etapes pour procéder à une modification :
1 lecture
2 affichage
3 edit interactif
4 écriture coté serveur
'''
#Demande de lecture spéciale pour contenir le délai
requete = "MODIFLEC:" + str(monPid) + ":" + str(idEnr)
fileVersServeur.send(
requete, priority=1) #Priorité plus elevée car c'est une modification
print("Demande de lecture envoyée...")
# Maintenant on attend la réponse sur une file crée grâce au pid du client
try:
fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid),
pos.O_CREAT | pos.O_EXCL)
except pos.ExistentialError:
print("/fileVersClient{} déjà existante".format(monPid))
fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid),
pos.O_CREAT)
reponse = fileVersClient.receive()[0]
if (reponse == "ENREGISTREMENT INTROUVABLE"):
print("Cet enregistrement n'existe pas/plus sur le serveur.")
else:
#Notre réponse serveur est sous cette forme :
#delai:Enregistrement ==> On découpe le string en deux parties
reponse = reponse.split(":")
delai = int(reponse[0])
#On joint le texte à partir de la case 1 au cas où l'enregistrement contient des double points
#Il ne s'agit que d'une précaution pour ne pas juste utiliser reponse[1]
texte = ''.join(reponse[1:])
signal.alarm(delai)
try:
#on modifie interactivement le texte
envoi = input_interactif(
"Procédez à la modification dans les {} secondes: \n".format(
delai), texte)
requete = "MODIFIER:" + str(monPid) + ":" + str(
idEnr) + ":" + envoi
print("Demande de modification envoyée...")
fileVersServeur.send(
requete,
priority=1) # Priorité plus elevée car c'est une modification
except Alarm:
print("\nTemps écoulé.\n")
signal.alarm(0)
fileVersClient.unlink()
def cree_file():
global fileVersServeur
global fileVersClient
global fileReponseSup
try:
fileVersServeur = pos.MessageQueue("/fileVersServeur")
except:
print("File vers serveur non existant! veuillez lancer servfic")
sys.exit(2)
try:
fileReponseSup = pos.MessageQueue("/reponseSup")
except pos.ExistentialError:
print("fileConfirmationSup pas existante(pas normal)")
def start(self):
self._helper = subprocess.Popen([helperExe, "--with_ui"],
stdin=subprocess.PIPE,
stdout=sys.stdout)
time.sleep(3)
try:
self.mq = {}
self.mq["send"] = posix_ipc.MessageQueue("/cmd")
self.mq["receive"] = posix_ipc.MessageQueue("/resp")
except sysv_ipc.ExistentialError as e:
DBG("ERROR: message queue creation failed " % str(e))
raise
self.thread_init()
def demander_visualiser():
requete = "VISUALISER:" + str(monPid)
fileVersServeur.send(requete)
try:
fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid),
pos.O_CREAT | pos.O_EXCL)
except pos.ExistentialError:
print("/fileVersClient{} déjà existante".format(monPid))
fileVersClient = pos.MessageQueue("/fileVersClient" + str(monPid),
pos.O_CREAT)
reponse = fileVersClient.receive()[0]
print(reponse)
fileVersClient.unlink()
def visualisation(pidC):
try:
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #création ou ouverture de la file
#print("FSC: Creation/Ouverture de la file de message serveur to client")
except pos.ExistentialError:
S = pos.unlink_message_queue("/queueFSC"+str(pidC)) #destruction de la file
FSC = pos.MessageQueue("/queueFSC"+str(pidC),pos.O_CREAT) #puis redemande
Svisu.acquire() #P(S)
try:
with open(nomFichier, "r") as fichier: #On ouvre le fichier en lecture
contenu = fichier.read() #On récupère entierement le contenu du fichier
except:
contenu = "Le fichier " + nomFichier + " est introuvable ou n'est pas accessible."
Svisu.release() #V(S)
FSC.send(contenu,None,int(pidC))
def __init__(self, config, index):
import posix_ipc
prefix = f'nsh_{index}'
try:
os.remove(os.path.join('/dev/mqueue', prefix))
except FileNotFoundError:
pass
max_message_size = config.getint('nsh', 'max_message_size')
self.sender = posix_ipc.MessageQueue(f'/{prefix}.e2g',
flags=posix_ipc.O_CREAT,
max_message_size=max_message_size)
self.receiver = posix_ipc.MessageQueue(
f'/{prefix}.g2e',
flags=posix_ipc.O_CREAT,
max_message_size=max_message_size)
def receive():
params = {}
line1 = "ITERATIONS=10"
line2 = "MESSAGE_QUEUE_NAME=/mq_test"
name, value = line1.split('=')
name = name.upper().strip()
if name == "PERMISSIONS":
value = int(value, 8)
elif "NAME" in name:
# This is a string; leave it alone.
pass
else:
value = int(value)
params[name] = value
name, value = line2.split('=')
name = name.upper().strip()
if name == "PERMISSIONS":
value = int(value, 8)
elif "NAME" in name:
# This is a string; leave it alone.
pass
else:
value = int(value)
params[name] = value
mq = posix_ipc.MessageQueue(params["MESSAGE_QUEUE_NAME"])
s, _ = mq.receive()
s = s.decode()
print(s)
def __init__(self, mq_name):
self.queue = ipc.MessageQueue(name=mq_name, flags=ipc.O_CREAT)
while True:
try:
self.queue.receive(0)
except ipc.BusyError:
break
def setSendQueue(self, qname=None):
"""
Name of a queue, where all messages
will be sent should be specified in first use
After that, the queue will be set to appropriate one
which comes in 'response' key in message dict
Might be changed with appopriate function call
"""
if qname is not None:
qname = '/' + qname
self.queues[1][0] = qname
try:
if ((qname is None) and (self.queues[1][0]) is not None):
qname = self.queues[1][0]
"""
Setting receiver message queue if exist
in order to send messages
"""
self.queues[1][1] = posix.MessageQueue(qname)
return True
except ValueError as error:
if __debug__:
log.error(error)
log.error('Queue name should be specified')
return False
except posix.ExistentialError:
if __debug__:
log.error('Cannot open queue %s', qname)
return False
return False
def test_read_flag_new_queue(self):
"""test that the read flag is respected on a new queue"""
mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, read=False)
mq.send('foo')
self.assertRaises(posix_ipc.PermissionsError, mq.receive)
mq.close()
mq.unlink()
def test_block_flag_false(self):
"""test blocking behavior when flag is false"""
mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, max_messages=3)
mq.block = False
# Queue is empty, so receive() should immediately raise BusyError
start = time.time()
self.assertRaises(posix_ipc.BusyError, mq.receive, 10)
elapsed = time.time() - start
# Not only should receive() have raised BusyError, it should have
# done so "immediately". I don't insist on extreme precision since
# OS-level task switching might mean that elapsed time is not
# vanishingly small as one might expect under most circumstances.
self.assertTrue(elapsed < 1.0)
# Now test send() the same way.
mq.send(' ')
mq.send(' ')
mq.send(' ')
# Queue is now full.
start = time.time()
self.assertRaises(posix_ipc.BusyError, mq.send, ' ', 10)
elapsed = time.time() - start
self.assertTrue(elapsed < 1.0)
mq.close()
mq.unlink()
def __init__(self,ip,port):
# global flyermmap
print(posix_ipc.MESSAGE_QUEUES_SUPPORTED)
print(posix_ipc.QUEUE_MESSAGES_MAX_DEFAULT)
print(posix_ipc.QUEUE_MESSAGE_SIZE_MAX_DEFAULT)
self.model_pub = rospy.Publisher("/gazebo/set_model_state",ModelState,queue_size=1)
self.bridge = CvBridge()
#self.image_sub = rospy.Subscriber("/mycam/image_raw",Image,self.callback)
self.image_sub = rospy.Subscriber("/multisense/camera/left/image_raw",Image,self.callback)
self.imageflag = 0
self.imagecnt = 0
self.key = 0
firstFoot = Foot([0,-0.1,0],Foot.RIGHT)
standingFoot = Foot([0,0.1,0],Foot.LEFT)
self.list = Steplist(firstFoot,standingFoot)
self.height = 1.6
self.tilt = 0.0
memory = posix_ipc.SharedMemory("flyermmap", posix_ipc.O_CREAT, size=8*Mib)
self.sem = posix_ipc.Semaphore("flyersem", posix_ipc.O_CREAT)
self.memmap = mmap.mmap(memory.fd, memory.size)
# flyermmap = self.memmap
memory.close_fd()
self.queue = posix_ipc.MessageQueue("/flyerqueue", posix_ipc.O_CREAT)
#self.wsproc = prc.Popen('python flyerws.py', shell=True )
self.wsproc = prc.Popen('python -u flyerws.py --ip %s --port %s' % (ip,port), shell=True )
self.writecnt = 0
self.loc = (0,0,0)
self.walker = Walker()
self.walker.init()
def test_unlink_message_queue(self):
"""Exercise unlink_message_queue"""
mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX)
posix_ipc.unlink_message_queue(mq.name)
mq.close()
self.assertRaises(posix_ipc.ExistentialError,
posix_ipc.MessageQueue, mq.name)
def catch_send_notification(socketio: SocketIO):
try:
posix_ipc.unlink_message_queue(config.QUEUE_NAME_UI_NOTIFICATION)
except:
pass
notificationQueue = posix_ipc.MessageQueue(
config.QUEUE_NAME_UI_NOTIFICATION, posix_ipc.O_CREX)
ui_language = config.UI_LANGUAGE
while True:
try:
notification = notificationQueue.receive(timeout=1)
message_name = json.loads(notification[0])["message_name"]
message = ui_languages[message_name][ui_language]
socketio.emit('notification', {
"message_name": message_name,
"message": message
},
namespace='/broadcast',
broadcast=True)
except:
continue
def test_max_messages(self):
"""test that the max_messages param is respected"""
mq = posix_ipc.MessageQueue(None, posix_ipc.O_CREX, max_messages=1)
mq.send('foo')
self.assertRaises(posix_ipc.BusyError, mq.send, 'bar', timeout=0)
mq.close()
mq.unlink()
def openQueue():
# Open, or create, the Queue that leads to the Database.
global queue
queue = ipc.MessageQueue(
'/netmToDB',
flags=ipc.O_CREAT,
)
def __init__(self, id=0):
BBSimInterface.__init__(self, id)
self.ang = ipc.MessageQueue("/bbsim_out1-{}".format(id),
max_messages=1)
self.pos = ipc.MessageQueue("/bbsim_out2-{}".format(id),
max_messages=1)
self.write = ipc.MessageQueue("/bbsim_in-{}".format(id),
max_messages=1)
self._reset = ipc.MessageQueue("/bbsim_reset-{}".format(id),
max_messages=1)
# Provides the possibility to read the state perfectly
self.x2 = ipc.MessageQueue("/bbsim_ballspeed-{}".format(id),
max_messages=1)
self.angle = 0
self.position = 0
self.ballspeed = 0
