c# - Lua で動的データを取得する

Question

NVIDIA UI Composer Studio を使用してインストルメンテーション クラスターを構築しました。アニメーションを制御するには、Lua スクリプト言語を使用します。今、私はLuaに本当に慣れていないので、私の質問は次のとおりです:

速度計を制御する Lua に次のコード シーケンスがあります。

self.vehicleSpeedData = {} -- 多くの値がここに入れられます

function self.speedSim( inFrame, theController )

local timeInSec, dummy
timeInSec, dummy = getElapsedTime()
-- data based on 60fps
actualFrameNumber = math.floor(timeInSec * 60)
local theSample = ((actualFrameNumber-1) % #self.vehicleSpeedData) + 1
theController.value = self.vehicleSpeedData[theSample] *0.06    

終わり

この例の配列は空です。ご覧のとおり、関数は配列の値を読み取ります。

しかし、私が必要としているのは、このデータを外部ソース (RS232 や CAN シミュレーションなど) から取得できることです...たとえば、C# のデータをその Lua スクリプトに配置できるかどうかです。

私が正確に何を望んでいるのかを説明するのは難しいです。私の考えでは、上記の Lua スクリプトは、データ ソースから C# で動的に読み取ったデータをリッスンして読み取ります。

どうもありがとうございました。この作業は私の学士号を取得するためのもので、この時点で長い間立ち往生しており、ほとんどアイデアがありません。

Answer 1

それはすべて、Nvidia がユーザーに何を公開するかに依存します (API および Lua ベース ライブラリに関して)。

それが利用可能であると仮定するとio.read、別のソースからデータファイル (csv など) を読み込み、それを自分で解析してテーブルに入れることができます。有効な Lua 構文を持つようにファイルを前処理できる場合 (たとえば、先頭に a を追加し、return {値を で区切り,、末尾を a}にする場合、loadstring を使用して文字列を直接ロードできます)。

許可されている場合は、RS232、Excel、ソケットなどとのインターフェイスに外部ライブラリを使用できます。

PS: LUA ではなく Lua です (頭字語ではありませんが、Moon のポルトガル語の名詞です ;))

編集：mkfifoの例

Linux では次のようになります: fifo を作成し、mkfifo fffそれに何か echo ' '> fff を入力して、Lua がブロックされないようにします。

ルアの場合:

fh=io.open('fff','rb')
while true do
    res = fh:read()
    if res then
        print(res)
    end
end

どんな猫でも fff (例: cat 10 > fff) にすると、Lua で出てきます。このようにして、利用可能な値を読み取り、関数の実行ごとにそれらを使用できます。

もう 1 つのオプションは標準入力を使用することですが、このコンポーザーで使用できるかどうかはわかりません。

Answer 2

_{あなたの学士号が無事だったことを願っています。この回答は 1.5 年遅すぎました。:)それにもかかわらず：}

UI Composer チームのメンバーであり、仲間の Lua スクリプターでもある私が、外部データとイベントをランタイムに非同期でストリーミングするためによく使用する手法の 1 つは、Lua ソケットライブラリを使用することです。その上に、UIC 動作として抽象化レイヤーを作成しました。

-- Expected message structure:
-- "<numbytes>,<optionaltag>\n<bytesofmessage>"
-- e.g. "11,simple\nHello World"
-- e.g. "40,\nThis has no tag,\nbut does have a newline"

local ok,socket = pcall(require,'socket')
if not ok then
    output("Error loading socket: "..socket)
else
    local output = output or print
    local sscallbacks = {} -- indexed by simplesocket instance, then tag
    SimpleSocket = {}
    local SSMeta = {}
    SSMeta.__index=SSMeta

    function SimpleSocket:server(port,ip,timeout)
        return self:create('server',port,ip,timeout)
    end

    function SimpleSocket:client(port,ip,timeout)
        return self:create('client',port,ip,timeout)
    end

    function SimpleSocket:create(kind,port,ip,timeout)
        if not port    then port    = 51423 end
        if not ip      then ip      = '*'   end
        if not timeout then timeout = 10    end
        local ss = setmetatable({
            kind    = kind,
            ip      = ip,
            port    = port,
            timeout = timeout/1000,
            queue   = {}
        },SSMeta)
        sscallbacks[ss] = {}
        return ss
    end

    function SSMeta:destroy()
        if self.socket then self.socket:close() end
        callbacks[self] = nil
    end

    function SSMeta:onData(callback,tag)
        self:setCallback('handler',callback,tag)
    end

    function SSMeta:toEncode(callback,tag)
        self:setCallback('encoder',callback,tag)
    end

    function SSMeta:toDecode(callback,tag)
        self:setCallback('decoder',callback,tag)
    end

    function SSMeta:setCallback(type,callback,tag)
        if not tag then tag = "" end
        if not sscallbacks[self][tag] then sscallbacks[self][tag] = {} end
        sscallbacks[self][tag][type] = callback
    end

    function self:onUpdate()
        self:sendQueuedMessages()
        self:receiveMessages()
    end

    function SSMeta:createSocket()
        output("Creating new "..self.kind.." socket to "..self.ip..":"..self.port)
        if self.kind=='server' then
            self.socket = assert(socket.bind(self.ip,self.port))
            self.socket:settimeout(self.timeout)
        else
            self.socket = assert(socket.connect(self.ip,self.port))
        end
    end

    -- Attempts to send all messages from the queue
    function self:sendQueuedMessages()
        for ss,_ in pairs(sscallbacks) do
            while ss.queue[1] do
                if ss:sendMessage(message[1]) then
                    table.remove(ss.queue,1)
                else
                    -- don't attempt any later messages, since ordering may be important
                    return 
                end
            end
        end
    end

    function self:receiveMessages()
        for ss,callbacks in pairs(sscallbacks) do
            if ss.kind=='client' then
                if not ss.socket then ss:createSocket() end
                ss.socket:settimeout(0) -- non-blocking for first byte
                local char1, err = ss.socket:receive(1)
                ss.socket:settimeout(ss.timeout) -- go back to blocking
                if not char1 then
                    -- probably just timed out
                else
                    local header, err = ss.socket:receive('*l')
                    if not header then
                        output(err)
                    else
                        header = char1..header
                        local comma = header:find(',')
                        local bytes = tonumber(header:sub(1,comma-1))
                        local tag   = header:sub(comma+1)
                        local data,err = ss.socket:receive(bytes)
                        if not data then
                            output(err)
                        else
                            if callbacks[tag] and callbacks[tag].decoder then
                                data = callbacks[tag].decoder(data)
                            elseif callbacks[true] and callbacks[true].decoder then
                                data = callbacks[true].decoder(data)
                            end
                            if callbacks[tag] and callbacks[tag].handler then
                                callbacks[tag].handler(data)
                            elseif callbacks[true] and callbacks[true].handler then
                                callbacks[true].handler(data)
                            end
                        end
                    end
                end
            end
        end
    end

    function SSMeta:send(data,tag)
        return self:sendMessage(self:encodeMessage(data,tag))
    end

    function SSMeta:ensureSend(data,tag)
        local message = self:encodeMessage(data,tag)
        if not self:sendMessage(message) then
            table.insert(self.queue,message)
        end
    end

    -- Internal only; use send() or ensureSend()
    function SSMeta:sendMessage(formattedMessage)
        if not self.socket then self:createSocket() end
        if not self.client then self.client = self.socket:accept() end
        if self.client then
            local lastbyte,err = self.client:send(formattedMessage)
            if lastbyte then
                -- TODO: verify that all bytes were sent
                return true
            else
                output(err)
                self.client:close()
                self.client = nil
            end
        else
            -- No client connected before the timeout
        end
    end

    function SSMeta:encodeMessage(data,tag)
        data = tostring(data)
        local callbacks = sscallbacks[self]
        if callbacks[tag] and callbacks[tag].encoder then
            data = callbacks[tag].encoder(data)
        elseif callbacks[true] and callbacks[true].encoder then
            data = callbacks[true].encoder(data)
        end
        return tostring(#data)..","..(tag or "").."\n"..data
    end

end

これにより、複数の異なるシステムが同じソケット上で異なるタグ付き通信を使用して通信し、場合によっては異なるエンコーダー/デコーダーを使用してデータをシリアル化/逆シリアル化することができます。

受信側では、これはたとえば次のように使用されます。

local ss = require 'SimpleSocket'

local client = ss:client()
client:onData(function(d) print("Client got *: "..d) end,true)