معماری IoT تحت فشار: ترموستات هوشمند ، یک مثال (قسمت 5)

import { Context } from "firmwareless/hosting"
import { IoStream } from "firmwareless/lib"

const TEMPERATURE = "temperature";
const FURNACE = "furnace";
const READ_TEMPERATURE_COMMAND = "r";
const FURNACE_ON_COMMAND = "1";
const FURNACE_OFF_COMMAND = "0";

let channel: IoStream | null = null;

export function setup(context: Context) {
    // This is the temperature we report when queried. To help
    // debugging we can edit this value manually in the UI to
    // observe the effects.
    context.status.register<i8>({
        id: TEMPERATURE,
        type: "environment/temperature",
        unit: "Celsius",
        editable: true,
        range: { nullable: true, minimum: 0, maximum: 40, step: 1 }
    });

    // This is the relay we control, we can observe this in the UI
    // to determine if everything is working as expected.
    context.status.register<u8>({
        id: FURNACE,
        type: "status/boolean",
    });

    // To simulate a physical device we open a stream for character 
    // device. The hosted firmware with our logic is agnostic
    // of the transport mechanism!
    channel = context.communication.stream.open({
        mode: "read-write",
        encoding: "ascii",
        onWrite: handleWrite
    });
}

export function teardown(context: Context) {
    channel?.close();
}

function handleWrite(context: Context, stream: IoStream, data: string) {
    if (data === READ_TEMPERATURE_COMMAND) {
        stream.writeLine(context.status.get<i8>(TEMPERATURE).toString());
    } else if (data === FURNACE_ON_COMMAND) {
        context.status.set<u8>(FURNACE, 1);
    } else if (data === FURNACE_OFF_COMMAND) {
        context.status.set<u8>(FURNACE, 0);
    }
}

#include "Arduino.h"
#include 

#define NUMBER_OF_READINGS_PER_MEASURE 4

#define TEMPERATURE_SENSOR_APIN A0
#define FURNACE_STATUS_INDICATOR LED_BUILTIN

#define READ_TEMPERATURE_COMMAND 'r'
#define FURNACE_ON_COMMAND '1'
#define FURNACE_OFF_COMMAND '0'

int8_t readTemperature();
void setFurnaceStatus(bool active);
char tryReadCommandFromMaster();

void setup() {
  pinMode(FURNACE_STATUS_INDICATOR, OUTPUT);
  Serial.begin(9600);
}

// We keep waiting for a command from the serial port, inputs
// are always commands (we ignore what we do not know) and the
// only output is the temperature (when we're asked to).
// Note that this is not what you would do in a real application
// but it mimics (more or less) how it could work with I2C.
void loop() {
  switch (tryReadCommandFromMaster()) {
    case READ_TEMPERATURE_COMMAND:
      Serial.println(readTemperature());
      break;
    case FURNACE_ON_COMMAND:
      setFurnaceStatus(true);
      break;
    case FURNACE_OFF_COMMAND:
      setFurnaceStatus(false);
      break;
  }
}

// The readings are fairly noisy, for this example it's
// enough to calculate a simple average.
int8_t readTemperature() {
  int16_t value = 0;
  for (int8_t i=0; i < NUMBER_OF_READINGS_PER_MEASURE; ++i) {
    value += analogRead(TEMPERATURE_SENSOR_APIN);
  }

  return (int8_t)((5 * value * 100.0) / 1024 / NUMBER_OF_READINGS_PER_MEASURE);
}

// This is a development board, we use a LED instead of
// turning on/off the heating.
void setFurnaceStatus(bool active) {
  digitalWrite(FURNACE_STATUS_INDICATOR, active);
}

// We read one byte (instead of a full line) because currently
// the supported commands are one byte only and we ignore what
// we do not know how to process (for example spaces and new lines).
int16_t tryReadCommandFromMaster() {
  if (Serial.available()) {
    return Serial.read();
  }
}

{
  "id": "76a38d89-d756-4412-ac87-604ff3cf84d0",
  "vendor": "Acme",
  "name": "Smart Thermostat Mod. 1",
  "version": "1.0.0",
  "compatibility": "1.0+",
  "channel": {
      "initiator": "host"
  },
  "config": {
      "monitoringInterval": "15 minutes",
      "schedulingInterval": "30 minutes",
      "minimumTemperature": "8 °C",
      "maximumTemperature": "30 °C"
  },
  "variables": [
    {
        "name": "furnace",
        "storage": "uint8",
        "type": "boolean"
    },
    {
        "name": "current_temp",
        "storage": "int8",
        "type": "measure/temperature",
    },
    {
        "name": "target_temp",
        "storage": "int8",
        "type": "measure/temperature",
    },
    {
        "name": "desired_temp_1",
        "storage": "int8",
        "type": "measure/temperature",
        "default": "16 °C"
    },
    {
        "name": "desired_temp_2",
        "storage": "int8",
        "type": "measure/temperature",
        "default": "18 °C"
    },
    {
        "name": "schedule",
        "label": "Schedule",
        "type": "system/schedule",
        "editable": true,
        "editorOptions": {
            "interval": "week",
            "granularity": "{{ config.schedulingInterval }}",
            "selection": "list",
            "default": "0",
            "listItems": [
                { "key", "0", "label", "Off" },
                { "key", "1", "label", "{{ variables.desired_temp_1 }}" },
                { "key", "2", "label", "{{ variables.desired_temp_2 }}" }
            ]
        }
    }
  ]
}

import { Context, Scheduling } from "firmwareless/hosting"
import { IoStream, Interval, Temperature } from "firmwareless/lib"

const READ_TEMPERATURE_COMMAND = "r";
const FURNACE_ON_COMMAND = "1";
const FURNACE_OFF_COMMAND = "0";

let channel: IoStream | null = null;

export function setup(context: Context) {
  // This is how often we are going to check for the temperature.
  context.schedule(Interval.parse(context.config.get("monitoringInterval")), main);

  // When these variables change value we need to recalculate
  // our status because they represent the desired temperatures
  // and our scheduling.
  context.variables.onChange(["desired_temp_1", "desired_temp_2", "schedule"], main);
}

export function teardown(context: Context) {
  // If we are going down then we want to be sure we are not
  // leaving the heater on!
  const stream = IoStream.Open(context.associatedDeviceId);
  try {
    stream.writeByte(FURNACE_OFF_COMMAND);
  }
  finally {
    stream.close();
  }
}

function main(context: Context) {
  const stream = IoStream.Open(context.associatedDeviceId);
  try {
    applyFurnaceStatus(context, stream);
  }
  finally {
    stream.close();
  }
}

function applyFurnaceStatus(context: Context, stream: IoStream) {
  const desiredTemperature = resolveDesiredTemperature(context);
  context.variables.set("target_temp", desiredTemperature);

  if (desiredTemperature === null) {
    stream.writeByte(FURNACE_OFF_COMMAND);
    return;
  }

  stream.writeByte(READ_TEMPERATURE_COMMAND);
  stream.flush();

  const temperature = Temperature.parse(stream.readLine(), "°C");
  const status = temperature < desiredTemperature;

  stream.writeByte(status ? FURNACE_ON_COMMAND : FURNACE_OFF_COMMAND);
  context.variables.set("furnace", status);
}

function resolveDesiredTemperature(context: Context) {
  // To "resolve" the desired temperature we need to read the list
  // of scheduled values from the "schedule" variable and pick the
  // selected one for the current date and time.
  // It's so common that we have an helper function for that.
  const temperatureId = Scheduling.resolve("schedule");

  if (temperatureId === "1") {
    return context.variables.get("desired_temp_1");
  }

  if (temperatureId === "2") {
    return context.variables.get("desired_temp_2");
  }

  // A value of "0" or an unknown key means "off".
  return null;
}

{
    ...
    "ui": [
        {
            "type": "page",
            "title": "Thermostat",
            "content": {
                "control": "ring",
                "label": "Temperature",
                "minimum": "{{ config.minimumTemperature }}",
                "maximum": "{{ config.maximumTemperature }}",
                "value": "{{ variables.current_temp}}",
                "steps": [ "{{ variables.target_temp }}" ],
                "text": true,
                "actions": [
                    { 
                        "type": "edit",
                        "target": "schedule",
                        "label": "Schedule"
                    },
                    { 
                        "type": "edit",
                        "target": "desired_temp_1",
                        "label": "Temperature 1"
                    },
                    { 
                        "type": "edit",
                        "target": "desired_temp_2",
                        "label": "Temperature 2"
                    }
                ]
            }
        }
    ]
}