GR Device Init

version 1.2.0

Server should use websocket transports

Of course, for first time user 'testtoken' to connect to socket

I did this to control linux-based robots with Raspberry Pi or Banana pi.

Also, It can work on Windows-based devices.

Updates

added 'this.robotObject.updateState' to update state for robotObject more useful

Main idea:

• We have deployed socket server
• Should just create connections for main and robot (or client/user and robot).
• Don't need to think about logic on server
• RobotController has several controllers and update his state by time.

Getting started

This library provides simple controller and connection to connect to the GRobotics server - this server has some methods to controll devices using socket.

It is a device and user's part.

You can see examples in 'example' folder.

At first, install npm package:

run npm i gr-device-init

Create user connection

const { User, newGroboticsClientConnection } = require("gr-device-init");

Create new user that should be pass into connection

const user = new User({
  id: 'USER_ID',
  setUserStatus(st) {
    console.log('user accepted', st);
  },
  robotMessageHandler(state) {
    console.log('state', state);
  },
  deviceMessageHandler(userId, msg) {
    console.log('received from device', msg);
  }
});

Now we can create connection with our user on this robot. Also, robot should get access to this user.

const connection = newGroboticsClientConnection(user, 'https://grobotics-socket-server.herokuapp.com/', 'testtoken');

Before send commands to robot, we should init user

connection.initUser('MY_ROBOT_ID');

Also, user can has a few robots

So, now we are possible to send command!

connection.send('MY_ROBOT_ID', 'ROBOT_DEVICE_ID', 'my message')

Create robot connection

At first, let's create robot controller

const {
  createRobotController,
  DeviceController,
  newGroboticsConnection,
} = require("gr-device-init");

const robotController = createRobotController(robotObject, "MY_ROBOT_ID");

Where robotObject is something to work with inner state as middleware, for example:

const robotObject = {
  init() {
    console.log("init robots");
  },
  validate() {
    // This method needs to validate command to robot. Just return true if does not need.
    return true;
  },

  initUser() {
    console.log("initUser");
  },

  serverConnected() {
    console.log("serverConnected");
  },

  serverDisconnected() {
    console.log("serverDisconnected");
  },
};

Now create some controller with device

const testDevice = {
  id: "TEST_DEVICE",
  messagesIdsMap: {
    serverConnected: "serverConnected",
    serverDisconnected: "serverDisconnected",
    initUser: "initUser",
  },
  initDevice(args) {
    console.log("init in testDevice");
  },
  attachMsgFromDevice(cb) {
    let count = 0;
    setInterval(() => {
      cb(count++)
    }, 100);
  },
  sendMessage(msg) {
    console.log("send testDevice", msg);
    // here should be validation for message 'initUser'
    // just return true or false.
    // At this moment, each device should return true to create access for user
  },
};

const testController = new DeviceController({
  id: "TEST",
  device: testDevice,
});

Important!!

Add controllers before create connections

robotController.addController(testController);
robotController.addController(testController1);
robotController.addController(testController2);
....

After adding controllers, we should connect robotController to server, like this:

const connection = newGroboticsConnection(
  "SOCKET SERVER URL",
  "/api/str/",
  "MY_ROBOT_ID",
  "testtoken"
);

connection(robotController);

Now, we can work and send command from user to robot!