Team Felix Grammling and Matthias Geckeler: D Team, Dionysios Satikidis

Published January 27, 2018 © GPL3+

LEA - Light Environment Automation

With Lea you can automate the lights according to the brightness of the environment.

IntermediateWork in progress5 hours1,690

Things used in this project

Hardware components

Particle Photon

Breadboard (generic)

NeoPixel Ring - 12 x 5050 RGB LED Adafruit 1643

SparkFun mini potocell SEN-09088

SparkFun Button

LED (generic)

Resistor 10k ohm

Used for photocell

Story

Intro

This project is created in context of the lecture “Internet of Things Ecosystems” atthe University of Applied Science Esslingen. It covers the invention of an own IoT Idea and Application from the scratch solving a real-world problem. In the design sprints the students learn about design, implementation (full-stack) and business aspects of Internet of Things applications.

IoT Prototyping Framework

The IoT Prototyping Framework (IoTPF) is a collection of tools, modules and samples with the aim to empower students and developers creating full-stack IoT prototypes in a short time period.

Contact:

Idea and Application: Felix Grammling and Matthias Geckeler

Lecture and IoTPF: dionysios.satikidis@gmail.com

Tools:

http://particle.io

https://tensorflow.org

https://www.losant.com

https://ifttt.com/

https://www.google.de

https://telegram.org

University of applied SciencesEsslingen 2018

The project idea

The project name LEA is an abbreviation and stands for Light Environment Automation. The idea behind that is to control the lights according to the brightness of the environment and in a user-defined period of time.

Think about the Christmastime or Halloween. You have several chains of lights at home and you have to turn them on one by one. Or see, there are chains with an integrated timer, which is always activated for a certain time, although you don't want this at all.

With LEA, you can solve all this problems. For this purpose LEA defines a start and a end time. The start time marks the beginning of the functionality. The functionality can be described in following easy states and processes:

The environment around LEA is dark - LEA turns the lights on.

The environment around LEA is bright - LEA turns the lights off.

But only in the given time period as defined before. If the time period is over all lights turn off automatically. So the light won't be on all night.

To demonstrate the proof of concept, our prototype uses the NeoPixel-Ring as a symbol for a lamp or a chain of light that is switched on in the dark. In the later final release the luminaires should be connected wired or wirelessly with LEA.

The architecture

The below shown state-machine shows how LEA works.

state-machine of LEA

The first action is to check whether LEA is online or offline. The status LEDs are set depending on the result. If LEA is offline unfortunately nothing can be done, because LEA can’t send commands to the connected luminaires.

If LEA is online, the next step is to check which mode LEA is in. We defined three modes:

Enabled Mode - all lights will be turned on independently to the brightness and the time period.

Disabled Mode - all lights will be turned off independently to the darkness, even in the time period.

Automatic Mode - LEA checks the brightness and the period of time and turns the lights on according to the settings.

The board

Following picture shows the implemented prototype of the board.

Particle Photon LEA prototype

In the upper left corner of the board you can see the installed status LEDs. They are showing the online (green) and offline (red) status of LEA.

In the middle of the board you see the NeoPixel-Ring, which represents any illuminant that is connected to LEA.

The light-sesor is mounted on the right-handside. The used hardware is a photocell which measures the brightness. The below shown diagrams should show the brightness values over a three-hours period in Esslingen am Neckar.

Between the NeoPixel-Ring and the light-sensor there are buttons for switching between the different modes of LEA. From left to right:

Enabled mode (turn light on)

Automatic mode

Disabled mode (turn light off)

light sensor brightness values

Webinterface

The threshold of brightness to define dark and bright can be user defined. So we implemented a simple Webinterface to define the period of time and the just mentioned threshold for the brightness. Following picture should give an impression to the Webinterface.

Webinterface of LEA

In the upper half, you can specify the time:

Startzeit (start-time) - save the start-time by clicking on "Speichern" (save)

Endzeit (end-time) - save the end-time by clicking on "Speichern" (save)

In the lower half, you can specify the threshold for the brightness:

Aktuell gemessen (measured currently) - get the currently measured brightness value by clicking on "Aktualisieren" (refresh).

Schwellwert (threshold) - set the threshold by clicking on "Speichern" (save)

Behind the Webinterface we communicate with the particle cloud to get and set the variables.

lea.ino

/*
 *  This file is a sample application, based
 *  on the IoT Prototyping Framework (IoTPF)

    This application and IoTPF is free software: you can redistribute it     and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    IoTPF is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU v3 General Public License for more details.

    Released under GNU v3

    You should have received a copy of the GNU General Public License
    along with IoTPF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 /**
    Internet of Things Prototyping Framework IoTPF  
    @Version 1.0
    @author Dionysios Satikidis
    
    LEA 2017/2018
    @version 1.0
    @author Matthias Geckeler and Felix Grammling
*/

#include "Button_Connection.h"
#include "Time_Connection.h"
#include "Light_Connection.h"
#include "LED_Connection.h"
#include "NeoPixelRing_Connection.h"

Time_Connection tc;
Light_Connection lc;
LED_Connection ledc;
NeoPixelRing_Connection nc;
Button_Connection bc;

typedef enum STATE{START, ONLINE, OFFLINE, ENABLED_MODE, AUTOMATIC_MODE, DISABLED_MODE, IN_TIME, NOT_IN_TIME, DARK, BRIGHT} STATE_TYPE;

STATE_TYPE actState = START;
STATE_TYPE nextState = START;

void setup() {
    tc.init();
    lc.init();
    ledc.init();
    nc.init();
    bc.init();
}

void loop() {

    switch(actState) {
        case START: 
            if (Particle.connected()) {
                nextState = ONLINE;
            }
            else {
                nextState = OFFLINE;
            }
            break;
            
        case OFFLINE: 
            ledc.turnGreenOff();
            ledc.turnRedOn();
            nextState = START;
            break;
            
        case ONLINE: 
            ledc.turnRedOff();
            ledc.turnGreenOn();
            bc.handleMode();
            if (bc.isEnabledMode()) {
                nextState = ENABLED_MODE;
            }
            if (bc.isAutomaticMode()) {
                nextState = AUTOMATIC_MODE;
            }
            if (bc.isDisabledMode()) {
                nextState = DISABLED_MODE;
            }
            break;
           
        case ENABLED_MODE:
            ledc.turnBlueOff();
            ledc.turnWhiteOn();
            nc.showAllPixels();
            nextState = START;
            break;
            
        case DISABLED_MODE:
            ledc.turnBlueOn();
            ledc.turnWhiteOff();
            nc.hideAllPixels();
            nextState = START;
            break;
        
        case AUTOMATIC_MODE:
            ledc.turnBlueOff();
            ledc.turnWhiteOff();
            if (tc.isInTime()) {
                nextState = IN_TIME;
            }
            else {
                nextState = NOT_IN_TIME;
            }
            break;
         
        case NOT_IN_TIME: 
            nc.hideAllPixels();
            nextState = START;
            break; 
            
        case IN_TIME: 
            if (lc.isBright()) {
                nextState = BRIGHT;
            }
            else {
                nextState = DARK;
            }
            break;
        
        case DARK: 
            nc.showAllPixels();
            nextState=START;
            break;
            
        case BRIGHT: 
            nc.hideAllPixels();
            nextState=START;
            break;
        
        default:
            nextState=START;
    }
    
    actState = nextState;

    delay(100);
}

Credits

D Team

2 projects • 1 follower

Dionysios Satikidis

17 projects • 32 followers

Dev. Experience Platforms Guy at Mercedes-Benz Lecturer IoT Ecosystems & Applied AI at Brunel Univ. and Univ. of Applied Sciences Esslingen.

Thanks to Dionysios Satikidis.

LEA - Light Environment Automation

Things used in this project

Hardware components

Story

Intro

IoT Prototyping Framework

Contact:

The project idea

The architecture

The board

Webinterface

Code

lea.ino

Credits

D Team

Dionysios Satikidis

Comments

Embed the widget on your own site

LEA - Light Environment Automation

LEA - Light Environment Automation

Things used in this project

Hardware components

Story

Intro

IoT Prototyping Framework

Contact:

The project idea

The architecture

The board

Webinterface

Code

lea.ino

Credits

D Team

Dionysios Satikidis

Comments

Related channels and tags