platform.apilevel = '2.5'

screen = platform.window
w = screen:width()
h = screen:height()

pcall(function () require 'bleCentral' end)

require "color"
local bleState = ''
local bleStatus = 'Stand by'
local peripheralName = ''
local myPeripheral = nil
local nameCheckList = {'Tag 2.0', 'CC2650'}
local nameList = {'TI Sensor Tag 2.0', 'CC2650 SensorTag', 'TI SensorTag 20'}
local sensorList = {'Barometric Pressure', 'Light Intensity', 'Accelerometer', 'Magnetometer', 'Gyroscope'}

local timeList = {}
var.store("timeList", timeList)
local timeIndex = 0
local pause = true
local baTemp = nil
local baroList = {}
var.store("baroList", baroList)
local lightList = {}
var.store("lightList", lightList)
local acc_x = {}
var.store("acc_x", acc_x)
local acc_y = {}
var.store("acc_y", acc_y)
local acc_z = {}
var.store("acc_z", acc_z)

-- TI Sensor Tag Init Variables

--Simple Keys
local keysRead = 'FFE1'
local keyPress = nil
local Lstart = 0
local Lstop = 0
local Rstart = 0
local Rstop = 0

-- Barometric Pressure
local baData = 'F000AA41-0451-4000-B000-000000000000'
local baConfig = 'F000AA42-0451-4000-B000-000000000000'
local baCalib = 'F000AA43-0451-4000-B000-000000000000'
local baPeriod = 'F000AA44-0451-4000-B000-000000000000'
local Pa = nil
local baTemp = nil

-- Light
local optData = 'F000AA71-0451-4000-B000-000000000000'
local optSwitch = 'F000AA72-0451-4000-B000-000000000000' -- 0: disable, 1: enable
local optPeriod = 'F000AA73-0451-4000-B000-000000000000' -- Period in tens of milliseconds
local Light = nil

-- Movement
local moveData = 'F000AA81-0451-4000-B000-000000000000'
local moveConf = 'F000AA82-0451-4000-B000-000000000000'
local movePeriod = 'F000AA83-0451-4000-B000-000000000000'

-- Layout Functions (resize and paint)

function on.resize()

w = screen:width() or 841
h = screen:height() or 567

pcall(function() ble.addStateListener(listenerCallback) end)
refreshMenu()

screen:invalidate()

end

function on.paint(gc)

w = screen:width() or 841
h = screen:height() or 567

local fontSize = math.floor(h/16 + 0.5)
fontSize = fontSize < 25 and fontSize or 24
fontSize = fontSize > 6 and fontSize or 7
if bleState:find("ON") then gc:setColorRGB(color.blue) else gc:setColorRGB(color.red) end
gc:setFont("sansserif", "r", fontSize)
local sw1 = gc:getStringWidth(bleState)
gc:drawString(bleState, w/3 - sw1/2, 0.95*h, "middle")

gc:setColorRGB(color.green)
gc:fillRect(0.9*w, 0.9*h, 0.1*w, 0.1*h)
gc:setColorRGB(color.black)
gc:drawRect(0.9*w, 0.9*h, 0.1*w, 0.1*h)
local sw = gc:getStringWidth('Scan')
gc:drawString('Scan', 0.95*w - sw/2, 0.95*h, 'middle')

gc:setColorRGB(color.red)
gc:fillRect(0, 0.9*h, 0.1*w, 0.1*h)
gc:setColorRGB(color.black)
gc:drawRect(0, 0.9*h, 0.1*w, 0.1*h)
local sw = gc:getStringWidth('Stop')
gc:drawString('Stop', 0.05*w - sw/2, 0.95*h, 'middle')

local sensorVarList = {Pa, Light, xA, xM, xG}

for n = 1, #sensorList do

local sw = gc:getStringWidth(sensorList[n])
if sensorVarList[n] then gc:setColorRGB(color.blue) else gc:setColorRGB(color.gray) end
gc:drawString(sensorList[n], 0.05*w, 0.05*h + h/(2+#sensorList) + (n-1)*h/(2+#sensorList), 'middle')

end

if peripheralName ~= '' then

gc:setColorRGB(color.blue)
local str = peripheralName..' Movement Explorer'
local sw = gc:getStringWidth(str)
gc:drawString(str, 0.5*w - sw/2, 0.05*h, 'middle')

else

gc:setColorRGB(color.gray)
local str = nameList[1]..' Movement Explorer'
local sw = gc:getStringWidth(str)
gc:drawString(str, 0.5*w - sw/2, 0.05*h, 'middle')

end

local sw2 = gc:getStringWidth(bleStatus)
gc:drawString(bleStatus, 2*w/3 - sw2/2, 0.95*h, "middle")

gc:setFont("sansserif", "b", fontSize)

gc:setColorRGB(color.black)

if Pa then

local msgP1 = string.format("%s %.1f hPa", "Pressure=", Pa)
local sw = gc:getStringWidth(msgP1)
gc:drawString(msgP1, 0.5*w - sw/2, 0.05*h + h/(2+#sensorList), 'middle')

if baTemp then

local msgP2 = string.format("%s %.1f °C", "Temp=", baTemp)
local sw = gc:getStringWidth(msgP2)
gc:drawString(msgP2, 0.8*w - sw/2, 0.05*h + h/(2+#sensorList), 'middle')

end

end

if Light then

local msgL1 = string.format("%s %.1f Lux", "Light Intensity=", Light)
local sw = gc:getStringWidth(msgL1)
gc:drawString(msgL1, 0.65*w - sw/2, 0.05*h + h/(2+#sensorList) + h/(2+#sensorList), 'middle')

end

if xA and yA and zA then

local msgA1 = string.format("%s %.1f hPa", "xA=", xA)
local sw = gc:getStringWidth(msgA1)
gc:drawString(msgA1, 0.4*w - sw/2, 0.05*h + h/(2+#sensorList) + 2*h/(2+#sensorList), 'middle')
local msgA2 = string.format("%s %.1f hPa", "yA=", yA)
local sw = gc:getStringWidth(msgA2)
gc:drawString(msgA2, 0.65*w - sw/2, 0.05*h + h/(2+#sensorList) + 2*h/(2+#sensorList), 'middle')
local msgA3 = string.format("%s %.1f hPa", "zA=", zA)
local sw = gc:getStringWidth(msgA3)
gc:drawString(msgA3, 0.9*w - sw/2, 0.05*h + h/(2+#sensorList) + 2*h/(2+#sensorList), 'middle')

end

if xM and yM and zM then

local msgM1 = string.format("%s %.1f hPa", "xM=", xM)
local sw = gc:getStringWidth(msgM1)
gc:drawString(msgM1, 0.4*w - sw/2, 0.05*h + h/(2+#sensorList) + 3*h/(2+#sensorList), 'middle')
local msgM2 = string.format("%s %.1f hPa", "yM=", yM)
local sw = gc:getStringWidth(msgM2)
gc:drawString(msgM2, 0.65*w - sw/2, 0.05*h + h/(2+#sensorList) + 3*h/(2+#sensorList), 'middle')
local msgM3 = string.format("%s %.1f hPa", "zM=", zM)
local sw = gc:getStringWidth(msgM3)
gc:drawString(msgM3, 0.9*w - sw/2, 0.05*h + h/(2+#sensorList) + 3*h/(2+#sensorList), 'middle')

end

if xG and yG and zG then

local msgG1 = string.format("%s %.1f hPa", "xG=", xG)
local sw = gc:getStringWidth(msgG1)
gc:drawString(msgG1, 0.4*w - sw/2, 0.05*h + h/(2+#sensorList) + 4*h/(2+#sensorList), 'middle')
local msgG2 = string.format("%s %.1f hPa", "yG=", yG)
local sw = gc:getStringWidth(msgG2)
gc:drawString(msgG2, 0.65*w - sw/2, 0.05*h + h/(2+#sensorList) + 4*h/(2+#sensorList), 'middle')
local msgG3 = string.format("%s %.1f hPa", "zG=", zG)
local sw = gc:getStringWidth(msgG3)
gc:drawString(msgG3, 0.9*w - sw/2, 0.05*h + h/(2+#sensorList) + 4*h/(2+#sensorList), 'middle')

end

end

--Menu, Keyboard and Mouse Functions--------------

function refreshMenu()

Menu={

{"Controls",

{"Scan and Connect", function() peripheralOn() end},
{"Disconnect", function() peripheralOff() end},
{"Reset", function()
bleState = ''
bleStatus = 'Stand by'
on.resize() end},

},

}

toolpalette.register(Menu)

end

function on.enterKey()

peripheralOn()

end

function on.escapeKey()

timeIndex = 0
timeList = {}
pause = true

-- Barometric Pressure
Pa = nil
baTemp = nil

-- Acceleration
xA = nil
yA = nil
zA = nil

-- Magnetometer
xM = nil
yM = nil
zM = nil

-- Gyroscope
xG = nil
yG = nil
zG = nil

Light = nil
lightList = {}
baroList = {}
acc_x = {}
acc_y = {}
acc_z = {}
var.store("acc_x", acc_x)
var.store("acc_y", acc_y)
var.store("acc_z", acc_z)
var.store("baroList", baroList)
var.store("timeList", timeList)
var.store("lightList", lightList)

screen:invalidate()

end

function resetall()

on.escapeKey()
peripheralOff()
on.resize()
screen:invalidate()

end

function on.mouseUp(x, y)

w = screen:width() or 841
h = screen:height() or 567

if x > 0.9*w and y > 0.9*h then on.enterKey() end
if x < 0.1*w and y > 0.9*h then resetall() end
screen:invalidate()

end

---

-- BLE General Functions -----------

function listenerCallback(state, scriptError)

if state == ble.ON then
bleState = 'BLE ON'
elseif state == ble.OFF then
bleState = 'BLE OFF'
elseif state == ble.RESETTING then
bleState = 'BLE RESET'
elseif state == ble.UNSUPPORTED then
bleState = 'UNSUPPORTED'
if scriptError then
print('Error message: BLE not supported')
end
end

screen:invalidate()

end

function peripheralOn()

bleCentral.startScanning(callbackScan)
bleStatus = 'Scanning'
screen:invalidate()

end

function peripheralOff()

bleCentral.stopScanning()

if myPeripheral then
myPeripheral:disconnect()
end

bleStatus = 'Stand by'
peripheralName = ''
screen:invalidate()

end

function callbackScan(peripheral)

if peripheral ~= nil then
peripheralName = peripheral:getName() or 'Unknown Device'
for n =1, #nameCheckList do

if peripheralName and peripheralName:find(nameCheckList[n]) then

peripheral:connect(callbackConnect)

elseif not peripheralName:find('unsupported') then

peripheralName = peripheralName..' (unsupported)'

end

end

end

screen:invalidate()

end

function callbackConnect(peripheral, event)

if event == bleCentral.CONNECTED then

bleCentral.stopScanning()
bleStatus = 'Connected'
myPeripheral = peripheral
peripheralName = peripheral:getName()
peripheral:discoverServices(callbackServices)

elseif event == bleCentral.DISCONNECTED then
bleStatus = 'Disconnected'
peripheralName = ''

end
screen:invalidate()

end

function callbackServices(peripheral)

if peripheral ~= nil and peripheral:getState() and peripheral:getState() == bleCentral.CONNECTED then

local services = peripheral:getServices()
for _,service in ipairs(services) do
service:discoverCharacteristics(callbackCharacteristics)
end

end

screen:invalidate()

end

-- BLE Specific Functions ---------

function callbackCharacteristics(service)

local characteristicsList = service:getCharacteristics()

for _,characteristic in ipairs(characteristicsList) do

-- Simple Keys
if characteristic:getUUID() == keysRead then

characteristic:setValueUpdateListener(callbackCharacteristic)

characteristic:setNotify(true)

end

-- Barometric Pressure
if characteristic:getUUID() == baData then

readBa = characteristic
readBa:setValueUpdateListener(callbackCharacteristic)
readBa:setNotify(true)

end

if characteristic:getUUID() == baCalib then

calibBa = characteristic
calibBa:setValueUpdateListener(callbackCharacteristic)
calibBa:read()

end

if characteristic:getUUID() == baConfig then

writeBa = characteristic
local msg = string.char(1)
writeBa:setWriteCompleteListener(callbackCharacteristic)
writeBa:write(msg, true)
local msg = string.char(2)
writeBa:setWriteCompleteListener(callbackCharacteristic)
writeBa:write(msg, true)

end

-- Light

if characteristic:getUUID() == optData then --01 M

characteristic:setValueUpdateListener(callbackCharacteristic)
characteristic:setNotify(true)

end

if characteristic:getUUID() == optSwitch then -- 02

local msg = 1 characteristic:setWriteCompleteListener(callbackCharacteristic) characteristic:write(string.char(msg), true)

end

--Movement SENSOR

if characteristic:getUUID() == moveData then

characteristic:setValueUpdateListener(callbackCharacteristic)
characteristic:setNotify(true)

end

if characteristic:getUUID() == moveConf then

local msg = ble.pack('u16', 0x007F)
characteristic:setWriteCompleteListener(callbackCharacteristic)
characteristic:write(msg, true)

end

if characteristic:getUUID() == movePeriod then

characteristic:setWriteCompleteListener(callbackCharacteristic)
characteristic:write(string.char(1), true)

end

end

end

function callbackCharacteristic(characteristic)

-- Simple Keys

if characteristic:getUUID() == keysRead then

local value = characteristic:getValue()
if value and string.len(tostring(value)) == 1 then

keyPress = ble.unpack("u8",value)

if keyPress then

if keyPress == 2 then
Lstart = timer.getMilliSecCounter()
bleStatus = "Left button"

end

if keyPress == 1 then

Rstart = timer.getMilliSecCounter()
bleStatus = "Right button"

end

if keyPress == 0 then

bleStatus = 'Connected'
if Lstart ~= 0 then Lstop = math.abs((Lstart - timer.getMilliSecCounter())/1000) end
if Rstart ~= 0 then Rstop = math.abs((Rstart - timer.getMilliSecCounter())/1000) end

end

if Lstop > 0 then

if Lstop > 1 then

on.enterKey()

else

pause = not pause

end
Lstart = 0
Lstop = 0

end

if Rstop > 0 then

if Rstop > 1 then

resetall()

else

on.escapeKey()

end
Rstart = 0
Rstop = 0

end

var.store("keypress", keyPress)

end

end

end

--BAROMETER
if characteristic:getUUID() == baData or characteristic:getUUID() == baCalib then

local value = characteristic:getValue()
if value and string.len(tostring(value)) > 4 then

local temp, pressure = ble.unpack('u24', value)
baTemp = temp/100
Pa = ble.unpack("u24", pressure)/100

end

end

-- Light Intensity
if characteristic:getUUID() == optData then

local value = characteristic:getValue()
if value then

local exponent, remnant = ble.unpack("u16", value)
local rawLux = ble.unpack('u16', value)
local exponent = bit.brshift(bit.band(rawLux, 0xF000), 12)
local mantissa = bit.band(rawLux, 0x0FFF)
Light = mantissa * math.pow(2, exponent)/100

end

end

-- Movement

if characteristic:getUUID() == moveData then

local value = characteristic:getValue()
if value then

local m1, m2, m3, m4, m5, m6, m7, m8, m9 = ble.unpack("s16s16s16s16s16s16s16s16s16", value)
xG = -1*tonumber(m1)* 500 / 65536
yG = -1*tonumber(m2)* 500 / 65536
zG = -1*tonumber(m3)* 500 / 65536
xA = -3.9*tonumber(m4)* 2 / 32768
yA = -3.9*tonumber(m5)* 2 / 32768
zA = -3.9*tonumber(m6)* 2 / 32768
xM = (tonumber(m7)
yM = (tonumber(m8)
zM = (tonumber(m9)

end

end

if pause == false then

if Pa then

timeIndex = timeIndex + 1
table.insert(timeList, timeIndex)
var.store("timeList", timeList)
table.insert(baroList, Pa)
var.store("baroList", baroList)

end

if Light then

table.insert(lightList, Light)
var.store("lightList", lightList)

end

if xA then

table.insert(acc_x, xA)
var.store("acc_x", acc_x)

end

if yA then

table.insert(acc_y, yA)
var.store("acc_y", acc_y)

end

if zA then

table.insert(acc_z, zA)
var.store("acc_z", acc_z)

end

end

screen:invalidate()

end

-- LuaBit v0.3 (Lua bit library) ---------

--[[---------------
LuaBit v0.3
-------------------
a bitwise operation lib for lua.
http://luaforge.net/projects/bit/
Under the MIT license.
copyright(c) 2006 hanzhao (abrash_han@hotmail.com)
--]]---------------

do

------------------------
-- bit lib implementions

local function check_int(n)
-- checking not float

if(n - math.floor(n) > 0) then

error("trying to use bitwise operation on non-integer!")

end

end

local function to_bits(n)

check_int(n)
if(n < 0) then

-- negative
return to_bits(bit.bnot(math.abs(n)) + 1)

end
-- to bits table
local tbl = {}
local cnt = 1
while (n > 0) do

local last = n % 2
if(last == 1) then

tbl[cnt] = 1

else

tbl[cnt] = 0

end

n = (n-last)/2
cnt = cnt + 1

end
return tbl

end

local function tbl_to_number(tbl)

local n = table.getn(tbl)
local rslt = 0
local power = 1
for i = 1, n do

rslt = rslt + tbl[i]*power

power = power*2
end
return rslt

end

local function expand(tbl_m, tbl_n)

local big = {}
local small = {}
if(table.getn(tbl_m) > table.getn(tbl_n)) then

big = tbl_m
small = tbl_n

else

big = tbl_n
small = tbl_m

end
-- expand small
for i = table.getn(small) + 1, table.getn(big) do

small[i] = 0

end

end

local function bit_or(m, n)

local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
local rslt = math.max(table.getn(tbl_m), table.getn(tbl_n))
for i = 1, rslt do

if(tbl_m[i]== 0 and tbl_n[i] == 0) then

tbl[i] = 0

else

tbl[i] = 1

end

end
return tbl_to_number(tbl)

end

local function bit_and(m, n)

local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
local rslt = math.max(table.getn(tbl_m), table.getn(tbl_n))
for i = 1, rslt do

if(tbl_m[i]== 0 or tbl_n[i] == 0) then

tbl[i] = 0

else

tbl[i] = 1

end

end
return tbl_to_number(tbl)

end

local function bit_not(n)

local tbl = to_bits(n)
local size = math.max(table.getn(tbl), 32)
for i = 1, size do

if(tbl[i] == 1) then

tbl[i] = 0

else

tbl[i] = 1

end

end
return tbl_to_number(tbl)

end

local function bit_xor(m, n)

local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
local rslt = math.max(table.getn(tbl_m), table.getn(tbl_n))
for i = 1, rslt do

if(tbl_m[i] ~= tbl_n[i]) then

tbl[i] = 1

else

tbl[i] = 0

end

end
--table.foreach(tbl, print)
return tbl_to_number(tbl)

end

local function bit_rshift(n, bits)

check_int(n)
local high_bit = 0
if(n < 0) then

-- negative
n = bit_not(math.abs(n)) + 1
high_bit = 2147483648 -- 0x80000000

end
for i=1, bits do

n = n/2
n = bit_or(math.floor(n), high_bit)

end
return math.floor(n)

end

-- logic rightshift assures zero filling shift

local function bit_logic_rshift(n, bits)

check_int(n)
if(n < 0) then

-- negative
n = bit_not(math.abs(n)) + 1

end
for i=1, bits do

n = n/2

end
return math.floor(n)

end

local function bit_lshift(n, bits)

check_int(n)
if(n < 0) then

-- negative
n = bit_not(math.abs(n)) + 1

end
for i=1, bits do

n = n*2

end
return bit_and(n, 4294967295) -- 0xFFFFFFFF

end

local function bit_xor2(m, n)

local rhs = bit_or(bit_not(m), bit_not(n))
local lhs = bit_or(m, n)
local rslt = bit_and(lhs, rhs)
return rslt

end

--------------------
-- bit lib interface

bit = {

-- bit operations
bnot = bit_not,
band = bit_and,
bor = bit_or,
bxor = bit_xor,
brshift = bit_rshift,
blshift = bit_lshift,
bxor2 = bit_xor2,
blogic_rshift = bit_logic_rshift,

-- utility func
tobits = to_bits,
tonumb = tbl_to_number,
}

end