Flexs Q5M

let uptime = now();
  print('Uptime Seconds: ',uptime);

print(string(__status())); //  {"vcc":23.814098,"contact":"","location":"","desc":"","name":"Flexs Vibration Monitor","uid":2585356324,"hw_v":9001,"fw_v":10,"cfg_v":164,"mqueue":0}

while(run()){

  setEnv('sys.utc_offset',-8); // Set UTC offset


  // minute hour weekDay monthDay month year valid epoch are all valid properties of the dateTime object
  // e.g. dateTime.year would return the current year

  // Log the unix epoch timestamp followed by the ch3 values
  //234323:    ch3: {"ripple":0.001314,"state":false,"max":0.002665,"min":0.001114,"inst":0.001841,"avg":0.001937}
  // string( is used to convert numbers to a string for logging.

  sd.append('log.txt',string(datetime().epoch) +  ":    ch3: " + string(23.454) + "\n");



  // Print the entire dateTime object to show all paramaters
  print(string(datetime()));
  // {"valid":true,"uptime":1437.058175,"epoch":1589247811,"year":2020,"month":5,"monthDay":12,"weekDay":2,"hour":1,"minute":43,"second":31}

  waitMS(10000); // wait 10 second before repeating

}

// Example JSON web client showing reading from external web servers and from another Q5 running the JSON WEB SERVER example

setEnv("http.aesKey","myAesPassphrase"); // Set end to end encryption key (Only used if encryption is enabled), if not set the device password is used

function getDateFromRemoteQ5(url)
{
   let request = {
    msg: "hello from client",
    epoch: datetime().epoch
  };

  let res = http.req(url,
                     string(request), // POST request payload
                     1000, // timeout
                     false // no encryption
                    );

  if(res.err === 0 && res.code === 200) // Valid response, process it!
  {

  let payload = JSON.parse(res.payload); // Parse text payload into a JSON object

  print("Remote Q5 Battery Voltage",payload.batteryVoltage);

  print(string(payload)); // Print the entire payload to the log

} else {
  print("Error reading data from remote Q5");
  print(string(res));
}

  print("");

}


while(run()){

// Request data from a remote Q5 running the json web server demo, change the URL to the appropriate URL of your device for testing
getDateFromRemoteQ5("http://172.16.220.39/app/abc");


 let res = http.req("http://172.16.220.39/app/xyz",
                    "", // No Payload
                    1000, // 1s timeout
                    false // no aes encryption
                   );

  print(string(res));

  waitMS(5000);

}

// Example JSON rest webserver
// Access the test webserver in your browser at http://<Q5 IP>/app/abc

setEnv("http.aesKey","myAesPassphrase"); // Set end to end encryption key (Only used if encryption is enabled), if not set the system password is used


function handleHttp(req){

   print(string(req));

  if(req.url === 'abc')
  {

    let reply = {
      batteryVoltage: 14.8,
      io: io,
      uptime: now(),
      epoch:  datetime().epoch
    };

    return string(reply);
  }

  return "Invalid Request URL, try /app/abc";

}


http.handle(handleHttp, // request handler funciton
            false); // no aes encryption

while(run()){
  waitMS(1000); // wait 1 second
}

// Example stream JSON measurements to server

function sendMeasurement(host){

    let payload = {
      batteryVoltage:14.3,
      uptime: now()
    };

    let res = http.req(host, 			// url
                       string(payload),	// payload
                       1000,			// timeout
                       false);			// aes encryption

    if(res.err === 0 || res.code === 200){
    print("Received from server",string(res));

    // Could receive messages back from server to change relays etc... See web client example for more info

    } else {
    print("Upload Error, http status=",res.code);
    }

}



while(run()){


  sendMeasurement("http://myserver.com/url");
  // server will receive a POST request with the json payload specified

  waitMS(5000);

}

// UDP Stream Example

while(run()){

      let payload = {
      batteryVoltage: 15.3,
      uptime: now()
    };

	udp.send("http://192.168.5.159:2115",string(payload));
	waitMS(1000);
}

// MQTT Publish and Subscribe Example, Requires Firmware V91 or greater


// Callback function which runs whenever a subscribed topic is received
// The 'event' object contains the topic info, the message can be binary
// data or a json string, json strings should be parsed, let data = json.parse(event.message);
// binary data can be converted into numerical arrays, see the binary data example

function mqttSubscriberCallback(event) {
    print("MQTT EVENT: ", string(event));
    // MQTT EVENT:  {"retain":false,"qos":0,"message":"Hello World","topic":"power_system/relays/1"}
}



while (run()) {


    // Connecting before each publish ensures that if the connection is ever disconnected it will reconnect,
    // If the client is connected it will just return code 207 (Already Connected)
    // return: Any response other than 0 indicates an error and the corresponding error code

    let ret = mqtt.connect({
        url: "mqtt://172.16.220.22:1883",
        client: "Nikiah Repeater",
        subscribe: ["power_system/relays/+"],
        callback: mqttSubscriberCallback
    });
    print("connect:", ret);


    let batteryVoltage = string(14.34);

    // Publish an event to the MQTT broker, the message data can be binary or text, if you are pushing an object it should
    // be converted to a string first, let msg = string( { object: "value" } );
    // arrays of numbers can be converted and packed to binary first, see the binary data examples

    ret = mqtt.publish("power_system/battery_voltage", batteryVoltage);
    print("publish:", ret);
    waitMS(5000);
}



mqtt.disconnect(); // Make sure the client is disconnected before exiting

// This function adjusts the measurement interval dependong on how full the queue is, adjusts the measurement interval to allow for storing more measurements during comm outages
function checkMeasurementInterval(){

     if(__status().mqueue > 75){ // 75% full
    setEnv("sys.meas_interval",3600);// 1 hr meas interval
    setEnv("sys.sync_interval",300);// 5 min upload
  }  else if(__status().mqueue > 10){ // 10% full
    setEnv("sys.meas_interval",300);// 5 min interval
    setEnv("sys.sync_interval",300); // 5 min upload
  } else { // Default Measurement & Upload Interval
    setEnv("sys.meas_interval",60);
    setEnv("sys.sync_interval",60);
  }

}


while(run()){

	checkMeasurementInterval();
}

while(run()){

let aesKey = bin.sha256("flexscadaFlexsQ5!");
print("KEY: ", bin.toHex(aesKey));

let secretMsg = string(  {msg: "I LOVE FLEXSCADA", code: 12.454 } );

let encrypted = bin.enc(secretMsg,aesKey);
let decrypted = bin.dec(encrypted,aesKey);


print("Size (Raw, Encrypted)",secretMsg.length,encrypted.length);

if(decrypted.valid){// decryption successful and checksums valid
  let decryptedObj = JSON.parse(decrypted.data);
  print(string(decryptedObj));
} else {
  print("AES Decryption Failed.");
}


waitMS(1000);
}

let plc = {lastUpdated:0};

while(run()){


   //  eip.disconnect();
  if(eip.connect("192.168.168.1") === 0){ // 0 = no error

  let res = eip.read("F103",1,4*4); // File: F103,  Offset: 1, Bytes: 4*8 (4x 4 byte floats)
    // Files can be prefixed with F,O,I,S,B,T,R,N depending on type


  if(res.status === 0){ // 0 = no error

    res.data.seek(0); // establish our binary reader cursor to parse the input data

    plc = {
      flow: res.data.read("F32ABCD"), // Parse the bytes into our object
      pressure: res.data.read() * 0.145038,// kPA to PSI,  
      pumpSpeed: res.data.read(),no read format specified. Use the last defined read format
      temp: res.data.read(),
      lastUpdated:now()
    };

    print( string (plc) ); // Print our result data

  } else {
    print("PLC Read Failed");
  }


  } else {
    print("PLC Connection Failed");

    let updatedAgo = now() - plc.lastUpdated;
    print("Last Updated ",updatedAgo, " S Ago");

  }

  eip.disconnect(); // End the connection


  waitMS(1000);

}

// This example creates a modbus data table that can be updated from logic and be read and written remotely via modbusTCP

let mbData = bin.alloc(20*4); // Allocate a modbus buffer with room for 18 float registers
modbus.setData(mbData); // Set the modbus data table to use our variable

while(run()){


if(modbus.setLock(true)){ // Lock the table from reads while data is being updated


  mbData.seek(0); // set the file position to the begining of the data table (byte 0)

  // write some values to our register table
  mbData.write("F32BADC",[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]); // append an array of values as float32's
  mbData.write("U32BADC",23.33); // append a single value as a unsigned 32 bit int with badc byte order

  // read 2 values back from the end of our register table (these values could be written to remotely using modbus set the holding register functions)
  let reg17_18 = mbData.read("F32BADC",2);
  print(string(reg17_18)); // print the values;

  modbus.setLock(false); // unlock the data table so that clients can read and write again
}





  waitMS(1000);
}

// Test using the free modpoll tool https://www.modbusdriver.com/modpoll.html

// read our devices register table
// modpoll.exe -0 -m tcp -t 4:float -r 0 -c 18 -a 0 -1 192.168.1.20

// write to the last two floats in our register table
// modpoll.exe -0 -m tcp -t 4:float -r32  -u -a 0 -1 192.168.1.20 123.456 456.789

// Please Note, Function Codes 1,2 and 15 expect a bit array

// === TRY CONNECT ===
let ret = modbus.connect("172.16.220.111",502,1); // Connect to the modbus master

if(ret === 0){

// === READ TEST ===

let ret = modbus.read(0, // port: 0=tcp, 1=ttl serial, 2=rs485
                      1, // slave unitID
                      4, // function, 3 = read multiple registers
                      0x88B9, // start register
                      30 //register / coil count
                      );

if(ret.status === 0){


		ret.data.seek(0);

  		let data = {
			meanWindSpeed: 		ret.data.read("U32DCBA")/10, // m/s
			meanWindDirection:	ret.data.read("U32")/10,  // degress
			airTemp: 			ret.data.read("S32")/10, // °C
            internalTemp: 		ret.data.read("S32")/10, // °C
            acousticTemp:		ret.data.read("S32")/10, // °C
            rawTemp: 			ret.data.read("S32")/10, // °C
            relativeHumidity: 	ret.data.read("U32")/10, // %rh
            dewpoint: 			ret.data.read("S32")/10, // °C
            absAirPressure: 	ret.data.read("U32")/100, // hPa
            relAirPressure: 	ret.data.read("U32")/100, // hPa
		};

  print(string(data));


} else {
  print("Read Failed, err=",string(ret));
}



// === WRITE TEST ===


let arrayData = [1,2,3,4,5,6,7,8];
let data = bin.fromArray(arrayData,"U16","AB"); // Convert array into packed binary structure
ret = modbus.write(0, // port: 0=tcp, 1=serial,
                   1, // slave unitID
                   16, // function, 16 = write multiple registers
                   0, // start register
                   arrayData.length, // register / coil count
                   data // data to write
                   );

if(ret === 0){
   print("Write Successful");
} else {
  print("Modbus Write Failed, err=",ret);
}





modbus.disconnect();

} else {
   print("Modbus Connect Failed, err=",ret);
}

let startTime = now();

while(run()){

  // Set the current alarm group
  alm.g("UV");

  // Evaluate an alarm condition (also returns the current priority of the alarm (if active) or 0 if not alarming
  let value = alm.e(
    alm.crit, // alarm priority
    "Reactor A Run Failure", // alarm title
    startTime.sAgo() > 5 && startTime.sAgo() < 12, // alarm condition
    5, // Alarm trigger delay (Condition must be true for this many seconds before the alarm activates)
    true, // Alarm automatically clearable?
    0, // Alarm clearing delay (Condition must be (false) AND alarm clearable (true) for this many seconds before the alarm automatically clears)
    startTime // Optional argument, the current value e.g. reservoir level etc. Included in log messages which are automatically recorded when faults change states
  );

  print("Run Time: ", startTime.sAgo(), "  Fault Value:", value);

  let groupValue = alm.v("UV"); // If multiple faults exist per group this will return the highest priority active alarm.  Multiple groups can be included as additional arguments

  let faultValue = alm.fV("UV","Reactor A Run Failure"); // Get the value of a specific fault under the "UV" category

  let faults = alm.list(); // Return an object with the status of all the registered alarms  {"UV":{"Reactor A Run Failure":0}}

  let max = alm.max(); // return the highest alarming priority across all groups

  waitMS(1000);

}

// Resetting Faults

alm.rst(); // reset all the faults
alm.ack(); // acknowledge all the faults

alm.rst("UV","Reactor A Run Failure"); // Reset a specific fault
alm.ack("UV","Reactor A Run Failure"); // Acknowledge a specific fault.. An optional false argument can be appended to cancel the acknowledgement

print("==== Convert an array of 16 bits to a binary string of two bytes ====");
{
  let bitArray = [ 1,0,0,0,0,0,0,0,    0,1,1,1,1,1,1,1 ]; // true or false could be used
  let bytes = bin.fromArray(bitArray,"RBITS");
  let hex = bin.toHex(bytes);

  print("raw bit array:", string(bitArray) );
  print("packed to bytes: ", hex); // 01fe
}
print("");

print("==== Convert two bytes from a hex string into an array of bits ====");
{
  let bytes = bin.fromHex("01fe");
  let bitArray = bin.toArray(bytes,"RBITS");

  print("raw hex: ", bin.toHex(bytes));
  print("converted to array: ", string(bitArray));
}
print("");

print("==== Convert an array of numbers to a 32 bit floating point packed data structure ====");
{
  let numberArray = [ 12345.6789,100,200,300,400 ];
  let bytes = bin.fromArray(numberArray,"F32","BADC");
  let hex = bin.toHex(bytes);

  print("raw number array:", string(numberArray) );
  print("packed to bytes: ", hex);
}
print("");

print("==== Convert packed 32 bit floating point numbers to an array ====");
{
  let hex = "e6b74640000042c80000434800004396000043c8"; // Hex output from previous run
  let bytes = bin.fromHex(hex);
  let numberArray = bin.toArray(bytes,"F32","BADC");

  print("raw hex: ", hex);
  print("converted to array: ", string(numberArray));
}

// Log a message (useful when using Grafana / influxdb cloud backend)

log(
  "Title",
  "Description / Message",
  3,     // type, 0 to 255, used for grouping alarm types
  2,     // message priority (0..255) user definable or use builtin alm.ok alm.info alm.warn alm.crit
  23.43  // alarm value, numeric value attached to alarm, user settable
);

while(run()){

  waitMS(1000);

}

udp.handle(9000, function(req){   // listen on port 9000; only a single udp.handle listener is supported
  let data = JSON.parse(req.data); // parse the received payload data as JSON
  for(let i in data){
    if(i === "users"){
      users = data[i];
    } else {
      rem[i] = data[i];
      rem[i]._lu = now();
    }
  }
}, true); // true: use AES-256 encryption

while(run()){
  waitMS(1000);
}

eip.handle(function(req){ // handle incoming EtherNet/IP read and write requests

  if(req.data){ // Is this a write request with write data?

    print("EtherIP Write Request");
    print("EIP File", req.file);
    print("EIP Payload:", bin.toHex(req.data));

    req.data.seek(0);
    let status = req.data.read("U16AB");

    io.PALL = {
      _lu: now(),
      skidInletValveD: (status & (1<<11)) > 0,
      skidInletValveC: (status & (1<<10)) > 0,
      skidInletValveB: (status & (1<<9))  > 0,
      skidInletValveA: (status & (1<<8))  > 0,
      chnMasterAlarm:  (status & (1<<6))  > 0,
      masterAlarm:     (status & (1<<5))  > 0,
      skidDAlarm:      (status & (1<<4))  > 0,
      skidCAlarm:      (status & (1<<3))  > 0,
      skidBAlarm:      (status & (1<<2))  > 0,
      skidAAlarm:      (status & (1<<1))  > 0,
      feedEnable:       status & 1,

      flowAvailable: req.data.read("U16AB") / 0.2777778,
      skidAStatus:   req.data.read(), // read using the same previously defined structure
      skidBStatus:   req.data.read(),
      skidCStatus:   req.data.read(),
    };
    req.data.seek(100);
    io.PALL.inletTurbidity = req.data.read();

  } else {
    // Read request.

    print("EtherIP Read Request");
    print("EIP File", req.file);
    print("EIP Bytes:", req.bytes); // the byte length of the requested data

    let pallW = {
      highClearwellAlarm: alm.v("Clearwell") >= alm.warn,
      highPressAlarm: alm.fV("PALL Intake","Inlet Pressure High") > 0,
      filterOutputPermission: true,
      flowRequest: 151.1999 * pallProcess.pumpsRunningCount.limit(1,4) // m3/h
    };

    let buff = bin.alloc(100); // empty 100-byte buffer; the read/write cursor is positioned on it automatically
    buff.write("BIT", [0, io.p304.running, io.p303.running, io.p302.running, io.p301.running,
                       pallW.highClearwellAlarm, pallW.highPressAlarm, pallW.filterOutputPermission,
                       0,0,0,0,0,0,0,0]);            // write our statuses as bits
    buff.write("U16AB", [pallW.flowRequest * 0.2777778,
                         io.clearwellLevel701.inst * 10]); // flow request + clearwell level as U16s
    return buff; // return our binary data
  }
});

let sp = {
  dialer: 0,

  p101Hrs: 0,
  p102Hrs: 0,
  p301Hrs: 0,
  p302Hrs: 0,

  p101Mode: 2,
  p102Mode: 2,
  p301Mode: 2,
  p302Mode: 2,

  // booster process
  millionGallonResPumpCall1: 85,
  millionGallonResPumpCall2: 80,
  millionGallonResFull: 95,

  clearwellLow: 50,
  clearwellResume: 60,
  boosterPumpSpeed: 57,
  boosterMinPumpFlow: 88 // per pump running 100% speed
};

let users = {}; // Blank users list.

let cfg = {
  load: function(){
    let ssp = nv.get(); // load from non-volatile memory; no offset argument = position 0
    if(ssp){            // nv.get() returns undefined if no valid string is detected
                        // (this can happen if the memory backup battery goes dead)
      let nsp = JSON.parse(ssp); // parse the saved setpoint string as a JSON object
      for(let key in nsp){ sp[key] = nsp[key]; }
      // Merging key-by-key (instead of sp = nsp) means setpoints added to the
      // code later keep their defaults when an older saved config is loaded.
    } else {
      print("Loaded Default Setpoints");
      cfg.save();
    }

    let u = nv.get(2048); // load the users object at a 2 kB offset —
                          // 4 kB total, so we split it in half
    if(u){
      users = JSON.parse(u); // parse the users string for our user authentication
    }
  },
  save: function(){
    nv.set(string(sp));
    nv.set(string(users), 2048);
  },
};

cfg.load(); // run at the beginning of the script, after setpoint and user declarations

cfg.save(); // run whenever setpoints or users are changed

can.init(125, false, false); // data rate (kbps), canFD, auto retransmission

can.listen(function(msg){    // CAN rx handler; msg = {id:164242, data:"hello from canbus"}
  print(string(msg));
});

while(run()){
  waitMS(1000);

  can.tx(
    12,             // id
    "Test Payload", // payload
    false,          // extended id
    false,          // canFD
    false           // remote frame (RTR)
  );
}

let port = 1; // Available ports vary depending on the device. Refer to the serial.init documentation
let aesKey = bin.sha256("password");

function serialRxCallback(msg){
  print("Received Serial Msg");
  print("Port:", msg.port);              // port of incoming msg
  print("Overflowed:", msg.ovf);         // msg.ovf is boolean true / false
  print("Data:", bin.toHex(msg.data));

  if(msg.data.length && !msg.ovf){       // received a complete message
    let payload = bin.fromHex(msg.data); // convert the hex message back to binary

    let decrypted = bin.dec(payload, aesKey); // decrypt the encrypted message

    if(decrypted.valid){ // decryption successful and checksums valid
      // For binary payloads we could parse directly, e.g.:
      // decrypted.data.seek(0); let value = decrypted.data.read("F32ABCD");
      let decryptedObj = JSON.parse(decrypted.data);
      print(string(decryptedObj));
    } else {
      print("AES Decryption Failed.");
    }
  }
}

function transmitMeasurements(){
  let data = { message: "Hello World!", voltage: 13.45, ch1: 3.99 };
  let payload = string(data);            // convert the object to a string
  let encrypted = bin.enc(payload, aesKey); // encrypted data includes a 256-bit checksum
  let hex = bin.toHex(encrypted);        // hex-encode for transmission over serial

  serial.tx(port, hex + "\r");           // append a carriage return to the end
}

serial.init(port, 19200);
serial.listen(port, "\r", serialRxCallback); // buffer rx until a carriage return arrives

while(run()){
  transmitMeasurements();
  waitMS(1000);
}

let port = 1; // Available ports vary depending on the device. Refer to the serial.init documentation

function serialRxCallback(msg){
  print("Received Serial Msg");
  print("Port:", msg.port);      // port of incoming msg
  print("Overflowed:", msg.ovf); // msg.ovf is boolean true / false
  print("Data:", msg.data);
}

serial.init(port, 19200);
serial.listen(port, "\r", serialRxCallback); // buffer rx until a carriage return arrives

while(run()){
  serial.tx(port, "Hello World over serial!\r");
  waitMS(1000);
}

let port = 1;  // Available ports vary depending on the device. Refer to the serial.init documentation

let ret = serial.init(port, 9600);

while(run()){
  let res = modbus.read(port,
                        1,  // slave unitID
                        3,  // function code
                        8,  // start register
                        10  // register count
                       );
  print(res.status);

  if(res.status === 0){
    res.data.seek(0);
    let registers = res.data.read("F32BADC", 8);

    print("voltage (reg0)=", registers[0]);
  }

  waitMS(1000);
}

let sp = {
pumpMode:0,
resFull:99,
resCall:80,
resLow:50,
minFlow:150,
maxFlow:320,
pumpHours:244
};




let cfg = {
changed:false,
lastSaved:now(),

load: function(){

let res = sd.read("setpoints.json");
if(!res.error){
  sp = JSON.parse(res.data);
} else {
  print("Failed to load configuration: ", string(res));
}

},

  save:function(){
  if(this.changed || this.lastSaved.sAgo() > 86400){ // save the setpoints immediately if changed otherwise daily to write the pump hours

  let res = sd.write("setpoints.json",string(sp));

    // Save a backup at least once a month in a seperate year month labeled file
    let date = datetime();
    let dateString = '/LOG/sp-' + string(date.year) + '-' + string(date.month) + '.json';
    sd.write(dateString,string(sp));

  if(res){
    log("Failed to save setpoints to SD Card",alm.warn);
    return false;
  }
  return true;
  }
}
};


cfg.load(); // Load the configuration initially 

while(run()){

waitMS(1000);
cfg.save();

}