sierrawireless / org.eclipse.koneki.ldt Goto Github PK

local airvantage    = require "airvantage"  -- Library to access AirVantage
local device        = require "devicetree"
local system        = require "system"
local serial        = require "serial"
local sched = require 'sched'
local serial    = require "serial"  -- Serial lib
local os        = require "os"      -- Operating system lib
local string = require 'string'
require 'pack'
local sendcommand =require "sendcommand"
local commandreceive =require "commandreceive"

-- Global Variables used for thread communication
contrast = 9
screen_brightness = 50
key_brightness = 50
line1 = string.rep(' ', 16)
line2 = string.rep(' ', 16)


----------------------------------------------------
-- The callback function that receives the commands
-- and prints the variable path and the table value
-- Need to return "ok" at the end
function line1command (assetInstance, value, path)
    print(path)
    print (value[1])
    sendcommand.line1(value[1])
    return "ok"
end

----------------------------------------------------
-- The callback function that receives the commands
-- and prints the variable path and the table value
-- Need to return "ok" at the end
function line2command (assetInstance, value, path)
    print(path)
    print (value[1])
    sendcommand.line2(value[1])
    return "ok"
end

----------------------------------------------------
-- The callback function that receives the commands
-- and prints the variable path and the table value
-- Need to return "ok" at the end
function contrastcommand (assetInstance, value, path)
    print(path)
    print (value[1])
    contrast = value[1]
    sendcommand.contrast(contrast)
    return "ok"
end

----------------------------------------------------
-- The callback function that receives the commands
-- and prints the variable path and the table value
-- Need to return "ok" at the end
function brightnesscommand (assetInstance, value, path)
    print(path)
    print (value[1])
    sendcommand.brightness(value[1], value[2])
    return "ok"
end


--------------------------------------------------------------------------------
-- Check if the serial port has been reserved for our use
-- if not, reserve it and reboot to gain control
local   function reserve_serial_port ()

    local serial_reserve_var = "system.aleos.reserve.ser0"

    local serial_available = assert (device.get(serial_reserve_var))
    if serial_available ~= 1 then
        print ("WARNING","serial port not available, reserving it now...")
        local result = assert (device.set(serial_reserve_var, 1))
        print ("WARNING","Serial port Reserved ok, rebooting now...")
        system.reboot("Reserving Serial Port")
        sched.wait(30)  -- stop here until the reset occurs
    end
    print ("Serial Port has been reserved for our use.")

    sched.wait(1)
end

--------------------------------------------------------------------------------
-- open and configure the serial port
local   function open_serial_port ()

    local portname = "/dev/ttyS0"
    local serial_config =
    { parity = "none", flowControl = "none", numDataBits = 8, numStopBits = 1, baudrate = 19200 }

    local serialdev = assert (serial.open(portname, serial_config))

    serialdev:settimeout(0)    -- set a timeout in seconds

    sched.wait(1)

    return serialdev
end

--------------------------------------------------------------------------------
-- Read up to a buffer full of data from the serial port
local   function read_serial_port (sdevice)

    while true do
        local full_buffer, err, partial_buffer = sdevice:read(250)    -- read data from serial port
        if full_buffer then
            return full_buffer
        elseif partial_buffer then
            return partial_buffer
        else
            if not string.match (err, 'timeout') then   -- if this wasn't a timeout with no data
                return nil, err
            end    -- timeout with no data, continue waiting...
        end
    end

end

local function doframes (dataframes)
    local i

    for i = 1, #dataframes do
        commandreceive.decodeframes (dataframes[i])
    end
end

local function read_serial (serdev)

    local dataframes
    while true do
        dataframes = commandreceive.getframes (read_serial_port(serdev))
        doframes (dataframes)
        dataframes = {}
    end

end


local function main ()

    airvantage.init ()
    local crystalasset = assert (airvantage.newasset("Crystal"))
    assert (crystalasset:start(), "Can't register Agent")

    sendcommand.init (crystalasset)
    commandreceive.init (crystalasset)

    --Ensure we are talking to correct server
    device.init()
    device.set ("config.server.url", "http://edge.m2mop.net/device/awtda/com")
    print (device.set ("config.agent.deviceId", "CA0012101361001"))
    server, status = device.get("config.server.url")

    -- Register Callback Functions Against Branches
    -- Note the name of the command in the tree
    crystalasset.tree.commands.Line1 = line1command
    crystalasset.tree.commands.Line2 = line2command
    crystalasset.tree.commands.Contrast = contrastcommand
    crystalasset.tree.commands.Brightness = brightnesscommand

    local i
    reserve_serial_port ()
    serdev = open_serial_port ()

    local threadname = sched.run (function()read_serial (serdev)end)

    sendcommand.getline1 ()
    sendcommand.getline2 ()

    sched.wait (5)
    crystalasset:pushdata("uplink", {line1=line1, timestamp=os.time()}, "hourly")
    crystalasset:pushdata("uplink", {line2=line2, timestamp=os.time()}, "hourly")

    sendcommand.contrast (contrast)
    sendcommand.brightness (screen_brightness)
    -- Push them into hourly queue


    while true do
        -- Connect to the server and push all the data up
        airvantage.triggerpolicy("*")
        airvantage.connecttoserver ()
        sched.wait(30)
    end

    os.exit()
end

sched.run(main)
sched.loop()

-- @usage local i 
-- local v
-- local h

local i
 local v
 local h