HTTPS SSH

Abstract: Project Sandstar

Background:

Sandstar integrates sandstar engine, haystack and sedona into a seamless whole:

Methods:

Device template is created in order to abstract system calls to GPIO, I2C, UART and other hardware level communication. Within this file we have utilized a tag called “channel”. A zinc in the form of grid with records where “channel” tag which is type number is generated. Within the zinc file we are forming all tags necessary to convert raw data into cur val data form. This consists of tags that defines programming data type, port definition, sandstar engine, localization conversion and last regular haystack tags are defined for application abstraction. Sandstar C/C++ engine consumes both files and communicates to both Sedona and Haystack rest api.

Results:

Abstraction in both hardware level and point definition level enables us to generate portable Sedona code. With the abstraction of IO, sedona code can be written in a way it covers all potential input, output and setpoint types. With the power of haystack ops (Rest api), we can add a record to the sandstar engine thus enabling the branch of the Sedona code that is waiting to be activated. We call this feature meta-morphing programing. On the roadmap, having haystack client in sedona will help us to have P2P device communication along with historical data and analytics based control.

Conclusion:

Sandstar project will change how we think of DDC. Major improvements are hardware independent sedona code, historical data based control logic, driver abstraction via haystack can be achieved now. With the improvements to haystack ops where Sedona components can be created changed deleted and linked, artificial intelligence can be utilized to generate and improve upon human generated DDC code.

Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

Prerequisites

BeagleBone board with 4G on board disk memory
Internet connection

Installing

Flash a fresh Debian 9.x IoT image onto a BeagleBone and log on as default debian user.
Issue the following commands:

  git clone https://bitbucket.org/ankalabs/sandstar.git
  cd sandstar
  git submodule init
  git submodule update
  mkdir build
  cd build

  #Release build
  cmake -DCMAKE_BUILD_TYPE=Release ../sandstar/
  #This will build software and create debian package for it.
  make -j3 package  
  #run application
  ./bin/svm --plat

  #Debug build
  cmake -DCMAKE_BUILD_TYPE=Debug ../sandstar/
  #This will build software and create debian package for it.
  make -j3 package  
  #run application
  ./bin/svmd --plat

Cross compilation

To cross compile from your host OS for arm target you need arm-linux-gnueabihf-g++ (g++-arm-linux-gnueabihf on debian) and arm-linux-gnueabihf-gcc (gcc-arm-linux-gnueabihf on debian) installed in your host OS.

  git clone https://bitbucket.org/ankalabs/sandstar.git
  cd sandstar
  git submodule init
  git submodule update
  mkdir arm-build
  cd arm-build

  #Release build
  cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=$PWD/../sandstar/platform/linux/armv7l.cmake ../sandstar/
  #This will build software and create debian package for it.
  make -j3 package  

  #Debug build
  cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=$PWD/../sandstar/platform/linux/armv7l.cmake ../sandstar/
  #This will build software and create debian package for it.
  make -j3 package  

Running the tests

Logon as eacio user with password of eacio
Test the installation with the following commands:

  makeunixvm
  sudo chmod +x /home/ws/bassgEAC/engine/bin/*
  cd /home/ws/bassgEAC/EacIo/EacIoApp
  sudo ../bin/svm --plat

Once svm is running, use a browser to open port 8085 of the BeagleBone, i.e., 192.168.1.33:8085.
Information about the unit will be displayed.