Created February 23, 2019
SensorNet Device for Smart Cities in India

This submission shows an application which can be used in smart city, to save electricity in the best way possible.
Things used in this project

Hardware components

Relay
10A / 250V AC
Resistor 1k ohm
General Purpose Transistor NPN
Resistor 10k ohm
NXP Rapid IoT Prototyping Kit
Story

Automation and monitoring helps to increase the productivity and effciency of human beings. This project demonstrates the use of NXP Rapid IoT kit to switch on the AC Supply of Street Pole, depending on the Light Sensor output.
In this way, this project demonstrates the application which can be used in Smart City.
Code

Street Light Control
#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 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 LightCompare_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightCompare_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t LightCompare_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(LightCompare, target));
	ATMO_CreateValueConverted(&targetNum, in->type, &targetStr);
	
	if(ATMO_CompareValues(in, &targetNum, ATMO_PROPERTY(LightCompare, condition), &conditionTrue) != ATMO_Status_Success)
	{
		ATMO_Value_t value;
		ATMO_InitValue(&value);
		ATMO_TriggerHandler(ATMO_TRIGGER(LightCompare, 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(LightCompare, conditionTrue), NULL);
		ATMO_FreeValue(&value);		
	}
	else
	{
		ATMO_Value_t value;
		ATMO_InitValue(&value);
		ATMO_TriggerHandler(ATMO_TRIGGER(LightCompare, conditionFalse), NULL);
		ATMO_FreeValue(&value);			
	}

	return ATMO_Status_Success;
	
}


ATMO_Status_t RelayClick_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_Config_t config;
config.relay1Pin = ATMO_PROPERTY(RelayClick, relay1Pin);
config.relay2Pin = ATMO_PROPERTY(RelayClick, relay2Pin);
config.gpioDriverInstance = ATMO_PROPERTY(RelayClick, gpioDriverInstance);
ATMO_RELAYCLICK_Init(&ATMO_VARIABLE(RelayClick, handle), &config);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setRelay1On(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE, true);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setRelay2On(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO, true);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setRelay1Off(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE, false);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setRelay2Off(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO, false);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_toggleRelay1(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_ToggleRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_toggleRelay2(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_ToggleRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setBothRelaysOn(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE, true);
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO, true);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_setBothRelaysOff(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE, false);
ATMO_RELAYCLICK_SetRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO, false);
return ATMO_Status_Success;
}


ATMO_Status_t RelayClick_toggleBothRelays(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_RELAYCLICK_ToggleRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_ONE);
ATMO_RELAYCLICK_ToggleRelay(ATMO_VARIABLE(RelayClick, handle), RELAY_TWO);
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 EmbeddedNxpRpkBuzzer_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_beep(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_MK64F_Buzzer_On();
    ATMO_PLATFORM_DelayMilliseconds(200);
    ATMO_MK64F_Buzzer_Off();
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_turnOn(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_MK64F_Buzzer_On();
    ATMO_CreateValueBool(out, true);
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_turnOff(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_MK64F_Buzzer_Off();
    ATMO_CreateValueBool(out, false);
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_toggle(ATMO_Value_t *in, ATMO_Value_t *out) {

    bool newState = false;
    ATMO_MK64F_Buzzer_Toggle(&newState);
    ATMO_CreateValueBool(out, newState);
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBuzzer_setState(ATMO_Value_t *in, ATMO_Value_t *out) {

    bool on = false;
    ATMO_GetBool(in, &on);

    if( on )
    {
        ATMO_MK64F_Buzzer_On();
    }
    else
    {
        ATMO_MK64F_Buzzer_Off();
    }
    ATMO_CreateValueBool(out, on);
    
	return ATMO_Status_Success;
    
}


ATMO_Status_t GetLightValue_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t GetAirQualityStr_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t ShowLightVal_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t ShowLightVal_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(ShowLightVal, x), ATMO_PROPERTY(ShowLightVal, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_onDisplayed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
    
}


ATMO_Status_t ShowLightVal_topRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_topLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_bottomLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_UI_PAGE_Config_t config;
	config.hidden = ATMO_PROPERTY(ShowLightVal, pageHidden);
	config.textColor = ATMO_PROPERTY(ShowLightVal, textColor);
    config.activeButtons = ATMO_UI_Page_GetButtonMask(ATMO_PROPERTY(ShowLightVal, topRightButtonEnabled),
    ATMO_PROPERTY(ShowLightVal,bottomRightButtonEnabled), ATMO_PROPERTY(ShowLightVal, topLeftButtonEnabled), ATMO_PROPERTY(ShowLightVal, bottomLeftButtonEnabled));
	config.x = ATMO_PROPERTY(ShowLightVal, x);
    config.x = ATMO_PROPERTY(ShowLightVal, x);
    config.y = ATMO_PROPERTY(ShowLightVal, y);
	strncpy(config.topLeftButtonLabel, ATMO_PROPERTY(ShowLightVal, topLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.topRightButtonLabel, ATMO_PROPERTY(ShowLightVal, topRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomLeftButtonLabel, ATMO_PROPERTY(ShowLightVal, bottomLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomRightButtonLabel, ATMO_PROPERTY(ShowLightVal, bottomRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
    config.spanX = ATMO_PROPERTY(ShowLightVal, spanX);
	config.spanY = ATMO_PROPERTY(ShowLightVal, spanY);
    config.title = ATMO_PROPERTY(ShowLightVal, pageTitle);
    config.titleHidden = ATMO_PROPERTY(ShowLightVal, titleHidden);
	ATMO_UI_SINGLEICONTEXT_Init(&config);
	ATMO_VARIABLE(ShowLightVal, pageHandle) = config.templateInstance;
    ATMO_UI_SINGLEICONTEXT_SetMainText(config.templateInstance, ATMO_PROPERTY(ShowLightVal, label));
    ATMO_UI_SINGLEICONTEXT_SetIcon(config.templateInstance, ATMO_PROPERTY(ShowLightVal, icon));
    ATMO_UI_SINGLEICONTEXT_RegisterOnDisplayedAbilityHandle(ATMO_VARIABLE(ShowLightVal,pageHandle), ATMO_ABILITY(ShowLightVal, onDisplayed));
    ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowLightVal,pageHandle), 1, ATMO_ABILITY(ShowLightVal, topRightButtonPressed));
	ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowLightVal,pageHandle), 2, ATMO_ABILITY(ShowLightVal, bottomRightButtonPressed));
	ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowLightVal,pageHandle), 3, ATMO_ABILITY(ShowLightVal, topLeftButtonPressed));
    ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowLightVal,pageHandle), 4, ATMO_ABILITY(ShowLightVal, bottomLeftButtonPressed));
    ATMO_UI_SINGLEICONTEXT_RegisterOnLeaveAbilityHandle(config.templateInstance, ATMO_ABILITY(ShowLightVal, onLeave));
	return ATMO_Status_Success;
    
}


ATMO_Status_t ShowLightVal_onLeave(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowLightVal_setLabel(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_SINGLEICONTEXT_SetMainText(ATMO_VARIABLE(ShowLightVal,pageHandle), label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t ShowAirQuality_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t ShowAirQuality_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(ShowAirQuality, x), ATMO_PROPERTY(ShowAirQuality, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_onDisplayed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
    
}


ATMO_Status_t ShowAirQuality_topRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_topLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_bottomLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_UI_PAGE_Config_t config;
	config.hidden = ATMO_PROPERTY(ShowAirQuality, pageHidden);
	config.textColor = ATMO_PROPERTY(ShowAirQuality, textColor);
    config.activeButtons = ATMO_UI_Page_GetButtonMask(ATMO_PROPERTY(ShowAirQuality, topRightButtonEnabled),
    ATMO_PROPERTY(ShowAirQuality,bottomRightButtonEnabled), ATMO_PROPERTY(ShowAirQuality, topLeftButtonEnabled), ATMO_PROPERTY(ShowAirQuality, bottomLeftButtonEnabled));
	config.x = ATMO_PROPERTY(ShowAirQuality, x);
    config.x = ATMO_PROPERTY(ShowAirQuality, x);
    config.y = ATMO_PROPERTY(ShowAirQuality, y);
	strncpy(config.topLeftButtonLabel, ATMO_PROPERTY(ShowAirQuality, topLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.topRightButtonLabel, ATMO_PROPERTY(ShowAirQuality, topRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomLeftButtonLabel, ATMO_PROPERTY(ShowAirQuality, bottomLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomRightButtonLabel, ATMO_PROPERTY(ShowAirQuality, bottomRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
    config.spanX = ATMO_PROPERTY(ShowAirQuality, spanX);
	config.spanY = ATMO_PROPERTY(ShowAirQuality, spanY);
    config.title = ATMO_PROPERTY(ShowAirQuality, pageTitle);
    config.titleHidden = ATMO_PROPERTY(ShowAirQuality, titleHidden);
	ATMO_UI_SINGLEICONTEXT_Init(&config);
	ATMO_VARIABLE(ShowAirQuality, pageHandle) = config.templateInstance;
    ATMO_UI_SINGLEICONTEXT_SetMainText(config.templateInstance, ATMO_PROPERTY(ShowAirQuality, label));
    ATMO_UI_SINGLEICONTEXT_SetIcon(config.templateInstance, ATMO_PROPERTY(ShowAirQuality, icon));
    ATMO_UI_SINGLEICONTEXT_RegisterOnDisplayedAbilityHandle(ATMO_VARIABLE(ShowAirQuality,pageHandle), ATMO_ABILITY(ShowAirQuality, onDisplayed));
    ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowAirQuality,pageHandle), 1, ATMO_ABILITY(ShowAirQuality, topRightButtonPressed));
	ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowAirQuality,pageHandle), 2, ATMO_ABILITY(ShowAirQuality, bottomRightButtonPressed));
	ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowAirQuality,pageHandle), 3, ATMO_ABILITY(ShowAirQuality, topLeftButtonPressed));
    ATMO_UI_SINGLEICONTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(ShowAirQuality,pageHandle), 4, ATMO_ABILITY(ShowAirQuality, bottomLeftButtonPressed));
    ATMO_UI_SINGLEICONTEXT_RegisterOnLeaveAbilityHandle(config.templateInstance, ATMO_ABILITY(ShowAirQuality, onLeave));
	return ATMO_Status_Success;
    
}


ATMO_Status_t ShowAirQuality_onLeave(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t ShowAirQuality_setLabel(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_SINGLEICONTEXT_SetMainText(ATMO_VARIABLE(ShowAirQuality,pageHandle), label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t LightCharacteristics_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightCharacteristics_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_BLE_GATTSAddService(
		ATMO_PROPERTY(LightCharacteristics, instance),
		&ATMO_VARIABLE(LightCharacteristics, bleServiceHandle), 
		ATMO_PROPERTY(LightCharacteristics, bleServiceUuid));
	
	uint8_t property = 0;
	uint8_t permission = 0;
	
	property |= ATMO_PROPERTY(LightCharacteristics, read) ? ATMO_BLE_Property_Read : 0;
	property |= ATMO_PROPERTY(LightCharacteristics, write) ? ATMO_BLE_Property_Write : 0;
	property |= ATMO_PROPERTY(LightCharacteristics, notify) ? ATMO_BLE_Property_Notify : 0;

	permission |= ATMO_PROPERTY(LightCharacteristics, read) ? ATMO_BLE_Permission_Read : 0;
	permission |= ATMO_PROPERTY(LightCharacteristics, write) ? ATMO_BLE_Permission_Write : 0;

	ATMO_DATATYPE types[3] = {ATMO_PROPERTY(LightCharacteristics, writeDataType), ATMO_PROPERTY(LightCharacteristics, readDataType), ATMO_PROPERTY(LightCharacteristics, notifyDataType)};
	
	ATMO_BLE_GATTSAddCharacteristic(
		ATMO_PROPERTY(LightCharacteristics, instance),
		&ATMO_VARIABLE(LightCharacteristics, bleCharacteristicHandle), 
		ATMO_VARIABLE(LightCharacteristics, bleServiceHandle), 
		ATMO_PROPERTY(LightCharacteristics, bleCharacteristicUuid), 
		property, permission, ATMO_GetMaxValueSize(3, 64, types));
	
	ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
		ATMO_PROPERTY(LightCharacteristics, instance),
		ATMO_VARIABLE(LightCharacteristics, bleCharacteristicHandle), 
		ATMO_BLE_Characteristic_Written, 
		ATMO_ABILITY(LightCharacteristics, written));
	
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightCharacteristics_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(LightCharacteristics, readDataType), in);

	ATMO_BLE_GATTSSetCharacteristic(
		ATMO_PROPERTY(LightCharacteristics, instance),
		ATMO_VARIABLE(LightCharacteristics, bleCharacteristicHandle),
		convertedValue.size, 
		(uint8_t *)convertedValue.data,
		NULL);
	
	ATMO_FreeValue(&convertedValue);
		
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightCharacteristics_written(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_CreateValueConverted(out, ATMO_PROPERTY(LightCharacteristics, writeDataType), in);
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightCharacteristics_subscibed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightCharacteristics_unsubscribed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t AirQualityCharacteristics_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t AirQualityCharacteristics_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_BLE_GATTSAddService(
		ATMO_PROPERTY(AirQualityCharacteristics, instance),
		&ATMO_VARIABLE(AirQualityCharacteristics, bleServiceHandle), 
		ATMO_PROPERTY(AirQualityCharacteristics, bleServiceUuid));
	
	uint8_t property = 0;
	uint8_t permission = 0;
	
	property |= ATMO_PROPERTY(AirQualityCharacteristics, read) ? ATMO_BLE_Property_Read : 0;
	property |= ATMO_PROPERTY(AirQualityCharacteristics, write) ? ATMO_BLE_Property_Write : 0;
	property |= ATMO_PROPERTY(AirQualityCharacteristics, notify) ? ATMO_BLE_Property_Notify : 0;

	permission |= ATMO_PROPERTY(AirQualityCharacteristics, read) ? ATMO_BLE_Permission_Read : 0;
	permission |= ATMO_PROPERTY(AirQualityCharacteristics, write) ? ATMO_BLE_Permission_Write : 0;

	ATMO_DATATYPE types[3] = {ATMO_PROPERTY(AirQualityCharacteristics, writeDataType), ATMO_PROPERTY(AirQualityCharacteristics, readDataType), ATMO_PROPERTY(AirQualityCharacteristics, notifyDataType)};
	
	ATMO_BLE_GATTSAddCharacteristic(
		ATMO_PROPERTY(AirQualityCharacteristics, instance),
		&ATMO_VARIABLE(AirQualityCharacteristics, bleCharacteristicHandle), 
		ATMO_VARIABLE(AirQualityCharacteristics, bleServiceHandle), 
		ATMO_PROPERTY(AirQualityCharacteristics, bleCharacteristicUuid), 
		property, permission, ATMO_GetMaxValueSize(3, 64, types));
	
	ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
		ATMO_PROPERTY(AirQualityCharacteristics, instance),
		ATMO_VARIABLE(AirQualityCharacteristics, bleCharacteristicHandle), 
		ATMO_BLE_Characteristic_Written, 
		ATMO_ABILITY(AirQualityCharacteristics, written));
	
	return ATMO_Status_Success;
	
}


ATMO_Status_t AirQualityCharacteristics_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(AirQualityCharacteristics, readDataType), in);

	ATMO_BLE_GATTSSetCharacteristic(
		ATMO_PROPERTY(AirQualityCharacteristics, instance),
		ATMO_VARIABLE(AirQualityCharacteristics, bleCharacteristicHandle),
		convertedValue.size, 
		(uint8_t *)convertedValue.data,
		NULL);
	
	ATMO_FreeValue(&convertedValue);
		
	return ATMO_Status_Success;
	
}


ATMO_Status_t AirQualityCharacteristics_written(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_CreateValueConverted(out, ATMO_PROPERTY(AirQualityCharacteristics, writeDataType), in);
	return ATMO_Status_Success;
	
}


ATMO_Status_t AirQualityCharacteristics_subscibed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t AirQualityCharacteristics_unsubscribed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightStatus_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightStatus_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_BLE_GATTSAddService(
		ATMO_PROPERTY(LightStatus, instance),
		&ATMO_VARIABLE(LightStatus, bleServiceHandle), 
		ATMO_PROPERTY(LightStatus, bleServiceUuid));
	
	uint8_t property = 0;
	uint8_t permission = 0;
	
	property |= ATMO_PROPERTY(LightStatus, read) ? ATMO_BLE_Property_Read : 0;
	property |= ATMO_PROPERTY(LightStatus, write) ? ATMO_BLE_Property_Write : 0;
	property |= ATMO_PROPERTY(LightStatus, notify) ? ATMO_BLE_Property_Notify : 0;

	permission |= ATMO_PROPERTY(LightStatus, read) ? ATMO_BLE_Permission_Read : 0;
	permission |= ATMO_PROPERTY(LightStatus, write) ? ATMO_BLE_Permission_Write : 0;

	ATMO_DATATYPE types[3] = {ATMO_PROPERTY(LightStatus, writeDataType), ATMO_PROPERTY(LightStatus, readDataType), ATMO_PROPERTY(LightStatus, notifyDataType)};
	
	ATMO_BLE_GATTSAddCharacteristic(
		ATMO_PROPERTY(LightStatus, instance),
		&ATMO_VARIABLE(LightStatus, bleCharacteristicHandle), 
		ATMO_VARIABLE(LightStatus, bleServiceHandle), 
		ATMO_PROPERTY(LightStatus, bleCharacteristicUuid), 
		property, permission, ATMO_GetMaxValueSize(3, 64, types));
	
	ATMO_BLE_GATTSRegisterCharacteristicAbilityHandle(
		ATMO_PROPERTY(LightStatus, instance),
		ATMO_VARIABLE(LightStatus, bleCharacteristicHandle), 
		ATMO_BLE_Characteristic_Written, 
		ATMO_ABILITY(LightStatus, written));
	
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightStatus_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(LightStatus, readDataType), in);

	ATMO_BLE_GATTSSetCharacteristic(
		ATMO_PROPERTY(LightStatus, instance),
		ATMO_VARIABLE(LightStatus, bleCharacteristicHandle),
		convertedValue.size, 
		(uint8_t *)convertedValue.data,
		NULL);
	
	ATMO_FreeValue(&convertedValue);
		
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightStatus_written(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_CreateValueConverted(out, ATMO_PROPERTY(LightStatus, writeDataType), in);
	return ATMO_Status_Success;
	
}


ATMO_Status_t LightStatus_subscibed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t LightStatus_unsubscribed(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}

//FOOTER START

//FOOTER END
Credits

Sanket Kulkarni

4 projects • 0 followers
Almost 4 years of Experience in Firmware developement. Aspiring to become a Industry 4.0 and Firmware and Hardware Expert.
SensorNet Device for Smart Cities in India

Things used in this project

Hardware components

Story

Schematics

Street Light Control

Application structure

Android App for smart City Application

Code

Street Light Control

Credits

Sanket Kulkarni

Comments

Embed the widget on your own site

SensorNet Device for Smart Cities in India

SensorNet Device for Smart Cities in India

Things used in this project

Hardware components

Story

Schematics

Street Light Control

Application structure

Android App for smart City Application

Code

Street Light Control

Credits

Sanket Kulkarni

Comments
