我使用NVIDIA UI Composer Studio构建了一个Instrumentation Cluster。 要控制动画，它使用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＃中从我的数据源动态读取的数据。
非常感谢你的帮助。这项工作是为了我的学士学位而且我很长一段时间陷入困境，而且我几乎没有想法。
答案 0 :(得分：1)
这一切都取决于Nvidia事物对用户的暴露程度（就API和Lua基础库而言）。
假设它可用，您可以使用io.read从其他来源读入数据文件（例如csv），然后将其自己解析到您的表中。如果您可以预处理文件以使用有效的Lua语法（例如，前置return {，将值分隔为,，并以}结尾，则可以使用loadstring直接加载该字符串）。
如果他们允许，您可以使用外部库与RS232，Excel，套接字等连接。
PS：它是Lua而不是LUA（不是缩写，而是月亮的葡萄牙名词;）
编辑：示例mkfifo
所以在Linux中它是这样的：用mkfifo fff创建一个fifo并为它提供echo''＆gt; fff阻止Lua阻止。
在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 :(得分：0)
我希望你的学士学位成绩好，这个回答是什么，为时已晚了1。5年。 :)尽管如此：
作为UI Composer团队的成员和Lua脚本编写者，我经常用于将外部数据和事件异步传输到运行时的一种技术是使用Lua Socket库。我在它上面写了一个抽象层作为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)