コード例 #1
0
ファイル: RProxy.cpp プロジェクト: fdieulle/r.net
SEXP rSet(SEXP p) {
	
	// 1 - Get data from SEXP
	p = CDR(p); // Skip the first parameter: because function name
	IUnknown* instancePtr = readInstanceFromSexp(p); p = CDR(p);
	char* strPropertyName = readStringFromSexp(p); p = CDR(p);
	LONGLONG valueAddresse = (LONGLONG)CAR(p);

	// 2 - Prepare arguments to call proxy
	SAFEARRAY* args = SafeArrayCreateVector(VT_VARIANT, 0, 3);
	long i = 0;

	// 2.1 - external pointer on .Net object 
	variant_t instance(instancePtr);
	SafeArrayPutElement(args, &i, &instance); i++;

	// 2.2 - Method name
	variant_t propertyName(strPropertyName);
	SafeArrayPutElement(args, &i, &propertyName); i++;

	// 2.3 property value
	variant_t value(valueAddresse);
	SafeArrayPutElement(args, &i, &value); i++;

	// 3 - Call the proxy
	CLR_OBJ result;
	char* errorMsg;
	HRESULT hr = callProxy(L"SetProperty", args, &result, &errorMsg);

	if(FAILED(hr)) {
		Rprintf(errorMsg);
		error("Exception during netSet !");
		free(errorMsg);
		return R_NilValue;
	}

	SafeArrayDestroy(args);
	return R_NilValue;
}
コード例 #2
0
ファイル: Spectrogram.cpp プロジェクト: xloem/pothos
    Spectrogram(const Pothos::ProxyEnvironment::Sptr &remoteEnv)
    {
        _display.reset(new SpectrogramDisplay());
        _display->setName("Display");

        auto registry = remoteEnv->findProxy("Pothos/BlockRegistry");
        _trigger = registry.callProxy("/comms/wave_trigger");
        _trigger.callVoid("setName", "Trigger");
        _trigger.callVoid("setMode", "PERIODIC");

        //register calls in this topology
        this->registerCall(this, POTHOS_FCN_TUPLE(Spectrogram, setNumFFTBins));
        this->registerCall(this, POTHOS_FCN_TUPLE(Spectrogram, setFreqLabelId));
        this->registerCall(this, POTHOS_FCN_TUPLE(Spectrogram, setRateLabelId));

        //connect to internal display block
        this->connect(this, "setTitle", _display, "setTitle");
        this->connect(this, "setDisplayRate", _display, "setDisplayRate");
        this->connect(this, "setSampleRate", _display, "setSampleRate");
        this->connect(this, "setCenterFrequency", _display, "setCenterFrequency");
        this->connect(this, "setNumFFTBins", _display, "setNumFFTBins");
        this->connect(this, "setWindowType", _display, "setWindowType");
        this->connect(this, "setTimeSpan", _display, "setTimeSpan");
        this->connect(this, "setReferenceLevel", _display, "setReferenceLevel");
        this->connect(this, "setDynamicRange", _display, "setDynamicRange");
        this->connect(this, "enableXAxis", _display, "enableXAxis");
        this->connect(this, "enableYAxis", _display, "enableYAxis");
        this->connect(_display, "frequencySelected", this, "frequencySelected");

        //connect to the internal snooper block
        this->connect(_display, "updateRateChanged", _trigger, "setEventRate");
        this->connect(this, "setNumFFTBins", _trigger, "setNumPoints");

        //connect stream ports
        this->connect(this, 0, _trigger, 0);
        this->connect(_trigger, 0, _display, 0);
    }
コード例 #3
0
ファイル: RProxy.cpp プロジェクト: fdieulle/r.net
SEXP rGetStatic(SEXP p) {

	// 1 - Get data from SEXP
	p = CDR(p); // Skip the first parameter: because function name
	char* strTypeName = readStringFromSexp(p); p = CDR(p);
	char* strPropertyName = readStringFromSexp(p); p = CDR(p);

	// 2 - Prepare arguments to call proxy
	SAFEARRAY* args = SafeArrayCreateVector(VT_VARIANT, 0, 2);
	long i = 0;

	// 2.1 - Type name
	variant_t typeName(strTypeName);
	SafeArrayPutElement(args, &i, &typeName); i++;

	// 2.2 - Method name
	variant_t propertyName(strPropertyName);
	SafeArrayPutElement(args, &i, &propertyName); i++;

	// 3 - Call the proxy
	CLR_OBJ result;
	char* errorMsg;
	HRESULT hr = callProxy(L"GetStaticProperty", args, &result, &errorMsg);
	
	if(FAILED(hr)) {
		Rprintf(errorMsg);
		error("Exception during netGetStatic !");
		free(errorMsg);
		return R_NilValue;
	}

	// 4 - Free memory
	SafeArrayDestroy(args);

	return convertToSEXP(result);
}
コード例 #4
0
// Copyright (c) 2014-2014 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <iostream>

POTHOS_TEST_BLOCK("/blocks/tests", test_signals_and_slots)
{
    auto env = Pothos::ProxyEnvironment::make("managed")->findProxy("Pothos/BlockRegistry");
    auto feeder = env.callProxy("/blocks/feeder_source", "int");
    auto collector = env.callProxy("/blocks/collector_sink", "int");
    auto messageToSignal = env.callProxy("/blocks/message_to_signal", "changeEvent");
    auto slotToMessage = env.callProxy("/blocks/slot_to_message", "handleEvent");

    //feed some msgs
    feeder.callProxy("feedMessage", Pothos::Object("msg0"));
    feeder.callProxy("feedMessage", Pothos::Object("msg1"));

    //run the topology
    {
        Pothos::Topology topology;
        topology.connect(feeder, 0, messageToSignal, 0);
        topology.connect(messageToSignal, "changeEvent", slotToMessage, "handleEvent");
        topology.connect(slotToMessage, 0, collector, 0);
        topology.commit();
        POTHOS_TEST_TRUE(topology.waitInactive());
    }

    //collect the messages
コード例 #5
0
ファイル: TestOpenClBlocks.cpp プロジェクト: xloem/pothos
"    out[i] = in0[i] + in1[i];\n"
"}"
"__kernel void copy_int(\n"
"    __global const int* in,\n"
"    __global int* out\n"
")\n"
"{\n"
"    const uint i = get_global_id(0);\n"
"    out[i] = in[i];\n"
"}"
;

POTHOS_TEST_BLOCK("/opencl/tests", test_opencl_kernel)
{
    auto registry = Pothos::ProxyEnvironment::make("managed")->findProxy("Pothos/BlockRegistry");
    auto collector = registry.callProxy("/blocks/collector_sink", "float32");

    auto feeder0 = registry.callProxy("/blocks/feeder_source", "float32");
    auto feeder1 = registry.callProxy("/blocks/feeder_source", "float32");

    auto openClKernel = registry.callProxy("/blocks/opencl_kernel", "0:0", std::vector<std::string>(2, "float"), std::vector<std::string>(1, "float"));
    openClKernel.callVoid("setSource", "add_2x_float32", KERNEL_SOURCE);
    openClKernel.callVoid("setLocalSize", 1);
    openClKernel.callVoid("setGlobalFactor", 1.0);
    openClKernel.callVoid("setProductionFactor", 1.0);

    //feed buffer
    auto b0 = Pothos::BufferChunk(10*sizeof(float));
    auto p0 = b0.as<float *>();
    for (size_t i = 0; i < 10; i++) p0[i] = i;
    feeder0.callProxy("feedBuffer", b0);
コード例 #6
0
ファイル: TestArithmeticBlocks.cpp プロジェクト: m0x72/pothos
// Copyright (c) 2014-2014 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <iostream>

POTHOS_TEST_BLOCK("/blocks/tests", test_arithmetic_add)
{
    auto registry = Pothos::ProxyEnvironment::make("managed")->findProxy("Pothos/BlockRegistry");

    auto feeder0 = registry.callProxy("/blocks/feeder_source", "int");
    auto feeder1 = registry.callProxy("/blocks/feeder_source", "int");
    auto adder = registry.callProxy("/blocks/arithmetic", "int", "ADD");
    auto collector = registry.callProxy("/blocks/collector_sink", "int");

    //load feeder blocks
    auto b0 = Pothos::BufferChunk(10*sizeof(int));
    auto p0 = b0.as<int *>();
    for (size_t i = 0; i < 10; i++) p0[i] = i;
    feeder0.callProxy("feedBuffer", b0);

    auto b1 = Pothos::BufferChunk(10*sizeof(int));
    auto p1 = b1.as<int *>();
    for (size_t i = 0; i < 10; i++) p1[i] = i+10;
    feeder1.callProxy("feedBuffer", b1);

    //run the topology
    {
        Pothos::Topology topology;
コード例 #7
0
        auto collector = Pothos::BlockRegistry::make("/blocks/collector_sink", "uint8");

        //setup the topology
        Pothos::Topology topology;
        topology.connect(feeder, 0, symsToBits, 0);
        topology.connect(symsToBits, 0, bitsToSyms, 0);
        topology.connect(bitsToSyms, 0, collector, 0);

        //create a test plan for streams
        std::cout << "Perform stream-based test plan..." << std::endl;
        Poco::JSON::Object::Ptr testPlan0(new Poco::JSON::Object());
        testPlan0->set("enableBuffers", true);
        testPlan0->set("enableLabels", true);
        testPlan0->set("minValue", 0);
        testPlan0->set("maxValue", (1 << mod) - 1);
        auto expected0 = feeder.callProxy("feedTestPlan", testPlan0);
        topology.commit();
        POTHOS_TEST_TRUE(topology.waitInactive(0.01));
        collector.callVoid("verifyTestPlan", expected0);

        //create a test plan for packets
        std::cout << "Perform packet-based test plan..." << std::endl;
        Poco::JSON::Object::Ptr testPlan1(new Poco::JSON::Object());
        testPlan1->set("enablePackets", true);
        testPlan1->set("enableLabels", true);
        testPlan1->set("minValue", 0);
        testPlan1->set("maxValue", (1 << mod) - 1);
        auto expected1 = feeder.callProxy("feedTestPlan", testPlan1);
        topology.commit();
        POTHOS_TEST_TRUE(topology.waitInactive(0.01));
        collector.callVoid("verifyTestPlan", expected1);
コード例 #8
0
// Copyright (c) 2015-2015 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <Poco/JSON/Object.h>
#include <iostream>
#include <complex>

POTHOS_TEST_BLOCK("/comms/tests", test_symbol_mapper_slicer_float)
{
    auto env = Pothos::ProxyEnvironment::make("managed");
    auto registry = env->findProxy("Pothos/BlockRegistry");

    auto feeder = registry.callProxy("/blocks/feeder_source", "unsigned char");
    auto mapper = registry.callProxy("/comms/symbol_mapper", "float");
    auto slicer = registry.callProxy("/comms/symbol_slicer", "float");
    auto collector = registry.callProxy("/blocks/collector_sink", "unsigned char");

    static const float mapD[] = {-3, -1, 1, 3};
    std::vector<float> map(mapD, mapD+4);
    mapper.callProxy("setMap", map);
    slicer.callProxy("setMap", map);

    //load feeder blocks
    auto b0 = Pothos::BufferChunk(10*sizeof(unsigned char));
    auto p0 = b0.as<unsigned char *>();
    for (size_t i = 0; i < 10; i++) p0[i] = i&3;
    feeder.callProxy("feedBuffer", b0);
コード例 #9
0
POTHOS_TEST_BLOCK("/fpga/tests", test_loopback)
{
    //create client environment
    auto env = getSimulationEnv("LoopbackTb");
    auto SimulationHarness = env->findProxy("Pothos/FPGA/SimulationHarness");

    auto sourceIndexes = SimulationHarness.call<std::vector<int>>("getSourceIndexes");
    POTHOS_TEST_EQUAL(sourceIndexes.size(), 1);
    POTHOS_TEST_EQUAL(sourceIndexes[0], 0);

    auto sinkIndexes = SimulationHarness.call<std::vector<int>>("getSinkIndexes");
    POTHOS_TEST_EQUAL(sinkIndexes.size(), 1);
    POTHOS_TEST_EQUAL(sinkIndexes[0], 0);

    auto source0 = SimulationHarness.callProxy("getSourceBlock", 0);
    auto sink0 = SimulationHarness.callProxy("getSinkBlock", 0);

    auto registry = env->findProxy("Pothos/BlockRegistry");
    auto feeder = registry.callProxy("/blocks/feeder_source", "int");
    auto collector = registry.callProxy("/blocks/collector_sink", "int");

    //create a test plan
    Poco::JSON::Object::Ptr testPlan(new Poco::JSON::Object());
    testPlan->set("enableBuffers", true);
    auto expected = feeder.callProxy("feedTestPlan", testPlan);

    //run the topology
    {
        Pothos::Topology topology;
        topology.connect(feeder, 0, sink0, 0);
コード例 #10
0
ファイル: TestConverter.cpp プロジェクト: m0x72/pothos
// Copyright (c) 2014-2014 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <Pothos/Remote.hpp>
#include <Poco/JSON/Object.h>
#include <iostream>

POTHOS_TEST_BLOCK("/blocks/tests", test_converter)
{
    auto env = Pothos::ProxyEnvironment::make("managed");
    auto registry = env->findProxy("Pothos/BlockRegistry");
    auto feeder = registry.callProxy("/blocks/feeder_source", "short");
    auto converter = registry.callProxy("/blocks/converter", "int");
    auto collector = registry.callProxy("/blocks/collector_sink", "int");

    //create a test plan
    Poco::JSON::Object::Ptr testPlan(new Poco::JSON::Object());
    testPlan->set("enableBuffers", true);
    testPlan->set("enableLabels", true);
    auto expected = feeder.callProxy("feedTestPlan", testPlan);

    //run the topology
    {
        Pothos::Topology topology;
        topology.connect(feeder, 0, converter, 0);
        topology.connect(converter, 0, collector, 0);
        topology.commit();
        POTHOS_TEST_TRUE(topology.waitInactive());
コード例 #11
0
ファイル: TestSimpleMac.cpp プロジェクト: m0x72/pothos
// Copyright (c) 2015-2015 Josh Blum
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <Poco/JSON/Object.h>
#include <iostream>

POTHOS_TEST_BLOCK("/blocks/tests", test_simple_mac)
{
    auto env = Pothos::ProxyEnvironment::make("managed");
    auto registry = env->findProxy("Pothos/BlockRegistry");

    //create test blocks
    auto feeder = registry.callProxy("/blocks/feeder_source", "uint8");
    auto collector = registry.callProxy("/blocks/collector_sink", "uint8");
    auto mac = registry.callProxy("/blocks/simple_mac");
    const unsigned short macId = std::rand() & 0xffff;
    mac.callVoid("setMacId", macId);

    //create a test packet
    Pothos::Packet pkt0;
    pkt0.payload = Pothos::BufferChunk("uint8", 100);
    for (size_t i = 0; i < pkt0.payload.elements(); i++)
        pkt0.payload.as<unsigned char *>()[i] = std::rand() & 0xff;
    pkt0.metadata["recipient"] = Pothos::Object(macId);
    feeder.callVoid("feedPacket", pkt0);

    //setup the topology
    Pothos::Topology topology;
コード例 #12
0
// SPDX-License-Identifier: BSL-1.0

#include <Pothos/Testing.hpp>
#include <Pothos/Proxy.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Exception.hpp>
#include <Pothos/Object/Containers.hpp>
#include <complex>
#include <iostream>

POTHOS_TEST_BLOCK("/util/tests", test_eval_expression)
{
    //check that the following does not throw
    auto env = Pothos::ProxyEnvironment::make("managed");
    auto EvalEnvironment = env->findProxy("Pothos/Util/EvalEnvironment");
    auto evalEnv = EvalEnvironment.callProxy("new");

    //booleans
    const auto resultT = evalEnv.call<Pothos::Object>("eval", "true");
    POTHOS_TEST_TRUE(resultT.convert<bool>());

    const auto resultF = evalEnv.call<Pothos::Object>("eval", "false");
    POTHOS_TEST_TRUE(not resultF.convert<bool>());

    //simple expression
    const auto result = evalEnv.call<Pothos::Object>("eval", "1 + 2");
    POTHOS_TEST_EQUAL(result.convert<int>(), 3);

    //a pothos type
    //const auto result2 = evalEnv.call<Pothos::Object>("eval", "DType(\"int32\")");
    //POTHOS_TEST_TRUE(result2.convert<Pothos::DType>() == Pothos::DType(typeid(int)));
コード例 #13
0
#include <iostream>

POTHOS_TEST_BLOCK("/blocks/tests", test_network_topology)
{
    //spawn a server and client
    std::cout << "create proxy server\n";
    Pothos::RemoteServer server("tcp://0.0.0.0");
    Pothos::RemoteClient client("tcp://localhost:"+server.getActualPort());

    //local and remote block registries
    auto remoteReg = client.makeEnvironment("managed")->findProxy("Pothos/BlockRegistry");
    auto localReg = Pothos::ProxyEnvironment::make("managed")->findProxy("Pothos/BlockRegistry");

    //create local and remote unit test blocks
    std::cout << "create remote feeder\n";
    auto feeder = remoteReg.callProxy("/blocks/feeder_source", "int");
    std::cout << "create local collector\n";
    auto collector = localReg.callProxy("/blocks/collector_sink", "int");

    //create a test plan
    Poco::JSON::Object::Ptr testPlan(new Poco::JSON::Object());
    testPlan->set("enableBuffers", true);
    testPlan->set("enableLabels", true);
    testPlan->set("enableMessages", true);
    auto expected = feeder.callProxy("feedTestPlan", testPlan);

    //run the topology
    std::cout << "run the topology\n";
    {
        Pothos::Topology topology;
        topology.connect(feeder, 0, collector, 0);