Published February 25, 2019 © CC BY

OXGROW: Smart Aquaponics System

It's an integrated cultivation of fish and plants. Co-operating a living ecosystem to help each other to grow based on NXP Rapid IoT.

AdvancedFull instructions provided20 hours1,512

Judges Choice - US Based Project

2019 China-US Young Maker Competition

Things used in this project

Hardware components

Raspberry Pi 3 Model B

DC motor (generic)

5 mm LED: Red

Power MOSFET N-Channel

Seeed Studio Grove - OLED Display 1.12'' V2

Hand tools and fabrication machines

CNC Machine

Laser cutter (generic)

Story

TL;DR

OXGROW is a Smart Aquaponics based on the NXP Rapid IoT Prototyping kit , In this Project we will show you how you can build a Smart Aquaponics system , it's include full step by step guide .

1 / 2

What is Aquaponics?

Simply, aquaponics is a integrated cultivation of fish and plants. Co-operating a living ecosystem to help each other to grow. In our case fish and plants will help each other and make a ecosystem to grow themselves by providing resources to grow one another. The Fish will produce the waste and the plants use the waste as the nutrients to grow. Then the Plants will filter the water and remove all wastes from the water, provide clean water for fish.

Concept Design

In order to go forward with the project I should need to plan to build one. First I drawn the basic diagram of the aquaponics. you can definitely find that below. Then I need to draw a 2D rough sketch of the final results. this should help me when the design process. After all the 3D concept design that will exactly tell how it should be look like in real world.

Then I made a diagram about the modules and hardware used that I am going to use in this project. May be in future, I need to be add more module if necessary.

need to design a compatible and stylish design for the OXGROW. So the OXGROW will be interior style friendly. I drawn a basic 2D design of the overall look of OXGROW. But it should have a lot of changes in future of this project.

After a while I designed a basic 2D view of OXGROW final result with the help of Adobe illustrator. You can figure out what am saying this whole time by viewing this image.

Rendered Photo Realistic Image

We designed and rendered the 3D model of my OXGROW aquaponics ecosystem by using fusion360. This will give me a totall understanding of howi need to get the final result in the end of this project.

Designing the Enclosure

shown the rendered image as well as my concept design early in this page. Now iam into the real business. I decided to start with body of OXGROW, it will give me a overall reference to the whole process of project building. I realized that I have some limitations to build the exact design, the real life scenario like this I know. The limitations faced are, I need to CNC mill the design so some curved design can't make with CNC and we have plywood only in our lab so the wood texture is long gone to dream. But I could make the design most likely to the concept design. I started to design the Parts for the enclosure. I choosed press-fit design, Sure I can avoid screws exposed to the view. The overall dimension of the design is given below.

Body

Width : 424mm
Hight : 350mm
Depth : 224mm

Aquarium

Width : 350mm
Hight : 156mm
Depth : 180mm

Grow Bed

Width : 362mm
Hight : 86mm
Depth : 192mm

CNC Milling the Enclossure

After cutting out the parts, I checked every parts are press fit each other. But when I disassemble them, some pieces from edges are ripped off. So I used some wood glue to glue them back to the place were the belong and used a G clamp to hold them together. The problem were solved, it is super strong now. They even cant noticed.

Smoothing and Painting

There are a lot of rough edges in the cut out parts. mostly it appear after CNC cutting. But here I also faced another problem, Unfortunately I used a poor quality plywood. So there is some bums around some areas. All I can do is now filing and sand papering. I also need to paint the pieces, So sanding is necessary to do. I used the small files that are available in the fablab. It is pretty handy because the right size and right files help me to remove all the rough parts from the CNC parts. Then I used 220 grit sand paper for sanding the Cut out parts. If necessary I also have 320 grit sandpaper for finishing touches. But I doesn't use the 320 grit much because the 220 grit is more enough to give a good result.

After along time of filing and sanding, roghly 3 hours I think. I take rest for a while. After that I decided to start the painting process. First I need to collect the material for painting. First I think about the can sparys but I decided to use normal painting with the brushes. Its more handy for this process. I need to paint a single coat of wood primer before painting them, adding another coat over it if necessory but it might not be needed. So first the shoping. I bought all the materials from a local hardware shop.

1 x White Paint matte(500grams)
1 x Wood primer(500grams)
1 x Terpendine aka tinner(250grams)
2 x Paint brushes (one is smooth)

After gathering all the key materials. I started to paint the primer first I took all the individual parts and painted them carefully. After applying primer to all the pieces I waited to dry the primer. It took almost 6 - 8 hours of time. I can utilize this time to take a nap.

After the paint tried, I took the pieces for painting. I mixed the paint and terpendine in a ration of 4:1. I assembled the whole body, If I assemble the body after painting I wont fit well. After assembling the body, I started to paint, it take almost 2 Hours. I used to coat of paint for a finishing touch. Then I took the body for drying. The curing time for the paint is about 24 hours. So I decided to utilize these time for building the Aquarium and grow bed.

Building the Aquarium

The paint took a long time to dry, so iam utilize the time to build a aquarium.I have two choices either build a aquarium or buy a pre made one But I decided to build one, That what meant fablab. I used a 6mm transparent Acrylic material to build the aquarium. I almost utilized two 6mm, 600mm x 300mm transparent acrylic sheets. SO first I take the dxf files of the design from fusion 360. Then laser cutted the design using the trotec speedy 200 machine.

1 / 2

After cutting out the parts. I started to glue the parts together. For this I used a heavy duty Super glue and Silicon sealant. First I attached the parts together using some masking tape that you can see the below image.

Then I also used the F clamp to holding the parts sturdy. Then I started to apply super glue in all edges with a liitle amount. AFter that I waited to cure the super glue. Then cleaned it and applied the silicon glue. The silicon glue is little tough to do. But my outcome is good enough. I used the silicon glue for sealing all edges and gaps. Then waited to cure the glue. To fully cure the glue, I need to wait about 24hours.

1 / 2

Building the Grow Bed

After building the Aquarium I put it for curing the selant. While in this time, I started to work onthe grow bed. I already designed the Grow bed while in the designing process.All ineed to do is cut out the requred pieces and assemble them. SO I used the laser cutter machine to cut out the designed pieces on a 6mm green color Acrylic sheet.

Iused the pressfit technic to attach the parts easly. After that I used the same way as I did in aquarium build to glue them together. Then I put the grow bed for curing the glue.

Building the Automatic Siphon

We need to pump the water from aquarium to the growbed and back to grow bed to aquarium. To do this, there are two methods commonly used. One is continues draining and other one is a siphone, using the siphon method, the siphone will hold the water to reach its top level and drain 90% of the water. The remaining 10% water will contains in the growbed is to give the plants a constant moisture source. But Building a siphone is not a easy task, Atleast for me how don't know nothing. So When i started planning the project i doesn't bother about the siphone because i dont know what it is. I was decided to use the countinues draining technic, it have pros and con. But a friend who already have some experince in aquaponics suggested me to do bell siphone. So i decide to a dive into comparing the two methods i will point them down here.

Bell Siphon

Using a bell siphon is an easy way to drain a grow-bed in an aquaponic or hydroponic system. The idea is that in an ebb and flow system, you have a tank of fertilizer (for aquaponics its a fish tank) and a grow bed full of plants. ... A bell siphon works solely on the physics principles of atmospheric pressure and vacuums!

The Best for Aquaponics I choose

From my observation from this. I decided to use the irrigation sytem with a bell siphon. Bell siphon is a type of autosiphon that exploits a few physical laws of hydrodynamics and allows the media bed to flood and drain automatically, periodically, without a any controller device. The action, timing and ultimate success of the siphon are dependent on the water’s flow rate into the bed, which is constant. This should be the best way.

Now the the bell siphone building parts. But before building the siphon i discussed about my project with some friends. From the information gathered from them and from google, i found out that the bell siphon wont work with my growbed. Its because of the depth and available PVC pipe size. My growbed only have a depth of 80mm. The smallest diameter PVC pipe available in our local store is 0.5" diameter. So i does not attempt to build the bell siphone, I dont have much time to try on siphons i have only few days left to present my final project. So Instead, I decided to find another way. I got the idea of Pythagorean cup. I decided to build a siphon just like how the Pythagorean cup works. But when comparing with the bell siphon, the bell siphone only work with high deapth growbeds, may be atleast 20cm depth. But the Pythagorean cup siphon will work with any depth, even a small centimeter depth. I will show you later my test video. This is the main advantage of this method while comparing with bell siphon.

To build the siphon, i used 1/2inch PVC pipe, 1/2inch PVC pipe end cap and 1/2inch PVC pipe adapter. I cut a 4cm PVC pipe and conected the PVC pipe to the top of the PVC adapter. Then i placed the adapter in the hole on growbed by sandwiching a rubber washer. After that i conected another PVC screw conecter to the bottom of the growbed.

1 / 2

I used the same method to the second hole too. The first hole that you can see on a side of the groebed is to attach a fish feeder that i will add as future upgrade to the OXGROW. Currently we are only using one hole that you can see in the center part of the growbed, That is used to atatch my siphon.

But i need to perfectly seal the pipes to avoid water leakage. For this first i choosed to use a PVC pipe sealant called Mseal, But i doesnt used it. Insted of that i used the same Silicon sealant to close all gaps. I also applied the sealant all over the corners of the growbed. I used a PVC glue to attach the PVC. It is compaltely optional because the PVC pipe joints are tight enough, but i used glue to avoid a incase.

Then i placed the growbed asaid to cure the glue.

Now i need to build the siphon part. To do this i used a 150mm flexible hose tube and two 1/2inch end caps that i previously bought from the same local hardware store were i bought the paints and brushes. First i drill 5mm hile on both 1/2inch end caps. I also cut off a side on of the endcap for placing it on the growbed surface for water incoming. Then i cut a 150mm hose piece and conected the endcaps one on a end another one 8mm away from the first endcap. Then used the super glue to fix them sturdy.

1 / 2

Then i conected the first endcap that i placed on the middle of the hose pipe on to the the PCV pipe, the hose pipe are go through the pipe to the aquarium. The second endcap is glue to the growbed surface to intake the water. How ever the hose pipe keep a 5mm surface clearance, by using this, there should be always keep a wet zone in growbed.

3D printing the Hose nozzle

I placed a hole for attaching the water pump to the grobed. So i decided to design and 3D print a nozzle that can attach the end of the hose pipe come from the water pump on end and the other end can place through the hole to the growbed.

I used the ultimaker 2 3D printer that in our fablab to print out the nozzle.

1 / 2

Attaching the back door

I included a door on the back of the OXGROW. The CNC part is all assembled when in the painting process. Now i need to complete the body assembling. There is only left to attach the door to the body. To do this is used two ordinary steel hinches. First i marked i placed the door piece then marked down where the hinches should placed. I drilled a the screw holes with a 4mm driller bit. Then attached the hinches to the body using 4mm screws. Then i screwed the door panel to the hinches that you can see in the image below.

1 / 3

Making the Grow Light

Grow light is the essential part of a indoor aquaponics system. There is only two source of light for a indoor plant one is place the plant near the windows to get the sunlight. The other way is to use growlight. The grow light is the sun of the indoor aquaponics system. The growlight is the source of light for the plants. We can use a normal bulb as a growlight. But the exact spectrum that the plants more needed should be better. So i made a little study on internet regardingthe grow light. I found out that the palnts absorb a ony abosrb the Blue spectrum (450nm) and RED spectrum (650nm) the plants only abosrb these lights from the natural light.

found out, most DIY aquaponics builders are used a commercial growlight. But I have two choices either i can buy a commercial one, if i bought one then i doesnt need to bother about the quality and i can save a lot of time. But building a growlight should be better for me, i can learn and build a custom one according to my design. I decided to make one for my aquaponics.

I decided to mix the red LEDs and BLUE LEDs in a ratio of 1:1. First i bought some budget friendly and quality LEDs strips from a local electronics shop. Each color have three strips and each strips have three LEDs.

I seprated each LEDs apart. Then i placed RED and BLUE LEDs strips one together in series and striped and twisted the wires together. After then i need to design a holder for the LEDs. For this I designed the holder as two parts first because 3D printing a this whole design take a lot of time and its not well strong. I designed the first part for placing the LEDs and 3D printed it.

1 / 2

After 3D print the part I ripped of and placed the LEDs, its fit perfectly. The LEDs strips hace 3M adhessive tap in the botton so i doesnt want to use any glue to fix it in place. Then i test the LEDs by conecting to the lab bench power supply with a 12v 200mA power source. They are working perfect and well bright.

1 / 2

Now i need to cutout the handle part using a laser cutter. I used a 6mm clear acrylic sheet and cut the part. Then i atached the two parts together. After then i attached the handle to the pocket that i made when the enclossure parts are CNC milled. The pocket is 10mm deapth to fill the the pocket i laser cutted a 4mm white acrylic piece same size as the pocket. This will mach the enclossure color and hold the handle strong. Then i screw the handle and the pocket close piece together.

1 / 2

OLED Display Protective Glass

To protect the OLED display from scratches and spills and also for a nice look i designed a protective glass that fit in the hole for OLED display. I used a 3mm clear acrylic sheet and 3mm black acrylic sheet. Then laset cutten the design and glued the two piece together. Aftewr that i placed it in the pront panel of OXGROW body.

1 / 3

Code

#include "callbacks.h"

//HEADER START

//HEADER END

void ATMO_Setup() {

}


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


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

    Backlight_SetLevel(ATMO_PROPERTY(Backlight, initialSetting));
	return ATMO_Status_Success;
	
}


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

    Backlight_SetLevel(BLIGHT_LEVEL_OFF);
	return ATMO_Status_Success;
    
}


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

    Backlight_SetLevel(BLIGHT_LEVEL_LOW);
	return ATMO_Status_Success;
	
}


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

    Backlight_SetLevel(BLIGHT_LEVEL_MEDIUM);
	return ATMO_Status_Success;
    
}


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

    Backlight_SetLevel(BLIGHT_LEVEL_HIGH);
	return ATMO_Status_Success;
	
}


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


ATMO_Status_t Light_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_TSL2572_Config_t config;
	config.address = ATMO_PROPERTY(Light, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(Light, i2cInstance);

	return ( ATMO_TSL2572_Init(&config) == ATMO_TSL2572_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t Light_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_TSL2572_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t Light_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_TSL2572_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t Light_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 Light_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 BLE_Light_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


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

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

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

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


ATMO_Status_t BLE_Light_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(BLE_Light, readDataType), in);

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


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

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


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


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


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


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

	ATMO_INTERVAL_Handle_t intervalHandle;
    ATMO_INTERVAL_AddAbilityInterval(
		ATMO_PROPERTY(delay, instance), 
		ATMO_ABILITY(delay, interval), 
		ATMO_PROPERTY(delay, time), 
		&intervalHandle
	);
	
	return ATMO_Status_Success;
	
}


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


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


ATMO_Status_t CO2_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_CCS811_Config_t config;
	config.operatingMode = ATMO_PROPERTY(CO2, operatingMode);
	config.address = ATMO_PROPERTY(CO2, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(CO2, i2cInstance);

	return ( ATMO_CCS811_Init(&config) == ATMO_CCS811_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t CO2_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t CO2_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t CO2_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 CO2_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 CO2_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 BLE_CO2_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


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

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

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

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


ATMO_Status_t BLE_CO2_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(BLE_CO2, readDataType), in);

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


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

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


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


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


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


ATMO_Status_t TVOC_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_CCS811_Config_t config;
	config.operatingMode = ATMO_PROPERTY(TVOC, operatingMode);
	config.address = ATMO_PROPERTY(TVOC, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(TVOC, i2cInstance);

	return ( ATMO_CCS811_Init(&config) == ATMO_CCS811_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t TVOC_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t TVOC_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_CCS811_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t TVOC_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 TVOC_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 TVOC_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 BLE_TVOC_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


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

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

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

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


ATMO_Status_t BLE_TVOC_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(BLE_TVOC, readDataType), in);

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


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

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


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


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


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


ATMO_Status_t Temperature_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_ENS210_Config_t config;
	config.address = ATMO_PROPERTY(Temperature, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(Temperature, i2cInstance);
	config.tempCalibrationOffset = ATMO_PROPERTY(Temperature, tempCalibrationOffset);

	return ( ATMO_ENS210_Init(&config) == ATMO_ENS210_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t Temperature_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t Temperature_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t Temperature_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 Temperature_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 Temperature_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 Humidity_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t Humidity_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_ENS210_Config_t config;
	config.address = ATMO_PROPERTY(Humidity, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(Humidity, i2cInstance);
	config.tempCalibrationOffset = ATMO_PROPERTY(Humidity, tempCalibrationOffset);

	return ( ATMO_ENS210_Init(&config) == ATMO_ENS210_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t Humidity_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t Humidity_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_ENS210_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t Humidity_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 Humidity_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 Humidity_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 Pressure_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t Pressure_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_MPL3115_Config_t config;
	config.address = ATMO_PROPERTY(Pressure, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(Pressure, i2cInstance);
	config.MPLsettings.mode = MPL_MODE_PRESSURE;
	config.MPLsettings.oversample = MPL_OS_0;			// oversampling = 1
	config.MPLsettings.autoAcquisitionTime = MPL_ST_0;	// Auto acquisition time = 1s
	config.MPLsettings.pressureOffset = ATMO_PROPERTY(Pressure, pressureOffset);	// Offset pressure correction = 4*-128 = -512Pa (8 bits signed integer)
	config.MPLsettings.altitudeOffset = ATMO_PROPERTY(Pressure, altitudeOffset);	// Offset altitude correction = 128m (signed 8 bits integer)
	config.MPLsettings.tempOffset = ATMO_PROPERTY(Pressure, tempOffset);			// Offset temperature correction -8°C (0.0625°C/LSB)
	config.MPLsettings.fifoMode = FIFO_DISABLED;		// FIFO mode disabled
	config.MPLsettings.fifoWatermark = 5;				// 6 bits to set the number of FIFO samples required to trigger a watermark interrupt.
	config.MPLsettings.fifoINTpin = FIFO_INT1;			// set pin INT1 as output for FIFO interrupt

	return ( ATMO_MPL3115_Init(&config) == ATMO_MPL3115_Status_Success ) ? ATMO_Status_Success : ATMO_Status_Fail;

}


ATMO_Status_t Pressure_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_MPL3115_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t Pressure_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_MPL3115_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t Pressure_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_MPL3115_SetEnabled(enabled);
return ATMO_Status_Success;
}


ATMO_Status_t Pressure_readAltitude(ATMO_Value_t *in, ATMO_Value_t *out) {
    uint32_t altitudeMeters;
    if(ATMO_MPL3115_GetAltitude(&altitudeMeters) != ATMO_MPL3115_Status_Success)
    {
        ATMO_CreateValueVoid(out);
        return ATMO_Status_Fail;
    }
    ATMO_CreateValueInt(out, (int)altitudeMeters);
    return ATMO_Status_Success;
}


ATMO_Status_t Pressure_readPressure(ATMO_Value_t *in, ATMO_Value_t *out) {
    uint32_t pressurePa;
    if(ATMO_MPL3115_GetPressure(&pressurePa) != ATMO_MPL3115_Status_Success)
    {
        ATMO_CreateValueVoid(out);
        return ATMO_Status_Fail;
    }
    ATMO_CreateValueInt(out, (int)pressurePa);
    return ATMO_Status_Success;
}


ATMO_Status_t Pressure_readPressureKpa(ATMO_Value_t *in, ATMO_Value_t *out) {
    uint32_t pressurePa;
    if(ATMO_MPL3115_GetPressure(&pressurePa) != ATMO_MPL3115_Status_Success)
    {
        ATMO_CreateValueVoid(out);
        return ATMO_Status_Fail;
    }
    ATMO_CreateValueInt(out, (int)(pressurePa/1000));
    return ATMO_Status_Success;
}


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


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

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

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

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


ATMO_Status_t BLE_Pressure_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(BLE_Pressure, readDataType), in);

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


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

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


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


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


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


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

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

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

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


ATMO_Status_t BLE_Temperature_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(BLE_Temperature, readDataType), in);

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


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

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


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


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


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


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

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

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

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


ATMO_Status_t BLE_Humidity_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(BLE_Humidity, readDataType), in);

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


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

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


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


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


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


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

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


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

	return ATMO_Status_Success;
    
}


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

	return ATMO_Status_Success;
	
}


ATMO_Status_t OXGROW_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {
...

This file has been truncated, please download it to see its full contents.

import time
import pygatt
import paho.mqtt.publish as publish
from time import sleep

RPK_ADDRESS = "MAC ID"

MQTT_SERVER = "localhost"

CHAR_UUIDS = {
    "ambient-light" : "2262d1c7-5e0f-447d-bccf-6455c7a901bf",
    "pressure" : "2262d1c7-5e0f-447d-bccf-6455c7a901c2",
    "tvoc" : "2262d1c7-5e0f-447d-bccf-6455c7a901c1",
    "co2" : "2262d1c7-5e0f-447d-bccf-6455c7a901c0",
    "temperature" : "2262d1c7-5e0f-447d-bccf-6455c7a901c3",
    "humidity" : "2262d1c7-5e0f-447d-bccf-6455c7a901c4"
}

adapter = pygatt.GATTToolBackend()

def readData():


    adapter = pygatt.GATTToolBackend()

    try:
        # Connect to the RPK device
        adapter.start()
        conn = adapter.connect(RPK_ADDRESS)

        time_info = int(time.time()*1000000000.0)

        # Get sensor values
        sensor_values = {}
        for sensor in CHAR_UUIDS:
            value = conn.char_read(CHAR_UUIDS[sensor])
            sensor_values[sensor] = float(value.decode("utf-8").rstrip('\x00'))

        light = sensor_values["ambient-light"]
        pressure = sensor_values["pressure"]
        tvoc = sensor_values["tvoc"]
        co2 = sensor_values["co2"]
        temperature = sensor_values["temperature"]
        humidity = sensor_values["humidity"]

    #Print Sensor data 
        print(light)
        print(pressure)
        print(tvoc)
        print(co2)
        print(temperature)
        print(humidity)
    
    #Publish Sensor data 
        publish.single("light",light, hostname=MQTT_SERVER)
        publish.single("pressure",pressure, hostname=MQTT_SERVER)
        publish.single("tvoc", tvoc , hostname=MQTT_SERVER)
        publish.single("co2", co2 , hostname=MQTT_SERVER)
        publish.single("temperature", temperature, hostname=MQTT_SERVER)
        publish.single("humidity", humidity, hostname=MQTT_SERVER)



    except Exception as e:
        print ("Error: ", e)

    finally:
        adapter.stop()



while True: # Run forever
 readData()
 sleep(10)

[{"id":"ff01a7f3.56cb68","type":"tab","label":"NXP IOT KIT","disabled":false,"info":""},{"id":"d308322d.3289b","type":"mqtt in","z":"ff01a7f3.56cb68","name":"Light","topic":"light","qos":"2","broker":"5b093380.b880ac","x":156,"y":86,"wires":[["6ecef283.37b88c"]]},{"id":"6ecef283.37b88c","type":"ui_gauge","z":"ff01a7f3.56cb68","name":"Light","group":"e7514166.5fc65","order":6,"width":0,"height":0,"gtype":"gage","title":"Light","label":"lux","format":"{{value}}","min":0,"max":"2500","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":433,"y":80,"wires":[]},{"id":"fc213c5f.44924","type":"mqtt in","z":"ff01a7f3.56cb68","name":"Air Quality","topic":"tvoc","qos":"2","broker":"5b093380.b880ac","x":168,"y":172,"wires":[["c5da88b2.54ba88"]]},{"id":"c5da88b2.54ba88","type":"ui_gauge","z":"ff01a7f3.56cb68","name":"Air Quality","group":"dbac2967.6a21f8","order":1,"width":0,"height":0,"gtype":"compass","title":"Air Quality","label":"ppm","format":"{{value}}","min":0,"max":"50","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":442,"y":153,"wires":[]},{"id":"8991d818.804378","type":"mqtt in","z":"ff01a7f3.56cb68","name":"CO2","topic":"co2","qos":"2","broker":"5b093380.b880ac","x":160,"y":237,"wires":[["8ae81fea.31bbf"]]},{"id":"34a44d4e.5320f2","type":"mqtt in","z":"ff01a7f3.56cb68","name":"Pressure","topic":"pressure","qos":"2","broker":"5b093380.b880ac","x":181,"y":306,"wires":[["8283b692.7a15e8"]]},{"id":"c5b9faf1.52a868","type":"mqtt in","z":"ff01a7f3.56cb68","name":"Temperature","topic":"temperature","qos":"2","broker":"5b093380.b880ac","x":197,"y":371,"wires":[["ad51ae16.1fb2b"]]},{"id":"ad51ae16.1fb2b","type":"ui_chart","z":"ff01a7f3.56cb68","name":"Temperature","group":"685cbe20.4604","order":4,"width":0,"height":0,"label":"Temperature","chartType":"line","legend":"false","xformat":"HH:mm","interpolate":"linear","nodata":"","dot":true,"ymin":"0","ymax":"50","removeOlder":"1","removeOlderPoints":"","removeOlderUnit":"86400","cutout":0,"useOneColor":false,"colors":["#1f77b4","#aec7e8","#ff7f0e","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5"],"useOldStyle":false,"x":489,"y":383,"wires":[[],[]]},{"id":"8ae81fea.31bbf","type":"ui_gauge","z":"ff01a7f3.56cb68","name":"CO2","group":"98bd2aec.a0c098","order":3,"width":0,"height":0,"gtype":"compass","title":"CO2","label":"ppm","format":"{{value}}","min":0,"max":"50","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":458,"y":217,"wires":[]},{"id":"8283b692.7a15e8","type":"ui_gauge","z":"ff01a7f3.56cb68","name":"","group":"66e460be.93b9d","order":5,"width":0,"height":0,"gtype":"gage","title":"Pressure","label":"pa","format":"{{value}}","min":0,"max":"300000","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":466,"y":297,"wires":[]},{"id":"5b093380.b880ac","type":"mqtt-broker","z":"","name":"Local","broker":"localhost","port":"1883","clientid":"","usetls":false,"compatmode":true,"keepalive":"60","cleansession":true,"birthTopic":"","birthQos":"0","birthPayload":"","closeTopic":"","closeQos":"0","closePayload":"","willTopic":"","willQos":"0","willPayload":""},{"id":"e7514166.5fc65","type":"ui_group","z":"","name":"light","tab":"ff785306.eaaf","order":4,"disp":true,"width":"6","collapse":false},{"id":"dbac2967.6a21f8","type":"ui_group","z":"","name":"TVOC","tab":"ff785306.eaaf","order":1,"disp":true,"width":"6","collapse":true},{"id":"685cbe20.4604","type":"ui_group","z":"","name":"Temp","tab":"ff785306.eaaf","order":5,"disp":true,"width":"27","collapse":false},{"id":"98bd2aec.a0c098","type":"ui_group","z":"","name":"CO2","tab":"ff785306.eaaf","order":2,"disp":true,"width":"6","collapse":false},{"id":"66e460be.93b9d","type":"ui_group","z":"","name":"Pressure","tab":"ff785306.eaaf","order":3,"disp":true,"width":"6","collapse":false},{"id":"ff785306.eaaf","type":"ui_tab","z":"","name":"Home","icon":"dashboard","disabled":false,"hidden":false}]

Credits

suhail jr

8 projects • 75 followers

Maker and electronics enthusiast

Comments

Awards

Judges Choice - US Based Project

2019 China-US Young Maker Competition

OXGROW: Smart Aquaponics System

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

TL;DR

What is Aquaponics?

Concept Design

Rendered Photo Realistic Image

Designing the Enclosure

Body

Aquarium

Grow Bed

CNC Milling the Enclossure

Smoothing and Painting

Building the Aquarium

Building the Grow Bed

Building the Automatic Siphon

Bell Siphon

The Best for Aquaponics I choose

3D printing the Hose nozzle

Attaching the back door

Making the Grow Light

OLED Display Protective Glass

Schematics

Architecture

Code

NXP_Main.c

NXP_main.bin

NXP_main.zip

BLEtoMQTT.py

nodred_flow.json

Credits

suhail jr

Comments

Awards

Embed the widget on your own site

OXGROW: Smart Aquaponics System

OXGROW: Smart Aquaponics System

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

TL;DR

What is Aquaponics?

Concept Design

Rendered Photo Realistic Image

Designing the Enclosure

Body

Aquarium

Grow Bed

CNC Milling the Enclossure

Smoothing and Painting

Building the Aquarium

Building the Grow Bed

Building the Automatic Siphon

Bell Siphon

The Best for Aquaponics I choose

3D printing the Hose nozzle

Attaching the back door

Making the Grow Light

OLED Display Protective Glass

Schematics

Architecture

Code

NXP_Main.c

NXP_main.bin

NXP_main.zip

BLEtoMQTT.py

nodred_flow.json

Credits

suhail jr

Comments

Awards

Related channels and tags