Jaipur Engineering College and Research Centre

Department of Electronics and Communication Engineering

Course Name: SKILL DEVELOPMENT LAB

Course Code: 8EC4- 22

Project 1: Password Based Door Lock System using 8051 Microcontroller

Project 2: ToDo GUI Application using Tkinter

Akshat Sharma
17EJCEC018
Section- 8ECE-A1
 Project 1

Title: Password Based Door Lock System using 8051 Microcontroller

Languages Used: C programming languages

Tools/Platforms Used:

Hardware Requirements

● 8051 Microcontroller
● 8051 Development Board
● 8051 Programmer
● 4×4 Matrix Keypad
● 16×2 LCD
● L293D Motor Driver Board
● DC Motor
● 10KΩ Potentiometer
● Connecting wires
● Power Supply

Software Requirements

● Keil µVision IDE

● Willar Programmer
● Proteus (for circuit diagram and simulation)

Project-Description:

Password Based Door Lock System using 8051 Microcontroller is a

simple project where a secure password will act as a door unlocking system.
Traditional lock systems using mechanical lock and key mechanism are being
replaced by new advanced techniques of locking system. These techniques are
an integration of mechanical and electronic devices and are highly intelligent.
One of the prominent features of these innovative lock systems is their
simplicity and high efficiency.
Such an automatic lock system consists of electronic control assembly, which
controls the output load through a password. This output load can be a motor
or a lamp or any other mechanical/electrical load.

Here, we developed an electronic code lock system using 8051

microcontroller (a Password based Door Lock System using 8051
Microcontroller), which provides control to the actuating the load. It is a
simple embedded system with input from the keyboard and the output being
actuated accordingly.

This system demonstrates a Password based Door Lock System using 8051
Microcontroller, wherein once the correct code or password is entered, the
door is opened and the concerned person is allowed access to the secured
area. Again, if another person arrives, it will ask to enter the password. If the
password is wrong, then door would remain closed, denying access to the
person.

Today people are facing more problems about security in all over world,
nowadays security is the most essential issue everywhere in the world; so
security of everything gains higher and higher importance in recent years.
Here in this paper, trying to reproduce the comprehensive literature study
related to the various door locks and gate security systems that are necessary
in the fields such as home, industries and vehicle security where possibilities
of incursion are increasing day by day. In past days, the research is gone on
various door lock security systems like traditional security systems which
provide indications using alarm. Due to the advancement in recent techniques,
some door lock security systems are based on microcontroller, GSM, GPS,
many sensors, software like MATLAB, PROTEUS, biometrics like face
recognition, Iris scanner, RFID, Smart Card and password etc. Each system has
their own advantages and disadvantages. In most of systems, SMS technique is
used for communication so the system will become cost effective, more
reliable and it will take less time to deliver message. As security becomes
major problem nowadays, the security monitoring systems today needs to
make use of the latest technology. In some papers, the authors have presented
door lock security monitoring system based on embedded and Zigbee and
sometimes the lock is protected by automatic password hence it could not
easily hack by hackers. Also the enhanced security systems are available
based on android platform, wireless techniques and embedded systems. A lot
of modification takes places in various Door lock security from the last few
years, in next coming years many changes will takes place.

Literature Survey:

1. This project Password Based Door Lock System using 8051 Microcontroller
is for the purpose of security and can be used as lock for doors . Its main
purpouse is to provide security from intruders .

2. There are many existing solution for this project which are based on same
concept with more sophisticated design and use .

3. The existing solution are expensive and more complex to use. This projest is
simple and made of easily available parts in market. These parts can be
assembled with very minimal help from the provider.

Block Diagram of the Project:

Involved Flowchart/Algorithms:

Brief of the Platform/Tools Used:

A. 8051 Microcontroller:

A microcontroller is a small computer on a single IC that integrates all the

features that are found in the microprocessor. In order to serve different
applications, it has a high concentration of on chip facilities such as RAM,
ROM, I/O ports, timers, serial port, clock circuit and interrupts.
Microcontrollers are used in various automatically controlled devices such as
remote controls, automobile engine control systems, medical devices, power
tools, office machines, toys, and other embedded systems.

8051 microcontrollers have four I/O ports where in each port contains 8 pins
that can be configured as inputs or outputs. The Pin configuration – whether it
to be configured as an I/P (1) or an O/P (0), depends on its logic state. In
order to configure a microcontroller pin as an output, it is necessary to apply a
logic zero (0) to the suitable I/O port bits. In this case, the voltage level at the
appropriate pin will be 0.
Similarly, in order to configure a microcontroller pin as an input, it is
necessary to apply a logic one (1) to the suitable port. In this case, the voltage
level on the appropriate pin will be 5V. This may seem confusing, It all
becomes clear after studying simple electronic circuits connected to an I/O
pin.

B. Keypad:

A matrix keypad is the kind of keypad you see on microwave ovens, gas
pumps, and calculators. A matrix keypad you can connect to a breadboard is
also great for prototypes and inventions where things like codes, times, or
other values have to be entered.

C. 16×2 LCD

An LCD (Liquid Crystal Display) screen is an electronic display module and

has a wide range of applications. A 16x2 LCD display is very basic module and
is very commonly used in various devices and circuits. A 16x2 LCD means it
can display 16 characters per line and there are 2 such lines. In this LCD each
character is displayed in 5x7 pixel matrix. The 16 x 2 intelligent alphanumeric
dot matrix display is capable of displaying 224 different characters and
symbols. This LCD has two registers, namely, Command and Data.Command
register stores various commands given to the display. Data register stores
data to be displayed. The process of controlling the display involves putting
the data that form the image of what you want to display into the data
registers, then putting instructions in the instruction register. In your arduino
project Liquid Crystal Library simplifies this for you so you don't need to
know the low-level instructions. Contrast of the display can be adjusted by
adjusting the potentiometer to be connected across VEE pin.

D. L293D Motor Driver Board:

The L293D is a popular 16-Pin Motor Driver IC. As the name suggests it is
mainly used to drive motors. A single L293D IC is capable of running two DC
motors at the same time; also the direction of these two motors can be
controlled independently. So if you have motors which has operating voltage
less than 36V and operating current less than 600mA, which are to be
controlled by digital circuits like Op-Amp, 555 timers, digital gates or even
Micron rollers like Arduino, PIC, ARM etc.

Brief of the Languages Used:

C is a programming language developed at AT & T’s Bell Laboratories of USA

in 1972. It was designed and written by a man named Dennis Ritchie. In the
late seventies C began to replace the more familiar languages of that time like
PL/I, ALGOL, etc

ANSI C standard emerged in the early 1980s, this book was split into two
titles: The original was still called Programming in C, and the title that
covered ANSI C was called Programming in ANSI C. This was done because it
took several years for the compiler vendors to release their ANSI C compilers
and for them to become ubiquitous. It was initially designed for programming
UNIX operating system. Now the software tool as well as the C compiler is
written in C. Major parts of popular operating systems like Windows, UNIX,
Linux is still written in C. This is because even today when it comes to
performance (speed of execution) nothing beats C. Moreover, if one is to
extend the operating system to work with new devices one needs to write
device driver programs. These programs are exclusively written in C. C seems
so popular is because it is reliable, simple and easy to use. often heard today
is – “C has been already superceded by languages like C++, C# and Java.
Program
There is a close analogy between learning English language and learning C
language. The classical method of learning English is to first learn the
alphabets used in the language, then learn to combine these alphabets to form
words, which in turn are combined to form sentences and sentences are
combined to form paragraphs. Learning C is similar and easier. Instead of
straight-away learning how to write programs, we must first know what

alphabets, numbers and special symbols are used in C, then how using them
constants, variables and keywords are constructed, and finally how are these
combined to form an instruction. A group of instructions would be combined
later on to form a program.So a computer program is just a collection of the
instructions necessary to solve a specific problem. The basic operations of a
computer system form what is known as the computer’s instruction set. And
the approach or method that is used to solve the problem is known as an
algorithm.

So for as programming language concern these are of two types.

 1) Low level language
2) High level language

Low level language:

Low level languages are machine level and assembly level language. In
machine level language computer only understand digital numbers i.e. in the
form of 0 and 1. So, instruction given to the computer is in the form binary
digit, which is difficult to implement instruction in binary code. This type of
program is not portable, difficult to maintain and also error prone. The
assembly language is on other hand modified version of machine level
language. Where instructions are given in English like word as ADD, SUM,
MOV etc. It is easy to write and understand but not understand by the
machine. So the translator used here is assembler to translate into machine
level. Although language is bit easier, programmer has to know low level
details related to low level language. In the assembly level language the data
are stored in the computer register, which varies for different computer.
Hence it is not portable.

High level language:

These languages are machine independent, means it is portable. The language

in this category is Pascal, Cobol, Fortran etc. High level languages are
understood by the machine. So it need to translate by the translator into
machine level. A translator is software which is used to translate high level
language as well as low level language in to machine level language.

Three types of translator are there:

1)Compiler

2)Interpreter

3)Assembler

Compiler and interpreter are used to convert the high level language into
machine level language. The program written in high level language is known
as source program and the corresponding machine level language program is
called as object program. Both compiler and interpreter perform the same
task but there working is different. Compiler read the program at-a-time and
searches the error and lists them. If the program is error free then it is
converted into object program. When program size is large then compiler is
preferred. Whereas interpreter read only one line of the source code and
convert it to object code. If it check error, statement by statement and hence
of take more time.

Source Code: .

#include<avr/io.h>
#include<util/delay.h>
voidLCD_intialize_4bit(void);
voidLCD_inst_4bit(unsigned int inst);
voidLCD_data_4bit_4bit(unsigned int data);
voidLCD_sentence_4bit(char*str);
voidLCD_two_digit_4bit(unsigned int number);
voidLCD_multidigit_4bit(unsigned int number);
unsigned int keypress(void);
int main(void)
{
DDRC=0xff;
DDRB=0x07;
DDRD=0x00;
PORTD=0x0f;
LCD_intialize_4bit();
while(1)
{
unsigned int predefined=1234,y,enterpassword=0;
LCD_inst_4bit(0x80);
LCD_sentence_4bit("Password Plz...");
do
 {
y=keypress();
if(y==12)
{
break;
}
else
{
enterpassword=enterpassword*10+y;
LCD_inst_4bit(0xcf);
LCD_multidigit_4bit(enterpassword);
}
}
while(y!=12);
if(predefined==enterpassword)
{
LCD_int_4bit(0x01);
_delay_ms(2);
LCD_inst_4bit(0xc3);
LCD_sentence_4bit("Authorized");
}
else
{
LCD_inst_4bit(0x01);
_delay_ms(2);
LCD_inst_4bit(0xc2);
 LCD_sentence_4bit("Un-Authorized");
}
_delay_ms(1000);
LCD_inst_4bit(0x01);
_delay_ms(2);
}
}
unsidned int keypress(void)
{
unsigned int k=1;
while(k++1)
{
PORTB=0b00000110;
_delay_ms(20);
if((PIND & 0b00001111)==0x0e)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 3;
}
else if((PIND & 0b00001111)==0x0d)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 6;
}
else if((PIND & 0b00001111)==0x0b)
{
while((PIND & 0b00001111)!=0x0f)!=oxof);
k=0;
return 9;
}
else if((PIND & 0b00001111)==0x07)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 12;
}
PORTB=ob00000101;
_delay_ms(20);
if((PIND & 0b00001111)==0x0e)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 5;
}
else if((PIND & 0b00001111)==0x0d)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 5;
}
else if((PIND & 0b00001111)==0x0b)
{ while((PIND & 0b00001111)!=0x0f)!=0x0f);
k=0;
return 8;
}
else if((PIND & 0b00001111)==0x07)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 0;
}
PORTB=ob00000011;
_delay_ms(20);
if((PIND & 0b00001111)==0x0e)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 4;
}
else if((PIND & 0b00001111)==0x0d)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 7;
}
else if((PIND & 0b00001111)==0x0b)
 {
while((PIND & 0b00001111)!=0x0f)!=0x0f);
k=0;
return 8;
}
else if((PIND & 0b00001111)==0x07)
{
while((PIND & 0b00001111)!=0x0f);
k=0;
return 11;
}
}
}
Screenshots of Project:

Outcome and Learning:

Able to understand the complexity of loop, IF statements and got the idea of
design a project

Future Aspects:

Future Aspects are to make this project better by adding wireless password
input, adding face detector, speech recognition software for password input.
And making it more fisible and cheaper
 Project 2

Title : ToDo GUI Application using Tkinter

Languages Used : Python

Tools/Platforms Used : Jupyter Notebook

Project Description: Python ToDo List is a software that holds information

about upcoming tasks or events. Users need a handy software that can be used
quickly for taking quick notes. And that is where the to-do list is used. This
todo app is designed to create your to-do list and delete the list as per the user
wish. Here, the module used is Tkinter()-It is a standard Python interface to
the Tk GUI toolkit shipped with Python. Python with tkinter outputs the
fastest and easiest way to create the GUI applications. Creating a GUI using
tkinter is an easy task. Also, the design of this system is pretty simple so that
the user won’t get any difficulties while working on it.

Literature Survey :

1. This app is to help us become more aware of how we spend time in the
process of doing those tasks and how productive that time is. It can help set
some constraints on social media to reduce distraction and track the time we
spend working on the todo items. When we have a better sense of the
estimated time we’ll need to spend on our tasks, along with the validated time
spent on the items for reference or personal/team reviews, we are able to
manage our daily routines more efficiently.

2. Social media and other easily accessible online distractions make it hard
for us to stay focused on our tasks and make it difficult for us to do our work
efficiently. Constantly switching between tasks may give us the false feeling that
we are being productive when we are, in fact, not. It’s more important for us to
prioritize tasks and work on those that are most important, rather than focusing on
deleting small items from our todo list just for the sake of appearances.

3. The purpose of this app is to weed out the unwanted stuff and focus on
the things that matter most. Creating a not-to-do list should take no more than
half an hour. Once you get it, however, you’ll recognize that your to-do list
shrinks to its half over time.

Block Diagram of the Project:

Involved Flowchart/Algorithms:
Brief of the Platform/Tools Used:

Jupyter Notebook

What Is a Jupyter Notebook?

The Jupyter Notebook is an open-source web application that allows you to

create and share documents that contain live code, equations, visualizations
and narrative text. Uses include: data cleaning and transformation, numerical
simulation, statistical modeling, data visualization, machine learning, and
much more.

In this case, "notebook" or "notebook documents" denote documents that

contain both code and rich text elements, such as figures, links, equations, ...
Because of the mix of code and text elements, these documents are the ideal
place to bring together an analysis description, and its results, as well as, they
can be executed perform the data analysis in real time.

The Jupyter Notebook App produces these documents.

One should know that "Jupyter" is a loose acronym meaning Julia, Python, and
R. These programming languages were the first target languages of the
Jupyter application, but nowadays, the notebook technology also
supports many other languages. 

As you just saw, the main components of the whole environment are, on the
one hand, the notebooks themselves and the application. On the other hand,
you also have a notebook kernel and a notebook dashboard.
What Is the Jupyter Notebook App?

As a server-client application, the Jupyter Notebook App allows you to

edit and run your notebooks via a web browser. The application can be
executed on a PC without Internet access, or it can be installed on a remote
server, where you can access it through the Internet.

Its two main components are the kernels and a dashboard.

A kernel is a program that runs and introspects the user’s code. The Jupyter
Notebook App has a kernel for Python code, but there are also kernels
available for other programming languages.

The dashboard of the application not only shows you the notebook documents
that you have made and can reopen but can also be used to manage the
kernels: you can which ones are running and shut them down if necessary.

The History of IPython and Jupyter Notebooks

To fully understand what the Jupyter Notebook is and what functionality it

has to offer you need to know how it originated. 

Let's back up briefly to the late 1980s. Guido Van Rossum begins to work on
Python at the National Research Institute for Mathematics and Computer
Science in the Netherlands.

Wait, maybe that's too far.

Let's go to late 2001, twenty years later. Fernando Pérez starts developing
IPython.

In 2005, both Robert Kern and Fernando Pérez attempted building a notebook
system. Unfortunately, the prototype had never become fully usable. 
Fast forward two years: the IPython team had kept on working, and in 2007,
they formulated another attempt at implementing a notebook-type system. By
October 2010, there was a prototype of a web notebook, and in the summer of
2011, this prototype was incorporated, and it was released with 0.12 on
December 21, 2011. In subsequent years, the team got awards, such as the
Advancement of Free Software for Fernando Pérez on 23 of March 2013 and
the Jolt Productivity Award, and funding from the Alfred P. Sloan Foundations,
among others. 

Lastly, in 2014, Project Jupyter started as a spin-off project from

IPython. IPython is now the name of the Python backend, which is also known
as the kernel. Recently, the next generation of Jupyter Notebooks has been
introduced to the community. It's called JupyterLab.

After all this, you might wonder where this idea of notebooks originated or
how it came about to the creators.

A brief research into the history of these notebooks learns that Fernando

Pérez and Robert Kern were working on a notebook just at the same time
as the Sage notebook was a work in progress. Since the layout of the Sage
notebook was based on the layout of Google notebooks, you can also conclude
that also Google used to have a notebook feature around that time. 

For what concerns the idea of the notebook, it seems that Fernando Pérez, as
well as William Stein, one of the creators of the Sage notebook, have
confirmed that they were avid users of the Mathematica notebooks and Maple
worksheets. The Mathematica notebooks were created as a front end or GUI in
1988 by Theodore Gray. 

The concept of a notebook, which contains ordinary text and calculation

and/or graphics, was definitely not new. 
Also, the developers had close contact with one another and this, together
with other failed attempts at GUIs for IPython and the use of "AJAX" =
web applications, which didn't require users to refresh the whole page every
time you do something, were two other motivations for the team of William
Stein to start developing the Sage notebooks. 

If you want to know more details, check out the personal accounts
of Fernando Pérez and William Stein about the history of their notebooks.
Alternatively, you can read more on the history and evolution from IPython to
Jupyter notebooks here.

Brief of the Languages Used:

 Python -

Python is a widely used general purpose, high level programming language. It

was initially designed by Guido van Rossum in 1991 and developed by Python
software Foundation. It was mainly developed for emphasis on code
redability, and its syntax allows programmers to express concepts in fewer
lines of code.

Python is a programming language that lets you work quickly and integrate
systems more efficiently.

Salient Features of Python:

Let us take a closer look at some of the salient features of Python.

1.Enhanced readability

In Python, uniform indents are used to delimit blocks of statements instead of

curly brackets like in C, C++ and Java. This enhances readability.
2.Dynamic typing
In Python, a variable to be used in a program need not have prior declaration
of its name and type. 

3.Interpreted language

Python is an interpreter-based language. An interpreter executes one

instruction at a time. So, if there is an error on line 7 of the code, it will
execute instructions till line 6 and then stop. This is unlike a compiler which
will not execute any of the instructions even if there is a single error. Thus,
an interpreter is useful if you are new to programming because it allows you
to see partial output of your code and identify the error location more easily.

4.Extensible language

Python extension modules implement new built-in object types and can call
C libraries and system calls which Python doesn’t have direct access to.

5.Standard DB2 API

A standard data connectivity API facilitates using data sources such as

Oracle, MySQL and SQLite as a backend to a Python program for storage,
retrieval and processing of data.

Uses of Python:
● Python can be used on a server to create web applications.
● Python can be used alongside software to create workflows.
● Python can connect to database systems. It can also read and modify files.
● Python can be used to handle big data and perform complex mathematics.
● Python can be used for rapid prototyping, or for production-ready
software development.
● Data Science and Data Visualization
● Python can be used on a Desktop GUI.
● Python can be used for CAD Applications and Embedded Applications.
Characteristics of Python:
Following are important characteristics of Python Programming –
 ∙ It supports functional and structured programming methods as well as OOP.
 ∙ It can be used as a scripting language or can be compiled to byte-code for
building large applications. 
∙ It provides very high-level dynamic data types and supports dynamic type
checking. 
∙ It supports automatic garbage collection. 
∙ It can be easily integrated with C, C++, COM, ActiveX, CORBA, and Java

Data Types in Python:

OOP:
Object-oriented programming is a programming paradigm based on the
concept of "objects", which can contain data and code: data in the form of
fields, and code, in the form of procedures. A feature of objects is that an
object's own procedures can access and often modify the data fields of itself.
Object-oriented programming (OOP) is a computer programming model that
organizes software design around data, or objects, rather than functions and
logic. An object can be defined as a data field that has unique attributes and
behaviour.

Selenium
Selenium is a powerful tool for controlling web browsers through programs
and performing browser automation. It is functional for all browsers, works
on all major OS and its scripts are written in various languages i.e. Python,
Java, C#, etc, we will be working with Python. Selenium Tutorial covers all
topics such as – WebDriver, WebElement, Unit Testing with selenium. This
Python Selenium Tutorial covers Selenium from basics to advanced and
professional uses.

● Open Source and Portable – Selenium is an open source and portable

Web testing Framework.

● Combination of tool and DSL – Selenium is combination of tools and

DSL (Domain Specific Language) in order to carry out various types of
tests.

● Easier to understand and implement – Selenium commands are

categorized in terms of different classes which make it easier to
understand and implement.
 ● Less burden and stress for testers – As mentioned above, the amount
of time required to do testing repeated test scenarios on each and every
new build is reduced to zero, almost. Hence, the burden of tester gets
reduced.

● Cost reduction for the Business Clients – The Business needs to pay
the testers their salary, which is saved using automation testing tool.
The automation not only saves time but gets cost benefits too, to the
business.

Python Tkinter

Tkinter was developed as a GUI extension for the Tcl scripting language by
John Ousterhout. The first release was in 1991. Tk proved as extremely
successful in the 1990's, because it is easier to learn and to use than other
toolkits. So it is no wonder that many programmers wanted to use Tk
independently of Tcl. That's why bindings for lots of other programming
languages have been developed, including Perl, Ada (called TASH), Python
(called Tkinter), Ruby, and Common Lisp.
Tkinter has long been an integral part of Python. It provides a robust and
platform independent windowing toolkit, that is available to Python
programmers using the tkinter package, and its extension, the tkinter.tix and
the tkinter.ttk modules.
The tkinter package is a thin object-oriented layer on top of tkinter. To use
tkinter, you don’t need to write Tcl code, but you will need to consult the Tk
documentation, and occasionally the Tcl documentation. tkinter is a set of
wrappers that implement the Tk widgets as Python classes. In addition, the
internal module _tkinter provides a threadsafe mechanism which allows
Python and tkinter to interact. tkinter’s chief virtues are that it is fast, and that
it usually comes bundled with Python. Although its standard documentation is
weak, good material is available, which includes: references, tutorials, a book
and others. tkinter is also famous for having an outdated look and feel, which
has been vastly improved in Tk 8.5. Nevertheless, there are many other GUI
libraries that you could be interested in. For more information about
alternatives, see the Other Graphical User Interface Packages section. Tkinter
tutorial provides basic and advanced concepts of Python Tkinter. Our Tkinter
tutorial is designed for beginners and professionals. Python provides the
standard library Tkinter for creating the graphical user interface for desktop
based applications. The tkinter package (“Tk interface”) is the standard
Python interface to the Tk GUI toolkit. Both Tk and tkinter are available on
most Unix platforms, as well as on Windows systems. (Tk itself is not part of
Python; it is maintained at ActiveState.)
Running python -m tkinter from the command line should open a window
demonstrating a simple Tk interface, letting you know that tkinter is properly
installed on your system, and also showing what version of Tcl/Tk is installed,
so you can read the Tcl/Tk documentation specific to that version.
Developing desktop based applications with python Tkinter is not a complex
task. An empty Tkinter top-level window can be created by using the
following steps.
1. import the Tkinter module.
2. Create the main application window.
3. Add the widgets like labels, buttons, frames, etc. to the window.
4. Call the main event loop so that the actions can take place on the user's
computer screen.

Source Code:
Screenshots of Project:
Outcome and Learning:
Social media and other easily accessible online distractions make it hard for
us to stay focused on our tasks and make it difficult for us to do our work
efficiently. Task Management applications have been built for structured
collaboration. They can handle due dates, reminders, dependencies,
discussions, priorities, task descriptions, documentations, task statuses,
assignments, etc. They manage different levels of action and offer complete
workflow management. Besides, a task management application gives context
to your work because you can organize your tasks in dedicated environments
and complete them on time.
This app shows which task you have to do in given time of the day in order to
complete each of your tasks effectively and in time.
Whatever your task is like accomplish projects, manage daily tasks, work
todos, learning languages, mastering skills, sports or travel, This app will help
you to collect, keep, organize and remind you about all your tasks you have to
do on that day.
Future Aspects:
This app is for managing all your “Daily Tasks” for increasing your
productivity. The app is a simple mixup of Task Manager & To-Do app that
helps you get stuff done in an organized way. Whether your task is like
accomplish projects, work todos, learning languages, mastering skills, sports
or travel, etc. This app will help you to collect, keep, organize and remind you
about all your tasks you have to do on that day or in coming days.
It helps to weed out the unwanted stuff and focus on the things that matter
most. Creating a not-to-do list should take no more than half an hour. Once
you get it, however, you’ll recognize that your to-do list shrinks to its half over
time.
Schedule a one-on-one meeting with yourself and compile a simple list of
tasks and activities that you want to get rid of. Cut the nonsense.