st-anything/lib/ST_Anything/Everything.cpp

429 lines
13 KiB
C++
Raw Normal View History

2023-03-11 14:11:03 +00:00
//******************************************************************************************
// File: Everything.cpp
// Authors: Dan G Ogorchock & Daniel J Ogorchock (Father and Son)
//
// Summary: st::Everything is a generic class which essentially acts as the main() routine.
// All st::Device type objects are managed by st::Everything. It is responsible for
// for calling the correct functions within each object it is responsible for at the
// proper time. It handles all initialization of and use of the SmarThings Shield library.
//
// THere are user-definable settings which will impact the st::Everything class stored in
// Constants.h. Please edit Constants.h to adjust these settings.
//
// In general, this file should not need to be modified.
//
// Change History:
//
// Date Who What
// ---- --- ----
// 2015-01-03 Dan & Daniel Original Creation
// 2015-01-10 Dan Ogorchock Minor improvements to support Door Control Capability
// 2015-03-14 Dan Ogorchock Added public setLED() function to control ThingShield LED
// 2015-03-28 Dan Ogorchock Added throttling capability to sendStrings to improve success rate of ST Cloud getting the data ("SENDSTRINGS_INTERVAL" is in CONSTANTS.H)
// 2017-02-07 Dan Ogorchock Added support for new SmartThings v2.0 library (ThingShield, W5100, ESP8266)
// 2017-02-19 Dan Ogorchock Fixed bug in throttling capability
// 2017-04-26 Dan Ogorchock Allow each communication method to specify unique ST transmission throttling delay
// 2019-02-09 Dan Ogorchock Add update() call to Executors in support of devices like EX_Servo that need a non-blocking mechanism
// 2019-02-24 Dan Ogorchock Added new special callOnMsgRcvd2 callback capability. Allows recvd string to be manipulated in the sketch before being processed by Everything.
// 2021-01-31 Marcus van Ierssel Improved the automatic refresh to prevent it from blocking other updates.
// 2021-05-23 Dan Ogorchock Address EXP8266 v3.0.0 board support package compatibility issue with Strings
//
//******************************************************************************************
//#include <Arduino.h>
//#include <avr/pgmspace.h>
#include "Everything.h"
long freeRam(); //freeRam() function prototype - useful in determining how much SRAM is available on Arduino
#if defined(ARDUINO_ARCH_SAMD)
extern "C" char* sbrk(int incr);
#endif
namespace st
{
//private
void Everything::updateDevices()
{
for(unsigned int index=0; index<m_nSensorCount; ++index)
{
m_Sensors[index]->update();
sendStrings();
}
for (unsigned int i = 0; i<m_nExecutorCount; ++i)
{
m_Executors[i]->update();
sendStrings();
}
}
#if defined(ENABLE_SERIAL)
void Everything::readSerial()
{
String message;
while(Serial.available()>0)
{
char c=Serial.read();
message+=c;
delay(10);
}
if(message.length()>0)
{
receiveSmartString(message);
}
}
#endif
void Everything::sendStrings()
{
unsigned int index;
//Loop through the Return_String buffer and send each "|" delimited string to ST Shield
while(Return_String.length()>=1 && Return_String[0]!='|')
{
index=Return_String.indexOf("|");
if(debug)
{
Serial.print(F("Everything: Sending: "));
Serial.println(Return_String.substring(0, index));
//Serial.print(F("Everything: getTransmitInterval() = "));
//Serial.println(SmartThing->getTransmitInterval());
}
#ifndef DISABLE_SMARTTHINGS
// if (millis() - sendstringsLastMillis < Constants::SENDSTRINGS_INTERVAL)
if (millis() - sendstringsLastMillis < SmartThing->getTransmitInterval())
{
// delay(Constants::SENDSTRINGS_INTERVAL - (millis() - sendstringsLastMillis)); //Added due to slow ST Hub/Cloud Processing. Events were being missed. DGO 2015-03-28
delay(SmartThing->getTransmitInterval() - (millis() - sendstringsLastMillis)); //modified to allow different values for each method of communicating to ST cloud. DGO 2017-04-26
}
SmartThing->send(Return_String.substring(0, index));
sendstringsLastMillis = millis();
#endif
#if defined(ENABLE_SERIAL) && defined(DISABLE_SMARTTHINGS)
Serial.println(Return_String.substring(0, index));
#endif
if(callOnMsgSend!=0)
{
callOnMsgSend(Return_String.substring(0, index));
}
Return_String=Return_String.substring(index+1);
}
Return_String.remove(0); //clear the Return_String buffer
}
void Everything::refreshDevices()
{
static int refresh_Executor = 0;
static int refresh_Sensor = 0;
/*
for(unsigned int i=0; i<m_nExecutorCount; ++i)
{
m_Executors[i]->refresh();
sendStrings();
}
for (unsigned int i = 0; i<m_nSensorCount; ++i)
{
m_Sensors[i]->refresh();
sendStrings();
}
*/
if (refresh_Executor < m_nExecutorCount) {
m_Executors[refresh_Executor]->refresh();
sendStrings();
refresh_Executor++;
refLastMillis = millis() - long(Constants::DEV_REFRESH_INTERVAL) * 1000 + 4 * SmartThing->getTransmitInterval();
}
else if (refresh_Sensor < m_nSensorCount) {
m_Sensors[refresh_Sensor]->refresh();
sendStrings();
refresh_Sensor++;
refLastMillis = millis() - long(Constants::DEV_REFRESH_INTERVAL) * 1000 + 4 * SmartThing->getTransmitInterval();
}
else {
refLastMillis = millis();
refresh_Executor = 0;
refresh_Sensor = 0;
}
}
//public
void Everything::init()
{
Serial.begin(Constants::SERIAL_BAUDRATE);
Return_String.reserve(st::Constants::RETURN_STRING_RESERVE); //allocate Return_String buffer one time to prevent Heap Fragmentation. RETURN_STRING_RESERVE is set in Constants.h
if(debug)
{
Serial.println(F("Everything: init started"));
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
#ifndef DISABLE_SMARTTHINGS
SmartThing->init();
#endif
if(debug)
{
Serial.println(F("Everything: init ended"));
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
}
void Everything::initDevices()
{
if(debug)
{
Serial.println(F("Everything: initDevices started"));
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
for(unsigned int index=0; index<m_nSensorCount; ++index)
{
m_Sensors[index]->init();
sendStrings();
}
for(unsigned int index=0; index<m_nExecutorCount; ++index)
{
m_Executors[index]->init();
sendStrings();
}
if(debug)
{
Serial.println(F("Everything: initDevices ended"));
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
refLastMillis = millis(); //avoid immediately refreshing after initialization
}
void Everything::run()
{
updateDevices(); //call each st::Sensor object to refresh data
#ifndef DISABLE_SMARTTHINGS
SmartThing->run(); //call the ST Shield Library to receive any data from the ST Hub
#endif
#if defined(ENABLE_SERIAL)
readSerial(); //read data from the Arduino IDE Serial Monitor window (useful for debugging sometimes)
#endif
sendStrings(); //send any pending updates to ST Cloud
#ifndef DISABLE_REFRESH //Added new check to allow user to disable REFRESH feature - setting is in Constants.h)
if ((bTimersPending == 0) && ((millis() - refLastMillis) >= long(Constants::DEV_REFRESH_INTERVAL) * 1000)) //DEV_REFRESH_INTERVAL is set in Constants.h
{
//refLastMillis = millis();
refreshDevices(); //call each st::Device object to refresh data (this is just a safeguard to ensure the state of the Arduino and the ST Cloud stay in synch should an event be missed)
}
#endif
if((debug) && (millis()%60000==0) && (millis()!=lastmillis))
{
lastmillis = millis();
Serial.print(F("Everything: Free Ram = "));
Serial.println(freeRam());
}
}
bool Everything::sendSmartString(const String &str)
{
//while(str.length()>1 && str[0]=='|') //get rid of leading pipes (messes up sendStrings()'s parsing technique)
//{
// str=str.substring(1);
//}
if((str.length()==1 && str[0]=='|') || str.length()==0)
{
return false;
}
if(Return_String.length()+str.length()>=Constants::RETURN_STRING_RESERVE)
{
if (debug)
{
Serial.print(F("Everything: ERROR: \""));
Serial.print(str);
Serial.println(F("\" would overflow the Return_String 'buffer'"));
}
return false;
}
else
{
Return_String+=str+"|"; //add the new message to the queue to be sent to ST Shield with a "|" delimiter
return true;
}
}
bool Everything::sendSmartStringNow(const String &str)
{
bool queued = sendSmartString(str);
if (queued) sendStrings(); //send any pending updates to ST Cloud immediately
return queued;
}
Device* Everything::getDeviceByName(const String &str)
{
for(unsigned int index=0; index<m_nSensorCount; ++index)
{
if(m_Sensors[index]->getName()==str)
return (Device*)m_Sensors[index];
}
for(unsigned int index=0; index<m_nExecutorCount; ++index)
{
if(m_Executors[index]->getName()==str)
return (Device*)m_Executors[index];
}
return 0; //null if no such device present
}
bool Everything::addSensor(Sensor *sensor)
{
if(m_nSensorCount>=Constants::MAX_SENSOR_COUNT)
{
if(debug)
{
Serial.print(F("Did not add sensor named "));
Serial.print(sensor->getName());
Serial.println(F("(You've exceeded maximum number of sensors; edit Constants.h)"));
}
return false;
}
else
{
m_Sensors[m_nSensorCount]=sensor;
++m_nSensorCount;
}
if(debug)
{
Serial.print(F("Everything: adding sensor named "));
Serial.println(sensor->getName());
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
return true;
}
bool Everything::addExecutor(Executor *executor)
{
if(m_nExecutorCount>=Constants::MAX_EXECUTOR_COUNT)
{
if(debug)
{
Serial.print(F("Did not add executor named "));
Serial.print(executor->getName());
Serial.println(F("(You've exceeded maximum number of executors; edit Constants.h)"));
}
return false;
}
else
{
m_Executors[m_nExecutorCount]=executor;
++m_nExecutorCount;
}
if(debug)
{
Serial.print(F("Everything: adding executor named "));
Serial.println(executor->getName());
Serial.print(F("Everything: Free RAM = "));
Serial.println(freeRam());
}
return true;
}
//friends!
void receiveSmartString(String message)
{
message.trim();
if(Everything::debug && message.length()>1)
{
Serial.print(F("Everything: Received: "));
Serial.println(message);
}
if (Everything::callOnMsgRcvd2 != 0)
{
Everything::callOnMsgRcvd2(message);
}
if (message == "refresh")
{
Everything::refreshDevices();
}
else if (message.length() > 1) //ignore empty string messages from the ST Hub
{
Device *p = Everything::getDeviceByName(message.substring(0, message.indexOf(' ')));
if (p != 0)
{
p->beSmart(message); //pass the incoming SmartThings Shield message to the correct Device's beSmart() routine
}
}
if(Everything::callOnMsgRcvd!=0)
{
Everything::callOnMsgRcvd(message);
}
}
//initialize static members
st::SmartThings* Everything::SmartThing=0; //initialize pointer to null
String Everything::Return_String;
Sensor* Everything::m_Sensors[Constants::MAX_SENSOR_COUNT];
Executor* Everything::m_Executors[Constants::MAX_EXECUTOR_COUNT];
byte Everything::m_nSensorCount=0;
byte Everything::m_nExecutorCount=0;
unsigned long Everything::lastmillis=0;
unsigned long Everything::refLastMillis=0;
unsigned long Everything::sendstringsLastMillis=0;
bool Everything::debug=false;
byte Everything::bTimersPending=0; //initialize variable
void (*Everything::callOnMsgSend)(const String &msg)=0; //initialize this callback function to null
void (*Everything::callOnMsgRcvd)(const String &msg)=0; //initialize this callback function to null
void(*Everything::callOnMsgRcvd2)(String &msg) = 0; //initialize this callback function to null
//SmartThings static members
//#ifndef DISABLE_SMARTTHINGS
// // Please refer to Constants.h for settings that affect whether a board uses SoftwareSerial or Hardware Serial calls
// #if defined(ST_SOFTWARE_SERIAL) //use Software Serial
// SmartThingsThingShield Everything::SmartThing(Constants::pinRX, Constants::pinTX, receiveSmartString);
// #elif defined(ST_HARDWARE_SERIAL) //use Hardware Serial
// SmartThingsThingShield Everything::SmartThing(Constants::SERIAL_TYPE, receiveSmartString);
// #endif
// SmartThingsNetworkState_t Everything::stNetworkState=(SmartThingsNetworkState_t)99; //bogus value for first pass through Everything::updateNetworkState()
//#endif
}
//freeRam() function - useful in determining how much SRAM is available on Arduino
long freeRam()
{
#if defined(ARDUINO_ARCH_AVR)
extern int __heap_start, *__brkval;
int v;
return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
#elif defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
return ESP.getFreeHeap();
#elif defined(ARDUINO_ARCH_SAMD)
char top;
return &top - reinterpret_cast<char*>(sbrk(0));
#else
return -1;
#endif // !
}