Hardware components | ||||||
 |
| × | 1 | |||
Software apps and online services | ||||||
| ||||||
Nowadays, even with many sensors and monitoring devices, it still lacks projects the monitors the workplace environment.
insalūbris is a project focused in using NXP Rapid IoT Prototyping to make the workplace safer. Using the Rapid IoT sensors, was possible to build a prototype which would be used by employees in hazardous areas.
The prototype measures temperature, humidity, vibration and Total Volatile Organic Compounds (TVOC)
The vibration is measured using the acceleration sensors and correlating the data to limits stablished by the industry as Whole-Body Vibrations (WBV) maximum. The temperature measured is verified if it's inside of the limits, which have to be 16ºC<t<30ºC. The Relative Humidity should be in between 30% and 70%. Also, the limits of the TVOC by the ASHRAE standard, is 500ppb.
The prototype is simple and uses the simple provisioning using the Rapid IoT Studio, which works as the flux of the operations. If any of these limits aren't covered, an alarm using the buzzer rings.
#include "callbacks.h"
//HEADER START
//HEADER END
void ATMO_Setup() {
}
ATMO_Status_t Interval_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t Interval_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_INTERVAL_Handle_t intervalHandle;
ATMO_INTERVAL_AddAbilityInterval(
ATMO_PROPERTY(Interval, instance),
ATMO_ABILITY(Interval, interval),
ATMO_PROPERTY(Interval, time),
&intervalHandle
);
return ATMO_Status_Success;
}
ATMO_Status_t Interval_interval(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_Config_t config;
config.address = ATMO_PROPERTY(ENS210TemperatureHumidity, i2cAddress);
config.i2cDriverInstance = ATMO_PROPERTY(ENS210TemperatureHumidity, i2cInstance);
config.tempCalibrationOffset = ATMO_PROPERTY(ENS210TemperatureHumidity, tempCalibrationOffset);
return ( ATMO_ENS210_Init(&config) == ATMO_ENS210_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;
}
ATMO_Status_t ENS210TemperatureHumidity_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(true);
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(false);
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_ENS210_SetEnabled(enabled);
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_readTemperature(ATMO_Value_t *in, ATMO_Value_t *out) {
float tempC;
if(ATMO_ENS210_GetTemperatureFloat(&tempC) == ATMO_ENS210_Status_Success)
{
ATMO_CreateValueFloat(out, tempC);
}
else
{
ATMO_CreateValueVoid(out);
}
return ATMO_Status_Success;
}
ATMO_Status_t ENS210TemperatureHumidity_readHumidity(ATMO_Value_t *in, ATMO_Value_t *out) {
float humidityPct;
if(ATMO_ENS210_GetHumidityFloat(&humidityPct) == ATMO_ENS210_Status_Success)
{
ATMO_CreateValueFloat(out, humidityPct);
}
else
{
ATMO_CreateValueVoid(out);
}
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_Config_t config;
config.operatingMode = ATMO_PROPERTY(CCS811AirQuality, operatingMode);
config.address = ATMO_PROPERTY(CCS811AirQuality, i2cAddress);
config.i2cDriverInstance = ATMO_PROPERTY(CCS811AirQuality, i2cInstance);
return ( ATMO_CCS811_Init(&config) == ATMO_CCS811_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;
}
ATMO_Status_t CCS811AirQuality_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(true);
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(false);
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_CCS811_SetEnabled(enabled);
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_readTVOC(ATMO_Value_t *in, ATMO_Value_t *out) {
uint16_t tvoc;
if(ATMO_CCS811_GetTVOC(&tvoc) == ATMO_CCS811_Status_Success)
{
ATMO_CreateValueUnsignedInt(out, (unsigned int)tvoc);
}
else
{
ATMO_CreateValueVoid(out);
}
return ATMO_Status_Success;
}
ATMO_Status_t CCS811AirQuality_readCO2(ATMO_Value_t *in, ATMO_Value_t *out) {
uint16_t co2;
if(ATMO_CCS811_GetCO2(&co2) == ATMO_CCS811_Status_Success)
{
ATMO_CreateValueInt(out, (int)co2);
}
else
{
ATMO_CreateValueVoid(out);
}
return ATMO_Status_Success;
}
ATMO_Status_t TSL2572AmbientLight_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t TSL2572AmbientLight_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_TSL2572_Config_t config;
config.address = ATMO_PROPERTY(TSL2572AmbientLight, i2cAddress);
config.i2cDriverInstance = ATMO_PROPERTY(TSL2572AmbientLight, i2cInstance);
return ( ATMO_TSL2572_Init(&config) == ATMO_TSL2572_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;
}
ATMO_Status_t TSL2572AmbientLight_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_TSL2572_SetEnabled(true);
return ATMO_Status_Success;
}
ATMO_Status_t TSL2572AmbientLight_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_TSL2572_SetEnabled(false);
return ATMO_Status_Success;
}
ATMO_Status_t TSL2572AmbientLight_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_TSL2572_SetEnabled(enabled);
return ATMO_Status_Success;
}
ATMO_Status_t TSL2572AmbientLight_readAmbientLight(ATMO_Value_t *in, ATMO_Value_t *out) {
float lightLux;
if(ATMO_TSL2572_GetAmbientLight(&lightLux) != ATMO_TSL2572_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueInt(out, (int)lightLux);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_FXOS8700_Config_t config;
config.address = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, i2cAddress);
config.i2cDriverInstance = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, i2cInstance);
config.gpioDriverInstance = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, gpioInstance);
config.int1En = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt1Enabled);
config.int2En = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt2Enabled);
config.int1Pin = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt1Gpio);
config.int2Pin = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt2Gpio);
switch(ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, motionDetectType))
{
case FXOS8700_NoDetect:
{
config.freefallEnabled = false;
config.motionEnabled = false;
config.tapDetectionEnabled = false;
break;
}
case FXOS8700_FreefallDetect:
{
config.freefallEnabled = true;
config.motionEnabled = false;
config.tapDetectionEnabled = false;
break;
}
case FXOS8700_MotionDetect:
{
config.freefallEnabled = false;
config.motionEnabled = true;
config.tapDetectionEnabled = false;
break;
}
case FXOS8700_TapDetect:
{
config.freefallEnabled = false;
config.motionEnabled = false;
config.tapDetectionEnabled = true;
break;
}
default:
{
config.freefallEnabled = false;
config.motionEnabled = false;
config.tapDetectionEnabled = false;
break;
}
}
ATMO_FXOS8700_SetMotionDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectMotion));
ATMO_FXOS8700_SetFreefallDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectFreefall));
ATMO_FXOS8700_SetTapDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectTap));
ATMO_FXOS8700_Init(&config);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_FXOS8700_SetEnabled(true);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_FXOS8700_SetEnabled(false);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_FXOS8700_SetEnabled(enabled);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelData(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if( ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success )
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValue3dVectorFloat(out, &data);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelX(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.x);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelY(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.y);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelZ(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.z);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagData(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if( ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success )
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValue3dVectorFloat(out, &data);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagX(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.x);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagY(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.y);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagZ(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_3dFloatVector_t data;
if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
{
ATMO_CreateValueVoid(out);
return ATMO_Status_Fail;
}
ATMO_CreateValueFloat(out, data.z);
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectTap(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectMotion(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectFreefall(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableFreefallDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableFreefallDetection() == ATMO_FXOS8700_Status_Success)
{
return ATMO_Status_Success;
}
return ATMO_Status_Fail;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableMotionDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableMotionDetection() == ATMO_FXOS8700_Status_Success)
{
return ATMO_Status_Success;
}
return ATMO_Status_Fail;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableTapDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableTapDetection() == ATMO_FXOS8700_Status_Success)
{
return ATMO_Status_Success;
}
return ATMO_Status_Fail;
}
ATMO_Status_t FXOS8700AccelerometerMagnetometer_disableDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_DisableAllDetection() == ATMO_FXOS8700_Status_Success)
{
return ATMO_Status_Success;
}
return ATMO_Status_Fail;
}
ATMO_Status_t CompAmbLight_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompAmbLight_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompAmbLight_evaluate(ATMO_Value_t *in, ATMO_Value_t *out) {
bool conditionTrue = false;
// Convert property to same type as input
ATMO_Value_t targetStr;
ATMO_Value_t targetNum;
ATMO_InitValue(&targetStr);
ATMO_InitValue(&targetNum);
ATMO_CreateValueString(&targetStr, ATMO_PROPERTY(CompAmbLight, target));
ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(CompAmbLight, condition), &conditionTrue) != ATMO_Status_Success)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAmbLight, invalidType), NULL);
ATMO_FreeValue(&value);
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
return ATMO_Status_Fail;
}
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
if(conditionTrue)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAmbLight, conditionTrue), NULL);
ATMO_FreeValue(&value);
}
else
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAmbLight, conditionFalse), NULL);
ATMO_FreeValue(&value);
}
return ATMO_Status_Success;
}
ATMO_Status_t CompHumHigh_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompHumHigh_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompHumHigh_evaluate(ATMO_Value_t *in, ATMO_Value_t *out) {
bool conditionTrue = false;
// Convert property to same type as input
ATMO_Value_t targetStr;
ATMO_Value_t targetNum;
ATMO_InitValue(&targetStr);
ATMO_InitValue(&targetNum);
ATMO_CreateValueString(&targetStr, ATMO_PROPERTY(CompHumHigh, target));
ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(CompHumHigh, condition), &conditionTrue) != ATMO_Status_Success)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumHigh, invalidType), NULL);
ATMO_FreeValue(&value);
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
return ATMO_Status_Fail;
}
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
if(conditionTrue)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumHigh, conditionTrue), NULL);
ATMO_FreeValue(&value);
}
else
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumHigh, conditionFalse), NULL);
ATMO_FreeValue(&value);
}
return ATMO_Status_Success;
}
ATMO_Status_t CompHumLow_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompHumLow_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompHumLow_evaluate(ATMO_Value_t *in, ATMO_Value_t *out) {
bool conditionTrue = false;
// Convert property to same type as input
ATMO_Value_t targetStr;
ATMO_Value_t targetNum;
ATMO_InitValue(&targetStr);
ATMO_InitValue(&targetNum);
ATMO_CreateValueString(&targetStr, ATMO_PROPERTY(CompHumLow, target));
ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(CompHumLow, condition), &conditionTrue) != ATMO_Status_Success)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumLow, invalidType), NULL);
ATMO_FreeValue(&value);
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
return ATMO_Status_Fail;
}
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
if(conditionTrue)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumLow, conditionTrue), NULL);
ATMO_FreeValue(&value);
}
else
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompHumLow, conditionFalse), NULL);
ATMO_FreeValue(&value);
}
return ATMO_Status_Success;
}
ATMO_Status_t CompAQ_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompAQ_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompAQ_evaluate(ATMO_Value_t *in, ATMO_Value_t *out) {
bool conditionTrue = false;
// Convert property to same type as input
ATMO_Value_t targetStr;
ATMO_Value_t targetNum;
ATMO_InitValue(&targetStr);
ATMO_InitValue(&targetNum);
ATMO_CreateValueString(&targetStr, ATMO_PROPERTY(CompAQ, target));
ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(CompAQ, condition), &conditionTrue) != ATMO_Status_Success)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAQ, invalidType), NULL);
ATMO_FreeValue(&value);
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
return ATMO_Status_Fail;
}
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
if(conditionTrue)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAQ, conditionTrue), NULL);
ATMO_FreeValue(&value);
}
else
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompAQ, conditionFalse), NULL);
ATMO_FreeValue(&value);
}
return ATMO_Status_Success;
}
ATMO_Status_t CompVibration_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompVibration_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t CompVibration_evaluate(ATMO_Value_t *in, ATMO_Value_t *out) {
bool conditionTrue = false;
// Convert property to same type as input
ATMO_Value_t targetStr;
ATMO_Value_t targetNum;
ATMO_InitValue(&targetStr);
ATMO_InitValue(&targetNum);
ATMO_CreateValueString(&targetStr, ATMO_PROPERTY(CompVibration, target));
ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(CompVibration, condition), &conditionTrue) != ATMO_Status_Success)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompVibration, invalidType), NULL);
ATMO_FreeValue(&value);
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
return ATMO_Status_Fail;
}
ATMO_FreeValue(&targetStr);
ATMO_FreeValue(&targetNum);
if(conditionTrue)
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompVibration, conditionTrue), NULL);
ATMO_FreeValue(&value);
}
else
{
ATMO_Value_t value;
ATMO_InitValue(&value);
ATMO_TriggerHandler(ATMO_TRIGGER(CompVibration, conditionFalse), NULL);
ATMO_FreeValue(&value);
}
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_BLE_GATTSAddService(
ATMO_PROPERTY(AmbLightChar, instance),
&ATMO_VARIABLE(AmbLightChar, bleServiceHandle),
ATMO_PROPERTY(AmbLightChar, bleServiceUuid));
uint8_t property = 0;
uint8_t permission = 0;
property |= ATMO_PROPERTY(AmbLightChar, read) ? ATMO_BLE_Property_Read : 0;
property |= ATMO_PROPERTY(AmbLightChar, write) ? ATMO_BLE_Property_Write : 0;
property |= ATMO_PROPERTY(AmbLightChar, notify) ? ATMO_BLE_Property_Notify : 0;
permission |= ATMO_PROPERTY(AmbLightChar, read) ? ATMO_BLE_Permission_Read : 0;
permission |= ATMO_PROPERTY(AmbLightChar, write) ? ATMO_BLE_Permission_Write : 0;
ATMO_DATATYPE types[3] = {ATMO_PROPERTY(AmbLightChar, writeDataType), ATMO_PROPERTY(AmbLightChar, readDataType), ATMO_PROPERTY(AmbLightChar, notifyDataType)};
ATMO_BLE_GATTSAddCharacteristic(
ATMO_PROPERTY(AmbLightChar, instance),
&ATMO_VARIABLE(AmbLightChar, bleCharacteristicHandle),
ATMO_VARIABLE(AmbLightChar, bleServiceHandle),
ATMO_PROPERTY(AmbLightChar, bleCharacteristicUuid),
property, permission, ATMO_GetMaxValueSize(3, 64, types));
ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
ATMO_PROPERTY(AmbLightChar, instance),
ATMO_VARIABLE(AmbLightChar, bleCharacteristicHandle),
ATMO_BLE_Characteristic_Written,
ATMO_ABILITY(AmbLightChar, written));
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_setValue(ATMO_Value_t *in, ATMO_Value_t *out) {
// Convert to the desired write data type
ATMO_Value_t convertedValue;
ATMO_InitValue(&convertedValue);
ATMO_CreateValueConverted(&convertedValue, ATMO_PROPERTY(AmbLightChar, readDataType), in);
ATMO_BLE_GATTSSetCharacteristic(
ATMO_PROPERTY(AmbLightChar, instance),
ATMO_VARIABLE(AmbLightChar, bleCharacteristicHandle),
convertedValue.size,
(uint8_t *)convertedValue.data,
NULL);
ATMO_FreeValue(&convertedValue);
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_written(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CreateValueConverted(out, ATMO_PROPERTY(AmbLightChar, writeDataType), in);
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_subscibed(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t AmbLightChar_unsubscribed(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FastInterval_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t FastInterval_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_INTERVAL_Handle_t intervalHandle;
ATMO_INTERVAL_AddAbilityInterval(
ATMO_PROPERTY(FastInterval, instance),
ATMO_ABILITY(FastInterval, interval),
ATMO_PROPERTY(FastInterval, time),
&intervalHandle
);
return ATMO_Status_Success;
}
ATMO_Status_t FastInterval_interval(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_BLE_GATTSAddService(
ATMO_PROPERTY(TVOCChar, instance),
&ATMO_VARIABLE(TVOCChar, bleServiceHandle),
ATMO_PROPERTY(TVOCChar, bleServiceUuid));
uint8_t property = 0;
uint8_t permission = 0;
property |= ATMO_PROPERTY(TVOCChar, read) ? ATMO_BLE_Property_Read : 0;
property |= ATMO_PROPERTY(TVOCChar, write) ? ATMO_BLE_Property_Write : 0;
property |= ATMO_PROPERTY(TVOCChar, notify) ? ATMO_BLE_Property_Notify : 0;
permission |= ATMO_PROPERTY(TVOCChar, read) ? ATMO_BLE_Permission_Read : 0;
permission |= ATMO_PROPERTY(TVOCChar, write) ? ATMO_BLE_Permission_Write : 0;
ATMO_DATATYPE types[3] = {ATMO_PROPERTY(TVOCChar, writeDataType), ATMO_PROPERTY(TVOCChar, readDataType), ATMO_PROPERTY(TVOCChar, notifyDataType)};
ATMO_BLE_GATTSAddCharacteristic(
ATMO_PROPERTY(TVOCChar, instance),
&ATMO_VARIABLE(TVOCChar, bleCharacteristicHandle),
ATMO_VARIABLE(TVOCChar, bleServiceHandle),
ATMO_PROPERTY(TVOCChar, bleCharacteristicUuid),
property, permission, ATMO_GetMaxValueSize(3, 64, types));
ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
ATMO_PROPERTY(TVOCChar, instance),
ATMO_VARIABLE(TVOCChar, bleCharacteristicHandle),
ATMO_BLE_Characteristic_Written,
ATMO_ABILITY(TVOCChar, written));
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_setValue(ATMO_Value_t *in, ATMO_Value_t *out) {
// Convert to the desired write data type
ATMO_Value_t convertedValue;
ATMO_InitValue(&convertedValue);
ATMO_CreateValueConverted(&convertedValue, ATMO_PROPERTY(TVOCChar, readDataType), in);
ATMO_BLE_GATTSSetCharacteristic(
ATMO_PROPERTY(TVOCChar, instance),
ATMO_VARIABLE(TVOCChar, bleCharacteristicHandle),
convertedValue.size,
(uint8_t *)convertedValue.data,
NULL);
ATMO_FreeValue(&convertedValue);
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_written(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CreateValueConverted(out, ATMO_PROPERTY(TVOCChar, writeDataType), in);
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_subscibed(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t TVOCChar_unsubscribed(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t AcceChar_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
return ATMO_Status_Success;
}
ATMO_Status_t AcceChar_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_BLE_GATTSAddService(
ATMO_PROPERTY(AcceChar, instance),
&ATMO_VARIABLE(AcceChar, bleServiceHandle),
ATMO_PROPERTY(AcceChar, bleServiceUuid));
uint8_t property = 0;
uint8_t permission = 0;
property |= ATMO_PROPERTY(AcceChar, read) ? ATMO_BLE_Property_Read : 0;
property |= ATMO_PROPERTY(AcceChar, write) ? ATMO_BLE_Property_Write : 0;
property |= ATMO_PROPERTY(AcceChar, notify) ? ATMO_BLE_Property_Notify : 0;
permission |= ATMO_PROPERTY(AcceChar, read) ? ATMO_BLE_Permission_Read : 0;
permission |= ATMO_PROPERTY(AcceChar, write) ? ATMO_BLE_Permission_Write : 0;
ATMO_DATATYPE types[3] = {ATMO_PROPERTY(AcceChar, writeDataType), ATMO_PROPERTY(AcceChar, readDataType), ATMO_PROPERTY(AcceChar, notifyDataType)};
ATMO_BLE_GATTSAddCharacteristic(
ATMO_PROPERTY(AcceChar, instance),
&ATMO_VARIABLE(AcceChar, bleCharacteristicHandle),
ATMO_VARIABLE(AcceChar, bleServiceHandle),
ATMO_PROPERTY(AcceChar, bleCharacteristicUuid),
property, permission, ATMO_GetMaxValueSize(3, 64, types));
ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
ATMO_PROPERTY(AcceChar, instance),
ATMO_VARIABLE(AcceChar, bleCharacteristicHandle),
ATMO_BLE_Characteristic_Written,
...
This file has been truncated, please download it to see its full contents.
Comments