EBF_STTS22H_TemperatureSensor updated to use the interrupt processing.

Author: 4project-co-il

examples/Products-EBF_STTS22H_TemperatureSensor_Interrupt/Products-EBF_STTS22H_TemperatureSensor_Interrupt.ino

@@ -0,0 +1,115 @@
+#include <Arduino.h>
+#include "wiring_private.h" // pinPeripheral() function
+
+#include "EBF_Products.h"
+
+// That example shows how to use STTS22H with an interrupt line connected to
+// Digital Input, which will notify when the temperature goes out of configured
+// thresholds, so there is no need to poll the sensor every time.
+// In order to enable interrupts for the EBF environment, you have to uncomment
+// the EBF_USE_INTERRUPTS flag in your EBF_Config.h file.
+// Using interrupts allow the EBF to use very low current while sleeping (when
+// sleep functionality enabled), and free the CPU for other tasks.
+
+// Timers enumeration
+enum {
+	TIMER1 = 0,
+
+	NUMBER_OF_TIMERS
+};
+
+// In that example we will use SERCOM2 on the SparkFun SAMD21 Mini board
+TwoWire Wire2(&sercom2, 4, 3);
+
+// EBF objects creation, should be global
+EBF_Core EBF;
+
+// EBF_I2C instance will use SERCOM2 assigned to Wire2 instance
+EBF_I2C i2c(Wire2);
+// If you would like to use the default Wire instance, on Arduino UNO for eaxmple:
+//EBF_I2C i2c;
+
+// EBF serial object will use the Arduino's Serial USB for communication
+EBF_Serial serial;
+
+// Initialize STTS22H temperature sensor communicating via EBF_I2C instance
+EBF_STTS22H_TemperatureSensor tempSensor(i2c);
+
+void onTemperatureHigh()
+{
+	float tempC;
+
+	serial.println("Temperature high alert");
+
+	tempC = tempSensor.GetValueC();
+	serial.print("temperature (C): ");
+	serial.println(tempC);
+}
+
+void onTemperatureLow()
+{
+	float tempC;
+
+	serial.println("Temperature low alert");
+
+	tempC = tempSensor.GetValueC();
+	serial.print("temperature (C): ");
+	serial.println(tempC);
+}
+
+void onTimer()
+{
+	serial.println(tempSensor.GetValueC());
+
+	EBF.StartTimer(TIMER1);
+}
+
+void setup()
+{
+	EBF.Init(NUMBER_OF_TIMERS, 16);
+
+	// Timer will just print current temperature for debug
+	EBF.InitTimer(TIMER1, onTimer, 1000);
+	EBF.StartTimer(TIMER1);
+
+	// Default Init is enough for printouts via Serial on 115200 boud speed
+	serial.Init();
+
+	// Using I2C with EBF products requires a stand-alone initialization since several products
+	// might use the same I2C interface, hence there is no need to do multiple initializations
+	// from within the product's Init
+	i2c.Init();
+	i2c.SetClock(400000);
+
+	// PIN re-assignment is required since SERCOM2 lines were configured for other usage by the Arduino code
+	// You don't need those calls if you're using the defauld Wire instance
+	pinPeripheral(4, PIO_SERCOM_ALT);
+	pinPeripheral(3, PIO_SERCOM_ALT);
+
+	// Initialize the temperature sensor on I2C address 0x3C
+	tempSensor.Init(0x3C);
+	// Interrupt line is connected to pin 10 on SparkFun'x SAMD21 Mini board
+	tempSensor.AttachInterrupt(10);
+
+	// Register high and low thresholds callbacks
+	tempSensor.SetOnThresholdHigh(onTemperatureHigh);
+	tempSensor.SetOnThresholdLow(onTemperatureLow);
+
+	// Set threshold levels
+	tempSensor.SetThresholdHigh(29.0);
+	tempSensor.SetThresholdLow(27.0);
+
+	// The operation mode can be changed any time during the execurion
+	// Polling interval will be set accordingly to the operation mode
+	// For example, for 1Hz mode, polling will be 1000mSec
+	tempSensor.SetOperationMode(EBF_STTS22H_TemperatureSensor::OperationMode::MODE_1HZ);
+	// We will use the interrupt line to trigger the threshold level notifications, so no polling is needed
+	tempSensor.SetPollInterval(EBF_NO_POLLING);
+}
+
+void loop()
+{
+	// Let EBF to do all the processing
+	// Your logic should be done in the callback functions
+	EBF.Process();
+}

src/Products/EBF_STTS22H_TemperatureSensor.cpp

@@ -1,6 +1,6 @@
 #include "EBF_STTS22H_TemperatureSensor.h"
-#include "wiring_private.h" // pinPeripheral() function
-
+#include "../Core/EBF_Logic.h"
+#include "../Core/EBF_DigitalInput.h"
 
 // Part of the code is based on the SparkFun_STTS22H_Arduino_Library
 // https://github.com/sparkfun/SparkFun_STTS22H_Arduino_Library/tree/main
@@ -14,8 +14,11 @@ extern void EBF_EmptyCallback();
 uint8_t EBF_STTS22H_TemperatureSensor::Init(uint8_t i2cAddress, OperationMode mode)
 {
 	uint8_t rc;
+	StatusRegister_t status;
 
 	this->state = InstanceState::STATE_IDLE;
+	this->interruptAttached = 0;
+	this->postProcessingFlags = 0;
 	this->highThresholdSet = 0;
 	this->lowThresholdSet = 0;
 	this->i2cAddress = i2cAddress;
@@ -30,6 +33,12 @@ uint8_t EBF_STTS22H_TemperatureSensor::Init(uint8_t i2cAddress, OperationMode mo
 		return rc;
 	}
 
+	// Reading status register to reset the interrupt line
+	rc = GetStatusRegister(status);
+	if (rc != EBF_OK) {
+		return rc;
+	}
+
 	rc = SetOperationMode(mode);
 	if (rc != EBF_OK) {
 		return rc;
@@ -38,6 +47,78 @@ uint8_t EBF_STTS22H_TemperatureSensor::Init(uint8_t i2cAddress, OperationMode mo
 	return EBF_OK;
 }
 
+uint8_t EBF_STTS22H_TemperatureSensor::AttachInterrupt(uint8_t interruptPin)
+{
+	uint8_t rc;
+	EBF_Logic *pLogic = EBF_Logic::GetInstance();
+
+	rc = pLogic->AttachInterrupt(interruptPin, this, EBF_DigitalInput::InterruptMode::MODE_LOW);
+	if (rc != EBF_OK) {
+		return rc;
+	}
+
+	interruptAttached = 1;
+
+	UpdatePollInterval();
+
+	return EBF_OK;
+}
+
+void EBF_STTS22H_TemperatureSensor::UpdatePollInterval()
+{
+	uint8_t needPolling = 0;
+
+	// No need to poll, unless some callbacks are needed and there is no interrupt attached
+	pollIntervalMs = EBF_NO_POLLING;
+
+	if (onChangeCallback != NULL && onChangeCallback != EBF_EmptyCallback) {
+		needPolling = 1;
+	}
+
+	if (!interruptAttached) {
+		if (onThresholdHigh != NULL && onThresholdHigh != EBF_EmptyCallback) {
+			needPolling = 1;
+		}
+
+		if (onThresholdLow != NULL && onThresholdLow != EBF_EmptyCallback) {
+			needPolling = 1;
+		}
+	}
+
+	if (needPolling) {
+		switch (operationMode)
+		{
+		case OperationMode::POWER_DOWN:
+			pollIntervalMs = EBF_NO_POLLING;
+			break;
+
+		case OperationMode::MODE_ONE_SHOT:
+			pollIntervalMs = 0;
+			break;
+
+		case OperationMode::MODE_1HZ:
+			pollIntervalMs = 1000;
+			break;
+
+		case OperationMode::MODE_25HZ:
+			pollIntervalMs = 1000 / 25;
+			break;
+
+		case OperationMode::MODE_50HZ:
+			pollIntervalMs = 1000 / 50;
+			break;
+
+		case OperationMode::MODE_100HZ:
+			pollIntervalMs = 1000 / 100;
+			break;
+
+		case OperationMode::MODE_200HZ:
+			pollIntervalMs = 1000 / 200;
+			break;
+		}
+	}
+}
+
 uint8_t EBF_STTS22H_TemperatureSensor::GetControlRegister(ControlRegister_t &ctrl)
 {
 	uint8_t rc;
@@ -102,6 +183,8 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 	uint8_t rc;
 	ControlRegister_t ctrl = {};
 
+	operationMode = mode;
+
 	// Any change should be done after the device is moved to power down mode
 	ctrl.fields.freeRun = 0;
 	ctrl.fields.mode_1Hz = 0;
@@ -110,31 +193,27 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 		return rc;
 	}
 
-	switch (mode)
+	switch (operationMode)
 	{
 	case OperationMode::POWER_DOWN:
 		state = InstanceState::STATE_IDLE;
-		pollIntervalMs = EBF_NO_POLLING;
 		break;
 
 	case OperationMode::MODE_ONE_SHOT:
 		state = InstanceState::STATE_ONE_SHOT;
-		pollIntervalMs = 0;
 
 		ctrl.fields.oneShot = 1;
 		break;
 
 	case OperationMode::MODE_1HZ:
 		state = InstanceState::STATE_MEASURING;
-		pollIntervalMs = 1000;
 
 		ctrl.fields.mode_1Hz = 1;
 		ctrl.fields.freeRun = 0;
 		break;
 
 	case OperationMode::MODE_25HZ:
 		state = InstanceState::STATE_MEASURING;
-		pollIntervalMs = 1000 / 25;
 
 		ctrl.fields.mode_1Hz = 0;
 		ctrl.fields.freeRun = 1;
@@ -143,7 +222,6 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 
 	case OperationMode::MODE_50HZ:
 		state = InstanceState::STATE_MEASURING;
-		pollIntervalMs = 1000 / 50;
 
 		ctrl.fields.mode_1Hz = 0;
 		ctrl.fields.freeRun = 1;
@@ -152,7 +230,6 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 
 	case OperationMode::MODE_100HZ:
 		state = InstanceState::STATE_MEASURING;
-		pollIntervalMs = 1000 / 100;
 
 		ctrl.fields.mode_1Hz = 0;
 		ctrl.fields.freeRun = 1;
@@ -161,7 +238,6 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 
 	case OperationMode::MODE_200HZ:
 		state = InstanceState::STATE_MEASURING;
-		pollIntervalMs = 1000 / 200;
 
 		ctrl.fields.mode_1Hz = 0;
 		ctrl.fields.freeRun = 1;
@@ -174,6 +250,8 @@ uint8_t EBF_STTS22H_TemperatureSensor::SetOperationMode(OperationMode mode)
 		SetControlRegister(ctrl);
 	}
 
+	UpdatePollInterval();
+
 	return EBF_OK;
 }
 
@@ -237,6 +315,19 @@ uint8_t EBF_STTS22H_TemperatureSensor::Process()
 	float change;
 	StatusRegister_t status;
 
+	// Process interrupt detected logic
+	if(postProcessingFlags) {
+		if(postProcessingFlags & postProcessHighThreshold) {
+			onThresholdHigh();
+		}
+
+		if(postProcessingFlags & postProcessLowThreshold) {
+			onThresholdLow();
+		}
+
+		postProcessingFlags = 0;
+	}
+
 	switch (state)
 	{
 	case InstanceState::STATE_IDLE:
@@ -282,6 +373,30 @@ uint8_t EBF_STTS22H_TemperatureSensor::Process()
 	return EBF_OK;
 }
 
+void EBF_STTS22H_TemperatureSensor::ProcessInterrupt()
+{
+	StatusRegister_t status;
+
+	// Status register is cleared on read
+	GetStatusRegister(status);
+
+	// Set the relevant post-processing flags
+	if(status.fields.overThreshold) {
+		postProcessingFlags |= postProcessHighThreshold;
+	}
+
+	if(status.fields.underThreshold) {
+		postProcessingFlags |= postProcessLowThreshold;
+	}
+
+	if (postProcessingFlags) {
+		// Pass the control back to EBF, so it will call the Process() function from normal run
+		EBF_Logic *pLogic = EBF_Logic::GetInstance();
+
+		pLogic->ProcessInterrupt(this);
+	}
+}
+
 // Sets high threshold value
 uint8_t EBF_STTS22H_TemperatureSensor::SetThresholdHigh(float temp)
 {

src/Products/EBF_STTS22H_TemperatureSensor.h

@@ -28,6 +28,8 @@ class EBF_STTS22H_TemperatureSensor : protected EBF_HalInstance {
 		uint8_t Init(uint8_t i2cAddress, OperationMode mode = POWER_DOWN);
 		// Setting polling interval in milli-seconds
 		void SetPollInterval(uint32_t ms) { pollIntervalMs = ms; }
+		// Call to attach the device to an interrupt line
+		uint8_t AttachInterrupt(uint8_t interruptPin);
 
 		void SetOnChange(EBF_CallbackType onChangeCallback, uint8_t changePercent = 5)
 		{
@@ -69,10 +71,19 @@ class EBF_STTS22H_TemperatureSensor : protected EBF_HalInstance {
 		EBF_I2C &i2c;
 		uint8_t i2cAddress;
 		InstanceState state;
+		OperationMode operationMode;
 		uint8_t highThresholdSet;
 		uint8_t lowThresholdSet;
 		float lastValue;
 		uint8_t changePercent;
+		uint8_t interruptAttached;
+
+		// Post processing that should be done after interrupt handler
+		volatile uint8_t postProcessingFlags;
+
+		const uint8_t postProcessHighThreshold	= 1<<0;
+		const uint8_t postProcessLowThreshold	= 1<<1;
+
 
 		// Callbacks
 		EBF_CallbackType onChangeCallback;
@@ -81,6 +92,8 @@ class EBF_STTS22H_TemperatureSensor : protected EBF_HalInstance {
 		EBF_CallbackType onThresholdLow;
 
 		uint8_t Process();
+		void ProcessInterrupt();
+		void UpdatePollInterval();
 
 	private:
 		// Device registers data