Instalação

Nota: É necessário possuir o NodeJS instalado

# Crie um diretório para conter o projeto
$ mkdir meu-projeto
# Acesse o diretório criado anteriormente
$ cd meu-projeto
# Inicialize o projeto
$ npm init -y
# Instale a biblioteca do SAIoT
$ npm install @saiot2/device

Introdução

Dispositivos SAIoT possuem sensores e atuadores. Sensores são capazes de enviar dados do dispositivo para a plataforma. Atuadores, por outro lado, recebem dados provenientes da plataforma e alteram o estado do dispositivo.

Criação de um dispositivo

A biblioteca disponibiliza as classes Saiot, Sensor e Actuator, para a criação de dispositivos, sensores e atuadores, respectivamente. Suas configurações iniciais são passadas através de seus construtores.

Crie um arquivo .js no diretório do projeto e escreva o código de um novo dispositivo, ou copie algum dos exemplos. Por fim, basta executá-lo com node nome-do-arquivo.js.

Para criar um dispositivo simples que possui um atuador que muda o estado de uma lâmpada, por exemplo, podemos usar:

quarto.js

const { Saiot, Actuator } = require("@saiot2/device");

const device = new Saiot(
    "Quarto", // nome
    "qualquer", // classe
    "Dispositivo que controla lâmpada do quarto" // descrição
);

let lampState = false;

function lampCallback(value) {
    const newState = value[0];
    if (newState === true) {
        console.log("Ligando a lâmpada");
    } else {
        console.log("Desligando a lâmpada");
    }
    lampState = newState;
    return lampState;
}

function setup() {
    // ATENÇÃO: Descomente essa linha para conectar-se à versão dev 
    // device.setBrokerUrl("dev");

    // Realiza o login
    // ATENÇÃO: Modifique o email e senha de acordo com as suas credenciais   
    device.setLogin("[email protected]", "sua-senha");

    const lamp = new Actuator(
        "lampada", // identificador
        "Minha lâmpada", // nome
        "switch", // tipo do atuador
        false, // estado inicial (desligada)
        lampCallback // função que é chamada ao acionar o interrutor na interface
    );

    // Adiciona o atuador ao dispositivo
    device.addActuator(lamp);
    // Inicia o dispositivo
    device.start();
}

function loop() {
    // Inicia o ciclo de envio de dados
    device.loop();
}

setup();
loop();

Dica: Para ver todas as propriedades do construtor e seus tipos, repouse o cursor no nome da classe, em seu editor de código. Propriedades opcionais são denotadas com um "?" após seu nome.

Dica: Você pode utilizar o método create para criar instâncias de classes a partir de um objeto.

No terminal, execute o script com o seguinte comando:

$ node quarto.js

Exemplos

const { Saiot, Sensor, Actuator } = require("@saiot2/device");

const saiotDevice = new Saiot(
    "Dispositivo geral",
    "geral",
    "Dispositivo que contêm todos os sensores e atuadores disponíveis"
);

let booleanSensorState = false;
let numericSensorState = 0;
let gpsSensorState = {
    latitude: -5.842552,
    longitude: -35.197645,
};
let heatmapSensorState = [
    [0, 0],
    [0, 0],
];
let switchActuatorState = false;
let numericActuatorState = 0;
let colorActuatorState = [0, 0, 0, 0];
let sliderActuatorState = 0;

function booleanSensorCallback() {
    booleanSensorState = !booleanSensorState;
    return booleanSensorState;
}

function numericSensorCallback() {
    numericSensorState = Number((28 + (Math.random() * 3 - 1)).toPrecision(4));
    return numericSensorState;
}

function gpsSensorCallback() {
    gpsSensorState.latitude += (Math.random() * 2 - 1) / 10000;
    gpsSensorState.longitude += (Math.random() * 2 - 1) / 10000;
    return [gpsSensorState.latitude, gpsSensorState.longitude];
}

function heatmapSensorCallback() {
    const matrix = [];
    const rows = 2;
    const cols = 2;
    for (let row = 0; row < rows; row++) {
        matrix[row] = [];
        for (let col = 0; col < cols; col++) {
            matrix[row][col] = Number((Math.random() * 99).toFixed(2));
        }
    }
    heatmapSensorState = matrix;
    return heatmapSensorState;
}

function switchActuatorCallback(value) {
    switchActuatorState = value[0];
    return switchActuatorState;
}

function numericActuatorCallback(value) {
    numericActuatorState = value[0];
    return numericActuatorState;
}

function colorActuatorCallback(value) {
    colorActuatorState = value;
    return colorActuatorState;
}

function sliderActuatorCallback(value) {
    sliderActuatorState = value[0];
    return sliderActuatorState;
}

function setup() {
    saiotDevice.setLogin("[email protected]", "sua-senha");

    const booleanSensor = new Sensor(
        "onOff",
        "Sensor boleano",
        "on/off",
        booleanSensorState,
        3,
        booleanSensorCallback
    );
    const numericSensor = new Sensor(
        "number",
        "Sensor numérico",
        "number",
        numericSensorState,
        2,
        numericSensorCallback
    );
    const gpsSensor = new Sensor(
        "gps",
        "Sensor de rastreamento",
        "gps",
        gpsSensorState,
        5,
        gpsSensorCallback
    );
    const heatmapSensor = new Sensor(
        "heatmap",
        "Sensor de mapa de calor",
        "heatmap",
        heatmapSensorState,
        3,
        heatmapSensorCallback,
        undefined,
        undefined,
        0,
        100
    );

    const switchActuator = new Actuator(
        "switch",
        "Atuador switch",
        "switch",
        switchActuatorState,
        switchActuatorCallback
    );
    const numericActuator = new Actuator(
        "number",
        "Atuador numérico",
        "number",
        numericActuatorState,
        numericActuatorCallback
    );
    const colorActuator = new Actuator(
        "color",
        "Atuador de cores",
        "color",
        colorActuatorState,
        colorActuatorCallback
    );
    const sliderActuator = new Actuator(
        "slider",
        "Atuador de deslizamento",
        "slider",
        sliderActuatorState,
        sliderActuatorCallback,
        0,
        20,
        1
    );

    saiotDevice.addSensor(booleanSensor);
    saiotDevice.addSensor(numericSensor);
    saiotDevice.addSensor(gpsSensor);
    saiotDevice.addSensor(heatmapSensor);
    saiotDevice.addActuator(switchActuator);
    saiotDevice.addActuator(numericActuator);
    saiotDevice.addActuator(colorActuator);
    saiotDevice.addActuator(sliderActuator);

    saiotDevice.start();
}

function loop() {
    saiotDevice.loop();
}

setup();
loop();

const { Saiot, Actuator } = require("@saiot2/device");

const saiotDevice = new Saiot(
    "Lâmpada RGB",
    "lampada-rgb",
    "Minha lâmpada RGB"
);

function RGBCallback(value) {
    const red = value[0];
    const green = value[1];
    const blue = value[2];
    const alpha = value[3];

    console.log(`Recebidos os valores ${red}, ${green}, ${blue}, ${alpha}`);

    return value;
}

function setup() {
    saiotDevice.setLogin("[email protected]", "sua-senha");

    const rgb = new Actuator(
        "rgb",
        "Lâmpada RGB",
        "color",
        [0, 0, 0, 0],
        RGBCallback
    );

    saiotDevice.addActuator(rgb);

    saiotDevice.start();
}

function loop() {
    saiotDevice.loop();
}

setup();
loop();

// require('loadavg-windows'); // Instale essa biblioteca caso estiver utilizando Windows
const os = require("os");
const { Saiot, Sensor } = require("@saiot2/device");

const saiotDevice = new Saiot(
    "Monitor de sistema",
    "monitor-de-sistema",
    "Monitor de CPU e RAM"
);

function convertFromBytesToGB(numberInBytes) {
    return numberInBytes / (1024 * 1024 * 1024);
}

function getCpuUsage() {
    const cpuLoad = os.loadavg();
    const numberOfCores = Object.keys(os.cpus()).length;
    const usedCPUInPercentage = (cpuLoad[0] * 100) / numberOfCores;

    return usedCPUInPercentage.toFixed(2);
}

function getRamUsage() {
    const totalMemory = os.totalmem();
    const freeMemory = os.freemem();
    const usedMemoryInGB = convertFromBytesToGB(totalMemory - freeMemory);

    return usedMemoryInGB.toFixed(2);
}

function getRamTotal() {
    const totalMemoryInGB = convertFromBytesToGB(os.totalmem());

    return totalMemoryInGB.toFixed(2);
}

function setup() {
    saiotDevice.setLogin("[email protected]", "sua-senha");

    const cpu = new Sensor(
        "cpu",
        "Uso de CPU",
        "number",
        0,
        1,
        getCpuUsage,
        undefined,
        "%"
    );
    const ram = new Sensor(
        "ram",
        "Uso de RAM",
        "number",
        0,
        1,
        getRamUsage,
        undefined,
        "GB",
        getRamTotal()
    );

    saiotDevice.addSensor(cpu);
    saiotDevice.addSensor(ram);

    saiotDevice.start();
}

function loop() {
    saiotDevice.loop();
}

setup();
loop();

const { Saiot, Sensor } = require("@saiot2/device");

const saiotDevice = new Saiot(
    "Rastreador GPS",
    "rastreador",
    "Um simples rastreador GPS"
);

let globalPosition = {
    latitude: -5.842552,
    longitude: -35.197645,
};

function getGlobalPosition() {
    globalPosition.latitude += (Math.random() * 2 - 1) / 10000;
    globalPosition.longitude += (Math.random() * 2 - 1) / 10000;

    console.log(
        `Movendo para: lat=${globalPosition.latitude}, long=${globalPosition.longitude}`
    );

    return [globalPosition.latitude, globalPosition.longitude];
}

function setup() {
    saiotDevice.setLogin("[email protected]", "sua-senha");

    const gps = new Sensor(
        "gps",
        "GPS",
        "gps",
        [-5.842552, -35.197645],
        1,
        getGlobalPosition
    );

    saiotDevice.addSensor(gps);

    saiotDevice.start();
}

function loop() {
    saiotDevice.loop();
}

setup();
loop();

const { Saiot, Sensor, Event } = require("@saiot2/device");
const os = require("os");

function convertFromBytesToGB(numberInBytes) {
    return numberInBytes / (1024 * 1024 * 1024);
}

function getRamUsage() {
    const totalMemory = os.totalmem();
    const freeMemory = os.freemem();
    const usedMemoryInGB = convertFromBytesToGB(totalMemory - freeMemory);

    return usedMemoryInGB.toFixed(2);
}

const saiotDevice = new Saiot("Medidor de RAM", "any", "Medidor de uso de RAM");

const alarmValue = 5; // O alarme será ativado quando a RAM ultrapassar 5 GB
const normalizationValue = 4.5; // O alarme será desativado quando a RAM normalizar em 4.5 GB ou menos

function alarmCondition(sensorId, sensorValue) {
    return sensorValue >= alarmValue;
}

function alarmCallback() {
    console.log(`Uso de RAM chegou a ${alarmValue} GB!`);
}

function normalizationCondition(sensorId, sensorValue) {
    return sensorValue <= normalizationValue;
}

function normalizationCallback() {
    console.log(`Uso de RAM normalizou-se em ${normalizationValue} GB.`);
}

function setup() {
    saiotDevice.setLogin("[email protected]", "sua-senha");

    const ram = new Sensor(
        "ram",
        "Uso de RAM",
        "number",
        0,
        1,
        getRamUsage,
        undefined,
        "GB"
    );
    const alarm = new Event(
        "ram.greater.5",
        "Uso de RAM maior que 5 GB",
        "alarm",
        alarmCondition,
        alarmCallback,
        true
    );
    const normalization = new Event(
        "ram.greater.5",
        "Uso de RAM menor que 4.5 GB",
        "normalization",
        normalizationCondition,
        normalizationCallback
    );

    saiotDevice.addSensor(ram);
    saiotDevice.addEvent(alarm, ["ram"]);
    saiotDevice.addEvent(normalization, ["ram"]);

    saiotDevice.start();
}

function loop() {
    saiotDevice.loop();
}

setup();
loop();

Métodos

device.start()

Inicia a conexão do dispositivo com a plataforma SAIoT.

device.loop()

Inicia o ciclo de envio de dados do dispositivo.

device.setLogin(email, password)

Realiza o login do dispositivo.

device.setBrokerUrl(url)

Define a URL de conexão com o broker MQTT. Esse método não precisa ser chamado caso esteja utilizando a versão em produção. Use url="dev" para conectar-se ao broker dev do SAIoT.

device.addSensor(sensor)

Adiciona um sensor ao dispositivo.

device.addActuator(actuator)

Adiciona um atuador ao dispositivo.

device.addEvent(event, sensors)

Adiciona um evento ao dispositivo.

• event é um evento com alguma das seguintes criticidades: event, alarm, normalization.

Gerar um evento de criticidade alarm indica que um alarme está ativo, e portanto deve ser mostrado na sessão de alarmes, na interface. Por outro lado, um evento de criticidade normalization gera uma normalização, isto é, desativa o alarme que corresponde à normalização. Para isso, é importante que os eventos de alarme e normalização possuam o mesmo id.

• sensors é uma array de strings que lista os ids dos sensores em que o evento pode ser acionado.

Saiot.create({}) (ou Sensor.create, Actuator.create, etc.)

Cria uma nova instância baseada em um objeto.

Ex:

const meuAtuator = Actuator.create({
    id: "meu-atuador",
    name: 'Meu atuador',
    type: 'number',
    value: 0,
    callback: (value: number[]) => {
        return value[0] + 1
    }
})

FAQ

Após gerado, o id é armazenado no caminho /node_modules/@saiot2/device/dist/id, a partir da raiz do seu projeto, portanto basta navegar para esse diretório e deletá-lo.

Parâmetros podem ser desabilitados utilizando o valor undefined. Por exemplo, se quisermos habilitar somente o parâmetro max de um sensor, usamos:

const numericSensor = new Sensor(
    "number", // id
    "Sensor numérico", // nome
    "number", // tipo
    0, // valor inicial
    2, // timeout
    numericSensorCallback, // callback
    undefined, // deadband
    undefined, // unit
    20 // max
);

Changelog

Leia CHANGELOG.md