|
The project associated with the course
Software Engineering 2 (02162) in autumn 2014 is
the development of a Smart Home Surveillance and Monitoring System, which
uses smart phones as sensors and actors.
The project will be presented and discussed with the students in the
lecture and project slots of the course. The rough idea of the project and
its scope are outlined below (see slides here).
Overview
This system should be designed
in a configurable way, so that different sensors of smart phones can be
combined and dynamically reconfigured, based on the input from these
devices.
For example, when a movement is detected at a door (by a phone attached to it),
one or more video apps could be automatically activated transmitting the video surveillance to some
server. At the same time, the home owner or some security company could be
notified, and presented with the online video footage from the activated cameras at the home. Based
on that, the user might raise an alarm to the police or just watch what is
going on via different video or audio streams. At the same time, another app
could switch on some light or play some sound, in order to pretend that
someone might be home.
The system should be flexible enough to easily create new kinds of
sensor and actor apps for phones and to easily register new sensor or actor apps
to an existing monitoring configuration; by defining rules for triggering
each other and notifying some persons, these apps could trigger each other
dynamically — and switch on and off recording based on the given situation
and newly incoming events. Of course, it should also be possible to start surveillance
manually.
Such a Smart Home Surveillance and Monitoring System consists of three
main parts:
- The apps for smart phones that use the sensors (video, audio, movement,
temperature, humidity, ..) for reporting them continuously or on demand
to the backend, and apps that serve as actors (flashlight, audio, ...)
- The backend to which the different sensor and actor apps register, and
which collects and combines their input, and triggers some actor apps,
based on some rules defined by the users. It is also the backends
responsibility to store (the required) information permanently in a
database or in files.
- A client, which can be used for monitoring the home and for configuring the
rules for the sensor and actuator apps. The client can also be used for
online surveillance or for viewing information that was recorded in
the past.
This client could be either a web application or a smart phone application
or a combination of both.
Perspective
 This project is done in
cooperation and the kind support of the CITIES project. The CITIES project is mostly interested in smart use of energy. Our Smart Home Surveillance and Monitoring System,
however, could be easily extended to record and monitor data relevant for reducing energy consumption
by taking the weather, temperature and lighting situation and the current energy consumption into account. During
the course of this project, the CITIES project will provide some smart phones and also some devices
for measuring energy consumption of a home. A feature for monitoring temperature and energy consumption
could be chosen as one of the optional features for the system (see below).
If you are interested, you will have the chance to pursue some of the ideas of this project in more depth,
in continuation of this course in the context of the CITIES project.
Minimum requirements
Below, there is a brief overview of the minimum requirements for the system to be implemented.
- Sensor and actor apps for smart phones:
- at least three different sensor or actor apps:
- video camera
- movement app (e.g. detecting that a door is opening when attached to it)
- playing some (pre-recorded) sounds on request
- one additional sensor or actor app that makes sense in the context
of home security or in the CITIES project
- Backend:
- server to which the apps can connect and that (if required) records the data
- server allows to set up and change the configuration and rules for
how the apps are used, and allows apps to register with it
- once, the apps are connected, the server should be able to control the
apps
- Clients (apps or web):
- a client that allows to change the
confifuration of the home security system
- a client on which the online status of the sensor (that can be selected by
the user) are shown
- a client that can be used to view recorded data of the system
- a client app that raises an alert, when some predefined event or combination
of events have occured
- Example configuration:
- a concrete configuration set up with apps, server and clients which demonstrates
the value of the system as a home security system.
The system should be implemented for the Android platform by using Eclipse ADT for
implementing the Apps. The backend should be implemented using Eclipse WPT and
the Glassfish server and some database (could be Derby, which is smoothly integrated
with Glassfish and the Eclipse WPT)
Scoping
In a productive setting, there would be many additional functional and non-functional
requirements on such a system. Due to the short timeframe, however, this project needs
to focus on only some of them. In addition to the above minimal requirements, the
flexibility and extensibility of the design are very important.
Issues like trust, privacy and security — even though extremely important in
general — are considered to be less important in the scope of this simple
project. So is the performance of the overall system and the
energy consumption on the smart phones (it can be assume that they are connected
to a power line for now). The system should, however, be performant enough to
work for a single home configuration in real-time.
|
