예제 #1
0
    def cb_initialize_plugin(self):
        self.config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = Fourier_Rect.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax * (self.max_approx + 1))

        print(['Fourier: process id: ', os.getpid()])

        self.HOST = self.config['host']['value']
        self.PORT = int(self.config['port']['value'])

        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)

        self.block1 = DBlock('Rectangle')
        for i in range(1, self.max_approx):
            self.block1.add_signal(DSignal('rect' + str(i)))

        self.pl_send_new_block_list([self.block1])

        return True
예제 #2
0
    def test_dblocks(self):
        dpl_1 = DPlugin()
        dpl_1.id = 1

        dbl_1 = DBlock('Block1')
        dbl_1.dplugin_id = dpl_1.id

        dbl_2 = DBlock('Block2')
        dbl_2.dplugin_id = dpl_1.id

        #check: add Parameter
        self.assertTrue(dpl_1.add_dblock(dbl_1))
        self.assertTrue(dpl_1.add_dblock(dbl_2))

        self.assertFalse(dpl_1.add_dblock(dbl_1))
        self.assertFalse(dpl_1.add_dblock(dbl_2))

        #Check: count of parameters

        self.assertEqual(len(dpl_1.get_dblocks().keys()), 2)

        #Check: rm parameter

        self.assertTrue(dpl_1.rm_dblock(dbl_1))
        self.assertEqual(len(dpl_1.get_dblocks().keys()), 1)
        self.assertTrue(dpl_1.rm_dblock(dbl_2))
        self.assertEqual(len(dpl_1.get_dblocks().keys()), 0)
예제 #3
0
    def cb_initialize_plugin(self):
        self.t = 0
        self.amax = Fourier_Rect_MOD.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect_MOD.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax * (self.max_approx + 1))

        print(['Fourier: process id: ', os.getpid()])

        self.HOST = "130.149.155.73"
        self.PORT = 9999
        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)

        self.block1 = DBlock('Rectangle')
        for i in range(1, self.max_approx):
            self.block1.add_signal(DSignal('rect' + str(i)))

        self.pl_send_new_block_list([self.block1])

        self.pl_set_event_trigger_mode(True)

        self.goOn = True

        self.thread = threading.Thread(target=self.thread_execute,
                                       args=(self.HOST, self.PORT))
        self.thread.start()

        return True
예제 #4
0
파일: Trigger.py 프로젝트: dani-l/PaPI
    def cb_initialize_plugin(self):



        self.block1 = DBlock('Progress')
        signal = DSignal('percent')
        self.block1.add_signal(signal)

        self.block2 = DBlock('Trigger')
        signal = DSignal('trigger')
        self.block2.add_signal(signal)

        self.block3 = DBlock('ResetTrigger')
        signal = DSignal('reset')
        self.block3.add_signal(signal)

        self.block4 = DBlock('ParaToSig')
        signal = DSignal('parameter')
        self.block4.add_signal(signal)

        blockList = [self.block1, self.block2, self.block3, self.block4]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Choose', default=0, Regex='\d+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        self.pl_set_event_trigger_mode(True)

        self.initialized = True

        return True
예제 #5
0
    def test_remove_signal(self):
        dblock = DBlock('SinMit_f1')
        ds_1 = DSignal(CORE_TIME_SIGNAL)
        dblock.add_signal(ds_1)

        subscription = DSubscription(dblock)
        subscription.add_signal(ds_1)
        self.assertTrue(subscription.rm_signal(ds_1))

        self.assertNotIn(ds_1, subscription.get_signals())

        self.assertTrue(subscription.add_signal(ds_1))
예제 #6
0
    def test_pl_send_new_block_list(self):
        self.assertRaises(pe.WrongType, self.basePlugin.pl_send_new_block_list,
                          None)
        self.assertRaises(pe.WrongLength,
                          self.basePlugin.pl_send_new_block_list, [])

        blocks = [DBlock('1'), 1, DBlock('3')]
        self.assertRaises(pe.WrongType, self.basePlugin.pl_send_new_block_list,
                          blocks)

        blocks = [DBlock('1'), DBlock('2'), DBlock('3')]
        self.assertRaises(AttributeError,
                          self.basePlugin.pl_send_new_block_list, blocks)
예제 #7
0
    def cb_initialize_plugin(self):

        self.block1 = DBlock('Progress')
        signal = DSignal('percent')
        self.block1.add_signal(signal)

        self.block2 = DBlock('Trigger')
        signal = DSignal('trigger')
        self.block2.add_signal(signal)

        self.block3 = DBlock('ResetTrigger')
        signal = DSignal('reset')
        self.block3.add_signal(signal)

        self.block4 = DBlock('ParaToSig')
        signal = DSignal('parameter')
        self.block4.add_signal(signal)

        blockList = [self.block1, self.block2, self.block3, self.block4]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Choose', default=0, Regex='\d+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        self.pl_set_event_trigger_mode(True)

        self.initialized = True

        return True
예제 #8
0
    def test_unsubscribe_all(self):
        #Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_3 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        #Create dblocks
        d_bl_1 = DBlock('Block_1')
        d_bl_2 = DBlock('Block_2')

        #assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name))

        print(d_bl_1.get_subscribers())

        self.assertEqual(len(d_pl_2.get_subscribtions()[d_pl_1.id].keys()), 2)

        self.dcore.unsubscribe_all(d_pl_2.id)

        self.assertNotIn(d_pl_1.id, d_pl_2.get_subscribtions())

        print(d_bl_1.get_subscribers())
        self.assertTrue(len(d_bl_1.get_subscribers())==1)
        self.assertTrue(len(d_bl_2.get_subscribers())==0)

        pass
예제 #9
0
    def test_rm_dplugin(self):
        #Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        #Create dblocks
        d_bl_1 = DBlock('Block_1')
        d_bl_2 = DBlock('Block_2')

        #assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        #create subscribtions

        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name)

        self.assertEqual(len(d_pl_2.get_subscribtions()[d_pl_1.id]), 2)
        self.assertEqual(len(d_bl_1.get_subscribers()), 1)
        self.assertEqual(len(d_bl_2.get_subscribers()), 1)

        self.dcore.rm_dplugin(d_pl_1.id)

        #Check if DPlugin d_pl_1 is missing

        self.assertFalse(self.dcore.get_dplugin_by_id(d_pl_1.id))

        #Check if all subscribtions were canceled

        self.assertEqual(len(d_pl_2.get_subscribtions().keys()), 0)
        self.assertEqual(len(d_bl_1.get_subscribers()), 0)
        self.assertEqual(len(d_bl_2.get_subscribers()), 0)

        pass
예제 #10
0
    def test_add_susbcribers(self):

        dbl = DBlock('DBlock1')
        dbl.id = 1

        dpl_1 = DPlugin()
        dpl_1.id = 2
        dpl_2 = DPlugin()
        dpl_2.id = 3

        self.assertTrue(dbl.add_subscribers(dpl_1))
        self.assertTrue(dbl.add_subscribers(dpl_2))

        self.assertEqual(len(dbl.get_subscribers()), 2)
예제 #11
0
    def test_attach_signal(self):
        dblock = DBlock('SinMit_f1')
        ds_1 = DSignal(CORE_TIME_SIGNAL)
        ds_2 = DSignal('f1_1')
        dblock.add_signal(ds_1)
        dblock.add_signal(ds_2)

        subscription = DSubscription(dblock)

        self.assertTrue(subscription.add_signal(ds_1))

        self.assertIn(ds_1, subscription.get_signals())

        self.assertFalse(subscription.add_signal(ds_1))
예제 #12
0
    def test_add_susbcribers(self):

        dbl = DBlock('DBlock1')
        dbl.id = 1

        dpl_1 = DPlugin()
        dpl_1.id = 2
        dpl_2 = DPlugin()
        dpl_2.id = 3

        self.assertTrue(dbl.add_subscribers(dpl_1))
        self.assertTrue(dbl.add_subscribers(dpl_2))

        self.assertEqual(len(dbl.get_subscribers()),2)
예제 #13
0
파일: TestDPlugin.py 프로젝트: dlaidig/PaPI
    def test_subscribtions(self):
        dpl_1 = DPlugin()
        dpl_1.id = 1
        dpl_2 = DPlugin()
        dpl_2.id = 2

        dbl_1 = DBlock('DBlock1')
        dbl_1.id = 3
        dbl_1.dplugin_id = dpl_2.id

        dbl_2 = DBlock('DBlock2')
        dbl_2.id = 4
        dbl_2.dplugin_id = dpl_2.id

        dpl_2.add_dblock(dbl_1)
        dpl_2.add_dblock(dbl_2)

        #Check: subscribe DBlocks
        self.assertTrue(dpl_1.subscribe(dbl_1))
        self.assertTrue(dpl_1.subscribe(dbl_2))

        self.assertFalse(dpl_1.subscribe(dbl_1))
        self.assertFalse(dpl_1.subscribe(dbl_2))

        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions()[dpl_2.id].keys()), 2)

        #Check: unsubscribe DBlock
        self.assertTrue(dpl_1.unsubscribe(dbl_1))

        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions().keys()), 1)
        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions()[dpl_2.id].keys()), 1)
예제 #14
0
    def test_rm_all_subscribers(self):
        #Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_3 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        #Create dblocks
        d_bl_1 = DBlock('Block_1')
        d_bl_2 = DBlock('Block_2')

        #assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name))
        self.assertTrue(self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_2.name))

        self.assertEqual(len(d_bl_1.get_subscribers()), 2)
        self.assertEqual(len(d_bl_2.get_subscribers()), 2)

        self.dcore.rm_all_subscribers(d_pl_1.id)

        self.assertEqual(len(d_bl_1.get_subscribers()), 0)
        self.assertEqual(len(d_bl_2.get_subscribers()), 0)

        pass
예제 #15
0
파일: Add.py 프로젝트: dlaidig/PaPI
    def cb_initialize_plugin(self):
        self.t = 0
        #print(['ADD: process id: ',os.getpid()] )
        self.approx_max = 300
        self.fac = 1
        self.amax = 20
        self.approx = self.approx_max * self.fac

        self.block1 = DBlock('AddOut1')
        signal = DSignal('Sum')
        self.block1.add_signal(signal)

        self.pl_send_new_block_list([self.block1])

        return True
예제 #16
0
    def cb_initialize_plugin(self):
        self.t = 0
        self.amax = Fourier_Rect_MOD.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect_MOD.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax* ( self.max_approx + 1) )

        print(['Fourier: process id: ',os.getpid()] )


        self.HOST = "130.149.155.73"
        self.PORT = 9999
        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)


        self.block1 = DBlock('Rectangle')
        for i in range(1,self.max_approx):
            self.block1.add_signal(DSignal('rect'+str(i)))

        self.pl_send_new_block_list([self.block1])

        self.pl_set_event_trigger_mode(True)

        self.goOn = True

        self.thread = threading.Thread(target=self.thread_execute, args=(self.HOST,self.PORT) )
        self.thread.start()



        return True
예제 #17
0
 def test_delete_block(self):
     self.assertRaises(pe.WrongType, self.basePlugin.pl_send_delete_block,
                       None)
     self.assertRaises(AttributeError, self.basePlugin.pl_send_delete_block,
                       'DBlock')
     self.assertRaises(AttributeError, self.basePlugin.pl_send_delete_block,
                       DBlock('DBlock'))
예제 #18
0
    def config_loader_subs(self, pl_to_start, subs_to_make,
                           parameters_to_change, signals_to_change):
        """
        Function for callback when timer finished to apply
            subscriptions and parameter changed of config.

        :param pl_to_start: list of plugins to start
        :type pl_to_start: list
        :param subs_to_make:  list of subscriptions to make
        :type subs_to_make: list
        :param parameters_to_change: parameter changes to apply
        :type parameters_to_change: list
        :param signals_to_change: signal name changes to apply
        :type signals_to_change: list
        :return:
        """

        for sub in subs_to_make:
            self.do_subscribe_uname(sub[0], sub[1], sub[2], sub[3], sub[4])

        for para in parameters_to_change:
            self.do_set_parameter_uname(para[0], para[1], para[2])

        for sig in signals_to_change:
            plugin_uname = sig[0]
            dblock_name = sig[1]
            dsignal_uname = sig[2]
            dsignal_dname = sig[3]

            self.do_edit_plugin_uname(
                plugin_uname, DBlock(dblock_name),
                {'edit': DSignal(dsignal_uname, dsignal_dname)})
예제 #19
0
    def update_block_list(self, ORTDSources):
        #self.block_id = self.block_id +1
        #newBlock = DBlock('SourceGroup'+str(self.block_id))
        #self.blocks['SourceGroup'+str(self.block_id)] = newBlock
        if 'SourceGroup0' in self.blocks:
            self.pl_send_delete_block('SourceGroup0')
        newBlock = DBlock('SourceGroup0')
        self.blocks['SourceGroup0'] = newBlock
        self.Sources = ORTDSources
        keys = list(self.Sources.keys())
        for key in keys:
            Source = self.Sources[key]
            sig_name = Source['SourceName']
            newBlock.add_signal(DSignal(sig_name))

        self.pl_send_new_block_list([newBlock])
예제 #20
0
파일: Fourier_Rect.py 프로젝트: dani-l/PaPI
    def cb_initialize_plugin(self):
        self.config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = Fourier_Rect.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax* ( self.max_approx + 1) )


        print(['Fourier: process id: ',os.getpid()] )


        self.HOST = self.config['host']['value']
        self.PORT = int( self.config['port']['value'] )

        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)


        self.block1 = DBlock('Rectangle')
        for i in range(1,self.max_approx):
            self.block1.add_signal(DSignal('rect'+str(i)))

        self.pl_send_new_block_list([self.block1])

        return True
예제 #21
0
파일: UDP_Plugin.py 프로젝트: dani-l/PaPI
    def update_block_list(self,ORTDSources):
        #self.block_id = self.block_id +1
        #newBlock = DBlock('SourceGroup'+str(self.block_id))
        #self.blocks['SourceGroup'+str(self.block_id)] = newBlock
        if 'SourceGroup0' in self.blocks:
            self.pl_send_delete_block('SourceGroup0')
        newBlock = DBlock('SourceGroup0')
        self.blocks['SourceGroup0'] = newBlock
        self.Sources = ORTDSources
        keys = list(self.Sources.keys())
        for key in keys:
            Source = self.Sources[key]
            sig_name = Source['SourceName']
            newBlock.add_signal(DSignal(sig_name))

        self.pl_send_new_block_list([newBlock])
예제 #22
0
파일: TestDCore.py 프로젝트: dani-l/PaPI
    def test_subscribe(self):
        # Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        # Create dblocks
        d_bl_1 = DBlock("Block_1")
        d_bl_2 = DBlock("Block_2")

        # assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name))

        self.assertTrue(d_pl_2.id in d_bl_1.get_subscribers())
        self.assertTrue(d_pl_2.id in d_bl_2.get_subscribers())
예제 #23
0
    def test_subscribe_signals(self):
        #Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_3 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        #Create dblocks
        d_bl_1 = DBlock('Block1')
        d_bl_2 = DBlock('Block2')

        #assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name)
        self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_2.name)


        self.assertTrue(self.dcore.subscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_1.name, [1, 2, 3]))

        self.assertTrue(self.dcore.subscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_2.name, [6, 4, 5]))

        self.assertTrue(self.dcore.subscribe_signals(d_pl_3.id, d_pl_1.id, d_bl_1.name, [9]))

        self.assertTrue(self.dcore.subscribe_signals(d_pl_3.id, d_pl_1.id, d_bl_2.name, [17,19,18]))


        subscription = d_pl_2.get_subscribtions()[d_pl_1.id][d_bl_1.name]

        self.assertIn(1, subscription.get_signals())
        self.assertIn(2, subscription.get_signals())
        self.assertIn(3, subscription.get_signals())

        subscription = d_pl_3.get_subscribtions()[d_pl_1.id][d_bl_2.name]

        self.assertIn(19, subscription.get_signals())
        self.assertIn(17, subscription.get_signals())
        self.assertIn(18, subscription.get_signals())

        subscription = d_pl_3.get_subscribtions()[d_pl_1.id][d_bl_1.name]

        self.assertIn(9, subscription.get_signals())
예제 #24
0
파일: TestDCore.py 프로젝트: dani-l/PaPI
    def test_rm_dplugin(self):
        # Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        # Create dblocks
        d_bl_1 = DBlock("Block_1")
        d_bl_2 = DBlock("Block_2")

        # assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        # create subscribtions

        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name)

        self.assertEqual(len(d_pl_2.get_subscribtions()[d_pl_1.id]), 2)
        self.assertEqual(len(d_bl_1.get_subscribers()), 1)
        self.assertEqual(len(d_bl_2.get_subscribers()), 1)

        self.dcore.rm_dplugin(d_pl_1.id)

        # Check if DPlugin d_pl_1 is missing

        self.assertFalse(self.dcore.get_dplugin_by_id(d_pl_1.id))

        # Check if all subscribtions were canceled

        self.assertEqual(len(d_pl_2.get_subscribtions().keys()), 0)
        self.assertEqual(len(d_bl_1.get_subscribers()), 0)
        self.assertEqual(len(d_bl_2.get_subscribers()), 0)

        pass
예제 #25
0
파일: TestDCore.py 프로젝트: dani-l/PaPI
    def test_unsubscribe_all(self):
        # Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_3 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        # Create dblocks
        d_bl_1 = DBlock("Block_1")
        d_bl_2 = DBlock("Block_2")

        # assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_1.name))
        self.assertTrue(self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name))

        print(d_bl_1.get_subscribers())

        self.assertEqual(len(d_pl_2.get_subscribtions()[d_pl_1.id].keys()), 2)

        self.dcore.unsubscribe_all(d_pl_2.id)

        self.assertNotIn(d_pl_1.id, d_pl_2.get_subscribtions())

        print(d_bl_1.get_subscribers())
        self.assertTrue(len(d_bl_1.get_subscribers()) == 1)
        self.assertTrue(len(d_bl_2.get_subscribers()) == 0)

        pass
예제 #26
0
    def test_subscribtions(self):
        dpl_1 = DPlugin()
        dpl_1.id = 1
        dpl_2 = DPlugin()
        dpl_2.id = 2

        dbl_1 = DBlock('DBlock1')
        dbl_1.id = 3
        dbl_1.dplugin_id = dpl_2.id

        dbl_2 = DBlock('DBlock2')
        dbl_2.id = 4
        dbl_2.dplugin_id = dpl_2.id

        dpl_2.add_dblock(dbl_1)
        dpl_2.add_dblock(dbl_2)

        #Check: subscribe DBlocks
        self.assertTrue(dpl_1.subscribe(dbl_1))
        self.assertTrue(dpl_1.subscribe(dbl_2))

        self.assertFalse(dpl_1.subscribe(dbl_1))
        self.assertFalse(dpl_1.subscribe(dbl_2))

        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions()[dpl_2.id].keys()), 2)

        #Check: unsubscribe DBlock
        self.assertTrue(dpl_1.unsubscribe(dbl_1))

        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions().keys()), 1)
        #Check: count of subscribtions
        self.assertEqual(len(dpl_1.get_subscribtions()[dpl_2.id].keys()), 1)
예제 #27
0
파일: TestDPlugin.py 프로젝트: dlaidig/PaPI
    def test_dblocks(self):
        dpl_1 = DPlugin()
        dpl_1.id = 1

        dbl_1 = DBlock('Block1')
        dbl_1.dplugin_id = dpl_1.id

        dbl_2 = DBlock('Block2')
        dbl_2.dplugin_id = dpl_1.id

        #check: add Parameter
        self.assertTrue(dpl_1.add_dblock(dbl_1))
        self.assertTrue(dpl_1.add_dblock(dbl_2))

        self.assertFalse(dpl_1.add_dblock(dbl_1))
        self.assertFalse(dpl_1.add_dblock(dbl_2))

        #Check: count of parameters

        self.assertEqual(len(dpl_1.get_dblocks().keys()), 2)

        #Check: rm parameter

        self.assertTrue(dpl_1.rm_dblock(dbl_1))
        self.assertEqual(len(dpl_1.get_dblocks().keys()), 1)
        self.assertTrue(dpl_1.rm_dblock(dbl_2))
        self.assertEqual(len(dpl_1.get_dblocks().keys()), 0)
예제 #28
0
파일: base_plugin.py 프로젝트: dlaidig/PaPI
    def pl_create_DBlock(self, block_name):
        """
        Creates a DBlock for use in a PaPI Plugin.

        :param block_name: Name of the block
        :type block_name: str
        :return: DBlock Object or None in case of error
        """
        if isinstance(block_name, str):
            block = DBlock(name=block_name)
            return block
        else:
            return None
예제 #29
0
    def test_parameterChanges(self):

        self.assertRaises(pe.WrongType, self.basePlugin.pl_emit_event, None,
                          None)
        self.assertRaises(AttributeError,
                          self.basePlugin._send_parameter_change, None,
                          "DBlock")
        self.assertRaises(AttributeError, self.basePlugin.pl_emit_event, None,
                          "DEvent")
        self.assertRaises(AttributeError,
                          self.basePlugin._send_parameter_change, None,
                          DBlock("Block"))
        self.assertRaises(AttributeError, self.basePlugin.pl_emit_event, None,
                          DEvent("Event"))
예제 #30
0
파일: TestDCore.py 프로젝트: dani-l/PaPI
    def test_unsubscribe_signals(self):
        # Create dplugins
        d_pl_1 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_2 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())
        d_pl_3 = self.dcore.add_plugin(None, 1, None, None, None, self.dcore.create_id())

        # Create dblocks
        d_bl_1 = DBlock("Block1")
        d_bl_2 = DBlock("Block2")

        # assign dblocks to DPlugin d_pl_1
        d_pl_1.add_dblock(d_bl_1)
        d_pl_1.add_dblock(d_bl_2)

        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_2.id, d_pl_1.id, d_bl_2.name)
        self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_1.name)
        self.dcore.subscribe(d_pl_3.id, d_pl_1.id, d_bl_2.name)

        self.dcore.subscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_1.name, [1, 2, 3])
        self.dcore.subscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_2.name, [6, 4, 5])
        self.dcore.subscribe_signals(d_pl_3.id, d_pl_1.id, d_bl_1.name, [9])
        self.dcore.subscribe_signals(d_pl_3.id, d_pl_1.id, d_bl_2.name, [17, 19, 18])

        self.assertTrue(self.dcore.unsubscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_1.name, [1, 2]))

        subscription = d_pl_2.get_subscribtions()[d_pl_1.id][d_bl_1.name]

        self.assertNotIn(1, subscription.get_signals())
        self.assertNotIn(2, subscription.get_signals())
        self.assertIn(3, subscription.get_signals())

        self.assertEqual(len(d_bl_1.get_subscribers()), 2)

        self.assertTrue(self.dcore.unsubscribe_signals(d_pl_2.id, d_pl_1.id, d_bl_1.name, [3]))

        self.assertEqual(len(d_bl_1.get_subscribers()), 1)
예제 #31
0
파일: Add.py 프로젝트: dani-l/PaPI
    def cb_initialize_plugin(self):
        self.t = 0
        #print(['ADD: process id: ',os.getpid()] )
        self.approx_max = 300
        self.fac= 1
        self.amax = 20
        self.approx = self.approx_max*self.fac


        self.block1 = DBlock('AddOut1')
        signal = DSignal('Sum')
        self.block1.add_signal(signal)


        self.pl_send_new_block_list([self.block1])


        return True
예제 #32
0
파일: Console.py 프로젝트: dlaidig/PaPI
    def cb_initialize_plugin(self):

        # ---------------------------
        # Read configuration
        # ---------------------------

        # --------------------------------
        # Create Widget
        # --------------------------------
        self.ConsoleW = PaPIConsoleWidget(plugin=self)

        # This call is important, because the background structure needs to know the used widget!
        # In the background the qmidiwindow will becreated and the widget will be added
        self.pl_set_widget_for_internal_usage(self.ConsoleW)

        self.ConsoleW.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ConsoleW.customContextMenuRequested.connect(
            self.show_context_menu)

        block = DBlock('Command')

        self.pl_send_new_block_list([block])

        return True
예제 #33
0
    def cb_initialize_plugin(self):
        config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = int(config['amax']['value'])
        self.f = float(config['f']['value'])


        self.block1 = DBlock('SinMit_f1')
        signal = DSignal('f1_1')
        signal.dname = 'f1_f1DNAME'
        self.block1.add_signal(signal)

        self.block2 = DBlock('SinMit_f2')
        signal = DSignal('f2_1')
        self.block2.add_signal(signal)

        self.block3 = DBlock('SinMit_f3')
        signal = DSignal('f3_1')
        self.block3.add_signal(signal)
        signal = DSignal('f3_2')
        self.block3.add_signal(signal)
        signal = DSignal('f3_scalar')
        self.block3.add_signal(signal)


        #self.block4 = self.create_new_block('Sin4', [CORE_TIME_SIGNAL,'f3_1','f3_2', 'Scalar'], [ 'numpy_vec', 'numpy_vec', 'numpy_vec', 'int'], 100 )

        blockList = [self.block1, self.block2, self.block3]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Frequenz Block SinMit_f3', default= 0.3, Regex='[0-9]+.[0-9]+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        print('Sinus started working')

        return True
예제 #34
0
파일: Trigger.py 프로젝트: dani-l/PaPI
class Trigger(dpp_base):
    def __init__(self):
        self.initialized = False

    def cb_initialize_plugin(self):



        self.block1 = DBlock('Progress')
        signal = DSignal('percent')
        self.block1.add_signal(signal)

        self.block2 = DBlock('Trigger')
        signal = DSignal('trigger')
        self.block2.add_signal(signal)

        self.block3 = DBlock('ResetTrigger')
        signal = DSignal('reset')
        self.block3.add_signal(signal)

        self.block4 = DBlock('ParaToSig')
        signal = DSignal('parameter')
        self.block4.add_signal(signal)

        blockList = [self.block1, self.block2, self.block3, self.block4]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Choose', default=0, Regex='\d+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        self.pl_set_event_trigger_mode(True)

        self.initialized = True

        return True

    def cb_pause(self):
        pass

    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        pass

    def cb_set_parameter(self, name, value):
        if not self.initialized:
            return
        value = int(float(value))
        if name == self.para3.name:
            if value == 0:
                self.pl_send_new_data('Progress', [0], {'percent': [20]})

            if value == 1:
                self.pl_send_new_data('Trigger', [0], {'trigger': [0]})

            if value == 2:
                self.pl_send_new_data('ResetTrigger', [0], {'reset': [0]})

            if value > 3:
                self.pl_send_new_data('ParaToSig', [0], {'parameter': [value]})


    def cb_get_plugin_configuration(self):
        config = {
        }
        return config

    def cb_quit(self):
        print('Trigger: will quit')

    def cb_plugin_meta_updated(self):
        pass
예제 #35
0
파일: Add.py 프로젝트: dani-l/PaPI
class Add(dpp_base):

    def cb_initialize_plugin(self):
        self.t = 0
        #print(['ADD: process id: ',os.getpid()] )
        self.approx_max = 300
        self.fac= 1
        self.amax = 20
        self.approx = self.approx_max*self.fac


        self.block1 = DBlock('AddOut1')
        signal = DSignal('Sum')
        self.block1.add_signal(signal)


        self.pl_send_new_block_list([self.block1])


        return True

    def cb_pause(self):
        pass


    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        #self.approx = round(self.approx_max*self.para1.value)
#        self.vec[1] = 0
#        self.vec[0] = Data[0]

#        vec = numpy.zeros( (1, 2) )

        #for i in range(self.amax):
            #for k in range(1,self.approx):
               # self.vec[i+self.amax] += Data[i + (k+1)*self.amax]
                #self.vec[1, i] = Data[k, i]

        # Get Time Vector

#        vec[0, :] = Data[CORE_TIME_SIGNAL]

        # n_rows = Data.shape[0]
        # n_cols = Data.shape[1]

        first_element = True

        for signal_name in Data:
            if signal_name is not CORE_TIME_SIGNAL:
                signal = Data[signal_name]

                if first_element is True:
                    first_element = False

                    result = signal
                else:
                    result = numpy.add(result, signal)


        self.pl_send_new_data('AddOut1', Data[CORE_TIME_SIGNAL], {'Sum':result})



    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        print('Add: will quit')

    def cb_plugin_meta_updated(self):
        pass

    def cb_get_plugin_configuration(self):
        return {}
예제 #36
0
class Fourier_Rect_MOD(iop_base):
    max_approx = 20
    amax = 20

    def cb_initialize_plugin(self):
        self.t = 0
        self.amax = Fourier_Rect_MOD.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect_MOD.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax * (self.max_approx + 1))

        print(['Fourier: process id: ', os.getpid()])

        self.HOST = "130.149.155.73"
        self.PORT = 9999
        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)

        self.block1 = DBlock('Rectangle')
        for i in range(1, self.max_approx):
            self.block1.add_signal(DSignal('rect' + str(i)))

        self.pl_send_new_block_list([self.block1])

        self.pl_set_event_trigger_mode(True)

        self.goOn = True

        self.thread = threading.Thread(target=self.thread_execute,
                                       args=(self.HOST, self.PORT))
        self.thread.start()

        return True

    def cb_pause(self):
        self.goOn = False
        self.thread.join()

    def cb_resume(self):
        self.goOn = True
        self.thread = threading.Thread(target=self.thread_execute,
                                       args=(self.HOST, self.PORT))
        self.thread.start()

    def thread_execute(self, host, port):
        #self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        #self.sock.setblocking(0)
        vec = numpy.zeros((self.max_approx, (self.amax)))

        while self.goOn:
            self.sock.sendto(b'GET', (self.HOST, self.PORT))

            try:
                received = self.sock.recv(60000)
            except socket.error:
                pass
            else:
                data = pickle.loads(received)

                vech = {}
                t = data[0 * self.amax:(0 + 1) * self.amax]

                for i in range(self.max_approx):
                    vech['rect' + str(i)] = data[i * self.amax:(i + 1) *
                                                 self.amax]

                self.pl_send_new_data('Rectangle', t, vech)

            time.sleep(0.001 * self.amax)

    def cb_execute(self, Data=None, block_name=None, plugin_uname=None):
        print("EXECUTE FUNC")
        pass

    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        self.goOn = False
        self.thread.join()

    def cb_plugin_meta_updated(self):
        pass

    def cb_get_plugin_configuration(self):
        return {}
예제 #37
0
class Fourier_Rect(iop_base):
    max_approx = 20
    amax = 20

    def cb_initialize_plugin(self):
        self.config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = Fourier_Rect.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax * (self.max_approx + 1))

        print(['Fourier: process id: ', os.getpid()])

        self.HOST = self.config['host']['value']
        self.PORT = int(self.config['port']['value'])

        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)

        self.block1 = DBlock('Rectangle')
        for i in range(1, self.max_approx):
            self.block1.add_signal(DSignal('rect' + str(i)))

        self.pl_send_new_block_list([self.block1])

        return True

    def cb_pause(self):
        pass

    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name=None, plugin_uname=None):
        # amount of elements per vector: self.amax
        # amount of vectors : self.max_approx+1
        vec = numpy.zeros((self.max_approx, (self.amax)))

        #        print("Amax: " + str(self.amax+1))
        #        print("Max_Approx"  + str(self.max_approx))

        # As you can see, there is no connect() call; UDP has no connections.
        # Instead, data is directly sent to the recipient via sendto().
        self.sock.sendto(b'GET', (self.HOST, self.PORT))

        try:
            received = self.sock.recv(60000)
        except socket.error:
            pass
        else:
            data = pickle.loads(received)

            vech = {}
            t = data[0 * self.amax:(0 + 1) * self.amax]

            for i in range(self.max_approx):
                vech['rect' + str(i)] = data[i * self.amax:(i + 1) * self.amax]

            self.pl_send_new_data('Rectangle', t, vech)

        time.sleep(0.001 * self.amax)

    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        print('Fourier_Rect: will quit')

    def cb_get_plugin_configuration(self):
        config = {
            'name': {
                'value': 'Fourier'
            },
            'host': {
                'value': "130.149.155.73",
                'regex': '\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}',
                'advanced': '1'
            },
            'port': {
                'value': 9999,
                'regex': '\d{1,5}',
                'advanced': '1'
            }
        }
        return config

    def cb_plugin_meta_updated(self):
        pass
예제 #38
0
파일: Fourier_Rect.py 프로젝트: dani-l/PaPI
class Fourier_Rect(iop_base):
    max_approx = 20
    amax = 20


    def cb_initialize_plugin(self):
        self.config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = Fourier_Rect.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax* ( self.max_approx + 1) )


        print(['Fourier: process id: ',os.getpid()] )


        self.HOST = self.config['host']['value']
        self.PORT = int( self.config['port']['value'] )

        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)


        self.block1 = DBlock('Rectangle')
        for i in range(1,self.max_approx):
            self.block1.add_signal(DSignal('rect'+str(i)))

        self.pl_send_new_block_list([self.block1])

        return True

    def cb_pause(self):
        pass

    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        # amount of elements per vector: self.amax
        # amount of vectors : self.max_approx+1
        vec = numpy.zeros( (self.max_approx,  (self.amax) ))

#        print("Amax: " + str(self.amax+1))
#        print("Max_Approx"  + str(self.max_approx))

        # As you can see, there is no connect() call; UDP has no connections.
        # Instead, data is directly sent to the recipient via sendto().
        self.sock.sendto(b'GET', (self.HOST, self.PORT) )


        try:
            received = self.sock.recv(60000)
        except socket.error:
            pass
        else:
            data = pickle.loads(received)

            vech = {}
            t = data[0*self.amax:(0+1)*self.amax]

            for i in range(self.max_approx):
                vech['rect'+str(i)] = data[i*self.amax:(i+1)*self.amax]

            self.pl_send_new_data('Rectangle', t, vech)

        time.sleep(0.001*self.amax )

    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        print('Fourier_Rect: will quit')

    def cb_get_plugin_configuration(self):
        config = {
            'name': {
                    'value': 'Fourier'
                    },
            'host': {
                     'value': "130.149.155.73",
                     'regex': '\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}',
                     'advanced' : '1'
            },
            'port': {
                    'value': 9999,
                    'regex': '\d{1,5}',
                     'advanced' : '1'
            }}
        return config

    def cb_plugin_meta_updated(self):
        pass
예제 #39
0
    def test_rm_subscribers(self):
        dbl = DBlock('DBlock1')
        dbl.id = 1

        dpl_1 = DPlugin()
        dpl_1.id = 2
        dpl_2 = DPlugin()
        dpl_2.id = 3

        dbl.add_subscribers(dpl_1)
        dbl.add_subscribers(dpl_2)

        self.assertEqual(len(dbl.get_subscribers()),2)

        dbl.rm_subscriber(dpl_1)

        self.assertEqual(len(dbl.get_subscribers()),1)

        dbl.rm_subscriber(dpl_2)

        self.assertEqual(len(dbl.get_subscribers()),0)

        self.assertFalse(dbl.rm_subscriber(dpl_1))
예제 #40
0
class Trigger(dpp_base):
    def __init__(self):
        self.initialized = False

    def cb_initialize_plugin(self):

        self.block1 = DBlock('Progress')
        signal = DSignal('percent')
        self.block1.add_signal(signal)

        self.block2 = DBlock('Trigger')
        signal = DSignal('trigger')
        self.block2.add_signal(signal)

        self.block3 = DBlock('ResetTrigger')
        signal = DSignal('reset')
        self.block3.add_signal(signal)

        self.block4 = DBlock('ParaToSig')
        signal = DSignal('parameter')
        self.block4.add_signal(signal)

        blockList = [self.block1, self.block2, self.block3, self.block4]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Choose', default=0, Regex='\d+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        self.pl_set_event_trigger_mode(True)

        self.initialized = True

        return True

    def cb_pause(self):
        pass

    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name=None, plugin_uname=None):
        pass

    def cb_set_parameter(self, name, value):
        if not self.initialized:
            return
        value = int(float(value))
        if name == self.para3.name:
            if value == 0:
                self.pl_send_new_data('Progress', [0], {'percent': [20]})

            if value == 1:
                self.pl_send_new_data('Trigger', [0], {'trigger': [0]})

            if value == 2:
                self.pl_send_new_data('ResetTrigger', [0], {'reset': [0]})

            if value > 3:
                self.pl_send_new_data('ParaToSig', [0], {'parameter': [value]})

    def cb_get_plugin_configuration(self):
        config = {}
        return config

    def cb_quit(self):
        print('Trigger: will quit')

    def cb_plugin_meta_updated(self):
        pass
예제 #41
0
    def test_rm_subscribers(self):
        dbl = DBlock('DBlock1')
        dbl.id = 1

        dpl_1 = DPlugin()
        dpl_1.id = 2
        dpl_2 = DPlugin()
        dpl_2.id = 3

        dbl.add_subscribers(dpl_1)
        dbl.add_subscribers(dpl_2)

        self.assertEqual(len(dbl.get_subscribers()), 2)

        dbl.rm_subscriber(dpl_1)

        self.assertEqual(len(dbl.get_subscribers()), 1)

        dbl.rm_subscriber(dpl_2)

        self.assertEqual(len(dbl.get_subscribers()), 0)

        self.assertFalse(dbl.rm_subscriber(dpl_1))
예제 #42
0
class Sinus(iop_base):

    def cb_initialize_plugin(self):
        config = self.pl_get_current_config_ref()

        self.t = 0
        self.amax = int(config['amax']['value'])
        self.f = float(config['f']['value'])


        self.block1 = DBlock('SinMit_f1')
        signal = DSignal('f1_1')
        signal.dname = 'f1_f1DNAME'
        self.block1.add_signal(signal)

        self.block2 = DBlock('SinMit_f2')
        signal = DSignal('f2_1')
        self.block2.add_signal(signal)

        self.block3 = DBlock('SinMit_f3')
        signal = DSignal('f3_1')
        self.block3.add_signal(signal)
        signal = DSignal('f3_2')
        self.block3.add_signal(signal)
        signal = DSignal('f3_scalar')
        self.block3.add_signal(signal)


        #self.block4 = self.create_new_block('Sin4', [CORE_TIME_SIGNAL,'f3_1','f3_2', 'Scalar'], [ 'numpy_vec', 'numpy_vec', 'numpy_vec', 'int'], 100 )

        blockList = [self.block1, self.block2, self.block3]
        self.pl_send_new_block_list(blockList)

        self.para3 = DParameter('Frequenz Block SinMit_f3', default= 0.3, Regex='[0-9]+.[0-9]+')
        para_l = [self.para3]

        self.pl_send_new_parameter_list(para_l)

        print('Sinus started working')

        return True

    def cb_pause(self):
        print('Sinus pause')
        pass

    def cb_resume(self):
        print('Sinus resume')
        pass

    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        vec = numpy.zeros( (2,self.amax))
        vec2 = numpy.zeros((2,self.amax))
        vec3 = numpy.zeros((3,self.amax))
        for i in range(self.amax):
            vec[0, i] = self.t
            vec[1, i] = math.sin(2*math.pi*0.8*self.t)
            vec2[0, i] = self.t
            vec2[1, i] = math.sin(2*math.pi*0.5*self.t)
            vec3[0, i] = self.t
            vec3[1, i] = math.sin(2*math.pi*self.para3.value*self.t)
            vec3[2, i] = math.sin(2*math.pi*0.1*self.t)
            self.t += 0.005

        self.pl_send_new_data('SinMit_f1' ,vec[0].tolist() , {'f1_1': vec[1] } )
        self.pl_send_new_data('SinMit_f2', vec2[0].tolist(), {'f2_1': vec2[1]} )
        self.pl_send_new_data('SinMit_f3', vec3[0].tolist(), {'f3_1': vec3[1], 'f3_2': vec3[2], 'f3_scalar': [10,10,10] } )

        time.sleep(self.amax*0.005)

    def cb_set_parameter(self, name, value):
        if name == self.para3.name:
            self.para3.value = float(value)


    def cb_get_plugin_configuration(self):
        config = {
            "amax": {
                'value': 3,
                'regex': '[0-9]+'
        }, 'f': {
                'value': "1",
                'regex': '\d+.{0,1}\d*'
        }}
        return config

    def cb_quit(self):
        print('Sinus: will quit')

    def cb_plugin_meta_updated(self):
        pass
예제 #43
0
    def cb_initialize_plugin(self):
        # --------------------------------
        # Step 0: Read documentation: http://tub-control.github.io/PaPI/
        # --------------------------------

        # --------------------------------
        # Step 1: Read configuration items (startup cfg)
        # OPTIONAL
        # --------------------------------
        #  Please read the Documentation of pl_get_config_element() to understand what is happening here.
        #  e.g. a configuration item named 'offset' is read.
        offset = self.pl_get_config_element('offset')
        offset = float(offset) if offset is not None else 0

        # --------------------------------
        # Step 2:Define blocks for output signals and define signals of blocks!
        # OPTIONAL
        # --------------------------------
        # Here: block called CPU_LOAD with 2 signals for Core1 and Core2
        blockLoad = DBlock('CPU_LOAD')
        sig_core1 = DSignal('Load_C1')
        sig_core2 = DSignal('Load_C2')

        blockLoad.add_signal(sig_core1)
        blockLoad.add_signal(sig_core2)

        self.pl_send_new_block_list([blockLoad])

        # --------------------------------
        # Step 3: Define parameter that are offered to PaPI
        # OPTIONAL
        # Sub-Step 1: Create Parameter Object
        # Sub-Step 2: Send list of Parameter Objects created to PaPI
        # --------------------------------
        #   use self. to remember the parameter object in this class/context for own usage!
        #   e.g. parameter named parameterName1 is created!
        #   Refer to the Doc of DParameter to read about advanced usages!
        self.parameter1 = DParameter('parameterName1')
        self.parameter2 = DParameter('parameterName2')
        self.pl_send_new_parameter_list([self.parameter1, self.parameter1])

        # --------------------------------
        # Step 4: Set the plugin trigger mode
        # OPTIONAL
        # In most cases for IOP you will leave it default, for DPP you will set it to true
        # Default will mean, that PaPI will decide on it.
        # --------------------------------
        self.pl_set_event_trigger_mode('default')

        # --------------------------------
        # Step 5: Developer and Plugin specific configuration
        # OPTIONAL
        # --------------------------------

        # --------------------------------
        # Step 6: Return Value
        # OBLIGATORY
        # Return True if the everything is alright!
        # False will lead to PaPI not starting this Plugin!
        # --------------------------------
        return True
예제 #44
0
파일: Add.py 프로젝트: dlaidig/PaPI
class Add(dpp_base):
    def cb_initialize_plugin(self):
        self.t = 0
        #print(['ADD: process id: ',os.getpid()] )
        self.approx_max = 300
        self.fac = 1
        self.amax = 20
        self.approx = self.approx_max * self.fac

        self.block1 = DBlock('AddOut1')
        signal = DSignal('Sum')
        self.block1.add_signal(signal)

        self.pl_send_new_block_list([self.block1])

        return True

    def cb_pause(self):
        pass

    def cb_resume(self):
        pass

    def cb_execute(self, Data=None, block_name=None, plugin_uname=None):
        #self.approx = round(self.approx_max*self.para1.value)
        #        self.vec[1] = 0
        #        self.vec[0] = Data[0]

        #        vec = numpy.zeros( (1, 2) )

        #for i in range(self.amax):
        #for k in range(1,self.approx):
        # self.vec[i+self.amax] += Data[i + (k+1)*self.amax]
        #self.vec[1, i] = Data[k, i]

        # Get Time Vector

        #        vec[0, :] = Data[CORE_TIME_SIGNAL]

        # n_rows = Data.shape[0]
        # n_cols = Data.shape[1]

        first_element = True

        for signal_name in Data:
            if signal_name is not CORE_TIME_SIGNAL:
                signal = Data[signal_name]

                if first_element is True:
                    first_element = False

                    result = signal
                else:
                    result = numpy.add(result, signal)

        self.pl_send_new_data('AddOut1', Data[CORE_TIME_SIGNAL],
                              {'Sum': result})

    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        print('Add: will quit')

    def cb_plugin_meta_updated(self):
        pass

    def cb_get_plugin_configuration(self):
        return {}
예제 #45
0
    def cb_initialize_plugin(self):
        print('ORTD', self.__id__, ':process id', os.getpid())
        self.config = self.pl_get_current_config_ref()
        # open UDP
        self.HOST = self.config['address']['value']
        self.SOURCE_PORT = int(self.config['source_port']['value'])
        self.OUT_PORT = int(self.config['out_port']['value'])

        self.LOCALBIND_HOST = ''  # config['source_address']['value']     #CK

        self.sendOnReceivePort = True if self.config['SendOnReceivePort'][
            'value'] == '1' else False
        self.UseSocketIO = True if self.config['UseSocketIO'][
            'value'] == '1' else False

        if self.UseSocketIO:
            self.SocketIOPort = int(self.config['socketio_port']['value'])

        #self.sendOnReceivePort = True  # NOTE: remove this
        #self.UseSocketIO = True  # NOTE: remove this

        print("SendOnReceivePort = ", self.sendOnReceivePort)
        print("UseSocketIO = ", self.UseSocketIO)

        self.PAPI_SIMULINK_BLOCK = False

        self.separate = int(self.config['SeparateSignals']['value'])

        self.onlyInitialConfig = self.config['OnlyInitialConfig'][
            'value'] == '1'
        self.hasInitialConfig = False

        if (not self.sendOnReceivePort):
            # SOCK_DGRAM is the socket type to use for UDP sockets
            self.sock_parameter = socket.socket(socket.AF_INET,
                                                socket.SOCK_DGRAM)
            self.sock_parameter.setblocking(1)

        self.ControlBlock = DBlock('ControllerSignals')
        self.ControlBlock.add_signal(DSignal('ControlSignalReset'))
        self.ControlBlock.add_signal(DSignal('ControlSignalCreate'))
        self.ControlBlock.add_signal(DSignal('ControlSignalSub'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalParameter'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalClose'))
        self.ControlBlock.add_signal(DSignal('ActiveTab'))
        self.pl_send_new_block_list([self.ControlBlock])

        self.t = 0

        self.pl_set_event_trigger_mode(True)

        self.sock_recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        if (not self.sendOnReceivePort):
            self.sock_recv.bind((self.LOCALBIND_HOST, self.SOURCE_PORT))  # CK
            print("UDP_Plugin-plugin listening on: ", self.LOCALBIND_HOST, ":",
                  self.SOURCE_PORT)  #CK
        else:
            print("---- Using client UDP mode (not binding to a port) ----")

        self.sock_recv.settimeout(1)

        self.thread_goOn = True
        self.lock = threading.Lock()
        self.thread = threading.Thread(target=self.thread_execute)
        self.thread.start()

        if self.UseSocketIO:
            print("Using socket.io connection on port", self.SocketIOPort)

            self.thread_socket_goOn = True
            self.thread_socketio = threading.Thread(
                target=self.thread_socketio_execute)

        self.blocks = {}
        self.Sources = {}

        self.parameters = {}

        self.signal_values = {}

        self.block_id = 0

        self.config_complete = False
        self.config_buffer = {}

        self.timer = Timer(3, self.callback_timeout_timer)
        self.timer_active = False

        self.ConsoleBlock = DBlock('ConsoleSignals')
        self.ConsoleBlock.add_signal(DSignal('MainSignal'))
        self.pl_send_new_block_list([self.ConsoleBlock])

        self.consoleIn = DParameter('consoleIn', default='')
        self.pl_send_new_parameter_list([self.consoleIn])

        if self.UseSocketIO:
            self.thread_socketio.start()

        return True
예제 #46
0
class UDP_Plugin(iop_base):
    def cb_get_plugin_configuration(self):
        config = {
            'address': {
                'value': '127.0.0.1',
                'advanced': '1'
            },
            'source_port': {
                'value': '20000',
                'advanced': '1'
            },
            'out_port': {
                'value': '20001',
                'advanced': '1'
            },
            'Cfg_Path': {
                'value':
                '/home/control/PycharmProjects/PaPI/data_sources/ORTD/DataSourceExample/ProtocollConfig.json',
                'type': 'file',
                'advanced': '0'
            },
            'SeparateSignals': {
                'value': '0',
                'advanced': '1'
            },
            'SendOnReceivePort': {
                'value': '0',  # NOTE: chnage back to 0
                'advanced': '1',
                'display_text': 'Use same port for send and receive'
            },
            "UseSocketIO": {
                'value': '0',  # NOTE: change back to 0 !!
                'advanced': '1',
                'tooltip': 'Use socket.io connection to node.js target-server',
                'type': 'bool'
            },
            'socketio_port': {
                'value': '8091',
                'advanced': '1'
            },
            "OnlyInitialConfig": {
                'value': '0',
                'tooltip':
                'Use only first configuration, ignore further configurations.',
                'type': 'bool'
            }
        }

        return config

    def cb_initialize_plugin(self):
        print('ORTD', self.__id__, ':process id', os.getpid())
        self.config = self.pl_get_current_config_ref()
        # open UDP
        self.HOST = self.config['address']['value']
        self.SOURCE_PORT = int(self.config['source_port']['value'])
        self.OUT_PORT = int(self.config['out_port']['value'])

        self.LOCALBIND_HOST = ''  # config['source_address']['value']     #CK

        self.sendOnReceivePort = True if self.config['SendOnReceivePort'][
            'value'] == '1' else False
        self.UseSocketIO = True if self.config['UseSocketIO'][
            'value'] == '1' else False

        if self.UseSocketIO:
            self.SocketIOPort = int(self.config['socketio_port']['value'])

        #self.sendOnReceivePort = True  # NOTE: remove this
        #self.UseSocketIO = True  # NOTE: remove this

        print("SendOnReceivePort = ", self.sendOnReceivePort)
        print("UseSocketIO = ", self.UseSocketIO)

        self.PAPI_SIMULINK_BLOCK = False

        self.separate = int(self.config['SeparateSignals']['value'])

        self.onlyInitialConfig = self.config['OnlyInitialConfig'][
            'value'] == '1'
        self.hasInitialConfig = False

        if (not self.sendOnReceivePort):
            # SOCK_DGRAM is the socket type to use for UDP sockets
            self.sock_parameter = socket.socket(socket.AF_INET,
                                                socket.SOCK_DGRAM)
            self.sock_parameter.setblocking(1)

        self.ControlBlock = DBlock('ControllerSignals')
        self.ControlBlock.add_signal(DSignal('ControlSignalReset'))
        self.ControlBlock.add_signal(DSignal('ControlSignalCreate'))
        self.ControlBlock.add_signal(DSignal('ControlSignalSub'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalParameter'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalClose'))
        self.ControlBlock.add_signal(DSignal('ActiveTab'))
        self.pl_send_new_block_list([self.ControlBlock])

        self.t = 0

        self.pl_set_event_trigger_mode(True)

        self.sock_recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        if (not self.sendOnReceivePort):
            self.sock_recv.bind((self.LOCALBIND_HOST, self.SOURCE_PORT))  # CK
            print("UDP_Plugin-plugin listening on: ", self.LOCALBIND_HOST, ":",
                  self.SOURCE_PORT)  #CK
        else:
            print("---- Using client UDP mode (not binding to a port) ----")

        self.sock_recv.settimeout(1)

        self.thread_goOn = True
        self.lock = threading.Lock()
        self.thread = threading.Thread(target=self.thread_execute)
        self.thread.start()

        if self.UseSocketIO:
            print("Using socket.io connection on port", self.SocketIOPort)

            self.thread_socket_goOn = True
            self.thread_socketio = threading.Thread(
                target=self.thread_socketio_execute)

        self.blocks = {}
        self.Sources = {}

        self.parameters = {}

        self.signal_values = {}

        self.block_id = 0

        self.config_complete = False
        self.config_buffer = {}

        self.timer = Timer(3, self.callback_timeout_timer)
        self.timer_active = False

        self.ConsoleBlock = DBlock('ConsoleSignals')
        self.ConsoleBlock.add_signal(DSignal('MainSignal'))
        self.pl_send_new_block_list([self.ConsoleBlock])

        self.consoleIn = DParameter('consoleIn', default='')
        self.pl_send_new_parameter_list([self.consoleIn])

        if self.UseSocketIO:
            self.thread_socketio.start()

        return True

    def SIO_callback_SCISTOUT(self, data):
        # Got a chunk of data from a console interface in the target server
        self.sio_count += 1

        self.pl_send_new_data(self.ConsoleBlock.name, [self.sio_count],
                              {'MainSignal': data['Data']})

    def SIO_callback_PAPICONFIG(self, data):
        # Got a new PaPI plugin configuration in JSON-format via socket.io connection
        # currently the config is transmitted via ORTD packets that may also be encapsulated into socket.io
        # added 12.8.15, CK

        print("Got a new config in JSON/socket.io format")
        print(data)

        self.check_and_process_cfg(data)

        # TODO: Test this

    def SIO_callback_ORTDPACKET(self, data):
        # Got an encapsulated packet from ORTD, not transfered via UDP but encapsulated within the socket.io connection
        #print ("Got data packet from ORTD via socket.io")
        #print (data)
        self.process_received_package(
            base64.b64decode(data))  # data must be a binary blob

    def thread_socketio_execute(self):
        #self.sio = SocketIO('localhost', 8091, LoggingNamespace)
        #self.sio.on('SCISTOUT',self.callback_SCISTOUT)

        while True:

            try:

                with SocketIO(self.HOST, self.SocketIOPort,
                              LoggingNamespace) as self.sio:
                    self.sio.on('SCISTOUT', self.SIO_callback_SCISTOUT)
                    self.sio.on('PAPICONFIG', self.SIO_callback_PAPICONFIG)
                    self.sio.on('ORTDPACKET', self.SIO_callback_ORTDPACKET)

                    self.request_new_config_from_ORTD()

                    self.sio_count = 0
                    while self.thread_socket_goOn:
                        self.sio.wait(seconds=1)

            except:
                print("Something failed within socket.io")

    def cb_pause(self):
        self.lock.acquire()
        self.thread_goOn = False
        self.lock.release()
        self.thread.join()

    def cb_resume(self):
        self.thread_goOn = True
        self.thread = threading.Thread(target=self.thread_execute,
                                       args=(self.HOST, self.SOURCE_PORT))
        self.thread.start()

    def thread_execute(self):
        time.sleep(2)  # TODO: Grrr. do not use sleep for thread sync...
        #try:

        if not self.UseSocketIO:
            self.request_new_config_from_ORTD()

        goOn = True
        newData = False
        signal_values = {}
        while goOn:
            try:
                if not self.sendOnReceivePort:
                    rev = self.sock_recv.recv(
                        65507
                    )  # not feasible for network connection other than loopback
                else:
                    #print ("---- Waiting for data ----")
                    rev, server = self.sock_recv.recvfrom(
                        65507
                    )  # not feasible for network connection other than loopback
                    #print ("---- got ----")
                    #print (rev)

            except socket.timeout:
                # print('timeout')
                newData = False

            except socket.error:
                print('ORTD got socket error')
            else:
                newData = True

            if newData:
                self.process_received_package(rev)

            # check if thread should go on
            self.lock.acquire()
            goOn = self.thread_goOn
            self.lock.release()
        # Thread ended
        self.sock_recv.close()

    def process_received_package(self, rev):
        SenderId, Counter, SourceId = struct.unpack_from('<iii', rev)

        if SourceId == -1 and len(self.blocks) > 0:
            # data stream finished
            self.process_finished_action(SourceId, rev)
            self.signal_values = {}

        if SourceId >= 0 and len(self.blocks) > 0:
            # got data stream
            self.process_data_stream(SourceId, rev)

        if SourceId == -2:
            # new config in ORTD available
            # send trigger to get new config
            self.request_new_config_from_ORTD()
            self.config_complete = False
            self.config_buffer = {}

        if SourceId == -100:
            self.PAPI_SIMULINK_BLOCK = True
            # got data stream from the PaPI-Simulink Block
            self.process_papi_data_stream(rev)

        if SourceId == -4:
            self.PAPI_SIMULINK_BLOCK = False
            # new configItem
            # print("Part of a new configuration");
            # receive new config item and execute cfg in PaPI

            # unpack package
            i = 16  # Offset: 4 ints
            unp = ''
            while i < len(rev):
                unp = unp + str(struct.unpack_from('<s', rev, i)[0])[2]
                i += 1

            if int(Counter) not in self.config_buffer:
                self.config_buffer[int(Counter)] = unp
            else:
                if self.config_buffer[int(Counter)] != unp:
                    self.config_buffer = {}

            # Check counter key series for holes
            counters = list(self.config_buffer.keys())
            counters.sort()
            i = 1
            config_file = ''

            self.config_complete = True
            for c in counters:
                if i == c:
                    config_file += self.config_buffer[c]
                    i += 1
                else:
                    self.config_complete = False
                    break
            if self.config_complete:
                if not self.check_and_process_cfg(config_file):
                    self.start_timeout_timer()
                else:
                    self.stop_timeout_timer()

            else:
                self.start_timeout_timer()

    def start_timeout_timer(self):
        if not self.timer_active:
            self.timer = Timer(3, self.callback_timeout_timer)
            self.timer.start()
            self.timer_active = True
        else:
            self.timer.cancel()
            self.timer = Timer(3, self.callback_timeout_timer)
            self.timer.start()

    def stop_timeout_timer(self):
        if self.timer_active:
            self.timer.cancel()
            self.timer_active = False
            #self.config_buffer = {}

    def callback_timeout_timer(self):
        print('ORTD_PLUGIN: Config timeout, requesting a new config')
        self.timer_active = False

        self.config_buffer = {}
        self.request_new_config_from_ORTD()

    def request_new_config_from_ORTD(self):
        Counter = 1
        data = struct.pack('<iiid', 12, Counter, int(-3), float(0))

        if self.UseSocketIO:
            print("Requesting config via socket.io")

            self.sio.emit('ORTDPACKET', base64.b64encode(data).decode('ascii'))
            # TODO test this

        else:

            if not self.sendOnReceivePort:
                self.sock_parameter.sendto(data, (self.HOST, self.OUT_PORT))
            else:
                self.sock_recv.sendto(data, (self.HOST, self.SOURCE_PORT))

    def check_and_process_cfg(self, config_file):
        try:
            # config completely received
            # extract new configuration
            cfg = json.loads(config_file)
            ORTDSources, ORTDParameters, plToCreate, \
            plToClose, subscriptions, paraConnections, activeTab = self.extract_config_elements(cfg)

            if self.hasInitialConfig and self.onlyInitialConfig:
                return True

            self.hasInitialConfig = True

            self.update_block_list(ORTDSources)
            self.update_parameter_list(ORTDParameters)

            self.process_papi_configuration(plToCreate, plToClose,
                                            subscriptions, paraConnections,
                                            activeTab)
            return True
        except ValueError as e:
            return False

    def process_papi_configuration(self, toCreate, toClose, subs,
                                   paraConnections, activeTab):

        self.pl_send_new_data(
            'ControllerSignals', [1], {
                'ControlSignalReset': 1,
                'ControlSignalCreate': None,
                'ControlSignalSub': None,
                'ControllerSignalParameter': None,
                'ControllerSignalClose': None,
                'ActiveTab': None
            })

        self.pl_send_new_data(
            'ControllerSignals', [1], {
                'ControlSignalReset': 0,
                'ControlSignalCreate': toCreate,
                'ControlSignalSub': subs,
                'ControllerSignalParameter': paraConnections,
                'ControllerSignalClose': toClose,
                'ActiveTab': activeTab
            })

    def parse_json_stream(self, stream):
        decoder = json.JSONDecoder()
        while stream:
            obj, idx = decoder.raw_decode(stream)
            yield obj
            stream = stream[idx:].lstrip()

    def update_parameter_list(self, ORTDParameter):

        newList = {}

        for para_id in ORTDParameter:
            para_name = ORTDParameter[para_id]['ParameterName']
            if para_name in self.parameters:
                para_object = self.parameters.pop(para_name)
            else:
                val_count = int(ORTDParameter[para_id]['NValues'])
                opt_object = OptionalObject(para_id, val_count)

                if "initial_value" in ORTDParameter[para_id]:
                    val = ORTDParameter[para_id]['initial_value']
                    if val_count > 1:
                        val = val[1:-1]
                        init_value = list(map(float, val.split(',')))
                    else:
                        init_value = float(val)
                else:
                    init_value = 0

                para_object = DParameter(para_name,
                                         default=str(init_value),
                                         OptionalObject=opt_object)
                self.pl_send_new_parameter_list([para_object])

            newList[para_name] = para_object

        toDeleteDict = self.parameters
        self.parameters = newList

        for par in toDeleteDict:
            self.pl_send_delete_parameter(par)

    def update_block_list(self, ORTDSources):
        #self.block_id = self.block_id +1
        #newBlock = DBlock('SourceGroup'+str(self.block_id))
        #self.blocks['SourceGroup'+str(self.block_id)] = newBlock
        if 'SourceGroup0' in self.blocks:
            self.pl_send_delete_block('SourceGroup0')
        newBlock = DBlock('SourceGroup0')
        self.blocks['SourceGroup0'] = newBlock
        self.Sources = ORTDSources
        keys = list(self.Sources.keys())
        for key in keys:
            Source = self.Sources[key]
            sig_name = Source['SourceName']
            newBlock.add_signal(DSignal(sig_name))

        self.pl_send_new_block_list([newBlock])

        # Remove BLOCKS
        #if 'SourceGroup'+str(self.block_id-1) in self.blocks:
        #self.pl_send_delete_block(self.blocks.pop('SourceGroup'+str(self.block_id-1)).name)

    def process_papi_data_stream(self, rev):

        timestamp = None

        offset = 4 * 4
        for i in range(len(self.Sources)):

            try:
                val = []
                #                offset += i*(4+4+4)

                # Get current signal ID:

                #                signal_id,data = struct.unpack_from('<id', rev, offset)
                signal_id, data = struct.unpack_from('<id', rev, offset)

                # print('Offset=' + str(offset))
                #
                # print('SignalID: ' + str(signal_id))
                #                print('Data: ' + str(data))
                if str(signal_id) in self.Sources:

                    Source = self.Sources[str(signal_id)]
                    NValues = int(Source['NValues_send'])

                    # print("NValues : " +  str(NValues))

                    #print("Offset:" + str(offset))

                    offset += 4
                    for n in range(NValues):
                        # print('#Value=' + str(n))
                        # print('Offset=' + str(offset))
                        try:
                            data = struct.unpack_from('<d', rev, offset)[0]
                            # print('Data=' + str(data))

                            val.append(data)
                        except struct.error:
                            # print(sys.exc_info()[0])
                            # print('!!!! except !!!!')
                            val.append(0)

                        offset += 8

                    # print('Data: ' + str(val))

                    # if NValues > 1:
                    #     signal_id,data = struct.unpack_from('<id%sd' %NValues, rev, offset)
                    #     offset += (NValues-1)*(4+4)
                    if self.Sources[str(signal_id)]["SourceName"] == "time":
                        timestamp = val[0]

                    self.signal_values[signal_id] = val

                #print("Signal: " + str(signal_id) + " Data: " + str(data)  );
            except struct.error:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno))
                print(sys.exc_info()[1])
                print("Can't unpack.")
        self.process_finished_action(-1, None, timestamp)

    def process_data_stream(self, SourceId, rev):
        # Received a data packet
        # Lookup the Source behind the given SourceId
        if str(SourceId) in self.Sources:
            Source = self.Sources[str(SourceId)]
            NValues = int(Source['NValues_send'])

            # Read NVales from the received packet
            val = []
            for i in range(NValues):
                try:
                    val.append(struct.unpack_from('<d', rev, 3 * 4 + i * 8)[0])
                except:
                    val.append(0)

            self.signal_values[SourceId] = val

        else:
            dp_info = self.pl_get_dplugin_info()
            print('ORTD_PLUGIN - ' + dp_info.uname +
                  ': received data with an unknown id (' + str(SourceId) + ')')

    def process_finished_action(self, SourceId, rev, timestamp=None):
        if SourceId == -1:
            # unpack group ID
            # GroupId = struct.unpack_from('<i', rev, 3 * 4)[0]
            self.t += 1.0

            keys = list(self.signal_values.keys())
            keys.sort(
            )  # REMARK: Die liste keys nur einmal sortieren; bei initialisierung

            signals_to_send = {}
            for key in keys:
                if str(key) in self.Sources:
                    sig_name = self.Sources[str(key)]['SourceName']
                    signals_to_send[sig_name] = self.signal_values[key]

            if len(list(self.blocks.keys())) > 0:
                block = list(self.blocks.keys())[0]

                if len(self.blocks[block].signals) == len(signals_to_send) + 1:
                    if timestamp is None:
                        self.pl_send_new_data(block, [self.t], signals_to_send)
                    else:
                        self.pl_send_new_data(block, [timestamp],
                                              signals_to_send)

    def cb_execute(self, Data=None, block_name=None, plugin_uname=None):
        raise Exception('Should not be called!')

    def cb_set_parameter(self, name, value):
        if name in self.parameters:
            parameter = self.parameters[name]
            Pid = parameter.OptionalObject.ORTD_par_id
            Counter = 111
            if value is not None:
                data = None

                # get values in float from string

                valueCast = ast.literal_eval(value)
                # check is it is a list, if not, cast to list
                if not isinstance(valueCast, list):
                    valueCast = [valueCast]

                if self.PAPI_SIMULINK_BLOCK:
                    data = struct.pack('<iii%sd' % len(valueCast), 12, Counter,
                                       int(Pid), *valueCast)
                else:
                    data = struct.pack('<iii%sd' % len(valueCast), 12, Counter,
                                       int(Pid), *valueCast)

                #if isinstance(valueCast, list):
                #data += struct.pack('%sd' %len(valueCast),*valueCast)
                #    for i in range(0,len(valueCast)):
                #        data += struct.pack('<d',valueCast[i])
                #else:
                #    data +=  struct.pack('d',float(value))

                if self.UseSocketIO:
                    print("Setting parameter via socket.io")

                    self.sio.emit('ORTDPACKET',
                                  base64.b64encode(data).decode('ascii'))
                    # TODO test this

                else:

                    if not self.sendOnReceivePort:
                        self.sock_parameter.sendto(data,
                                                   (self.HOST, self.OUT_PORT))
                    else:
                        self.sock_recv.sendto(data,
                                              (self.HOST, self.SOURCE_PORT))
        else:
            if name == 'consoleIn':
                self.sio.emit('ConsoleCommand', {
                    'ConsoleId': '1',
                    'Data': value
                })

    def cb_quit(self):
        self.lock.acquire()
        self.thread_goOn = False
        self.lock.release()
        self.thread.join()
        if not self.sendOnReceivePort:
            self.sock_parameter.close()
        print('ORTD-Plugin will quit')

    def cb_plugin_meta_updated(self):
        pass

    def plconf(self):
        cfg = {}
        subs = {}
        paras = {}
        close = {}
        if 'PaPIConfig' in self.ProtocolConfig:
            if 'ToCreate' in self.ProtocolConfig['PaPIConfig']:
                cfg = self.ProtocolConfig['PaPIConfig']['ToCreate']
            if 'ToSub' in self.ProtocolConfig['PaPIConfig']:
                subs = self.ProtocolConfig['PaPIConfig']['ToSub']
            if 'ToControl' in self.ProtocolConfig['PaPIConfig']:
                paras = self.ProtocolConfig['PaPIConfig']['ToControl']
            if 'ToClose' in self.ProtocolConfig['PaPIConfig']:
                close = self.ProtocolConfig['PaPIConfig']['ToClose']
        return cfg, subs, paras, close

    def extract_config_elements(self, configuration):
        plToCreate = {}
        subscriptions = {}
        paraConnections = {}
        plToClose = {}
        ORTDSources = {}
        ORTDParameters = {}
        activeTab = 'PaPI-Tab'

        if 'PaPIConfig' in configuration:
            if 'ToCreate' in configuration['PaPIConfig']:
                plToCreate = configuration['PaPIConfig']['ToCreate']

            if 'ToSub' in configuration['PaPIConfig']:
                subscriptions = configuration['PaPIConfig']['ToSub']

            if 'ToControl' in configuration['PaPIConfig']:
                paraConnections = configuration['PaPIConfig']['ToControl']

            if 'ToClose' in configuration['PaPIConfig']:
                plToClose = configuration['PaPIConfig']['ToClose']

            if 'ActiveTab' in configuration['PaPIConfig']:
                activeTab = configuration['PaPIConfig']['tab']

        if 'SourcesConfig' in configuration:
            ORTDSources = configuration['SourcesConfig']

        if 'ParametersConfig' in configuration:
            ORTDParameters = configuration['ParametersConfig']
        return ORTDSources, ORTDParameters, plToCreate, plToClose, subscriptions, paraConnections, activeTab
예제 #47
0
class Fourier_Rect_MOD(iop_base):
    max_approx = 20
    amax = 20
    def cb_initialize_plugin(self):
        self.t = 0
        self.amax = Fourier_Rect_MOD.amax
        self.amplitude = 1
        self.max_approx = Fourier_Rect_MOD.max_approx
        self.freq = 1
        self.vec = numpy.ones(self.amax* ( self.max_approx + 1) )

        print(['Fourier: process id: ',os.getpid()] )


        self.HOST = "130.149.155.73"
        self.PORT = 9999
        # SOCK_DGRAM is the socket type to use for UDP sockets
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(0)


        self.block1 = DBlock('Rectangle')
        for i in range(1,self.max_approx):
            self.block1.add_signal(DSignal('rect'+str(i)))

        self.pl_send_new_block_list([self.block1])

        self.pl_set_event_trigger_mode(True)

        self.goOn = True

        self.thread = threading.Thread(target=self.thread_execute, args=(self.HOST,self.PORT) )
        self.thread.start()



        return True

    def cb_pause(self):
        self.goOn = False
        self.thread.join()


    def cb_resume(self):
        self.goOn = True
        self.thread = threading.Thread(target=self.thread_execute, args=(self.HOST,self.PORT) )
        self.thread.start()

    def thread_execute(self,host,port):
        #self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        #self.sock.setblocking(0)
        vec = numpy.zeros( (self.max_approx,  (self.amax) ))

        while self.goOn:
            self.sock.sendto(b'GET', (self.HOST, self.PORT) )

            try:
                received = self.sock.recv(60000)
            except socket.error:
                pass
            else:
                data = pickle.loads(received)

                vech = {}
                t = data[0*self.amax:(0+1)*self.amax]

                for i in range(self.max_approx):
                    vech['rect'+str(i)] = data[i*self.amax:(i+1)*self.amax]

                self.pl_send_new_data('Rectangle', t, vech)

            time.sleep(0.001*self.amax )


    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        print("EXECUTE FUNC")
        pass

    def cb_set_parameter(self, name, value):
        pass

    def cb_quit(self):
        self.goOn = False
        self.thread.join()

    def cb_plugin_meta_updated(self):
        pass

    def cb_get_plugin_configuration(self):
        return {}
예제 #48
0
    def cb_initialize_plugin(self):
        # --------------------------------
        # Step 0: Read documentation: http://tub-control.github.io/PaPI/
        # --------------------------------

        # --------------------------------
        # Step 1: Read configuration items (startup cfg)
        # OPTIONAL
        # --------------------------------
        #  Please read the Documentation of pl_get_config_element() to understand what is happening here.
        #  e.g. a configuration item named 'offset' is read.
        offset = self.pl_get_config_element('offset')
        offset = float(offset) if offset is not None else 0

        # --------------------------------
        # Step 2:Define blocks for output signals and define signals of blocks!
        # OPTIONAL
        # --------------------------------
        # Here: block called CPU_LOAD with 2 signals for Core1 and Core2
        blockLoad = DBlock('CPU_LOAD')
        sig_core1 = DSignal('Load_C1')
        sig_core2 = DSignal('Load_C2')

        blockLoad.add_signal(sig_core1)
        blockLoad.add_signal(sig_core2)

        self.pl_send_new_block_list([blockLoad])

        # --------------------------------
        # Step 3: Define parameter that are offered to PaPI
        # OPTIONAL
        # Sub-Step 1: Create Parameter Object
        # Sub-Step 2: Send list of Parameter Objects created to PaPI
        # --------------------------------
        #   use self. to remember the parameter object in this class/context for own usage!
        #   e.g. parameter named parameterName1 is created!
        #   Refer to the Doc of DParameter to read about advanced usages!
        self. parameter1 = DParameter('parameterName1')
        self. parameter2 = DParameter('parameterName2')
        self.pl_send_new_parameter_list([self.parameter1, self.parameter1])

        # --------------------------------
        # Step 4: Set the plugin trigger mode
        # OPTIONAL
        # In most cases for IOP you will leave it default, for DPP you will set it to true
        # Default will mean, that PaPI will decide on it.
        # --------------------------------
        self.pl_set_event_trigger_mode('default')

        # --------------------------------
        # Step 5: Developer and Plugin specific configuration
        # OPTIONAL
        # --------------------------------

        # --------------------------------
        # Step 6: Return Value
        # OBLIGATORY
        # Return True if the everything is alright!
        # False will lead to PaPI not starting this Plugin!
        # --------------------------------
        return True
예제 #49
0
파일: UDP_Plugin.py 프로젝트: dani-l/PaPI
class UDP_Plugin(iop_base):
    def cb_get_plugin_configuration(self):
        config = {
            'address': {
                'value': '127.0.0.1',
                'advanced': '1'
            },
            'source_port': {
                'value': '20000',
                'advanced': '1'
            },
            'out_port': {
                'value': '20001',
                'advanced': '1'
            },
            'Cfg_Path': {
                'value': '/home/control/PycharmProjects/PaPI/data_sources/ORTD/DataSourceExample/ProtocollConfig.json',
                'type': 'file',
                'advanced': '0'
            },
            'SeparateSignals': {
                'value': '0',
                'advanced': '1'
            },
            'SendOnReceivePort': {
                'value': '0',    # NOTE: chnage back to 0
                'advanced': '1',
                'display_text': 'Use same port for send and receive'
            },
            "UseSocketIO" : {
                'value' : '0',   # NOTE: change back to 0 !!
                'advanced' : '1',
                'tooltip' : 'Use socket.io connection to node.js target-server',
                'type' : 'bool'
            },
            'socketio_port': {
                'value': '8091',
                'advanced': '1'
            },
            "OnlyInitialConfig" : {
                'value' :'0',
                'tooltip' : 'Use only first configuration, ignore further configurations.',
                'type' : 'bool'
            }
        }

        return config

    def cb_initialize_plugin(self):
        print('ORTD', self.__id__, ':process id', os.getpid())
        self.config = self.pl_get_current_config_ref()
        # open UDP
        self.HOST = self.config['address']['value']
        self.SOURCE_PORT = int(self.config['source_port']['value'])
        self.OUT_PORT = int(self.config['out_port']['value'])

        self.LOCALBIND_HOST = '' # config['source_address']['value']     #CK



        self.sendOnReceivePort = True if self.config['SendOnReceivePort']['value'] == '1' else False
        self.UseSocketIO = True if self.config['UseSocketIO']['value'] == '1' else False

        if self.UseSocketIO:
            self.SocketIOPort = int(self.config['socketio_port']['value'])


        #self.sendOnReceivePort = True  # NOTE: remove this
        #self.UseSocketIO = True  # NOTE: remove this


        print ("SendOnReceivePort = ", self.sendOnReceivePort)
        print ("UseSocketIO = ", self.UseSocketIO)

        self.PAPI_SIMULINK_BLOCK = False

        self.separate = int(self.config['SeparateSignals']['value'])

        self.onlyInitialConfig = self.config['OnlyInitialConfig']['value'] == '1'
        self.hasInitialConfig = False

        if (not self.sendOnReceivePort):
            # SOCK_DGRAM is the socket type to use for UDP sockets
            self.sock_parameter = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock_parameter.setblocking(1)



        self.ControlBlock = DBlock('ControllerSignals')
        self.ControlBlock.add_signal(DSignal('ControlSignalReset'))
        self.ControlBlock.add_signal(DSignal('ControlSignalCreate'))
        self.ControlBlock.add_signal(DSignal('ControlSignalSub'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalParameter'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalClose'))
        self.ControlBlock.add_signal(DSignal('ActiveTab'))
        self.pl_send_new_block_list([self.ControlBlock])


        self.t = 0

        self.pl_set_event_trigger_mode(True)

        self.sock_recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        if (not self.sendOnReceivePort):
            self.sock_recv.bind((self.LOCALBIND_HOST, self.SOURCE_PORT)) # CK
            print("UDP_Plugin-plugin listening on: ", self.LOCALBIND_HOST, ":", self.SOURCE_PORT)     #CK
        else:
            print ("---- Using client UDP mode (not binding to a port) ----")


        self.sock_recv.settimeout(1)

        self.thread_goOn = True
        self.lock = threading.Lock()
        self.thread = threading.Thread(target=self.thread_execute)
        self.thread.start()

        if self.UseSocketIO:
            print ("Using socket.io connection on port", self.SocketIOPort)

            self.thread_socket_goOn = True
            self.thread_socketio = threading.Thread(target=self.thread_socketio_execute)

        self.blocks = {}
        self.Sources = {}

        self.parameters = {}

        self.signal_values = {}

        self.block_id = 0

        self.config_complete = False
        self.config_buffer = {}

        self.timer = Timer(3,self.callback_timeout_timer)
        self.timer_active = False



        self.ConsoleBlock = DBlock('ConsoleSignals')
        self.ConsoleBlock.add_signal(DSignal('MainSignal'))
        self.pl_send_new_block_list([self.ConsoleBlock])

        self.consoleIn      = DParameter('consoleIn',default='')
        self.pl_send_new_parameter_list([self.consoleIn])

        if self.UseSocketIO:
            self.thread_socketio.start()

        return True

    def SIO_callback_SCISTOUT(self, data):
        # Got a chunk of data from a console interface in the target server
        self.sio_count += 1

        self.pl_send_new_data(self.ConsoleBlock.name, [self.sio_count], {'MainSignal':data['Data']})

    def SIO_callback_PAPICONFIG(self, data):
        # Got a new PaPI plugin configuration in JSON-format via socket.io connection
        # currently the config is transmitted via ORTD packets that may also be encapsulated into socket.io
        # added 12.8.15, CK

        print ("Got a new config in JSON/socket.io format")
        print (data)

        self.check_and_process_cfg(data)

        # TODO: Test this

    def SIO_callback_ORTDPACKET(self, data):
        # Got an encapsulated packet from ORTD, not transfered via UDP but encapsulated within the socket.io connection
        #print ("Got data packet from ORTD via socket.io")
        #print (data)
        self.process_received_package(base64.b64decode(data))  # data must be a binary blob






    def thread_socketio_execute(self):
        #self.sio = SocketIO('localhost', 8091, LoggingNamespace)
        #self.sio.on('SCISTOUT',self.callback_SCISTOUT)

        while True:

            try:

                with SocketIO(self.HOST, self.SocketIOPort, LoggingNamespace) as self.sio:
                    self.sio.on('SCISTOUT',self.SIO_callback_SCISTOUT)
                    self.sio.on('PAPICONFIG',self.SIO_callback_PAPICONFIG)
                    self.sio.on('ORTDPACKET',self.SIO_callback_ORTDPACKET)

                    self.request_new_config_from_ORTD()

                    self.sio_count = 0
                    while self.thread_socket_goOn:
                        self.sio.wait(seconds=1)

            except:
                print("Something failed within socket.io")




    def cb_pause(self):
        self.lock.acquire()
        self.thread_goOn = False
        self.lock.release()
        self.thread.join()

    def cb_resume(self):
        self.thread_goOn = True
        self.thread = threading.Thread(target=self.thread_execute, args=(self.HOST, self.SOURCE_PORT))
        self.thread.start()

    def thread_execute(self):
        time.sleep(2)                       # TODO: Grrr. do not use sleep for thread sync...
        #try:

        if not self.UseSocketIO:
            self.request_new_config_from_ORTD()


        goOn = True
        newData = False
        signal_values = {}
        while goOn:
            try:
                if not self.sendOnReceivePort:
                    rev = self.sock_recv.recv(65507)  # not feasible for network connection other than loopback
                else:
                    #print ("---- Waiting for data ----")
                    rev, server = self.sock_recv.recvfrom(65507)  # not feasible for network connection other than loopback
                    #print ("---- got ----")
                    #print (rev)

            except socket.timeout:
                # print('timeout')
                newData = False

            except socket.error:
                print('ORTD got socket error')
            else:
               newData = True

            if newData:
               self.process_received_package(rev)

            # check if thread should go on
            self.lock.acquire()
            goOn = self.thread_goOn
            self.lock.release()
        # Thread ended
        self.sock_recv.close()

    def process_received_package(self, rev):
        SenderId, Counter, SourceId = struct.unpack_from('<iii', rev)

        if SourceId == -1 and len(self.blocks) > 0:
            # data stream finished
            self.process_finished_action(SourceId, rev)
            self.signal_values = {}

        if SourceId >= 0 and len(self.blocks) > 0:
            # got data stream
            self.process_data_stream(SourceId, rev)

        if SourceId == -2:
            # new config in ORTD available
            # send trigger to get new config
            self.request_new_config_from_ORTD()
            self.config_complete = False
            self.config_buffer = {}

        if SourceId == -100:
            self.PAPI_SIMULINK_BLOCK = True
            # got data stream from the PaPI-Simulink Block
            self.process_papi_data_stream(rev)
    
        if SourceId == -4:
            self.PAPI_SIMULINK_BLOCK = False
            # new configItem
            # print("Part of a new configuration");
            # receive new config item and execute cfg in PaPI

            # unpack package
            i = 16 # Offset: 4 ints
            unp = ''
            while i < len(rev):
                unp = unp + str(struct.unpack_from('<s',rev,i)[0])[2]
                i += 1

            if int(Counter) not in self.config_buffer:
                self.config_buffer[int(Counter)] = unp
            else:
                if self.config_buffer[int(Counter)] != unp:
                    self.config_buffer = {}

            # Check counter key series for holes
            counters = list(self.config_buffer.keys())
            counters.sort()
            i = 1
            config_file = ''

            self.config_complete = True
            for c in counters:
                if i == c:
                    config_file += self.config_buffer[c]
                    i += 1
                else:
                    self.config_complete = False
                    break
            if self.config_complete:
                if not self.check_and_process_cfg(config_file):
                    self.start_timeout_timer()
                else:
                    self.stop_timeout_timer()

            else:
                self.start_timeout_timer()


    def start_timeout_timer(self):
        if not self.timer_active:
            self.timer = Timer(3,self.callback_timeout_timer)
            self.timer.start()
            self.timer_active = True
        else:
            self.timer.cancel()
            self.timer = Timer(3,self.callback_timeout_timer)
            self.timer.start()

    def stop_timeout_timer(self):
        if self.timer_active:
            self.timer.cancel()
            self.timer_active = False
            #self.config_buffer = {}

    def callback_timeout_timer(self):
        print('ORTD_PLUGIN: Config timeout, requesting a new config')
        self.timer_active = False

        self.config_buffer = {}
        self.request_new_config_from_ORTD()

    def request_new_config_from_ORTD(self):
        Counter = 1
        data = struct.pack('<iiid', 12, Counter, int(-3), float(0))

        if self.UseSocketIO:
            print ("Requesting config via socket.io")

            self.sio.emit('ORTDPACKET', base64.b64encode(data).decode('ascii') )
            # TODO test this

        else:

            if not self.sendOnReceivePort:
                self.sock_parameter.sendto(data, (self.HOST, self.OUT_PORT))
            else:
                self.sock_recv.sendto(data, (self.HOST, self.SOURCE_PORT))



    def check_and_process_cfg(self, config_file):
        try:
            # config completely received
            # extract new configuration
            cfg = json.loads(config_file)
            ORTDSources, ORTDParameters, plToCreate, \
            plToClose, subscriptions, paraConnections, activeTab = self.extract_config_elements(cfg)


            if self.hasInitialConfig and self.onlyInitialConfig:
                return True

            self.hasInitialConfig = True

            self.update_block_list(ORTDSources)
            self.update_parameter_list(ORTDParameters)

            self.process_papi_configuration(plToCreate, plToClose, subscriptions, paraConnections, activeTab)
            return True
        except ValueError as e:
            return False


    def process_papi_configuration(self, toCreate, toClose, subs, paraConnections, activeTab):

        self.pl_send_new_data('ControllerSignals', [1], {'ControlSignalReset': 1,
                                                              'ControlSignalCreate':None,
                                                              'ControlSignalSub':None,
                                                              'ControllerSignalParameter':None,
                                                              'ControllerSignalClose':None,
                                                              'ActiveTab': None })

        self.pl_send_new_data('ControllerSignals', [1], {'ControlSignalReset':0,
                                                              'ControlSignalCreate':toCreate,
                                                              'ControlSignalSub':subs,
                                                              'ControllerSignalParameter':paraConnections,
                                                              'ControllerSignalClose':toClose,
                                                              'ActiveTab': activeTab})

    def parse_json_stream(self,stream):
        decoder = json.JSONDecoder()
        while stream:
            obj, idx = decoder.raw_decode(stream)
            yield obj
            stream = stream[idx:].lstrip()

    def update_parameter_list(self, ORTDParameter):

        newList ={}

        for para_id in ORTDParameter:
            para_name = ORTDParameter[para_id]['ParameterName']
            if para_name in self.parameters:
                para_object = self.parameters.pop(para_name)
            else:
                val_count = int(ORTDParameter[para_id]['NValues'])
                opt_object = OptionalObject(para_id, val_count)

                if "initial_value" in ORTDParameter[para_id]:
                    val = ORTDParameter[para_id]['initial_value']
                    if val_count > 1:
                        val = val[1:-1]
                        init_value = list(map(float,val.split(',')))
                    else:
                        init_value = float(val)
                else:
                    init_value = 0

                para_object = DParameter(para_name, default=str(init_value), OptionalObject=opt_object)
                self.pl_send_new_parameter_list([para_object])


            newList[para_name] = para_object

        toDeleteDict = self.parameters
        self.parameters = newList

        for par in toDeleteDict:
            self.pl_send_delete_parameter(par)


    def update_block_list(self,ORTDSources):
        #self.block_id = self.block_id +1
        #newBlock = DBlock('SourceGroup'+str(self.block_id))
        #self.blocks['SourceGroup'+str(self.block_id)] = newBlock
        if 'SourceGroup0' in self.blocks:
            self.pl_send_delete_block('SourceGroup0')
        newBlock = DBlock('SourceGroup0')
        self.blocks['SourceGroup0'] = newBlock
        self.Sources = ORTDSources
        keys = list(self.Sources.keys())
        for key in keys:
            Source = self.Sources[key]
            sig_name = Source['SourceName']
            newBlock.add_signal(DSignal(sig_name))

        self.pl_send_new_block_list([newBlock])

        # Remove BLOCKS
        #if 'SourceGroup'+str(self.block_id-1) in self.blocks:
            #self.pl_send_delete_block(self.blocks.pop('SourceGroup'+str(self.block_id-1)).name)

    def process_papi_data_stream(self, rev):

        timestamp = None

        offset = 4*4
        for i in range(len(self.Sources)):

            try:
                val = []
#                offset += i*(4+4+4)

                # Get current signal ID:

#                signal_id,data = struct.unpack_from('<id', rev, offset)
                signal_id, data = struct.unpack_from('<id', rev, offset)

                # print('Offset=' + str(offset))
                #
                # print('SignalID: ' + str(signal_id))
#                print('Data: ' + str(data))
                if str(signal_id) in self.Sources:

                    Source = self.Sources[str(signal_id)]
                    NValues = int(Source['NValues_send'])

                    # print("NValues : " +  str(NValues))

                    #print("Offset:" + str(offset))

                    offset += 4
                    for n in range(NValues):
                        # print('#Value=' + str(n))
                        # print('Offset=' + str(offset))
                        try:
                            data = struct.unpack_from('<d', rev, offset)[0]
                            # print('Data=' + str(data))

                            val.append(data)
                        except struct.error:
                            # print(sys.exc_info()[0])
                            # print('!!!! except !!!!')
                            val.append(0)

                        offset += 8

                    # print('Data: ' + str(val))

                    # if NValues > 1:
                    #     signal_id,data = struct.unpack_from('<id%sd' %NValues, rev, offset)
                    #     offset += (NValues-1)*(4+4)
                    if self.Sources[str(signal_id)]["SourceName"] == "time":
                            timestamp = val[0]

                    self.signal_values[signal_id] = val

                #print("Signal: " + str(signal_id) + " Data: " + str(data)  );
            except struct.error:
                print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno))
                print(sys.exc_info()[1])
                print("Can't unpack.")
        self.process_finished_action(-1,None, timestamp)
    

    def process_data_stream(self, SourceId, rev):
        # Received a data packet
        # Lookup the Source behind the given SourceId
        if str(SourceId) in self.Sources:
            Source = self.Sources[str(SourceId)]
            NValues = int(Source['NValues_send'])

            # Read NVales from the received packet
            val = []
            for i in range(NValues):
                try:
                    val.append(struct.unpack_from('<d', rev, 3 * 4 + i * 8)[0])
                except:
                    val.append(0)

            self.signal_values[SourceId] = val

        else:
            dp_info = self.pl_get_dplugin_info()
            print('ORTD_PLUGIN - '+dp_info.uname+': received data with an unknown id ('+str(SourceId)+')')

    def process_finished_action(self, SourceId, rev, timestamp=None):
        if SourceId == -1:
            # unpack group ID
            # GroupId = struct.unpack_from('<i', rev, 3 * 4)[0]
            self.t += 1.0

            keys = list(self.signal_values.keys())
            keys.sort()                    # REMARK: Die liste keys nur einmal sortieren; bei initialisierung

            signals_to_send = {}
            for key in keys:
                if str(key) in self.Sources:
                    sig_name = self.Sources[str(key)]['SourceName']
                    signals_to_send[sig_name] = self.signal_values[key]

            if len( list(self.blocks.keys()) ) >0:
                block = list(self.blocks.keys())[0]

                if len(self.blocks[block].signals) == len(signals_to_send)+1:
                    if timestamp is None:
                        self.pl_send_new_data(block, [self.t], signals_to_send )
                    else:
                        self.pl_send_new_data(block, [timestamp], signals_to_send )

    def cb_execute(self, Data=None, block_name = None, plugin_uname = None):
        raise Exception('Should not be called!')

    def cb_set_parameter(self, name, value):
        if name in self.parameters:
            parameter = self.parameters[name]
            Pid = parameter.OptionalObject.ORTD_par_id
            Counter = 111
            if value is not None:
                data = None

                # get values in float from string

                valueCast = ast.literal_eval(value)
                # check is it is a list, if not, cast to list
                if not isinstance(valueCast,list):
                    valueCast = [valueCast]

                if self.PAPI_SIMULINK_BLOCK:
                    data = struct.pack('<iii%sd' %len(valueCast), 12, Counter, int(Pid),*valueCast)
                else:
                    data = struct.pack('<iii%sd' %len(valueCast), 12, Counter, int(Pid),*valueCast)

                #if isinstance(valueCast, list):
                    #data += struct.pack('%sd' %len(valueCast),*valueCast)
                #    for i in range(0,len(valueCast)):
                #        data += struct.pack('<d',valueCast[i])
                #else:
                #    data +=  struct.pack('d',float(value))


                if self.UseSocketIO:
                    print ("Setting parameter via socket.io")

                    self.sio.emit('ORTDPACKET', base64.b64encode(data).decode('ascii') )
                    # TODO test this

                else:

                    if not self.sendOnReceivePort:
                        self.sock_parameter.sendto(data, (self.HOST, self.OUT_PORT))
                    else:
                        self.sock_recv.sendto(data, (self.HOST, self.SOURCE_PORT))
        else:
            if name == 'consoleIn':
                self.sio.emit('ConsoleCommand', { 'ConsoleId' : '1' ,  'Data' : value  })


    def cb_quit(self):
        self.lock.acquire()
        self.thread_goOn = False
        self.lock.release()
        self.thread.join()
        if not self.sendOnReceivePort:
            self.sock_parameter.close()
        print('ORTD-Plugin will quit')

    def cb_plugin_meta_updated(self):
        pass

    def plconf(self):
        cfg   = {}
        subs  = {}
        paras = {}
        close = {}
        if 'PaPIConfig' in self.ProtocolConfig:
            if 'ToCreate' in self.ProtocolConfig['PaPIConfig']:
                cfg = self.ProtocolConfig['PaPIConfig']['ToCreate']
            if 'ToSub' in self.ProtocolConfig['PaPIConfig']:
                subs = self.ProtocolConfig['PaPIConfig']['ToSub']
            if 'ToControl' in self.ProtocolConfig['PaPIConfig']:
                paras = self.ProtocolConfig['PaPIConfig']['ToControl']
            if 'ToClose' in self.ProtocolConfig['PaPIConfig']:
                close = self.ProtocolConfig['PaPIConfig']['ToClose']
        return cfg, subs, paras, close

    def extract_config_elements(self, configuration):
        plToCreate   = {}
        subscriptions  = {}
        paraConnections = {}
        plToClose = {}
        ORTDSources = {}
        ORTDParameters = {}
        activeTab = 'PaPI-Tab'

        if 'PaPIConfig' in configuration:
            if 'ToCreate' in configuration['PaPIConfig']:
                plToCreate = configuration['PaPIConfig']['ToCreate']

            if 'ToSub' in configuration['PaPIConfig']:
                subscriptions = configuration['PaPIConfig']['ToSub']

            if 'ToControl' in configuration['PaPIConfig']:
                paraConnections = configuration['PaPIConfig']['ToControl']

            if 'ToClose' in configuration['PaPIConfig']:
                plToClose = configuration['PaPIConfig']['ToClose']

            if 'ActiveTab' in configuration['PaPIConfig']:
                activeTab = configuration['PaPIConfig']['tab']

        if 'SourcesConfig' in configuration:
            ORTDSources = configuration['SourcesConfig']

        if 'ParametersConfig' in configuration:
            ORTDParameters = configuration['ParametersConfig']
        return ORTDSources, ORTDParameters, plToCreate, plToClose, subscriptions, paraConnections, activeTab
예제 #50
0
파일: UDP_Plugin.py 프로젝트: dani-l/PaPI
    def cb_initialize_plugin(self):
        print('ORTD', self.__id__, ':process id', os.getpid())
        self.config = self.pl_get_current_config_ref()
        # open UDP
        self.HOST = self.config['address']['value']
        self.SOURCE_PORT = int(self.config['source_port']['value'])
        self.OUT_PORT = int(self.config['out_port']['value'])

        self.LOCALBIND_HOST = '' # config['source_address']['value']     #CK



        self.sendOnReceivePort = True if self.config['SendOnReceivePort']['value'] == '1' else False
        self.UseSocketIO = True if self.config['UseSocketIO']['value'] == '1' else False

        if self.UseSocketIO:
            self.SocketIOPort = int(self.config['socketio_port']['value'])


        #self.sendOnReceivePort = True  # NOTE: remove this
        #self.UseSocketIO = True  # NOTE: remove this


        print ("SendOnReceivePort = ", self.sendOnReceivePort)
        print ("UseSocketIO = ", self.UseSocketIO)

        self.PAPI_SIMULINK_BLOCK = False

        self.separate = int(self.config['SeparateSignals']['value'])

        self.onlyInitialConfig = self.config['OnlyInitialConfig']['value'] == '1'
        self.hasInitialConfig = False

        if (not self.sendOnReceivePort):
            # SOCK_DGRAM is the socket type to use for UDP sockets
            self.sock_parameter = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock_parameter.setblocking(1)



        self.ControlBlock = DBlock('ControllerSignals')
        self.ControlBlock.add_signal(DSignal('ControlSignalReset'))
        self.ControlBlock.add_signal(DSignal('ControlSignalCreate'))
        self.ControlBlock.add_signal(DSignal('ControlSignalSub'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalParameter'))
        self.ControlBlock.add_signal(DSignal('ControllerSignalClose'))
        self.ControlBlock.add_signal(DSignal('ActiveTab'))
        self.pl_send_new_block_list([self.ControlBlock])


        self.t = 0

        self.pl_set_event_trigger_mode(True)

        self.sock_recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        if (not self.sendOnReceivePort):
            self.sock_recv.bind((self.LOCALBIND_HOST, self.SOURCE_PORT)) # CK
            print("UDP_Plugin-plugin listening on: ", self.LOCALBIND_HOST, ":", self.SOURCE_PORT)     #CK
        else:
            print ("---- Using client UDP mode (not binding to a port) ----")


        self.sock_recv.settimeout(1)

        self.thread_goOn = True
        self.lock = threading.Lock()
        self.thread = threading.Thread(target=self.thread_execute)
        self.thread.start()

        if self.UseSocketIO:
            print ("Using socket.io connection on port", self.SocketIOPort)

            self.thread_socket_goOn = True
            self.thread_socketio = threading.Thread(target=self.thread_socketio_execute)

        self.blocks = {}
        self.Sources = {}

        self.parameters = {}

        self.signal_values = {}

        self.block_id = 0

        self.config_complete = False
        self.config_buffer = {}

        self.timer = Timer(3,self.callback_timeout_timer)
        self.timer_active = False



        self.ConsoleBlock = DBlock('ConsoleSignals')
        self.ConsoleBlock.add_signal(DSignal('MainSignal'))
        self.pl_send_new_block_list([self.ConsoleBlock])

        self.consoleIn      = DParameter('consoleIn',default='')
        self.pl_send_new_parameter_list([self.consoleIn])

        if self.UseSocketIO:
            self.thread_socketio.start()

        return True