diff --git a/barco_telnet/barco_telnet_control.py b/barco_telnet/barco_telnet_control.py
index fbc4c5e..abe6eda 100644
--- a/barco_telnet/barco_telnet_control.py
+++ b/barco_telnet/barco_telnet_control.py
@@ -5,7 +5,7 @@ import telnetlib3
 import toml
 from socket import gethostname
 
-mainBarcoIP = '192.168.192.12'
+mainBarcoIP = 'localhost' #'192.168.192.12'
 sideBarcoIP = '192.168.192.13'
 
 # TODO all the checks and stuff
@@ -32,25 +32,25 @@ def parse_barco_response(raw: str):
 
 
 async def barco_telnet_command(client, writer, select: str):
-    onSub = f"p1/projectors/{select}/#"
+    onSub = f"p01/projectors/{select}/#"
     #print('TEST', onSub)
-    onMatch = f"p1/projectors/{select}/command/+"
+    onMatch = f"p01/projectors/{select}/command/+"
     await client.subscribe(onSub)
-    async with client.messages() as msgs:
-        async for mesg in msgs:
-            # print(mesg.topic.value)
-            # print(mesg.payload.decode())
-            # print('on', select)
+    #async with client.messages as msgs:
+    async for mesg in client.messages:
+        # print(mesg.topic.value)
+        # print(mesg.payload.decode())
+        # print('on', select)
 
-            if mesg.topic.matches(onMatch):
-                # print("test")
-                cmd = mesg.topic.value.split("/")[-1]
-                #val = '1' if mesg.payload.decode() == 'ON' else '0'
-                val = '1' if mesg.payload.decode() == 'ON' else '0' # refactor to direct 0 and 1
-                barcoCmd = f"[{cmdMap[cmd]}{val}]"
-                print("Received: [" + mesg.topic.value + "] payload: [" + mesg.payload.decode() + "]")
-                print("Sending command to Barco: " + barcoCmd)
-                writer.write(barcoCmd)
+        if mesg.topic.matches(onMatch):
+            # print("test")
+            cmd = mesg.topic.value.split("/")[-1]
+            #val = '1' if mesg.payload.decode() == 'ON' else '0'
+            val = '1' if mesg.payload.decode() == '1' else '0' # refactor to direct 0 and 1
+            barcoCmd = f"[{cmdMap[cmd]}{val}]"
+            print("Received: [" + mesg.topic.value + "] payload: [" + mesg.payload.decode() + "]")
+            print("Sending command to Barco: " + barcoCmd)
+            writer.write(barcoCmd)
             
 
 async def barco_telnet_read_status(client, reader, select: str):
@@ -62,7 +62,7 @@ async def barco_telnet_read_status(client, reader, select: str):
         if parsed == None:
             continue  #TODO alert for errors
         print(f"Updating topic [{parsed[0]}] with value [{parsed[1]}]")
-        await client.publish(f"p1/projectors/{select}/status/{parsed[0]}", payload=parsed[1])
+        await client.publish(f"p01/projectors/{select}/status/{parsed[0]}", payload=parsed[1])
 
 
 async def barco_telnet_query_status(writer, select: str):
@@ -88,17 +88,17 @@ async def main():
     #mainBarcoIP = conf[gethostname()]['projektor_glavni']
     #sideBarcoIP = conf[gethostname()]['projektor_stranski']
     mainReader, mainWriter = await telnetlib3.open_connection(mainBarcoIP, 3023)
-    sideReader, sideWriter = await telnetlib3.open_connection(sideBarcoIP, 3023)
+    #sideReader, sideWriter = await telnetlib3.open_connection(sideBarcoIP, 3023)
     async with aiomqtt.Client('localhost', 1883) as client:
         task_status_query_main = asyncio.create_task(barco_telnet_query_status(mainWriter, 'glavni'))
         task_status_reader_main = asyncio.create_task(barco_telnet_read_status(client, mainReader, 'glavni'))
         task_control_main = asyncio.create_task(barco_telnet_command(client, mainWriter, 'glavni'))
-        task_status_query_side = asyncio.create_task(barco_telnet_query_status(sideWriter, 'stranski'))
-        task_status_reader_side = asyncio.create_task(barco_telnet_read_status(client, sideReader, 'stranski'))
-        task_control_side = asyncio.create_task(barco_telnet_command(client, sideWriter, 'stranski'))
+        #task_status_query_side = asyncio.create_task(barco_telnet_query_status(sideWriter, 'stranski'))
+        #task_status_reader_side = asyncio.create_task(barco_telnet_read_status(client, sideReader, 'stranski'))
+        #task_control_side = asyncio.create_task(barco_telnet_command(client, sideWriter, 'stranski'))
 
-        await asyncio.gather(task_status_query_main, task_status_reader_main, task_control_main,
-                             task_status_query_side, task_status_reader_side, task_control_side)
+        await asyncio.gather(task_status_query_main, task_status_reader_main, task_control_main)#,
+                             #task_status_query_side, task_status_reader_side, task_control_side)
 
 
 ### fuj to, ne tk delat
diff --git a/frontend/vju_display/src/components/Platno.vue b/frontend/vju_display/src/components/Platno.vue
index a069e4b..721bd49 100644
--- a/frontend/vju_display/src/components/Platno.vue
+++ b/frontend/vju_display/src/components/Platno.vue
@@ -92,9 +92,9 @@ const platnoStatus = ref(platnoState.UNKNOWN)
       <!-- TODO lepš -->
       <h4>platna {{ props.position }}</h4>
       <button 
-        @click="publishMQTTMsg(publishPrefix + 'go', 'UP')"><UpIcon/></button>
+        @click="publishMQTTMsg(publishPrefix + 'goto', 'UP')"><UpIcon/></button>
       <button 
-      @click="publishMQTTMsg(publishPrefix + 'go', 'DOWN')"><DownIcon/></button>
+      @click="publishMQTTMsg(publishPrefix + 'goto', 'DOWN')"><DownIcon/></button>
       <div>
         <h5>Manual control</h5>
         <button 
diff --git a/tse_serial/tse_serial_controler.py b/tse_serial/tse_serial_controler.py
index 4432535..758b8df 100644
--- a/tse_serial/tse_serial_controler.py
+++ b/tse_serial/tse_serial_controler.py
@@ -5,15 +5,15 @@ import aiomqtt
 from tse_serial_interpreter import *
 from dataclasses import dataclass
 
-room = 'p1' #TODO make be do get fronm file of configuration 
+room = 'p01' #TODO make be do get fronm file of configuration 
 
-aser: aioserial.AioSerial = aioserial.AioSerial(
-    port='/dev/cu.usbserial-14240', #TODO not hardcode it
-    baudrate=1200,
-    parity=serial.PARITY_NONE,
-    bytesize=serial.EIGHTBITS,
-    stopbits=serial.STOPBITS_ONE
-    )
+# aser: aioserial.AioSerial = aioserial.AioSerial(
+#     port='/dev/cu.usbserial-14240', #TODO not hardcode it
+#     baudrate=1200,
+#     parity=serial.PARITY_NONE,
+#     bytesize=serial.EIGHTBITS,
+#     stopbits=serial.STOPBITS_ONE
+#     )
 # TODO adjust serial on actual TSE interface
 
 #TODO get this from file da ni hardcoded
@@ -44,16 +44,11 @@ shades_mapping = {
 # TODO simple reverse lookup za ko kripa pove kaj
 
 
-def parse_topic_from_mqtt(topic: str):
-    topicArr = topic.split()
-
-
-
 async def task_status2mqtt(statusClient: aiomqtt.Client):
     while True:
-        data = await aser.read_until_async()
-        data = data.decode(errors='ignore').strip()
-        print("TSE box sent: " + data)
+        #data = await aser.read_until_async()
+        #data = data.decode(errors='ignore').strip()
+        #print("TSE box sent: " + data)
         #relState = resp_to_relay_state(data)
         #command = reverse_lookup[relState.relay_id]
         #action = relState.state
@@ -70,62 +65,64 @@ async def task_status2mqtt(statusClient: aiomqtt.Client):
         await asyncio.sleep(0.01)
 
 
-async def executeAndPublish(topicVal, mqttClient, pubTopic, pubPayload, relStat):
+async def executeAndPublish(mqttClient, pubTopic, pubPayload, relStat):
     setRelayCmd = relay_state_to_cmd(relStat)
-    print("Received: [" + topicVal + "] payload: [" + pubPayload + "]")
+    #print("Received: [" + topicVal + "] payload: [" + pubPayload + "]")
     print("Sending to TSE box: " + setRelayCmd)
     print(f"Also publishing topic [{pubTopic}] with status [{pubPayload}]")
+    print()
     #await aser.write_async(bytes(setRelayCmd + '\r\n', "ascii"))
     await mqttClient.publish(pubTopic, payload=pubPayload)
 
     
-async def handleTsePower(tval, client, sysSelect, cmd):
+async def handleTsePower(client, sysSelect, cmd):
     rel = RelayState(mapping_toggles[sysSelect], cmd == '1')
-    await executeAndPublish(tval, client, f'{room}/power/{sysSelect}/status', cmd, rel)
+    await executeAndPublish(client, f'{room}/power/{sysSelect}/platno/status', cmd, rel)
 
-async def handleTseSencilo(tval, client, cmd):
+async def handleTseSencilo(client, cmd):
     #relName = tval.split('/')[3]
     topicPub = f'{room}/firanki/status'
     if cmd == "MOVE_UP":
         rel = RelayState(shades_mapping['gor'], True)
-        await executeAndPublish(tval, client, topicPub, "MOVING_UP", rel)
+        await executeAndPublish(client, topicPub, "MOVING_UP", rel)
     elif cmd == "MOVE_DOWN":
         rel = RelayState(shades_mapping['dol'], True)
-        await executeAndPublish(tval, client, topicPub, "MOVING_DOWN", rel)
+        await executeAndPublish(client, topicPub, "MOVING_DOWN", rel)
     else:
-        await executeAndPublish(tval, client, topicPub, "STATIONARY", RelayState(shades_mapping['gor'], False))
-        await executeAndPublish(tval, client, topicPub, "STATIONARY", RelayState(shades_mapping['dol'], False))        
+        await executeAndPublish(client, topicPub, "STATIONARY", RelayState(shades_mapping['gor'], False))
+        await executeAndPublish(client, topicPub, "STATIONARY", RelayState(shades_mapping['dol'], False))        
     
 
 platnoBckgdMoving = False # mucho importante variable prav zares dedoles
 
-async def platnoTimeout(topicVal, mqttClient, pubTopic, pubPayload, relStat):
+async def platnoTimeout(mqttClient, pubTopic, pubPayload, relStat: RelayState, intent):
     global platnoBckgdMoving
     await asyncio.sleep(3) #TODO time actual delay
     relStat.state = False
-    executeAndPublish(topicVal, mqttClient, pubTopic, pubPayload, relStat)
+    await executeAndPublish(mqttClient, pubTopic, intent, relStat)
     platnoBckgdMoving = False
 
-async def handleTsePlatno(tval, client, proj, cmdType, cmd):
+async def handleTsePlatno(client, proj, cmdType, cmd):
     global platnoBckgdMoving
-    topicSplit = tval.split('/') 
+    #topicSplit = tval.split('/') 
     # {room} {projectors} {[select]} {platno} {move/goto}
-    projector = topicSplit[2]
-    command = topicSplit[4]
-    pubTop = f'{room}/projectors/{projector}/status'
+    #projector = topicSplit[2]
+    #command = topicSplit[4]
+    pubTop = f'{room}/projectors/{proj}/status'
 
     if platnoBckgdMoving:
         if cmd == 'STOP':
             pubPld = 'UNKNOWN'
-            rel1 = RelayState(platno_mapping[projector]['gor'], False)
-            rel2 = RelayState(platno_mapping[projector]['dol'], False)
-            executeAndPublish(tval,client,pubTop, pubPld, rel1)
-            executeAndPublish(tval,client,pubTop, pubPld, rel2)
+            rel1 = RelayState(platno_mapping[proj]['gor'], False)
+            rel2 = RelayState(platno_mapping[proj]['dol'], False)
+            await executeAndPublish(client,pubTop, pubPld, rel1)
+            await executeAndPublish(client,pubTop, pubPld, rel2)
+            platnoBckgdMoving = False
         else:
             return # ignore any other move commands while moving
         
     #movement cmds 
-    if cmdType == 'move':
+    elif cmdType == 'move':
         rel: RelayState
         if cmd == 'UP':
             rel = RelayState(platno_mapping[proj]['gor'], True)
@@ -133,51 +130,60 @@ async def handleTsePlatno(tval, client, proj, cmdType, cmd):
             rel = RelayState(platno_mapping[proj]['dol'], True)
         else:
             return # in case of invalid input skip
-        platnoBckgdState = True
+        platnoBckgdMoving = True
         pubPld = 'MOVING'
-        executeAndPublish(tval, client, pubTop, pubPld, rel)
+        await executeAndPublish(client, pubTop, pubPld, rel)
 
     elif cmdType == 'goto':
+        # print('received GOTO')
         rel: RelayState
         if cmd == 'UP':
             rel = RelayState(platno_mapping[proj]['gor'], True)
+            intent = 'UP'
         elif cmd == 'DOWN':
             rel = RelayState(platno_mapping[proj]['dol'], True)
+            intent = 'DOWN'
         else:
             return # in case of invalid input skip
-        platnoBckgdState = True
+        platnoBckgdMoving = True
         pubPld = 'MOVING'
-        executeAndPublish(tval, client, pubTop, pubPld, rel)
-        asyncio.create_task(platnoTimeout(tval, client, pubTop, pubPld, rel))
+        await executeAndPublish(client, pubTop, pubPld, rel)
+        asyncio.create_task(platnoTimeout(client, pubTop, pubPld, rel, intent))
 
     return
 
 async def task_command2serial(controlClient: aiomqtt.Client):
+    #print('oge')
+
     await controlClient.subscribe(f"{room}/#")
-    async with controlClient.messages as msgs:
-        async for mesg in msgs:
-            mesg: aiomqtt.Message
-            topicVal = mesg.topic.value
-            msgTopic = mesg.topic.value.split('/')
-            cmnd = mesg.payload.decode()
+    #print('ogee')
+    #async with controlClient.messages as msgs:
+    async for mesg in controlClient.messages:
+        #print('oge')
 
-            if mesg.topic.matches(f'{room}/projectors/+/platno/#'):
-                proj = msgTopic[2] # glavni / stranski
-                cmdType = msgTopic[4] # move / goto
-                await handleTsePlatno(topicVal, controlClient, proj, cmdType, cmnd)
+        #mesg: aiomqtt.Message
+        topicVal = mesg.topic.value
+        msgTopic = mesg.topic.value.split('/')
+        cmnd = mesg.payload.decode()
+        #print('Received on: ', topicVal, ' with:', cmnd)
+        #print('bfr')
+        if mesg.topic.matches(f'{room}/projectors/+/platno/#'):
+            proj = msgTopic[2] # glavni / stranski
+            cmdType = msgTopic[4] # move / goto
+            await handleTsePlatno(controlClient, proj, cmdType, cmnd)
 
-            elif mesg.topic.matches(f'{room}/power/#'):
-                systype = msgTopic[2]
-                await handleTsePower(topicVal, controlClient, systype, cmnd)
+        elif mesg.topic.matches(f'{room}/power/#'):
+            systype = msgTopic[2]
+            await handleTsePower(controlClient, systype, cmnd)
 
-            elif mesg.topic.matches(f'{room}/firanki/command/#'):
-                await handleTseSencilo(topicVal, controlClient, cmnd)
+        elif mesg.topic.matches(f'{room}/firanki/command/#'):
+            await handleTseSencilo(topicVal, controlClient, cmnd)
 
-            else:
-                continue 
-                # code after if block doesnt execute in this case
-            
-            await asyncio.sleep(0.01)
+        else:
+            continue 
+            # code after if block doesnt execute in this case
+        #print("after")
+        await asyncio.sleep(0.01)
 
 
 async def main():