# Motion Master Client

The Motion Master Client is a [TypeScript](https://www.typescriptlang.org) library designed to facilitate communication with the [Motion Master](https://synapticon.github.io/motion_master/) process via [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) connections. It utilizes [Protocol Buffers](https://developers.google.com/protocol-buffers) for efficient message serialization during data exchange.

You can find various examples in the official [Motion Master Client Examples](https://github.com/synapticon/motion-master-client-examples) GitHub repository.

## Usage

The Motion Master Client library is versatile and can be used both in server environments with [Node.js](https://nodejs.org/) and in browsers.

The key classes for making requests are:

- [MotionMasterClient](https://synapticon.github.io/oblac/motion-master-client/classes/MotionMasterClient.html)
- [MotionMasterReqResClient](https://synapticon.github.io/oblac/motion-master-client/classes/MotionMasterReqResClient.html)

### Server usage

Initialize a project:

```sh
mkdir hello-somanet
cd hello-somanet
npm init --yes
```

Install the required dependencies:

```sh
npm install --save motion-master-client rxjs ws
npm install --save-dev ts-node typescript
```

Create a TypeScript configuration:

```sh
npx tsc --init
```

Create a main program file:

```sh
touch main.ts
```

Add the following content to the _main.ts_ file:

```ts
import { createMotionMasterClient } from 'motion-master-client';
import { lastValueFrom } from 'rxjs';

// Ensure that Node.js has the global WebSocket object available.
Object.assign(globalThis, { WebSocket: require('ws') });

const client = createMotionMasterClient('192.168.200.253');

client
  .whenReady()
  .then(async () => {
    const devices = await lastValueFrom(client.request.getDevices());
    const message = JSON.stringify(devices, null, 2);
    console.log(message);
  })
  .finally(() => client.closeSockets());
```

Run the program:

```sh
npx ts-node main.ts
```

The program will:

1. Create an instance of the client and connect to a Motion Master process running at 192.168.200.253.
2. The client needs some time to connect, so it must be ready before making requests. Most of the requests are implemented and documented in the [MotionMasterReqResClient](https://synapticon.github.io/oblac/motion-master-client/classes/MotionMasterReqResClient.html) class.
3. The client requests a list of devices, which are then printed to the console.
4. The client closes opened sockets.

Here's another example that demonstrates how to get and set device parameter values:

```ts
import { createMotionMasterClient } from 'motion-master-client';

// Ensure that Node.js has the global WebSocket object available.
Object.assign(globalThis, { WebSocket: require('ws') });

const client = createMotionMasterClient('192.168.200.253');

client
  .whenReady()
  .then(async () => {
    // Device is referenced by a position (0).
    const motorRatedCurrent = await client.request.upload(0, 0x6075, 0);
    console.log(`Motor rated current: ${motorRatedCurrent}`);

    // The device parameter is referenced by an ID, which consists of
    // the index (0x6076), subindex (0x00), and the device serial number (8504-03-0002369-2329).
    const motorRatedTorque = await client.request.upload('0x6076:00.8504-03-0002369-2329');
    console.log(`Motor rated current: ${motorRatedTorque}`);

    // Update the Max current parameter value to 2000.
    await client.request.download(0, 0x6073, 0, 2000);
  })
  .finally(() => client.closeSockets());
```

## Understanding requests

When the client is instantiated, it connects to the Motion Master process using the WebSocket protocol. As it is a bi-directional, full-duplex communication protocol, there needs to be a mechanism that couples requests with responses. This is solved by having a message ID that is a mandatory attribute of each request; responses produced by that request will include the same message ID.

For some requests, such as firmware installation, Motion Master will send progress messages until the firmware installation is complete. Therefore, when making a request with the client library, functions will return an Observable of request statuses. This means that you can subscribe to an Observable and receive status messages over time. These observables are asynchronous, meaning your program can continue to do other things while the request executes. For the purpose of utilizing Observables and implementing reactive programming, the client library uses [RxJs](https://rxjs.dev/).

To demonstrate the use of reactive programming, let's create a program that monitors the drive and core temperatures:

```ts
import { createMotionMasterClient } from 'motion-master-client';
import { map, mergeMap } from 'rxjs';

// Ensure that Node.js has the global WebSocket object available.
Object.assign(globalThis, { WebSocket: require('ws') });

const client = createMotionMasterClient('192.168.200.253');

const subscription = client.onceReady$
  .pipe(
    mergeMap(() =>
      client.startMonitoring(
        [
          [0, 0x2030, 1], // Core temperature
          [0, 0x2031, 1], // Drive temperature
        ],
        1000000, // microseconds
        { topic: 'temperatures-monitoring', distinct: true }
      )
    ),
    map((values) => `core=${values[0]} drive=${values[1]}`)
  )
  .subscribe(console.log);

process.on('SIGINT', function () {
  console.log('\nGracefully shutting down from SIGINT (Ctrl-C).\nStopping monitoring and closing sockets.');
  subscription?.unsubscribe();
  client.closeSockets();
  process.exit(0);
});
```
