-- TI Innovator User set up

function on.escapeKey()

TI_Innovator.Send(hubStrOff)
on.resize()
screen:invalidate()

function on.mouseDown(x, y)

TI_Innovator.Send(hubStrOn) -- This is an example of sending a SET command to the Hub
screen:invalidate()

function on.mouseUp (x,y)

TI_Innovator.Send(hubStrOff)
screen:invalidate()

function str2list(input, def)
local list = {}
if input:find(def) then

list = input:split(def)
table.foreachi(list,print)

list = {input}

function TI_InnovatorReadCallback(port, error_msg) -- this is the callback function that is defined above and catches the result of a READ command send to the Hub.

rxValue = port:getValue() or '' -- this gets the actual return value from the hub and puts it in the variable rxValue. The user may choose any variable name and also may do any calibration or ranging of the value here. Note that rxValue may be numeric, list or string (hence the utility function list2str)
if tonumber(rxValue) then rxValue = math.floor(100*rxValue+0.5)/100
else rxValue = tostring(rxValue) rxValue = str2list(rxValue,string.char(10))[1] end
addMsg(hubStrOn)
if tonumber(rxValue) then voltage = (rxValue/2^14)*3.3 end -- an example of converting a raw 14 bit ADC value into voltage.
screen:invalidate()

function TI_InnovatorStateCallback(event)

addMsg("TI_InnovatorStateCallback")
if 'ready' == event then
TI_InnovatorConfig()
elseif "disconnected" == event then
-- user may choose to do some clean up or display a msg when the Hub is disconnected.
addMsg("TI_Innovator Hub disconnected")
end
screen:invalidate()

function TI_InnovatorConfig() -- this function is called from TI_InnovatorStateCallback() when a ready connection is succesful.

-- place CONNECT and other Hub startup commands here
addMsg("TI_Innovator Hub connected")

--End of user code do not modify below this line

-- TI Innovator Code Do not modify any code below this line

-- oneShotTimer BEGINS

local timerstart = timer.start
local timerstop = timer.stop
timer.start = nil
timer.stop = nil
local currentTimer = nil

local function timerStart(t)

currentTimer = t
timerstart(t.period/1000)

end

local function timerStop()

currentTimer = nil
timerstop()

end

local function setTimer(t)

if t.period==nil or type(t.period)~='number' or t.period < 10 then error('period in milliseconds >= 10') end
timerStart(t)
return t

end

function oneShotTimer(period, listenerHandler, ...)

if type(listenerHandler) ~= 'function' then

error('createTimerOneShot: function expected')

end
setTimer {

period = period,
oneShot = true,
listenerHandler = listenerHandler,
params = { ... },

}

end

function on.timer()

local ct = currentTimer
if currentTimer == nil then

timerStop()

end
if currentTimer.oneShot then

currentTimer = nil
timerStop()

end
ct.listenerHandler(unpack(ct.params))

end

-- oneShotTimer ENDS

-- TI Innovator BEGINS

TI_Innovator = { }

function TI_Innovator.init(theStateCallback)

if not pcall(function() require 'asi' end) then

addMsg('Hub NOT available')
return

end

addMsg('Hub available')

isASIavailable = true

local HANDSHAKE_GREETING = 'ISTI\n'
local HANDSHAKE_ANSWER = 'TISTEM'
local portFoundList = { }
local state
local handshakeState
local notifyEvent
local asiStateListener
local startScanning
local stopScanning
local portFoundListener
local portStateListener
local handshake_SendListener
local handshake_readListener
local handshake_port
local TI_Innovator_port
local baudRate = asi.BAUD_RATE_DEFAULT
local readTimeout = asi.READ_TIMEOUT_DEFAULT

-- User callbacks
local stateCallback = theStateCallback
local SendCallback
local readCallback

function notifyEvent(event)

addMsg('notifying '.. event)
if stateCallback then

stateCallback(event)

else

addMsg('no callback registered')

end

end

function startScanning()

if isASIavailable then

asi.startScanning(portFoundListener)
notifyEvent('scanning')

end

end

function stopScanning()

handshake_port = nil
portFoundList = { }
asi.stopScanning()

end

function asiStateListener(asiState)

if asi.ON == asiState then

if state == 'active' then

startScanning()

end

elseif asi.UNSUPPORTED == asiState then

notifyEvent(asi.UNSUPPORTED)

end

end

function portFoundListener(portFound)

addMsg('portFoundListener '.. portFound:getName())
table.insert(portFoundList, portFound)
if not TI_Innovator_port and not handshake_port then

handshake_port = portFoundList[1]
oneShotTimer(100, handshake_port.connect, handshake_port, portStateListener)

end

end

function portStateListener(reportedPort, event, error_msg)

addMsg('portStateListener '..reportedPort:getName()..' '..event)
if asi.CONNECTED == event then

-- configure port for handshake
reportedPort:setWriteListener(handshake_writeListener)
reportedPort:setReadListener(handshake_readListener)
reportedPort:setReadTimeout(500)
handshakeState = 'handshake'
-- write handshake greeting
addMsg("HANDSHAKE_GREETING: "..HANDSHAKE_GREETING)
oneShotTimer(200, reportedPort.write, reportedPort, HANDSHAKE_GREETING)

elseif asi.CONNECTING_FAILED == event then

if reportedPort == handshake_port then

table.remove(portFoundList, 1)
if #portFoundList>0 then

handshake_port = portFoundList[1]
handshake_port:connect(portStateListener)

else

handshake_port = nil

end

elseif reportedPort == TI_Innovator_port then

TI_Innovator_port = nil
asi.startScanning(portFoundListener)

end

elseif asi.DISCONNECTED == event then

if reportedPort == TI_Innovator_port then

if state == 'active' then

if reportedPort:getState() == asi.DISCONNECTED then

reportedPort:connect(portStateListener)

else

TI_Innovator_port = nil
asi.startScanning(portFoundListener)

end

notifyEvent('disconnected')

end

end

end

end

function handshake_writeListener(reportedPort, error_msg)

if error_msg then

addMsg('handshake_writeListener '..error_msg)
return

end
if 'handshake' == handshakeState then

reportedPort:read(#HANDSHAKE_ANSWER+2)

end

end

function handshake_readListener(reportedPort, error_msg)

if error_msg then

addMsg('handshake_writeListener '..error_msg)
return

end
local answer = reportedPort:getValue()
if 'handshake' == handshakeState then

-- Validate answer
if answer and answer:find(HANDSHAKE_ANSWER) then

addMsg("HANDSHAKE_ANSWER: "..HANDSHAKE_ANSWER)
stopScanning()
handshakeState = 'ready'
reportedPort:write('BEGIN\n')
reportedPort:read(7)

else

reportedPort:disconnect()
table.remove(portFoundList, 1)
if #portFoundList>0 then

handshake_port = portFoundList[1]
handshake_port:connect(portStateListener)

else

handshake_port = nil

end

end

elseif 'ready' == handshakeState then

if answer and answer:find('READY') then

-- Configure port for normal use
TI_Innovator_port = reportedPort
TI_Innovator_port:setReadTimeout(readTimeout)
TI_Innovator.setWriteListener(SendCallback)
TI_Innovator.setReadListener(readCallback)
-- Notify launchpad is ready
notifyEvent('ready')

end

end

end

-- INTERFACE -- BEGINS --

function TI_Innovator.connect()

state = 'active'
startScanning()

end

function TI_Innovator.disconnect()

state = 'inactive'
if isASIavailable then

if TI_Innovator_port then

TI_Innovator_port:disconnect()
TI_Innovator_port = nil

end
stopScanning()

end

end

function TI_Innovator.setWriteListener(newWriteCallback)

writeCallback = newWriteCallback
if TI_Innovator_port then

TI_Innovator_port:setWriteListener(writeCallback)

end

end

function TI_Innovator.setReadListener(newReadCallback, newReadObject)

readCallback = newReadCallback
if TI_Innovator_port then

TI_Innovator_port:setReadListener(readCallback)

end

end

function TI_Innovator.setBaudRate(newBaudRate)

baudRate = newBaudRate
if TI_Innovator_port then

TI_Innovator_port:setBaudRate(baudRate)

end

end

function TI_Innovator.setReadTimeout(newReadTimeout)

readTimeout = newReadTimeout
if TI_Innovator_port then

TI_Innovator_port:setReadTimeout(readTimeout)

end

end

function TI_Innovator.Send(data)

if not TI_Innovator_port then

addMsg('No Hub attached')
return 'No Hub attached'

end
local result = TI_Innovator_port:write(data .. '\n')
if result then addMsg(tostring(data)..': '.. tostring(result))
else addMsg(tostring(data)) end
return result

end

function TI_Innovator.Read(bytes_to_read)

addMsg('TI_Innovator.Read')
if not TI_Innovator_port then

return "No TI Hub attached"

end
return TI_Innovator_port:read(bytes_to_read)

end

function TI_Innovator.request(request)

if not TI_Innovator_port then

return "No TI Hub attached"

end
local result = TI_Innovator_port:write(request .. '\n')
if result then addMsg(tostring(request)..': '.. tostring(result))
else addMsg(tostring(request)) end
result = TI_Innovator_port:read()
addMsg('read() '.. tostring(result))
if result then

addMsg('Error sending request: ' .. tostring(request))

end
return result

end

function TI_Innovator.isConnected()

if not TI_Innovator_port then

return false

end
return TI_Innovator_port:getState() == asi.CONNECTED

end

function TI_Innovator.getName()

if not TI_Innovator_port then

return "No TI Hub attached"

end
return TI_Innovator_port:getName()

end

function TI_Innovator.getIdentifier()

if not TI_Innovator_port then

return "No TI Hub attached"

end
return TI_Innovator_port:getIdentifier()

end

-- INTERFACE -- ENDS --

-- Wait for the ASI to be up and running

asi.addStateListener(asiStateListener)

end